datalib

type ActionSlideMovementInfo struct {
	SlideFlatDuration     float32 `json:"slide_flat_duration"`     // The exit duration when sliding on flat ground
	SlideFlatSpeed        float32 `json:"slide_flat_speed"`        // The speed when sliding on flat ground
	SlideUphillDuration   float32 `json:"slide_uphill_duration"`   // The exit duration when sliding into max uphill slopes
	SlideUphillSpeed      float32 `json:"slide_uphill_speed"`      // The speed when sliding into uphill slopes
	SlideDownhillDuration float32 `json:"slide_downhill_duration"` // The exit duration when sliding down max downhill slopes
	SlideDownhillSpeed    float32 `json:"slide_downhill_speed"`    // The speed when sliding down downhill slopes
}

type ActiveEffectSetting struct {
	ID           stingray.ThinHash // [string]Identifier for this effect, used when playing effects from behavior
	StartEnabled uint8             // [bool]If true, effect is triggered on spawn

	Effect EffectSetting // Particle effect to play while the entity lives and is destroyed on death.
	// contains filtered or unexported fields
}

type AnimationComponent struct {
	MergeOptions                 AnimationMergeOptions // Animation merge options (or animation sharing options).
	Variables                    [8]AnimationVariable  // Information about any variables to be set when spawning the animated entity.
	HotjoinSyncAnimationTime     uint8                 // [bool]If set, the time into the current animation is also synced. Useful for long animations, such as the dropship sequence.
	IgnoreInvisibileUnitsForLods uint8                 // [bool]If set, invisible units are ignored for the OOBB used to select LOD steps.
	// contains filtered or unexported fields
}

type AnimationMergeOptions struct {
	MaxStartTime  float32 `json:"max_start_time"` // Sets the maximum time into an animation that we can start, in seconds. If a value of `0.2` is set, it means that if we can find any existing player playing this animation that has played for 0-0.2 seconds, then we will reuse that player instead of creating a new one. The animation will jump to the position where that player is, instead of starting at t=0. The default is `0`, which allows animation evaluations to be merged only if they began in the same frame.
	MaxDrift      float32 `json:"max_drift"`      // Controls how much the displayed animation time is allowed to drift from the actual animation time. If two animations that are sharing a player are played with different speeds, they will eventually drift apart. At some point the animations will be considered too different and the evaluator will be split in two. This parameter controls when that happens. A value of `0.2` means that if the animations differs more than 0.2 seconds, the evaluator will be split.
	ClockFidelity float32 `json:"clock_fidelity"` // This controls how much the animation will respect the set playing speed. By slightly changing the playing speed of an animation, the animation player can prevent two playing animations from drifting apart and thus forcing a split of the evaluators. A clock fidelity of `0.9` means that the speed will be within 90% of what has been requested: i.e. it is allowed to change by 10 percent. The default value of `1.0` means that the speed will be exactly what has been requested.
}

type AnimationVariable struct {
	Name  stingray.ThinHash // [string]The name of the animation variable to set.
	Value float32           // The value to set on the animation variable.
}

type ArcWeaponComponent struct {
	Type                enum.ArcType // Type of arc it fires
	RoundsPerMinute     float32      // Rounds per minute depending on weapon setting.
	InfiniteAmmo        uint8        // [bool]True if this projectile weapon can never run out of ammo.
	RPCSyncedFireEvents uint8        // [bool]ONLY USE FOR SINGLE-FIRE/SLOW FIRING WEAPONS. Primarily useful for sniper rifles, explosive one-shots etc. that need the firing event to be highly accurately synced!

	FireSingleAudioEvent        stingray.ThinHash     // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	UnknownHash                 stingray.ThinHash     // Unknown, name length 27
	FireFailAudioEvent          stingray.ThinHash     // [wwise]The audio event to trigger when the arc fails to hit anything on the first shot.
	HapticsFireSingleAudioEvent stingray.ThinHash     // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	FireSourceNode              stingray.ThinHash     // [string]The node to play the firing audio events at.
	OnRoundFiredShakes          WeaponCameraShakeInfo // Settings for local and in-world camera shakes to play on every round fired.
	MuzzleFlash                 stingray.Hash         // [particles]Particle effect of the muzzle flash, played on attach_muzzle.
	MuzzleFlashFail             stingray.Hash         // [particles]Particle effect of the muzzle flash, when the arc weapon fails to hit, played on attach_muzzle.
	// contains filtered or unexported fields
}

type ArmorSet struct {
	Name         string
	SetId        uint32
	Passive      CustomizationKitPassive
	Type         CustomizationKitType
	UnitMetadata map[stingray.Hash]UnitData
}

type AttachableComponent struct {
	DynamicActor         stingray.ThinHash // [string]Name of the dynamic actor that should be disabled when attached and enabled when dropped.
	AttachedDynamicActor stingray.ThinHash // [string]Name of the dynamic actor that should be enabled when attached and disabled when dropped.
	UseAllDynamicActors  uint8             // [bool]True if all dynamic actors should be disabled when attached and enabled when dropped.

	Offset                      mgl32.Vec3        // If set, this offset is applied on top of any other offsets when attaching the entity.
	RotationOffset              mgl32.Vec3        // If set, this rotation (in angles) is applied on top of any other offsets when attaching the entity.
	OffsetNode                  stingray.ThinHash // [string]If specified, the local space position and rotation of the node relative to the unit root will be added to the offset when attaching.
	AttachAnim                  stingray.ThinHash // [string]Animation to play when attaching.
	ParentAttachAnim            stingray.ThinHash // [string]Animation to play on the parent when attaching.
	DetachAnim                  stingray.ThinHash // [string]Animation to play when detaching.
	ParentDetachAnim            stingray.ThinHash // [string]Animation to play on the parent when detaching.
	AffectScale                 uint8             // [bool]This should only be applied to main entities that will attach to something in the world, like hellpods.
	IgnoreWeaponDamageForParent uint8             // [bool]This variable will decide if we should be able to damage our parent with our weapons.
	InheritAngularMomentum      uint8             // [bool]Should this attachable inherit angular momentum?
	UnknownBool1                uint8             // [bool]Unknown, name length 21
	UnknownBool2                uint8             // [bool]Unknown, name length 24
	UnknownBool3                uint8             // [bool]Unknown, name length 24
	// contains filtered or unexported fields
}

type AvatarComponent struct {
	InputInfo                    AvatarInputSettings           // Contains information about avatar input handling
	MovementInfo                 MoveInfo                      // Contains information about avatar movement
	SteepSlopeMovement           SteepSlopeMovementInfo        // Contains information about avatar movement in steep slopes
	SlideMovementInfo            ActionSlideMovementInfo       // Contains information about the avatar action slide
	ClimbInformation             ClimbInfo                     // Contains information about avatar climbing behaviour
	ShortThrowInfo               ThrowInfo                     // Contains information about throwing stuff underhand.
	LongThrowInfo                ThrowInfo                     // Contains information about throwing stuff overhand.
	DetectInfo                   DetectionInfo                 // Contains information about stealth and being detected.
	WeatheringSettings           AvatarWeatheringSettings      // Contains information about how fast dirt and wear and tear is added to the avatar.
	MovementHaptics              AvatarMovementHapticsSettings // Contains information about the avatar's movement haptics.
	ExertionLevels               [8]ExertionLevelInfo          // The different levels of exertion levels.
	ExertionVoiceOverParams      ExertionVoParams              // Different VO Events
	HealSelfDuration             float32                       // The duration in seconds it takes to heal yourself.
	HealSelfDecayWaitTime        float32                       // The duration in seconds to wait before starting to decaying healing progress.
	HealSelfDecayRate            float32                       // The rate at which your healing progress decays if not healing.
	HealSelfCancelDamageAmount   float32                       // The amount of damage you take for cancelling healing.
	RagdollDamageVelocityLower   float32                       // The lower value at which our limbs deal ragdoll damage.
	RagdollDamageVelocityUpper   float32                       // The upper value at which our limbs deal ragdoll damage.
	RagdollDamageMin             float32                       // The lowest amount of ragdoll damage we deal.
	RagdollDamageMax             float32                       // The highest amount of ragdoll damage we deal.
	RagdollDamageSnowModifier    float32                       // The modifier which we decrease ragdoll damage in snow by.
	MinAimDuration               float32                       // Time it takes to aim at max ergonomics level
	MaxAimDuration               float32                       // Time it takes to aim at min ergonomics level
	MinFireReadyDuration         float32                       // Time it takes to get ready to fire a shot at max ergonomics level
	MaxFireReadyDuration         float32                       // Time it takes to get ready to fire a shot at min ergonomics level
	TauntTimeBeforeDrain         float32                       // Time it takes for the taunt probability to start draining
	TauntDrainPerSecond          float32                       // How much of the taunt probability we drain per second
	TauntOnTriggerProbabilityMul float32                       // By how much do we multiply the probability upon a successful taunt?
	TauntCooldownTimer           float32
}

type AvatarInputSettings struct {
	HoldStanceButtonTimeForProne float32 `json:"hold_stance_button_time_for_prone"` // The time needed to hold down the Switch Stance button until prone is toggled
}

type AvatarMovementHapticsSettings struct {
	LeftSprinting  stingray.ThinHash // [wwise]Left sprinting haptic
	RightSprinting stingray.ThinHash // [wwise]Right sprinting haptic
	LeftJogging    stingray.ThinHash // [wwise]Left jogging haptic
	RightJogging   stingray.ThinHash // [wwise]Right jogging haptic
	LeftWalking    stingray.ThinHash // [wwise]Left walking haptic
	RightWalking   stingray.ThinHash // [wwise]Right walking haptic
	LeftCrouching  stingray.ThinHash // [wwise]Left crouching haptic
	RightCrouching stingray.ThinHash // [wwise]Right crouching haptic
	LeftCrawling   stingray.ThinHash // [wwise]Left crawling haptic
	RightCrawling  stingray.ThinHash // [wwise]Right crawling haptic
}

type AvatarWeatheringSettings struct {
	MoveSpeedRequirement float32 `json:"move_speed_requirement"` // Start adding dirt after moving at this speed.
	DirtSpeedStanding    float32 `json:"dirt_speed_standing"`    // How dirty to get while moving standing up.
	DirtSpeedCrouching   float32 `json:"dirt_speed_crouching"`   // How dirty to get while crouch moving.
	DirtSpeedProne       float32 `json:"dirt_speed_prone"`       // How dirty to get while crawling around.
	DirtSpeedSliding     float32 `json:"dirt_speed_sliding"`     // How dirty to get while sliding.
}

type BeamPrisms struct {
	LightBeamType          enum.BeamType `json:"light_beam_type"`
	LightHeatGenerationMul float32       `json:"light_heat_generation_mul"`
	HeavyBeamType          enum.BeamType `json:"heavy_beam_type"`
	HeavyHeatGenerationMul float32       `json:"heavy_heat_generation_mul"`
}

type BeamWeaponComponent struct {
	Type                enum.BeamType // Type of beam it fires.
	Prisms              BeamPrisms    // Beam Prism Settings for weapons with the weapon function.
	ScopeResponsiveness float32       // How quickly the scope/sight follows changes in aim and movement.
	ScopeCrosshair      mgl32.Vec2    // Crosshair position on screen in [-1, 1] range.
	FocalDistances      mgl32.Vec3    // The focal distances of the weapon's lens
	UseFirenodePose     float32
	UseMidiEventSystem  uint8 // [bool]Fire event will be posted using Wwise's MIDI system as a MIDI sequence (cannot be paused/resumed).

	MidiTimingRandomization mgl32.Vec2        // Events posted during the MIDI sequence will have a random time offset, measured in milliseconds.
	MidiStopDelay           float32           // A delay for when to notify Wwise that the MIDI sequence has stopped, measured in milliseconds.
	FireLoopStartAudioEvent stingray.ThinHash // [wwise] The looping audio event to start when starting to fire.
	FireLoopStopAudioEvent  stingray.ThinHash // [wwise] The looping audio event to play when stopping fire.
	FireSingleAudioEvent    stingray.ThinHash // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).

	MuzzleFlash                   stingray.Hash     // [particles]Muzzle flash effect
	NoiseTimer                    float32           // How often does the weapon make noise?
	FireSourceNode                stingray.ThinHash // [string]The node to play the firing audio events at.
	DryFireAudioEvent             stingray.ThinHash // [wwise]The wwise sound id to play when dry firing.
	DryFireRepeatAudioEvent       stingray.ThinHash // [wwise]The wwise sound id to play when repeatedly dry firing.
	OnFireStartedWielderAnimEvent stingray.ThinHash // [string]Animation event to trigger on the wielder when we start firing.
	OnFireStoppedWielderAnimEvent stingray.ThinHash // [string]Animation event to trigger on the wielder when we stop firing.
	// contains filtered or unexported fields
}

type Body struct {
	Type          CustomizationKitBodyType
	Unk00         uint32
	PiecesAddress int64
	PiecesCount   int64
}

type CharacterNameComponent struct {
	Race               enum.RaceType     // Must not be none if the name should be selected from random templates.
	RandomNameTemplate stingray.ThinHash // [string]If not empty, use a random name from the name list and insert it into the NAME localization variable of the template.
	CharacterName      uint32            // [string]The localization string identifier of the character name, as displayed in subtitles.
	UsePersistentSeed  uint8             // [bool]If set, this character uses a predictable seed based on peer id. This is most useful for ship characters.
	// contains filtered or unexported fields
}

type ChargeStateSetting struct {
	ChargeTime         float32             `json:"charge_time"`
	ProjType           enum.ProjectileType `json:"projectile_type"`
	ProjectileParticle stingray.Hash       `json:"projectile_particle"`
	UnknownThinHash    stingray.ThinHash   `json:"unknown"` // 17 chars long name
	// contains filtered or unexported fields
}

type ClimbInfo struct {
	StartOffset                                mgl32.Vec3 `json:"start_offset"`                                      // Offset from root to climb point/ledge at the time we attach to it
	ClimbOffset                                mgl32.Vec3 `json:"climb_offset"`                                      // Offset from root to climb point/ledge at the time we reach hanging
	MinHeightFalling                           float32    `json:"min_height_falling"`                                // Min height falling
	MaxHeight                                  mgl32.Vec2 `json:"max_height"`                                        // Max height of an obstacle to be able to perform a climb (from gound and from air)
	MaxForwardDistance                         mgl32.Vec2 `json:"max_forward_distance"`                              // Max forward distance (from gound and from air)
	ForwardStartCheckDistancePerMeterPerSecond float32    `json:"forward_start_check_distance_per_meter_per_second"` // Distance forward per m/s movement speed to add to the minimum check distance
	MaxAutoStepUpHeight                        float32    `json:"max_auto_step_up_height"`                           // Indicates the maximun height with which we can trigger an auto step up climb.
	AutoStepUpCooldown                         float32    `json:"auto_step_up_cooldown"`                             // Indicates how much cooldown between auto step ups triggers we should have.
	ClimbRefInterpolationSpeed                 float32    `json:"climb_ref_interpolation_speed"`                     // climb reference interpolation speed
}

type Component interface {
	ToSimple(lookupHash HashLookup, lookupThinHash ThinHashLookup, lookupStrings StringsLookup) any
}

type ComponentDeltaSettings struct {
	ComponentIndex uint32                       `json:"component_index"`
	Deltas         []ComponentModificationDelta `json:"deltas,omitempty"`
}

type ComponentEntityDeltaStorage map[stingray.Hash]EntityDeltaSettings

type ComponentIndexData struct {
	Resource stingray.Hash
	Index    uint32
	// contains filtered or unexported fields
}

type ComponentModificationDelta struct {
	Offset uint32 `json:"offset"`
	Data   []byte `json:"data,omitempty"`
}

type CustomizationKitBodyType uint32

type CustomizationKitPassive uint32

type CustomizationKitPieceType uint32

type CustomizationKitRarity uint32

type CustomizationKitSlot uint32

type CustomizationKitType uint32

type CustomizationKitWeight uint32

type DLBitfieldOrArrayLen uint16

type DLEnumDesc struct {
	Name       string            `json:"name"`
	NameOffset uint32            `json:"name_offset"`
	Flags      DLTypeFlags       `json:"flags"`
	Storage    DLTypeStorage     `json:"storage"`
	Values     []DLEnumValueDesc `json:"values"`
}

type DLEnumValueDesc struct {
	Name    string   `json:"name"`
	Comment string   `json:"comment,omitempty"`
	Value   uint64   `json:"value"`
	Aliases []string `json:"aliases,omitempty"`
}

type DLHash uint32

type DLHashLookup func(DLHash) string

type DLInstance struct {
	DLInstanceHeader
	Data []byte
}

type DLInstanceHeader struct {
	Magic   [4]byte
	Version uint32
	Type    DLHash
	Size    uint32
	Is64Bit uint8
	// contains filtered or unexported fields
}

type DLMemberDesc struct {
	Name         string      `json:"name"`
	NameOffset   uint32      `json:"name_offset"`
	Comment      string      `json:"comment,omitempty"`
	Type         DLType      `json:"type_flags"`
	TypeID       DLHash      `json:"type"`
	Size         uint32      `json:"size"`
	Alignment    uint32      `json:"alignment"`
	Offset       uint32      `json:"offset"`
	DefaultValue []uint8     `json:"-"`
	Flags        DLTypeFlags `json:"flags"`
}

type DLSubdata struct {
	DLSubdataHeader
	Data []byte
}

type DLSubdataHeader struct {
	Magic   [4]byte
	Version uint32
	Type    DLHash
	Size    uint32
	Is64Bit uint8
	// contains filtered or unexported fields
}

type DLType struct {
	Atom                   DLTypeAtom           `json:"atom"`
	Storage                DLTypeStorage        `json:"storage"`
	BitfieldInfoOrArrayLen DLBitfieldOrArrayLen `json:"union_arrayinfo_bfinfo"`
}

type DLTypeAtom uint8

type DLTypeDesc struct {
	Name          string         `json:"name"`
	NameOffset    uint32         `json:"name_offset"`
	Flags         DLTypeFlags    `json:"flags"`
	Size          uint32         `json:"size"`
	Alignment     uint32         `json:"alignment"`
	Members       []DLMemberDesc `json:"members,omitempty"`
	Comment       string         `json:"comment,omitempty"`
	CommentOffset uint32         `json:"comment_offset,omitzero"`
}

type DLTypeFlags uint32

type DLTypeLib struct {
	DLTypeLibHeader `json:"header"`
	Types           map[DLHash]DLTypeDesc `json:"types,omitempty"`
	Enums           map[DLHash]DLEnumDesc `json:"enums,omitempty"`
}

type DLTypeLibHeader struct {
	ID      [4]uint8 `json:"-"`
	Version uint32   `json:"version"`

	TypeCount      uint32 `json:"type_count"`
	EnumCount      uint32 `json:"enum_count"`
	MemberCount    uint32 `json:"member_count"`
	EnumValueCount uint32 `json:"enum_value_count"`
	EnumAliasCount uint32 `json:"enum_alias_count"`

	DefaultValueSize    uint32 `json:"default_value_size"`
	TypeInfoStringsSize uint32 `json:"typeinfo_strings_size"`
}

type DLTypeStorage uint8

type DLWidthDependentUInt32 [2]uint32

type DamageableZone struct {
	Info   DamageableZoneInfo    // Damageable Zone Info
	Actors [24]stingray.ThinHash // [string]Damageable Zone Actors
}

type DamageableZoneInfo struct {
	OnDeadEffect         EffectSetting     // Particle effect to play when this damage zone dies
	OnDownedEffect       EffectSetting     // Particle effect to play when this damage zone gets downed.
	ZoneName             stingray.ThinHash // [string]The name of this zone
	OnDeadScriptEvent    stingray.ThinHash // [string]The script event to trigger when this damage zone dies.
	OnDeadAnimationEvent stingray.ThinHash // [string]The animation event to trigger when this damage zone dies.
	OnDeadUnknownEvent   stingray.ThinHash // Some event grouped with other on dead events with a name length of 31 chars.
	OnDeadAudioEvent     stingray.ThinHash // [wwise]The audio event to trigger when this damage zone dies.
	OnDeadAudioEventNode stingray.ThinHash // [string]The audio node to use when this damage zone dies.
	OnDeadUnknownBool    uint8             // An unknown bool with a name length of 34 chars

	OnDeadHideVisiblityGroup    stingray.ThinHash     // [string]Visibility group to hide when this damage zone dies.
	OnDeadShowVisiblityGroup    stingray.ThinHash     // [string]Visibility group to show when this damage zone dies.
	OnDeadHideVisiblityMask     stingray.ThinHash     // [string]Visibility mask to hide when this damage zone dies.
	OnDeadShowVisiblityMask     stingray.ThinHash     // [string]Visibility mask to show when this damage zone dies.
	OnDownedHideVisiblityMask   stingray.ThinHash     // [string]Visibility mask to hide when this damage zone gets downed.
	OnDownedShowVisiblityMask   stingray.ThinHash     // [string]Visibility mask to show when this damage zone gets downed.
	DestroyedAssignmentEvent    stingray.ThinHash     // [string]Assignment event tag to send when destroyed, either once when killed or once when entering downed state
	OnDeadLocomotionSet         stingray.ThinHash     // [string]The name of the locomotion set to activate when it dies. It will not trigger if another zone that affects locomotion is dead. In this case the locomotion set 'crawling' will be triggered.
	OnHitScriptEvent            stingray.ThinHash     // [string]The script event to trigger when this damage zone gets hit without taking damage.
	OnBleedoutScriptEvent       stingray.ThinHash     // [string]The script event to trigger when this damage zone gets bled out.
	OnDownedScriptEvent         stingray.ThinHash     // [string]The script event to trigger when this damage zone goes into constitution.
	OnHealScriptEvent           stingray.ThinHash     // [string]The script event to trigger when this damage zone gets healed.
	OnDownedAudioEvent          stingray.ThinHash     // [wwise]The audio event to trigger when this damage zone goes into constitution.
	OnDownedAudioEventNode      stingray.ThinHash     // [string]The audio node to use when this damage zone goes into constitution.
	OnDownedLocomotionSet       stingray.ThinHash     // [string]The name of the locomotion set to activate when it goes into constitution. It will not trigger if another zone that affects locomotion is dead. In this case the locomotion set 'crawling' will be triggered.
	OnDamageScriptEvent         stingray.ThinHash     // [string]The script event to trigger when this damage zone takes damage.
	DamageMultiplier            enum.DamageMultiplier // Damage Multiplier
	DamageMultiplierDPS         enum.DamageMultiplier // Damage Multipler for DPS weapons
	ProjectileDurableResistance float32               // Projectiles have 2 damages - Normal and Durable. This indicates how much it should scale the damage between the 2 values [Normal] -> [Durable].
	Armor                       uint32                // Armor
	ArmorAngleCheck             uint8                 // [bool]Whether or not projectiles should check for armor penetration boost on hit.

	MaxArmor          uint32 // Maximum armor the angle check scales to.
	IgnoreArmorOnSelf uint8  // [bool]If checked, this entity does (not?) apply armor reduction on damage to itself, but still applies armor penetration reduction on the thing damaging it. Useful for shields that should take damage but stop projectiles/beams.

	Health               int32 // The max health of this zone
	Constitution         int32 // The max constitution of the zone
	Immortal             uint8 // [bool]If this is true, this zone cannot die until the entire entity dies.
	CausesDownedOnDowned uint8 // [bool]If this is true, the downing of this zone puts the entity in constitution.
	CausesDeathOnDowned  uint8 // [bool]If this is true, the downing of this zone triggers the immediate death of the entity.
	CausesDownedOnDeath  uint8 // [bool]If this is true, the death of this zone puts the entity in constitution.
	CausesDeathOnDeath   uint8 // [bool]If this is true, the death of this zone triggers the immediate death of the entity.

	AffectsMainHealth         float32               // As a multiplier between 0-1, this damage only affects the health pool of the damageable zone itself, not the entity's main health.
	ChildZones                [16]stingray.ThinHash // [string]The name of the zones that are children to this zone.
	KillChildrenOnDeath       uint8                 // [bool]If true, when this damageable zone dies we will kill all of it's child damageable zones as well.
	RegenerationEnabled       uint8                 // [bool]If true, this damage zone will regenerate when the health components regeneration cooldown isn't active.
	BleedoutEnabled           uint8                 // [bool]If true, this damage zone will start to bleedout when it's entered constitution.
	AffectedByExplosions      uint8                 // [bool]If true, explosions are applied to this damage zone. If not, the default zone is affected.
	ExplosiveDamagePercentage float32               // Looks like the amount of explosive damage taken - 27 chars long
	UnknownFloat2             float32               // idk, 28 chars long
	OnDeadDisableAllActors    uint8                 // [bool]If true, we disable all actors in this damage zone as it dies.
	UnknownBool               uint8                 // idk, 23 chars long

	ExplosionVerificationMode          enum.ExplosionVerificationMode // Defines when explosions are verified by raycast.
	MainHealthAffectCappedByZoneHealth uint8                          // [bool]If true, the main health contribution is capped by the health + constitutiuon of the damage zone. Should be true for zones that can be gibbed/dismembered.

	HitEffectReceiverType enum.HitEffectReceiverType // The type of hit effect to play when the zone gets hit. If this is set to HitEffectReceiverType_Count, it will assume the hit effect of the HitEffectComponent.
	UseSurfaceEffect      uint8                      // [bool]If enabled, will use the surface effect rather than the hit effect.

	HealthEventTriggers [4]HealthEventTrigger // Events that get played at certain health percentages.
	UnknownHash         stingray.ThinHash     // Unknown, 31 chars long
	UnknownFloat3       float32               // Unknown, 30 chars long
	UnknownBool2        uint8                 // Unknown, 9 chars long
	UnknownBool3        uint8                 // Unknown, 14 chars long
	// contains filtered or unexported fields
}

type DangerWarningComponent struct {
	WarningType   enum.DangerWarningType // Warning enum
	TriggerRadius float32                // If the player is within this radius that will show the warning. If less than 0 then always active
	StartActive   uint8                  // [bool]If true then this warning is active as soon as this entity exists
	// contains filtered or unexported fields
}

type DecaySettings struct {
	Mode         enum.DeathDecayMode `json:"mode"`         // If and how this entity decays on death.
	Acceleration float32             `json:"acceleration"` // Acceleration (m/s^2) of the decay velocity.
	MinDelay     float32             `json:"min_delay"`    // Only valid with Regular decay mode, this dictates how long to wait (at a minimum) before decaying,
	MaxDelay     float32             `json:"max_delay"`    // Only valid with Regular decay mode, this dictates how long to wait (at a maximum) before decaying,
	UnkFloat     float32             `json:"unk_float"`
	UnkBool      uint8               `json:"unk_bool"`
	// contains filtered or unexported fields
}

type DepositComponent struct {
	Capacity               uint32            // Total capacity.
	StartAmount            int32             // Initial capacity
	RefillAmount           uint32            // How much should this backpack be refilled for when getting ammo?
	DeductOwnerVoEvent     stingray.ThinHash // [string]VO event to play on the owner of the deposit component entity when being deducted.
	LastDeductOwnerVoEvent stingray.ThinHash // [string]VO event to play on the owner of the deposit component entity when deducting the last deduct.

	DronePath               stingray.Hash  // [adhd]If specified, the backpack will spawn the targeted drone.
	FriendlyInteractAbility enum.AbilityId // If specified, will enable other helldivers' interact zones, as long as you have ammo.
	SelfInteractAbility     enum.AbilityId // If specified, will allow you to self-interact with your backpack.
	ShowSelfInteract        uint8          // [bool]If we don't have an ability for this backpack, but still run self-interact logic, set this to true.

	NodeHidingOrder              [20]stingray.ThinHash // [string]Depending on the amount left, these nodes will be hidden accordingly.
	NodeHidingOrderPostAnimEvent stingray.ThinHash     // [string]After deducting, what animation should we play.
	RefillStyle                  enum.DepositRefill    // How does this deposit gain charges? Ammo/Meds/None etc.

	AssistedReloadWeaponPath stingray.Hash // [string]If specified, the backpack will only work with the specified assist-reloadable weapon.
	// contains filtered or unexported fields
}

type DetectionInfo struct {
	SightModifierStanding  float32 `json:"sight_modifier_standing"`  // Modifier for enemy sight range when standing up
	SightModifierCrouching float32 `json:"sight_modifier_crouching"` // Modifier for enemy sight range when crouching
	SightModifierProne     float32 `json:"sight_modifier_prone"`     // Modifier for enemy sight range when prone
}

type EffectSetting struct {
	ParticleEffect       stingray.Hash
	Offset               mgl32.Vec3
	RotationOffset       mgl32.Vec3
	NodeName             stingray.ThinHash
	TriggerEmitEventName stingray.ThinHash
	LinkOption           enum.UnitEffectOrphanStrategy
	Flags                EffectSettingFlags
}

type EffectSettingFlags uint32

type ElementDamage struct {
	Type  enum.ElementType `json:"type"`
	Value float32          `json:"value"`
}

type EnemyPackageComponent struct {
	BundleTag stingray.ThinHash // [string]The loadout package will be generated with this bundle tag. Has no runtime effect.

	Package          stingray.Hash // [package]The loadout package to laod for this entity.
	SubentityPackage stingray.Hash // Name length 17 chars.
	AudioResource    stingray.Hash // [wwise_dep]The wwise bank to include in the package for this entity.
	// contains filtered or unexported fields
}

type EnemyTagSwap struct {
	Tag  enum.EnemyTag
	Name stingray.ThinHash
}

type Entity struct {
	GameObjectID stingray.ThinHash
	Components   map[DLHash]Component
}

type EntityDeltaSettings struct {
	ModifiedComponents []ComponentDeltaSettings `json:"modified_components,omitempty"`
}

type EntityDeltaTypeData struct {
	ResourceID stingray.Hash
	Index      uint32
	// contains filtered or unexported fields
}

type EntitySettings struct {
	Resource         stingray.Hash
	ComponentsOffset uint64
	ComponentsCount  uint64
	GameObjectID     stingray.ThinHash
	// contains filtered or unexported fields
}

type EquipmentComponent struct {
	WieldNode                 stingray.ThinHash // [string]Name of the node on the wielder that this equipment should be attached to when wielded.
	WieldNodeRotationOffset   mgl32.Vec3        // If set, this rotation offset is applied when wielded.
	WieldNodePositionOffset   mgl32.Vec3        // If set, this position offset is applied when wielded.
	HolsterNode               stingray.ThinHash // [string]Name of the node on the wielder that this equipment should be attached to when holstered.
	HolsterNodeRotationOffset mgl32.Vec3        // If set, this rotation offset is applied when holstered.
	HolsterNodePositionOffset mgl32.Vec3        // If set, this position offset is applied when holstered.
	HolsterDuration           float32           // The time it takes to holster this equipment.
	WieldDuration             float32           // The time it takes to wield this equipment.
	PickupDuration            float32           // The time it takes to pickup this equipment.
	UnknownHash               stingray.ThinHash // unknown, name length 23
	WieldAnimation            stingray.ThinHash // [string]Name of the animation to play on the wielder when wielding.
	PickupAnimation           stingray.ThinHash // [string]Name of the animation to play on the wielder when picking up otherwise fallback to wield animation.
	HolsterAnimation          stingray.ThinHash // [string]Name of the animation to play on the wielder when holstering.
	DropAnimation             stingray.ThinHash // [string]Name of the animation to play on the wielder when dropping.
	AmmocheckAnimation        stingray.ThinHash // [string]Name of the animation to play on the wielder when checking ammo.
	UnknownBool               uint8             // unknown, name length 30
	UnknownBool2              uint8             // unknown, name length 20

	HolsterDurationForAttach      float32                // The time it takes to have the equipment attach itself to the holster node when we start holstering.
	WieldDurationForAttach        float32                // The time it takes to have the equipment attach itself to the wield node when we start wielding.
	AttachLerpTime                float32                // Should we apply lerp to the attachable component when we wield/holster and if so, how long should it lerp for?
	OnHolsterAnimationEvent       stingray.ThinHash      // [string]Animation event to trigger when this entity is holstered.
	WieldAnimationSelf            stingray.ThinHash      // [string]Name of the animation to play on the equipment when wielding.
	PickupAnimationSelf           stingray.ThinHash      // [string]Name of the animation to play on the equipment when picking up otherwise fallback to wield animation.
	HolsterAnimationSelf          stingray.ThinHash      // [string]Name of the animation to play on the equipment when holstering.
	UnknownHash3                  stingray.ThinHash      // Unknown, name length 29
	EquipmentType                 enum.EquipmentType     // The category of this equipment piece, mostly used for AI purposes.
	DropMode                      enum.EquipmentDropMode // How the equipment should be treated when dropped.
	DropAudioEvent                stingray.ThinHash      // [wwise]Audio event to trigger when getting rid of an equipment.
	UnknownAudioEvent             stingray.ThinHash      // Unknown, name length 20, probably an audio event
	DropIconUi                    stingray.Hash          // Unknown, name length 12
	PickupAudioEvent              stingray.ThinHash      // [wwise]Audio event to trigger when putting on a new equipment.
	UnknownEvent2                 stingray.ThinHash      // Unknown, name length 21
	UnknownEvent3                 stingray.ThinHash      // Unknown, name length 33
	UnknownEvent4                 stingray.ThinHash      // Unknown, name length 32
	WeaponSwitchWieldAudioEvent   stingray.ThinHash      // [wwise]Audio event to trigger when wielding the weapon.
	WeaponSwitchHolsterAudioEvent stingray.ThinHash      // [wwise]Audio event to trigger when holstering the weapon.
	PickupAbility                 enum.AbilityId         // Ability to play when picking up from the ground. Currently only used for the avatar.
	DropAbility                   enum.AbilityId         // ability to play when dropping equipment
	GripType                      enum.WeaponGripType    // Grip type for this weapon.
	IsOneHanded                   uint8                  // [bool]Whether the weapon can be wielded in one hand or not.
	AllowWieldOnShip              uint8                  // [bool]If the weapon can be wielded while on the ship, only intended use for debug purposes.
	ShowInPickupWidget            uint8                  // [bool]True the equipment should be shown in the pickup widget.

	HolsterUnit             stingray.Hash            // [unit]Path to the holster unit. This is an additional unit to spawn on the holster node that doesn't move with the equipment. Useful for sheaths etc. Note that since it's an additional unit it's more expensive than building the sheath into the parent unit, so only use when needed.
	HintId                  stingray.ThinHash        // [string]Hint ID to trigger when equipping this equipment
	UnknownHash4            stingray.ThinHash        // Unknown, name length 14
	EquipmentWwiseIndex     enum.EquipmentWwiseIndex // the wwise item index for this equipment
	BackpackWwiseIndex      enum.BackpackWwiseIndex  // the wwise item index for this backpack if it is a backpack
	UseBackpackFilledSwitch uint8                    // [bool]If yes set_switch would be called on audio source before pickup drop foley and impact sounds

	UnknownHash5 stingray.ThinHash // Unknown, name length 22
	// contains filtered or unexported fields
}

type ErrorComponent struct {
	// contains filtered or unexported fields
}

type ExertionLevelInfo struct {
	Index                              enum.ExertionLevelIndex // The corresponding index to this level.
	ExertionThreshold                  float32                 // The Threshold of exertion that considers this level.
	SwayMultiplierScoped               float32                 // Multiplier to sway when scoped, changing its magnitude
	SwayMultiplierThirdperson          float32                 // Multiplier to sway in thirdperson, changing its magnitude
	SwayFrequencyMultiplierScoped      float32                 // Multiplier to sway when scoped, changing its frequency
	SwayFrequencyMultiplierThirdperson float32                 // Multiplier to sway in thirdperson, changing its frequency
	SwayRecoilMultiplierScoped         float32                 // Multiplier to sway when scoped, changing its recoil
	SwayRecoilMultiplierThirdperson    float32                 // Multiplier to sway in thirdperson, changing its recoil
	SwayInterpSpeed                    float32                 // The interpolation speed used for all sway values
	EnterAnimationEvent                stingray.ThinHash       // [string]The animation event to play when entering this exertion level.
	ExitAnimationEvent                 stingray.ThinHash       // [string]The animation event to play when exiting this exertion level.
	ExertionGrowsVo                    stingray.ThinHash       // [string]Breath Audio event
	ExertionRecoversVo                 stingray.ThinHash       // [string]Breath Audio event
}

type ExertionVoParams struct {
	OnDeath                  stingray.ThinHash // [string] audio event to play on death
	OnSpawn                  stingray.ThinHash // [string] audio event to play on spawn
	OnExertionStart          stingray.ThinHash // [string] audio event to play on exertion start
	OnExertionStop           stingray.ThinHash // [string] audio event to play on exertion stop
	OnBleedoutStop           stingray.ThinHash // [string] audio event to play on bleedout stop
	InjuryHpThreshold        float32           // injury_hp_threshold
	CriticalBleedHpThreshold float32           // critical_bleed_hp_threshold
}

type FactionComponent struct {
	Factions              [3]enum.FactionType   // Which factions this entity belongs to.
	TargetingNode         stingray.ThinHash     // [string]Node used for line of sight/aiming at entity.
	UnknownHashes         [4]stingray.Hash      // name length 28
	HalfWidth             float32               // Distance from which an enemy can attack you from the side.
	HalfForwardSize       float32               // Distance from which an enemy can attack you from the front or back.
	Priority              float32               // Used when selecting target
	UnknownFloat1         float32               // name length 22
	UnknownFloat2         float32               // name length 15
	ComplexTargetingNodes [16]stingray.ThinHash // [string]Multiple nodes specified for larger targets, such as vehicles
	UnknownBool           uint8                 // name length 17
	// contains filtered or unexported fields
}

type GetResourceFunc func(id stingray.FileID, typ stingray.DataType) (data []byte, exists bool, err error)

type HashLookup func(stingray.Hash) string

type HealthComponent struct {
	Health                   int32   // Max health
	HeathChangerate          float32 // How the health changes when not wounded, units per second
	HealthChangerateDisabled uint8   // [bool]If the regeneration is disabled

	HeathChangerateCooldown          float32 // How long after taking any damage to wait until we start regenerating.
	RegenerationSegments             uint32  // The number of segments for regeneration.
	RegenerationChangerate           float32 // How health changes in regeneration, units per seconds
	Constitution                     int32   // Negative health (after health is depleted the constitution ticks down until entity is dead)
	ConstitutionChangerate           float32 // The rate at which health is changed in constitution, units per second
	ConstitutionDisablesInteractions uint8   // [bool]Should interactions be disabled when this goes into constitution

	ZoneBleedoutChangerate float32       // The rate at which health is changed in constitution for zones, units per second
	Size                   enum.UnitSize // The size category of the unit, this is used for systems such as the gib system. Small = Humansized, Medium = Bug Warrior sized, Large = Tunneler, Massive = Even larger
	Mass                   float32       // The mass of the unit, this is used for systems such as vehicle collision damage calculations, when the unit is relying on a static or keyframed body.
	KillScore              uint32        // The score to accumulate when killing this.
	Wounded                WoundedState  // The effect wounds has on this character

	DefaultDamageableZoneInfo  DamageableZoneInfo // Contains information about default damage zone, which is used if no specific damage zone was hit
	DamageableZones            [38]DamageableZone // Contains all damage zones for the entity.
	ElementDamageValues        [4]ElementDamage
	Decay                      DecaySettings         // At least mode is required, for regular, more info may be needed
	DeathSoundIDs              [10]stingray.ThinHash // [wwise]Sounds to trigger when the entity experiences real death.
	TriggerDeathSoundsOnRemove uint8                 // [bool]Should this entity trigger death sounds if it gets removed?

	OnHitEffect       EffectSetting          // Particle effect to play when the entity gets hit by damage that is not dps.
	WhileLivingEffect [2]ActiveEffectSetting // Particle effects to play while the entity lives and is destroyed on death.
	OnDeathEffect     EffectSetting          // Particle effect to play when the entity dies.
	BledToDeathEffect EffectSetting          // Particle effect to play when the entity dies from bleeding out(cancels out the on_death_effect in that case).
	UnknownEffect     EffectSetting          // Unknown, 27 char long name
	RequireDemolition uint8                  // [bool]Does this entity require demolition damage to be damaged?

	DownedAnim                    stingray.ThinHash            // [string]Animation event that gets called when entering constitution.
	DeadAnim                      stingray.ThinHash            // [string]Animation event that gets called when entering death.
	UnknownFloat                  float32                      // Not sure, 31 char long name
	UnknownHash1                  stingray.ThinHash            // Unsure, 14 char name
	UnknownHash2                  stingray.ThinHash            // Unsure, 13 char name
	UnknownHash3                  stingray.ThinHash            // Unsure, 14 char name
	OnDownedHideVisibilityGroup   stingray.ThinHash            // [string]Visibility group to hide when this unit gets downed.
	OnDownedShowVisibilityGroup   stingray.ThinHash            // [string]Visibility group to show when this unit gets downed.
	OnDeadHideVisibilityGroup     stingray.ThinHash            // [string]Visibility group to hide when this unit dies.
	OnDeadShowVisibilityGroup     stingray.ThinHash            // [string]Visibility group to show when this unit dies.
	UnknownVisibilityGroupHashes  [4]stingray.ThinHash         // 29 char name, same as OnDead(Show/Hide)VisibilityGroup
	UnknownVisibilityGroupHashes2 [4]stingray.ThinHash         // 29 char name, same as OnDead(Show/Hide)VisibilityGroup
	UnknownDeathDestructionHash   stingray.ThinHash            // 26 char name, same as OnDeathDestructionLevel
	OnDeathDestructionLevel       enum.DestructionTemplateType // If this unit dies from the health component, then apply this level of destrction to itself from the destruction system
	CanDieNaturally               uint8                        // [bool]Normally if a unit takes enough damage, they'll die. If this is disabled, it will only go down to constitution and needs to be killed via outside forces, such as behavior.

	DeathPropagation enum.DeathPropagation // If this unit dies, It'll propagate the death to the selected inheritance direction selected in this field.
	UnknownHashArray [4]stingray.ThinHash  // Name length 17 chars
	UnknownBool1     uint8                 // Name length 33 chars
	UnknownBool2     uint8                 // Name length 18 chars
	UnknownBool3     uint8                 // Name length 30 chars
	// contains filtered or unexported fields
}

type HealthEventTrigger struct {
	HealthPercent     float32           // Health percent we need to go under in order to trip the event.
	EventName         stingray.ThinHash // [string]Event name that gets fired off to the behavior.
	UnknownEventName1 stingray.ThinHash // Could be animation, audio, bone, or other event name
	UnknownEventName2 stingray.ThinHash // Could be animation, audio, bone, or other event name
	UnknownEventName3 stingray.ThinHash // Could be animation, audio, bone, or other event name
}

type HeatsinkOverrides struct {
	HeatCapacity float32 // No clue really
	ProjType     enum.ProjectileType
	Particles    stingray.Hash
	MaybeEvent   stingray.ThinHash
	StatusEffect enum.StatusEffectType
}

type HelldiverCustomizationKit struct {
	Id               uint32
	DlcId            uint32
	SetId            uint32
	NameUpper        uint32
	NameCased        uint32
	Description      uint32
	Rarity           CustomizationKitRarity
	Passive          CustomizationKitPassive
	Archive          stingray.Hash
	Type             CustomizationKitType
	Unk00            uint32
	BodyArrayAddress int64
	BodyCount        int64
}

type HellpodComponent struct {
	HellpodVariant enum.HellpodVariant // What kind of hellpod is this? Used for determining special-case settings.
	UnknownBool    uint8               // Unknown, 15 chars long

	SpawnHeight                float32    // At what Z level should the hellpod spawn?
	UnknownVec                 mgl32.Vec2 // unknown, 22 chars long
	InitialVelocity            float32    // What's the initial velocity of the hellpod?
	BreakingHeight             float32    // How far above ground should we start breaking? [sic]
	BreakingVelocity           float32    // What's the breaking velocity of the hellpod? [sic]
	BreakingVelocityTargetTime float32    // How long until we reach our breaking velocity? [sic]
	UnknownBool2               uint8      // unknown, 24 chars long

	AudioThrustersIgniteLoop        stingray.ThinHash // [string][wwise]Thruster Ignite Sound Loop
	AudioThrustersIgniteEnd         stingray.ThinHash // [string][wwise]Thruster Ignite Sound End
	AudioThrustersIgnition          stingray.ThinHash // [string][wwise]Thruster Ignite Sound
	AudioEntryWooshLoop             stingray.ThinHash // [string][wwise]Woosh Sound Loop
	AudioEntryWooshEnd              stingray.ThinHash // [string][wwise]Woosh Sound End
	AudioChassiShakeLoop            stingray.ThinHash // [string][wwise]Chassi Shake Sound Loop
	AudioChassiShakeEnd             stingray.ThinHash // [string][wwise]Chassi Shake Sound End
	AudioSupersonicBoom             stingray.ThinHash // [string][wwise]Supersonic Boom Sound
	AudioImpact                     stingray.ThinHash // [string][wwise]Impact Sound
	AudioBoltBlowing                stingray.ThinHash // [string][wwise]Bolt Blowing Sound
	AudioLidBlowing                 stingray.ThinHash // [string][wwise]Lid Blowing Sound
	AudioThrusterStart              stingray.ThinHash // [string][wwise]Thruster Start Sound
	AudioHellpodPreImpactRiser      stingray.ThinHash // [string][wwise]Hellpod Preimpact Riser Sound
	AudioMusicHellpodGroundApproach stingray.ThinHash // [string][wwise]Music Hellpod Ground Approach Switch
	AudioMusicHellpodLand           stingray.ThinHash // [string][wwise]Music Hellpod Land Switch
	UnknownBool3                    uint8             // Unknown, name length 12 chars
	// contains filtered or unexported fields
}

type HellpodPayloadComponent struct {
	RemoveTime       float32        `json:"remove_time"`        // The time between playing the retraction animation event and removing the entity.
	LifeTime         float32        `json:"life_time"`          // The life time of this payload. 0 is infinite.
	OnRetractAbility enum.AbilityId `json:"on_retract_ability"` // Ability to play on this unit when it's retracted.
}

type HellpodRackComponent struct {
	Payloads         [8]RackAttach // Payloads to attach (what & where).
	LastRetractDelay float32       // Extra time deloy to play the retract functionality on the last retracting attachment.
	DisableRetract   uint8         // [bool]Special case to disable the retract animations from playing on both sides of the rack.

	MapIcon                   stingray.Hash     // [material]Map Icon for this hellpod rack
	MapName                   uint32            // [string]Localization tag for the map name of this hellpod rack
	RackDeployAudioEvent      stingray.ThinHash // [wwise]
	RackRetractAudioEvent     stingray.ThinHash // [wwise]
	DoorRetractAudioEvent     stingray.ThinHash // [wwise]
	DeployAbility             enum.AbilityId    // Ability to play when deploying.
	LastRetractAbility        enum.AbilityId    // Ability to play when we are out of items.
	RandomPayloadSize         uint32            // If we have a random payload size above 0, then we will attach random items from the payload settings. Override spawn_payload_size
	SpawnPayloadSize          uint32            // Indicates how many payloads should spawn from the settings list.
	DisableInitialInteraction uint8             // [bool]Should we prevent the initial interaction for the payload, meaning you have to destroy the rack in order to get them?
	// contains filtered or unexported fields
}

type HitZoneClassValues struct {
	Normal  float32 `json:"normal"`
	Durable float32 `json:"durable"`
}

type HudMarkerTypeOverride struct {
	Node                stingray.ThinHash  // [string]What node to look for on the unit.
	MaxHitPosDistance   float32            // Max distance between raycast hit and node position.
	MaxHitAngDifference float32            // Max angle difference (2D) between raycast dir and node forward.
	MaxFuzzyDistance    float32            // Max fuzzy distance for the override, a combination between distance and FOV.
	MarkerType          enum.HudMarkerType // Maximum amount rewarded per pick-up. [sic]
}

type InventoryComponent struct {
	DefaultPrimary     stingray.Hash // [adhd]Path to the primary equipment entity.
	DefaultSidearm     stingray.Hash // [adhd]Path to the sidearm equipment entity.
	DefaultSupport     stingray.Hash // [adhd]Path to the support equipment entity.
	DefaultThrowable   stingray.Hash // [adhd]Path to the throwable equipment entity.
	DefaultBackpack    stingray.Hash // [adhd]Path to the backpack entity.
	DefaultMeleeWeapon stingray.Hash // [adhd]Path to the melee entity.
	StartAmountStims   uint32        // max amount of stims. [sic]
	RefillAmountStims  uint32        // max amount of stims. [sic]
	MaxAmountStims     uint32        // max amount of stims.
	CanDropEquipment   uint8         // [bool]Indicates if this unit can drop the equipment or not

	UnknownHashArray [10]stingray.Hash // Unknown, name length 33
	// contains filtered or unexported fields
}

type LoadoutPackageComponent struct {
	BundleTag stingray.ThinHash // [string]The loadout package will be generated with this bundle tag. Has no runtime effect.

	Package                      stingray.Hash // [package]The loadout package to laod for this entity.
	AudioResource                stingray.Hash // [wwise_dep]The wwise bank to include in the package for this entity.
	IncludeDefaultCustomizations uint8         // [bool]If set any default customizations are included in the package generated for this .adhd file. Affects the entire package
	UnknownBool                  uint8         // [bool] unknown, 27 chars long
	// contains filtered or unexported fields
}

type LocalUnitComponent struct {
	UnitPath stingray.Hash // [unit]Path to the unit for this entity.
	Scale    float32       // Scale value.
}

type MagazinePattern struct {
	Projectiles     [32]enum.ProjectileType // Pattern of projectiles to fire. None denotes end if the full size is not used. Pattern is repeated and aligned so the last projectile in the pattern is always the last in the magazine (should it not divide evenly).
	FirstProjectile enum.ProjectileType     // to trigger start/stop event
}

type MaterialSwap struct {
	Name stingray.ThinHash // [string]The name of the swap.

	Material stingray.Hash // [material]The material to set.
	// contains filtered or unexported fields
}

type MaterialSwapComponent struct {
	MaterialSlots [8]MaterialSwapSlot  // Material slots that can be set
	EnemyNames    [8]stingray.ThinHash // name is guessed - name length 11
	EnemyTagSwaps [8]EnemyTagSwap
}

type MaterialSwapSlot struct {
	MaterialSlotName stingray.ThinHash // [string]The material slot to set on. If not set, then applied to all material slots.

	SwapSettings [8]MaterialSwap
	// contains filtered or unexported fields
}

type MaterialVariableAnimation struct {
	Name        stingray.ThinHash // [string]The name of the animation. Used to start and stop it from abilities.
	TargetValue mgl32.Vec4        // The target value to animate towards.
	Duration    float32           // The duration in seconds of the animation.
	Loops       uint32            // The amount of time this animation should loop, before ending. Setting it to 0 makes it infinite.
	AnimType    enum.MaterialVariableAnimationType
}

type MaterialVariableValue struct {
	Name  stingray.ThinHash
	Value mgl32.Vec4
}

type MaterialVariables struct {
	VariableName     stingray.ThinHash            // [string]The name of the material variable to set.
	MaterialSlotName stingray.ThinHash            // [string]The material slot to set on. If not set, then applied to all material slots.
	Type             enum.MaterialVariableType    // The type of the material variable to set.
	Value            mgl32.Vec4                   // The value to set on the material variable.
	Animations       [4]MaterialVariableAnimation // The animations that can be used on this variable.
	Values           [4]MaterialVariableValue     // The values that can be set on this variable
	UnknownBool1     uint8                        // unknown, name length 14
	UnknownBool2     uint8                        // unknown, name length 16
	// contains filtered or unexported fields
}

type MaterialVariablesComponent struct {
	Variables [8]MaterialVariables // Information about any variables that can be set / modified.
}

type MeleeAttackComponent struct {
	OverrideMeleeAbility         enum.AbilityId `json:"override_melee_ability"`           // If not invalid, it'll override the melee ability that gets executed while helding this entity, this could be a weapon, an attachment or a carryable.
	Weight                       uint32         `json:"weight"`                           // Used to indicate how much weight this override has when trying to pick the final override_melee_ability
	OverrideMeleeAbilityForProne enum.AbilityId `json:"override_melee_ability_for_prone"` // If not invalid, it'll override the melee ability that gets executed while being prone and helding this entity, this could be a weapon, an attachment or a carryable.
	WeightForProne               uint32         `json:"weight_for_prone"`                 // Used to indicate how much weight this override has when trying to pick the final override_melee_ability_for_prone
}

type MountComponent struct {
	Infos [5]MountInfo // Path and node info for each entity to mount.
}

type MountInfo struct {
	Path       stingray.Hash     // [adhd]Path to the adhd-entity to mount.
	AttachNode stingray.ThinHash // [string]Node where to attach the adhd-entity.
	MountSide  enum.MountSide    // Is this mounted on the left side of the parent, the right side of the parent, or neither side in particular?
	Name       stingray.ThinHash // [string]The name to use in scripts to refer to this mount.
	// contains filtered or unexported fields
}

type MoveInfo struct {
	Speeds                     MoveSpeeds `json:"speeds"`                        // Information about motion speed in the different states.
	SprintStaminaDecayDuration float32    `json:"sprint_stamina_decay_duration"` // The duration it takes for stamina to decay all the way to 0 when sprinting
	JogStaminaDecayDuration    float32    `json:"jog_stamina_decay_duration"`    // The duration it takes for stamina to decay all the way to 0 when jogging
	StaminaRecoverTimeStand    float32    `json:"stamina_recover_time_stand"`    // The duration until stamina is fully recovered while in stand
	StaminaRecoverTimeCrouch   float32    `json:"stamina_recover_time_crouch"`   // The duration until stamina is fully recovered while in crouch
	StaminaRecoverTimeProne    float32    `json:"stamina_recover_time_prone"`    // The duration until stamina is fully recovered while in prone
	StaminaRecoverDelay        float32    `json:"stamina_recover_delay"`         // The duration until stamina starts recovering
	StaminaCostJump            float32    `json:"stamina_cost_jump"`             // The stamina cost of jumping
	StaminaCostDodge           float32    `json:"stamina_cost_dodge"`            // The stamina cost of dodging
	StaminaCostVault           float32    `json:"stamina_cost_vault"`            // The stamina cost of vaulting
	StaminaCostClimb           float32    `json:"stamina_cost_climb"`            // The stamina cost of climbing
	StaminaCostSlide           float32    `json:"stamina_cost_slide"`            // The stamina cost of sliding
	VisibilityJump             float32    `json:"visibility_jump"`               // The stamina cost of jumping
	VisibilityDodge            float32    `json:"visibility_dodge"`              // The stamina cost of dodging
	VisibilityVault            float32    `json:"visibility_vault"`              // The stamina cost of vaulting
	VisibilityClimb            float32    `json:"visibility_climb"`              // The stamina cost of climbing
	VisibilitySlide            float32    `json:"visibility_slide"`              // The stamina cost of sliding
	HipfireTime                float32    `json:"hipfire_time"`                  // The time that the avatar remains in hipfire.
	ThrowHipfireTime           float32    `json:"throw_hipfire_time"`            // The time that the avatar remains in hipfire after throws.
	CrouchTurnSpeedMultiplier  float32    `json:"crouch_turn_speed_multiplier"`  // The turn speed multiplier used when crouching
	ProneTurnSpeedMultiplier   float32    `json:"prone_turn_speed_multiplier"`   // The turn speed multiplier used when prone
	JogTurnSpeedMultiplier     float32    `json:"jog_turn_speed_multiplier"`     // The turn speed multiplier used when jogging
	SprintTurnSpeedMultiplier  float32    `json:"sprint_turn_speed_multiplier"`  // The turn speed multiplier used when sprinting
	DownedTurnSpeedMultiplier  float32    `json:"downed_turn_speed_multiplier"`  // The turn speed multiplier used when downed
	SwimTurnSpeedMultiplier    float32    `json:"swim_turn_speed_multiplier"`    // The turn speed multiplier used when swimming
	SprintNoiseRadius          float32    `json:"sprint_noise_radius"`           // The noise radius when sprinting, enemies within range will be alerted
}

type MoveSpeeds struct {
	ReversingMultiplier float32 `json:"reversing_multiplier"` // A multiplier to movement speed when moving backwards.
	Aim                 float32 `json:"aim"`                  // Movement speed when aiming.
	Walk                float32 `json:"walk"`                 // Movement speed when walking.
	Jog                 float32 `json:"jog"`                  // Movement speed when jogging.
	Sprint              float32 `json:"sprint"`               // Movement speed when sprinting.
	SprintExerted       float32 `json:"sprint_exerted"`       // Movement speed when sprinting exerted.
	CrouchAim           float32 `json:"crouch_aim"`           // Movement speed when crouch aiming.
	CrouchWalk          float32 `json:"crouch_walk"`          // Movement speed when crouching.
	CrouchJog           float32 `json:"crouch_jog"`           // Movement speed when crouching.
	CrouchSprint        float32 `json:"crouch_sprint"`        // Movement speed when starting to crouch sprint.
	Prone               float32 `json:"prone"`                // Movement speed when in prone (or downed).
	Swim                float32 `json:"swim"`                 // Movement speed when swimming.
}

type OpticSetting struct {
	OpticsFunction enum.WeaponFunctionType
	SomeHash       stingray.ThinHash
	CrosshairValue enum.CrosshairWeaponType
}

type Piece struct {
	Path              stingray.Hash
	Slot              CustomizationKitSlot
	Type              CustomizationKitPieceType
	Weight            CustomizationKitWeight
	Unk00             uint32
	MaterialLut       stingray.Hash
	PatternLut        stingray.Hash
	CapeLut           stingray.Hash
	CapeGradient      stingray.Hash
	CapeNac           stingray.Hash
	DecalScalarFields stingray.Hash
	BaseData          stingray.Hash
	DecalSheet        stingray.Hash
	ToneVariations    stingray.Hash
}

type ProjectileMultipliers struct {
	SpeedMultiplierMin              float32 `json:"speed_multiplier_min"`              // The value to multiply the projectile speed with when at the smallest charge amount.
	SpeedMultiplierOvercharge       float32 `json:"speed_multiplier_overcharge"`       // The value to multiply the projectile speed with when fully overcharged.
	DamageMultiplierMin             float32 `json:"damage_multiplier_min"`             // The value to multiply the projectile damage with when at the smallest charge amount.
	DamageMultiplierOvercharge      float32 `json:"damage_multiplier_overcharge"`      // The value to multiply the projectile damage with when fully overcharged.
	PenetrationMultiplierMin        float32 `json:"penetration_multiplier_min"`        // The value to multiply the projectile penetration with when at the smallest charge amount.
	PenetrationMultiplierOvercharge float32 `json:"penetration_multiplier_overcharge"` // The value to multiply the projectile penetration with when fully overcharged.
	DistanceMultiplerMin            float32 `json:"distance_multipler_min"`            // The value to multiply the arc distance with when at the smallest charge amount.
	DistanceMultiplerOvercharge     float32 `json:"distance_multipler_overcharge"`     // The value to multiply the arc distance with when fully overcharged.
	ExtraArcSplitsMin               float32 `json:"extra_arc_splits_min"`              // The amount of extra splits this arc can do with minimum charge amount.
	ExtraArcSplitsOvercharge        float32 `json:"extra_arc_splits_overcharge"`       // The amount of extra splits this arc can do when fully overcharged.
	ExtraArcChainsMin               float32 `json:"extra_arc_chains_min"`              // The amount of extra chains this arc can do with minimum charge amount.
	ExtraArcChainsOvercharge        float32 `json:"extra_arc_chains_overcharge"`       // The amount of extra chains this arc can do when fully overcharged.
}

type ProjectileWeaponComponent struct {
	ProjType           enum.ProjectileType // Type of projectile it fires.
	RoundsPerMinute    mgl32.Vec3          // Rounds per minute depending on weapon setting. Y is the default ROF.
	ZeroingSlots       mgl32.Vec3          // The zeroing distances of the weapon.
	ZeroingHipfire     float32             // The default zeroing distance while not aiming a weapon
	CurrentZeroingSlot uint32              // The slot in the zeroing distances to use by default.
	InfiniteAmmo       uint8               // [bool]True if this projectile weapon can never run out of ammo.

	ProjectileEntity      stingray.Hash     // [adhd]If this is set an entity is spawned when firing instead of adding a projectile to the projectile manager.
	UseFirenodePose       float32           // This may not be correct, the type has changed since the last time this member had a name
	HeatBuildup           WeaponHeatBuildup // Controls visual heat effects on the weapon.
	ScaleDownUsedFireNode uint8             // [bool]If set, scale down the used fire node to zero (in order to hide a rocket for example)

	OnRoundFiredShakes     WeaponCameraShakeInfo   // Settings for local and in-world camera shakes to play on every round fired.
	NumLowAmmoRounds       uint32                  // Number of rounds to play the low ammo effects
	LowAmmoAudioEvent      stingray.ThinHash       // [string]Audio event to play in addition to the regular firing audio when low on ammo.
	LastBulletAudioEvent   stingray.ThinHash       // [string]Audio event to play in addition to the regular firing audio for the last bullet.
	LastBulletOwnerVOEvent stingray.ThinHash       // [string]VO event to play on the owner of the weapon when the last bullet has been fired.
	WindEffect             enum.WindEffectTemplate // Wind effect template to play when firing.
	SpeedMultiplier        float32                 // Projectile speed multiplier.
	DamageAddends          HitZoneClassValues      // Damage to add to the projectile's value for each damage class. Used by weapon customizaitons.
	APAddends              HitZoneClassValues      // Armor penetration to add to the projectile's value for each damage class. Used by weapon customizaitons.
	SpinupTime             float32                 // Time from 'start fire' to first projectile firing
	RPCSyncedFireEvents    uint8                   // [bool]ONLY USE FOR SINGLE-FIRE/SLOW FIRING WEAPONS. Primarily useful for sniper rifles, explosive one-shots etc. that need the firing event to be highly accurately synced!

	CasingEject        WeaponCasingEffectInfo // Particle effect of the shellcasing.
	MuzzleFlash        stingray.Hash          // [particles]Particle effect of the muzzle flash, played on attach_muzzle.
	ShockwaveType      enum.SurfaceImpactType // The surface effect to play normal to the ground underneath the muzzle.
	UseFaintShockwave  uint8                  // [bool]If true, a small shockwave is played when [1m, 2m] from the ground instead of the regular one.
	UseMidiEventSystem uint8                  // [bool]Fire event will be posted using Wwise's MIDI system as a MIDI sequence (cannot be paused/resumed).

	MidiTimingRandomization        mgl32.Vec2        // Events posted during the MIDI sequence will have a random time offset, measured in milliseconds.
	MidiStopDelay                  float32           // A delay for when to notify Wwise that the MIDI sequence has stopped, measured in milliseconds.
	FireLoopStartAudioEvent        stingray.ThinHash // [wwise]The looping audio event to start when starting to fire.
	FireLoopStopAudioEvent         stingray.ThinHash // [wwise]The looping audio event to play when stopping fire.
	FireSingleAudioEvent           stingray.ThinHash // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	FireReflectAudioEvent          stingray.ThinHash // [wwise]The audio event to trigger to simulate an early reflection.
	SilencedFireReflectAudioEvent  stingray.ThinHash // [wwise]The audio event to trigger to simulate an early reflection, with silencer equipped.
	HapticsFireLoopStartAudioEvent stingray.ThinHash // [wwise]The looping audio event to start when starting to fire.
	HapticsFireLoopStopAudioEvent  stingray.ThinHash // [wwise]The looping audio event to play when stopping fire.
	HapticsFireSingleAudioEvent    stingray.ThinHash // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).

	FireLoopCameraShake             stingray.Hash     // [camera_shake]The camera shake to run when firing
	FireLoopCameraShakeRadius       mgl32.Vec2        // Inner/outer camera shake radiuses when firing.
	SilencedFireLoopStartAudioEvent stingray.ThinHash // [wwise]The looping audio event to start when starting to fire with suppressor.
	SilencedFireLoopStopAudioEvent  stingray.ThinHash // [wwise]The looping audio event to play when stopping fire with suppressor.
	SilencedFireSingleAudioEvent    stingray.ThinHash // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds) with suppressor.
	FireSourceNode                  stingray.ThinHash // [string]The node to play the firing audio events at.
	DryFireAudioEvent               stingray.ThinHash // [wwise]The wwise sound id to play when dry firing.
	DryFireRepeatAudioEvent         stingray.ThinHash // [wwise]The wwise sound id to play when repeatedly dry firing.
	HeatPercentageMaterialVariable  stingray.ThinHash // [string]The material variable to try to set on each mesh when heat is updated
	Silenced                        uint8             // [bool]If this weapon should use the silenced sound or not. Used by / overridden by customization

	AimZeroingQuality         enum.ProjectileZeroingQuality // How well to attempt to compensate for drag when aiming. Defaults to High (8 iterations). Set to None to ignore drag.
	CasingEjectDisabledOnFire uint8                         // [bool]Turns off casing ejection/effects when firing the weapon.

	BurstFireRate                float32             // If above 0, the fire rate will be changed to this, when the weapon is set to Burst.
	WeaponFunctionMuzzleVelocity float32             // If we have the Muzzle Velocity weapon function and we switch to it, what should our projectile velocity be?
	WeaponFunctionProjectileType enum.ProjectileType // If we have the Programmable Ammo weapon function and we switch to it, what should our projectile type be?
	UnknownParticleHash          stingray.Hash       // added after strings removed
	UnknownBool                  uint8               // added after strings removed
	// contains filtered or unexported fields
}

type RackAttach struct {
	Item                  stingray.Hash
	Node                  stingray.ThinHash // [string]Node where to attach the hellpod rack payload.
	Offset                mgl32.Vec3        // Offset from 'node'.
	RotationOffset        mgl32.Vec3        // Rotation offset from 'node' in degrees.
	DeployAnimationEvent  stingray.ThinHash // [string]Animation to play when deploying this attach.
	RetractAnimationEvent stingray.ThinHash // [string]Animation to play when retracting this attach.
	RetractAudioEvent     stingray.ThinHash // [wwise]
	ApplyDeltas           uint8             // [bool]If true, apply any stratagem customization deltas to this entity when spawning.

	RackSide    enum.RackSide // Is this item on the left or right side of the rack? Cannot be left on None.
	UnknownBool uint8         // [bool]Unknown, name length 25
	// contains filtered or unexported fields
}

type RecoilComponentInfo struct {
	HorizontalRecoil float32    `json:"horizontal_recoil"` // Defined in degrees / second, first value is first shot, second value is when rounds fired.
	VerticalRecoil   float32    `json:"vertical_recoil"`   // Defined in degrees / second, first value is first shot, second value is when rounds fired.
	HorizontalBias   float32    `json:"horizontal_bias"`   // In format Start / End: How much the recoil is biased, 0 is center.
	RandomAmount     mgl32.Vec2 `json:"random_amount"`     // How much of the drift is random per axis. (0-1). Default 10% for vertical and 100% for horizontal. Higher values means larger range (1 is full).
}

type RecoilInfo struct {
	Drift    RecoilComponentInfo `json:"drift"`         // In what way the gun is affected by the recoil.
	Climb    RecoilComponentInfo `json:"climb"`         // In what way the camera is affected by the recoil.
	UnkFloat float32             `json:"unknown_float"` // Might be a weight or something
}

type RecoilModifiers struct {
	HorizontalMultiplier      float32 `json:"horizontal_multiplier"`       // This is both applied to climb and drift, and to both start and end values of recoil
	VerticalMultiplier        float32 `json:"vertical_multiplier"`         // This is both applied to climb and drift, and to both start and end values of recoil.
	DriftHorizontalMultiplier float32 `json:"drift_horizontal_multiplier"` // This applies only to drift recoil values, and to both start and end values of recoil
	DriftVerticalMultiplier   float32 `json:"drift_vertical_multiplier"`   // This applies only to drift recoil values, and to both start and end values of recoil.
	ClimbHorizontalMultiplier float32 `json:"climb_horizontal_multiplier"` // This applies only to climb recoil values, and to both start and end values of recoil
	ClimbVerticalMultiplier   float32 `json:"climb_vertical_multiplier"`   // This applies only to climb recoil values, and to both start and end values of recoil
}

type SeekingMissileComponent struct {
	TargetingMode           enum.SeekingMissileTargetingMode // Determines which targeting mode is used.
	UnknownFloat            float32                          // name length 19, maybe targeting_mode_time?
	AutoplayStartingEffects uint8                            // [bool]If disabled, the missile wont play the audio and trail FX.

	TimeToEnableGuidance                        float32           // Time that it takes to enable guidance, 0 means will be enable from the start, -1 means that we should enable it manually.
	TimeToDisableGuidance                       float32           // Time that it takes to disable guidance, 0 means will be disable from the start, -1 means that we should disable it manually.
	UnknownFloat2                               float32           // name length 27
	UnknownFloat3                               float32           // name length 28
	AngleLostGuidance                           float32           // [0,180] - If the angle between the target and the missile exceeds this, disable guidance
	MovementPredictionAccuracy                  float32           // [0,1] - How much the missile is predicting the point of impact depending on current target velocity (1 is best prediction)
	TimeToEnableMovement                        float32           // Time that it takes to enable movement, 0 means will be enable from the start, -1 means that we should enable it manually.
	TimeToEnableExplosive                       float32           // Time that it takes to enable explosive, 0 means will be enable from the start, -1 means that we should enable it manually.
	MaxLifetime                                 float32           // Time before the missile blows itself up. Set to 0 or lower to disable and have the missile live forever.
	StartingSpeed                               float32           // The speed at which the missile launches at.
	MinimumSpeed                                float32           // The minimum speed at which this missile can travel.
	PreferredSpeed                              float32           // The target speed at which this missile wants to travel.
	Acceleration                                float32           // The missile's speed acceleration.
	MaxAngleToTarget                            float32           // The missile will be at its slowest but turn the fastest at or above this angle to the target.
	MinTurnSpeed                                float32           // How fast this missile can turn while going at its preferred speed.
	MaxTurnSpeed                                float32           // How fast this missile can turn while going at its slowest speed.
	PFactor                                     float32           // How much of the difference in current and target speed to consider when changing speed.
	IFactor                                     float32           // How much of the speed difference over time to consider.
	DFactor                                     float32           // How much of the speed delta to consider.
	TargetUpdateInterval                        float32           // How often do we update our target?
	MissileTrail                                EffectSetting     // Particle effect trail that gets attached to the missile.
	MissileTrailAudioEvent                      stingray.ThinHash // [wwise]What audio event to play when the missile is fired.
	MissileTrailAudioEventStop                  stingray.ThinHash // [wwise]What audio event to play when the missile has exploded.
	TargetDotMinimum                            float32           // What's the minimum dot product between the current forward of this entity and its target position before we can update the position? -1 to disable.
	JavelinFiringMode                           uint8             // [bool]When enabled, the missile that is fired will curve up and then down.
	MovementShouldBeProcessedByProjectileSystem uint8             // [bool]If set, the projectile system will handle collision/explosions/damages/vfx/sfx getting that data from the projectile setting.

	ProjectileTypeToProcess enum.ProjectileType             // The projectile type that it should process by the projectile manager, if it set to none it should be passed through the spawn context.
	Deviation               SeekingMissileDeviationSettings // A struct containing info about missile deviations
	UnknownFloat4           float32                         // Name length 31
	UnknownHash             stingray.ThinHash               // Name length 28
	UnknownBool             uint8                           // Name length 23
	UnknownBool2            uint8                           // Name length 28

	UnknownFloat5 float32 // Name length 35
	UnknownFloat6 float32 // Name length 35
	// contains filtered or unexported fields
}

type SeekingMissileDeviationSettings struct {
	Enabled uint8 // [bool] Not 100% sure this is correct, but it matches the name length and would make sense

	MinSeekingDeviation float32    // Not sure, name length 21
	MaxSeekingDeviation float32    // Not sure, name length 21
	UnkFloat3           float32    // Not sure, name length 21
	UnkFloat4           float32    // Not sure, name length 21
	UnkVector           mgl32.Vec3 // Name length 27
	UnkVector2          mgl32.Vec3 // Name length 27
	UnkBool             uint8      // Name length 38

	UnkFloat5 float32 // Name length 29
	UnkFloat6 float32 // Name length 21
	UnkFloat7 float32 // Name length 18
	UnkFloat8 float32 // Name length 22
	UnkFloat9 float32 // Name length 39
	// contains filtered or unexported fields
}

type SimpleActiveEffectSetting struct {
	ID           string              `json:"id"`
	StartEnabled bool                `json:"start_enabled"`
	Effect       SimpleEffectSetting `json:"effect"`
}

type SimpleAnimationComponent struct {
	MergeOptions                 AnimationMergeOptions     `json:"merge_options"`
	Variables                    []SimpleAnimationVariable `json:"variables,omitempty"`
	HotjoinSyncAnimationTime     bool                      `json:"hotjoin_sync_animation_time"`
	IgnoreInvisibileUnitsForLods bool                      `json:"ignore_invisible_units_for_lods"`
}

type SimpleAnimationVariable struct {
	Name  string  `json:"name"`
	Value float32 `json:"value"`
}

type SimpleArcWeaponComponent struct {
	Type                        enum.ArcType                `json:"arc_type"`                        // Type of arc it fires
	RoundsPerMinute             float32                     `json:"rounds_per_minute"`               // Rounds per minute depending on weapon setting.
	InfiniteAmmo                bool                        `json:"infinite_ammo"`                   // [bool]True if this projectile weapon can never run out of ammo.
	RPCSyncedFireEvents         bool                        `json:"rpc_synced_fire_events"`          // [bool]ONLY USE FOR SINGLE-FIRE/SLOW FIRING WEAPONS. Primarily useful for sniper rifles, explosive one-shots etc. that need the firing event to be highly accurately synced!
	FireSingleAudioEvent        string                      `json:"fire_single_audio_event"`         // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	UnknownHash                 string                      `json:"unknown_event"`                   // Unknown, name length 27
	FireFailAudioEvent          string                      `json:"fire_fail_audio_event"`           // [wwise]The audio event to trigger when the arc fails to hit anything on the first shot.
	HapticsFireSingleAudioEvent string                      `json:"haptics_fire_single_audio_event"` // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	FireSourceNode              string                      `json:"fire_source_node"`                // [string]The node to play the firing audio events at.
	OnRoundFiredShakes          SimpleWeaponCameraShakeInfo `json:"on_round_fired_shakes"`           // Settings for local and in-world camera shakes to play on every round fired.
	MuzzleFlash                 string                      `json:"muzzle_flash"`                    // [particles]Particle effect of the muzzle flash, played on attach_muzzle.
	MuzzleFlashFail             string                      `json:"muzzle_flash_fail"`               // [particles]Particle effect of the muzzle flash, when the arc weapon fails to hit, played on attach_muzzle.
}

type SimpleAttachableComponent struct {
	DynamicActor                string     `json:"dynamic_actor"`
	AttachedDynamicActor        string     `json:"attached_dynamic_actor"`
	UseAllDynamicActors         bool       `json:"use_all_dynamic_actors"`
	Offset                      mgl32.Vec3 `json:"offset"`
	RotationOffset              mgl32.Vec3 `json:"rotation_offset"`
	OffsetNode                  string     `json:"offset_node"`
	AttachAnim                  string     `json:"attach_anim"`
	ParentAttachAnim            string     `json:"parent_attach_anim"`
	DetachAnim                  string     `json:"detach_anim"`
	ParentDetachAnim            string     `json:"parent_detach_anim"`
	AffectScale                 bool       `json:"affect_scale"`
	IgnoreWeaponDamageForParent bool       `json:"ignore_weapon_damage_for_parent"`
	InheritAngularMomentum      bool       `json:"inherit_angular_momentum"`
	UnknownBool1                bool       `json:"unknown_bool1"`
	UnknownBool2                bool       `json:"unknown_bool2"`
	UnknownBool3                bool       `json:"unknown_bool3"`
}

type SimpleAvatarComponent struct {
	InputInfo                    AvatarInputSettings                 `json:"input_info"`                       // Contains information about avatar input handling
	MovementInfo                 MoveInfo                            `json:"movement_info"`                    // Contains information about avatar movement
	SteepSlopeMovement           SteepSlopeMovementInfo              `json:"steep_slope_movement"`             // Contains information about avatar movement in steep slopes
	SlideMovementInfo            ActionSlideMovementInfo             `json:"slide_movement_info"`              // Contains information about the avatar action slide
	ClimbInformation             ClimbInfo                           `json:"climb_information"`                // Contains information about avatar climbing behaviour
	ShortThrowInfo               ThrowInfo                           `json:"short_throw_info"`                 // Contains information about throwing stuff underhand.
	LongThrowInfo                ThrowInfo                           `json:"long_throw_info"`                  // Contains information about throwing stuff overhand.
	DetectInfo                   DetectionInfo                       `json:"detect_info"`                      // Contains information about stealth and being detected.
	WeatheringSettings           AvatarWeatheringSettings            `json:"weathering_settings"`              // Contains information about how fast dirt and wear and tear is added to the avatar.
	MovementHaptics              SimpleAvatarMovementHapticsSettings `json:"movement_haptics"`                 // Contains information about the avatar's movement haptics.
	ExertionLevels               []SimpleExertionLevelInfo           `json:"exertion_levels"`                  // The different levels of exertion levels.
	ExertionVoiceOverParams      SimpleExertionVoParams              `json:"exertion_voice_over_params"`       // Different VO Events
	HealSelfDuration             float32                             `json:"heal_self_duration"`               // The duration in seconds it takes to heal yourself.
	HealSelfDecayWaitTime        float32                             `json:"heal_self_decay_wait_time"`        // The duration in seconds to wait before starting to decaying healing progress.
	HealSelfDecayRate            float32                             `json:"heal_self_decay_rate"`             // The rate at which your healing progress decays if not healing.
	HealSelfCancelDamageAmount   float32                             `json:"heal_self_cancel_damage_amount"`   // The amount of damage you take for cancelling healing.
	RagdollDamageVelocityLower   float32                             `json:"ragdoll_damage_velocity_lower"`    // The lower value at which our limbs deal ragdoll damage.
	RagdollDamageVelocityUpper   float32                             `json:"ragdoll_damage_velocity_upper"`    // The upper value at which our limbs deal ragdoll damage.
	RagdollDamageMin             float32                             `json:"ragdoll_damage_min"`               // The lowest amount of ragdoll damage we deal.
	RagdollDamageMax             float32                             `json:"ragdoll_damage_max"`               // The highest amount of ragdoll damage we deal.
	RagdollDamageSnowModifier    float32                             `json:"ragdoll_damage_snow_modifier"`     // The modifier which we decrease ragdoll damage in snow by.
	MinAimDuration               float32                             `json:"min_aim_duration"`                 // Time it takes to aim at max ergonomics level
	MaxAimDuration               float32                             `json:"max_aim_duration"`                 // Time it takes to aim at min ergonomics level
	MinFireReadyDuration         float32                             `json:"min_fire_ready_duration"`          // Time it takes to get ready to fire a shot at max ergonomics level
	MaxFireReadyDuration         float32                             `json:"max_fire_ready_duration"`          // Time it takes to get ready to fire a shot at min ergonomics level
	TauntTimeBeforeDrain         float32                             `json:"taunt_time_before_drain"`          // Time it takes for the taunt probability to start draining
	TauntDrainPerSecond          float32                             `json:"taunt_drain_per_second"`           // How much of the taunt probability we drain per second
	TauntOnTriggerProbabilityMul float32                             `json:"taunt_on_trigger_probability_mul"` // By how much do we multiply the probability upon a successful taunt?
	TauntCooldownTimer           float32                             `json:"taunt_cooldown_timer"`
}

type SimpleAvatarMovementHapticsSettings struct {
	LeftSprinting  string `json:"left_sprinting"`  // [wwise]Left sprinting haptic
	RightSprinting string `json:"right_sprinting"` // [wwise]Right sprinting haptic
	LeftJogging    string `json:"left_jogging"`    // [wwise]Left jogging haptic
	RightJogging   string `json:"right_jogging"`   // [wwise]Right jogging haptic
	LeftWalking    string `json:"left_walking"`    // [wwise]Left walking haptic
	RightWalking   string `json:"right_walking"`   // [wwise]Right walking haptic
	LeftCrouching  string `json:"left_crouching"`  // [wwise]Left crouching haptic
	RightCrouching string `json:"right_crouching"` // [wwise]Right crouching haptic
	LeftCrawling   string `json:"left_crawling"`   // [wwise]Left crawling haptic
	RightCrawling  string `json:"right_crawling"`  // [wwise]Right crawling haptic
}

type SimpleBeamWeaponComponent struct {
	Type                          enum.BeamType `json:"beam_type"`
	Prisms                        BeamPrisms    `json:"beam_prisms"`
	ScopeResponsiveness           float32       `json:"scope_responsiveness"`
	ScopeCrosshair                mgl32.Vec2    `json:"scope_crosshair"`
	FocalDistances                mgl32.Vec3    `json:"focal_distances"`
	UseFirenodePose               float32       `json:"use_firenode_pose"`
	UseMidiEventSystem            bool          `json:"use_midi_event_system"`
	MidiTimingRandomization       mgl32.Vec2    `json:"midi_timing_randomization"`
	MidiStopDelay                 float32       `json:"midi_stop_delay"`
	FireLoopStartAudioEvent       string        `json:"fire_loop_start_audio_delay"`
	FireLoopStopAudioEvent        string        `json:"fire_loop_stop_audio_event"`
	FireSingleAudioEvent          string        `json:"fire_single_audio_event"`
	MuzzleFlash                   string        `json:"muzzle_flash"`
	NoiseTimer                    float32       `json:"noise_timer"`
	FireSourceNode                string        `json:"fire_source_node"`
	DryFireAudioEvent             string        `json:"dry_fire_audio_event"`
	DryFireRepeatAudioEvent       string        `json:"dry_fire_repeat_audio_event"`
	OnFireStartedWielderAnimEvent string        `json:"on_fire_started_wielder_anim_event"`
	OnFireStoppedWielderAnimEvent string        `json:"on_fire_stopped_wielder_anim_event"`
}

type SimpleCharacterNameComponent struct {
	Race               enum.RaceType `json:"race"`
	RandomNameTemplate string        `json:"random_name_template"`
	CharacterName      string        `json:"character_name"`
	UsePersistentSeed  bool          `json:"use_persistent_seed"`
}

type SimpleDamageableZone struct {
	Info   SimpleDamageableZoneInfo `json:"info"`             // Damageable Zone Info
	Actors []string                 `json:"actors,omitempty"` // [string]Damageable Zone Actors
}

type SimpleDamageableZoneInfo struct {
	OnDeadEffect                       SimpleEffectSetting            `json:"on_dead_effect"`                           // Particle effect to play when this damage zone dies
	OnDownedEffect                     SimpleEffectSetting            `json:"on_downed_effect"`                         // Particle effect to play when this damage zone gets downed.
	ZoneName                           string                         `json:"zone_name"`                                // [string]The name of this zone
	OnDeadScriptEvent                  string                         `json:"on_dead_script_event"`                     // [string]The script event to trigger when this damage zone dies.
	OnDeadAnimationEvent               string                         `json:"on_dead_animation_event"`                  // [string]The animation event to trigger when this damage zone dies.
	OnDeadUnknownEvent                 string                         `json:"on_dead_unknown_event"`                    // Some event grouped with other on dead events with a name length of 31 chars.
	OnDeadAudioEvent                   string                         `json:"on_dead_audio_event"`                      // [wwise]The audio event to trigger when this damage zone dies.
	OnDeadAudioEventNode               string                         `json:"on_dead_audio_event_node"`                 // [string]The audio node to use when this damage zone dies.
	OnDeadUnknownBool                  bool                           `json:"on_dead_unknown_bool"`                     // An unknown bool with a name length of 34 chars
	OnDeadHideVisiblityGroup           string                         `json:"on_dead_hide_visiblity_group"`             // [string]Visibility group to hide when this damage zone dies.
	OnDeadShowVisiblityGroup           string                         `json:"on_dead_show_visiblity_group"`             // [string]Visibility group to show when this damage zone dies.
	OnDeadHideVisiblityMask            string                         `json:"on_dead_hide_visiblity_mask"`              // [string]Visibility mask to hide when this damage zone dies.
	OnDeadShowVisiblityMask            string                         `json:"on_dead_show_visiblity_mask"`              // [string]Visibility mask to show when this damage zone dies.
	OnDownedHideVisiblityMask          string                         `json:"on_downed_hide_visiblity_mask"`            // [string]Visibility mask to hide when this damage zone gets downed.
	OnDownedShowVisiblityMask          string                         `json:"on_downed_show_visiblity_mask"`            // [string]Visibility mask to show when this damage zone gets downed.
	DestroyedAssignmentEvent           string                         `json:"destroyed_assignment_event"`               // [string]Assignment event tag to send when destroyed, either once when killed or once when entering downed state
	OnDeadLocomotionSet                string                         `json:"on_dead_locomotion_set"`                   // [string]The name of the locomotion set to activate when it dies. It will not trigger if another zone that affects locomotion is dead. In this case the locomotion set 'crawling' will be triggered.
	OnHitScriptEvent                   string                         `json:"on_hit_script_event"`                      // [string]The script event to trigger when this damage zone gets hit without taking damage.
	OnBleedoutScriptEvent              string                         `json:"on_bleedout_script_event"`                 // [string]The script event to trigger when this damage zone gets bled out.
	OnDownedScriptEvent                string                         `json:"on_downed_script_event"`                   // [string]The script event to trigger when this damage zone goes into constitution.
	OnHealScriptEvent                  string                         `json:"on_heal_script_event"`                     // [string]The script event to trigger when this damage zone gets healed.
	OnDownedAudioEvent                 string                         `json:"on_downed_audio_event"`                    // [wwise]The audio event to trigger when this damage zone goes into constitution.
	OnDownedAudioEventNode             string                         `json:"on_downed_audio_event_node"`               // [string]The audio node to use when this damage zone goes into constitution.
	OnDownedLocomotionSet              string                         `json:"on_downed_locomotion_set"`                 // [string]The name of the locomotion set to activate when it goes into constitution. It will not trigger if another zone that affects locomotion is dead. In this case the locomotion set 'crawling' will be triggered.
	OnDamageScriptEvent                string                         `json:"on_damage_script_event"`                   // [string]The script event to trigger when this damage zone takes damage.
	DamageMultiplier                   enum.DamageMultiplier          `json:"damage_multiplier"`                        // Damage Multiplier
	DamageMultiplierDPS                enum.DamageMultiplier          `json:"damage_multiplier_dps"`                    // Damage Multipler for DPS weapons
	ProjectileDurableResistance        float32                        `json:"projectile_durable_resistance"`            // Projectiles have 2 damages - Normal and Durable. This indicates how much it should scale the damage between the 2 values [Normal] -> [Durable].
	Armor                              uint32                         `json:"armor"`                                    // Armor
	ArmorAngleCheck                    bool                           `json:"armor_angle_check"`                        // [bool]Whether or not projectiles should check for armor penetration boost on hit.
	MaxArmor                           uint32                         `json:"max_armor"`                                // Maximum armor the angle check scales to.
	IgnoreArmorOnSelf                  bool                           `json:"ignore_armor_on_self"`                     // [bool]If checked, this entity does (not?) apply armor reduction on damage to itself, but still applies armor penetration reduction on the thing damaging it. Useful for shields that should take damage but stop projectiles/beams.
	Health                             int32                          `json:"health"`                                   // The max health of this zone
	Constitution                       int32                          `json:"constitution"`                             // The max constitution of the zone
	Immortal                           bool                           `json:"immortal"`                                 // [bool]If this is true, this zone cannot die until the entire entity dies.
	CausesDownedOnDowned               bool                           `json:"causes_downed_on_downed"`                  // [bool]If this is true, the downing of this zone puts the entity in constitution.
	CausesDeathOnDowned                bool                           `json:"causes_death_on_downed"`                   // [bool]If this is true, the downing of this zone triggers the immediate death of the entity.
	CausesDownedOnDeath                bool                           `json:"causes_downed_on_death"`                   // [bool]If this is true, the death of this zone puts the entity in constitution.
	CausesDeathOnDeath                 bool                           `json:"causes_death_on_death"`                    // [bool]If this is true, the death of this zone triggers the immediate death of the entity.
	AffectsMainHealth                  float32                        `json:"affects_main_health"`                      // As a multiplier between 0-1, this damage only affects the health pool of the damageable zone itself, not the entity's main health.
	ChildZones                         []string                       `json:"child_zones"`                              // [string]The name of the zones that are children to this zone.
	KillChildrenOnDeath                bool                           `json:"kill_children_on_death"`                   // [bool]If true, when this damageable zone dies we will kill all of it's child damageable zones as well.
	RegenerationEnabled                bool                           `json:"regeneration_enabled"`                     // [bool]If true, this damage zone will regenerate when the health components regeneration cooldown isn't active.
	BleedoutEnabled                    bool                           `json:"bleedout_enabled"`                         // [bool]If true, this damage zone will start to bleedout when it's entered constitution.
	AffectedByExplosions               bool                           `json:"affected_by_explosions"`                   // [bool]If true, explosions are applied to this damage zone. If not, the default zone is affected.
	ExplosiveDamagePercentage          float32                        `json:"explosive_damage_percentage"`              // idk, 27 chars long
	UnknownFloat2                      float32                        `json:"unknown_float2"`                           // idk, 28 chars long
	OnDeadDisableAllActors             bool                           `json:"on_dead_disable_all_actors"`               // [bool]If true, we disable all actors in this damage zone as it dies.
	UnknownBool                        bool                           `json:"unknown_bool"`                             // idk, 23 chars long
	ExplosionVerificationMode          enum.ExplosionVerificationMode `json:"explosion_verification_mode"`              // Defines when explosions are verified by raycast.
	MainHealthAffectCappedByZoneHealth bool                           `json:"main_health_affect_capped_by_zone_health"` // [bool]If true, the main health contribution is capped by the health + constitutiuon of the damage zone. Should be true for zones that can be gibbed/dismembered.
	HitEffectReceiverType              enum.HitEffectReceiverType     `json:"hit_effect_receiver_type"`                 // The type of hit effect to play when the zone gets hit. If this is set to HitEffectReceiverType_Count, it will assume the hit effect of the HitEffectComponent.
	UseSurfaceEffect                   bool                           `json:"use_surface_effect"`                       // [bool]If enabled, will use the surface effect rather than the hit effect.
	HealthEventTriggers                []SimpleHealthEventTrigger     `json:"health_event_triggers"`                    // Events that get played at certain health percentages.
	UnknownHash                        string                         `json:"unknown_hash"`                             // Unknown, 31 chars long
	UnknownFloat3                      float32                        `json:"unknown_float3"`                           // Unknown, 30 chars long
	UnknownBool2                       bool                           `json:"unknown_bool2"`                            // Unknown, 9 chars long
	UnknownBool3                       bool                           `json:"unknown_bool3"`                            // Unknown, 14 chars long
}

type SimpleDangerWarningComponent struct {
	WarningType   enum.DangerWarningType `json:"warning_type"`
	TriggerRadius float32                `json:"trigger_radius"`
	StartActive   bool                   `json:"start_active"`
}

type SimpleDepositComponent struct {
	Capacity                     uint32             `json:"capacity"`
	StartAmount                  int32              `json:"start_amount"`
	RefillAmount                 uint32             `json:"refill_amount"`
	DeductOwnerVoEvent           string             `json:"deduct_owner_vo_event"`
	LastDeductOwnerVoEvent       string             `json:"last_deduct_owner_vo_event"`
	DronePath                    string             `json:"drone_path"`
	FriendlyInteractAbility      enum.AbilityId     `json:"friendly_interact_ability"`
	SelfInteractAbility          enum.AbilityId     `json:"self_interact_ability"`
	ShowSelfInteract             bool               `json:"show_self_interact"`
	NodeHidingOrder              []string           `json:"node_hiding_order"`
	NodeHidingOrderPostAnimEvent string             `json:"node_hiding_order_post_anim_event"`
	RefillStyle                  enum.DepositRefill `json:"refill_style"`
	AssistedReloadWeaponPath     string             `json:"assisted_reload_weapon_path"`
}

type SimpleEffectSetting struct {
	ParticleEffect       string                        `json:"particle_effect"`
	Offset               mgl32.Vec3                    `json:"offset"`
	RotationOffset       mgl32.Vec3                    `json:"rotation_offset"`
	NodeName             string                        `json:"node"`
	TriggerEmitEventName string                        `json:"trigger_emit_event_name"`
	LinkOption           enum.UnitEffectOrphanStrategy `json:"link_option"`
	InheritRotation      bool                          `json:"inherit_rotation"`
	Linked               bool                          `json:"linked"`
	SpawnOnCamera        bool                          `json:"spawn_on_camera"`
}

type SimpleEnemyPackageComponent struct {
	BundleTag        string `json:"bundle_tag"`
	Package          string `json:"package"`
	SubentityPackage string `json:"subentity_package"`
	AudioResource    string `json:"audio_resource"`
}

type SimpleEnemyTagSwap struct {
	Tag  enum.EnemyTag `json:"tag"`
	Name string        `json:"name"`
}

type SimpleEntity struct {
	GameObjectID string         `json:"game_object_id"`
	Components   map[string]any `json:"components"`
}

type SimpleEquipmentComponent struct {
	WieldNode                     string                   `json:"wield_node"`
	WieldNodeRotationOffset       mgl32.Vec3               `json:"wield_node_rotation_offset"`
	WieldNodePositionOffset       mgl32.Vec3               `json:"wield_node_position_offset"`
	HolsterNode                   string                   `json:"holster_node"`
	HolsterNodeRotationOffset     mgl32.Vec3               `json:"holster_node_rotation_offset"`
	HolsterNodePositionOffset     mgl32.Vec3               `json:"holster_node_position_offset"`
	HolsterDuration               float32                  `json:"holster_duration"`
	WieldDuration                 float32                  `json:"wield_duration"`
	PickupDuration                float32                  `json:"pickup_duration"`
	UnknownHash                   string                   `json:"unknown_hash"`
	WieldAnimation                string                   `json:"wield_animation"`
	PickupAnimation               string                   `json:"pickup_animation"`
	HolsterAnimation              string                   `json:"holster_animation"`
	DropAnimation                 string                   `json:"drop_animation"`
	AmmocheckAnimation            string                   `json:"ammocheck_animation"`
	UnknownBool                   bool                     `json:"unknown_bool"`
	UnknownBool2                  bool                     `json:"unknown_bool2"`
	HolsterDurationForAttach      float32                  `json:"holster_duration_for_attach"`
	WieldDurationForAttach        float32                  `json:"wield_duration_for_attach"`
	AttachLerpTime                float32                  `json:"attach_lerp_time"`
	OnHolsterAnimationEvent       string                   `json:"on_holster_animation_event"`
	WieldAnimationSelf            string                   `json:"wield_animation_self"`
	PickupAnimationSelf           string                   `json:"pickup_animation_self"`
	HolsterAnimationSelf          string                   `json:"holster_animation_self"`
	UnknownHash3                  string                   `json:"unknown_hash3"`
	EquipmentType                 enum.EquipmentType       `json:"equipment_type"`
	DropMode                      enum.EquipmentDropMode   `json:"drop_mode"`
	DropAudioEvent                string                   `json:"drop_audio_event"`
	UnknownAudioEvent             string                   `json:"unknown_event"`
	DropIconUi                    string                   `json:"drop_icon_ui"`
	PickupAudioEvent              string                   `json:"pickup_audio_event"`
	UnknownEvent2                 string                   `json:"unknown_event2"`
	UnknownEvent3                 string                   `json:"unknown_event3"`
	UnknownEvent4                 string                   `json:"unknown_event4"`
	WeaponSwitchWieldAudioEvent   string                   `json:"weapon_switch_wield_audio_event"`
	WeaponSwitchHolsterAudioEvent string                   `json:"weapon_switch_holster_audio_event"`
	PickupAbility                 enum.AbilityId           `json:"pickup_ability"`
	DropAbility                   enum.AbilityId           `json:"drop_ability"`
	GripType                      enum.WeaponGripType      `json:"grip_type"`
	IsOneHanded                   bool                     `json:"is_one_handed"`
	AllowWieldOnShip              bool                     `json:"allow_wield_on_ship"`
	ShowInPickupWidget            bool                     `json:"show_in_pickup_widget"`
	HolsterUnit                   string                   `json:"holster_unit"`
	HintId                        string                   `json:"hint_id"`
	UnknownHash4                  string                   `json:"unknown_hash4"`
	EquipmentWwiseIndex           enum.EquipmentWwiseIndex `json:"equipment_wwise_index"`
	BackpackWwiseIndex            enum.BackpackWwiseIndex  `json:"backpack_wwise_index"`
	UseBackpackFilledSwitch       bool                     `json:"use_backpack_filled_switch"`
	UnknownHash5                  string                   `json:"unknown_hash5"`
}

type SimpleExertionLevelInfo struct {
	Index                              enum.ExertionLevelIndex `json:"index"`                                 // The corresponding index to this level.
	ExertionThreshold                  float32                 `json:"exertion_threshold"`                    // The Threshold of exertion that considers this level.
	SwayMultiplierScoped               float32                 `json:"sway_multiplier_scoped"`                // Multiplier to sway when scoped, changing its magnitude
	SwayMultiplierThirdperson          float32                 `json:"sway_multiplier_thirdperson"`           // Multiplier to sway in thirdperson, changing its magnitude
	SwayFrequencyMultiplierScoped      float32                 `json:"sway_frequency_multiplier_scoped"`      // Multiplier to sway when scoped, changing its frequency
	SwayFrequencyMultiplierThirdperson float32                 `json:"sway_frequency_multiplier_thirdperson"` // Multiplier to sway in thirdperson, changing its frequency
	SwayRecoilMultiplierScoped         float32                 `json:"sway_recoil_multiplier_scoped"`         // Multiplier to sway when scoped, changing its recoil
	SwayRecoilMultiplierThirdperson    float32                 `json:"sway_recoil_multiplier_thirdperson"`    // Multiplier to sway in thirdperson, changing its recoil
	SwayInterpSpeed                    float32                 `json:"sway_interp_speed"`                     // The interpolation speed used for all sway values
	EnterAnimationEvent                string                  `json:"enter_animation_event"`                 // [string]The animation event to play when entering this exertion level.
	ExitAnimationEvent                 string                  `json:"exit_animation_event"`                  // [string]The animation event to play when exiting this exertion level.
	ExertionGrowsVo                    string                  `json:"exertion_grows_vo"`                     // [string]Breath Audio event
	ExertionRecoversVo                 string                  `json:"exertion_recovers_vo"`                  // [string]Breath Audio event
}

type SimpleExertionVoParams struct {
	OnDeath                  string  `json:"on_death"`                    // [string] audio event to play on death
	OnSpawn                  string  `json:"on_spawn"`                    // [string] audio event to play on spawn
	OnExertionStart          string  `json:"on_exertion_start"`           // [string] audio event to play on exertion start
	OnExertionStop           string  `json:"on_exertion_stop"`            // [string] audio event to play on exertion stop
	OnBleedoutStop           string  `json:"on_bleedout_stop"`            // [string] audio event to play on bleedout stop
	InjuryHpThreshold        float32 `json:"injury_hp_threshold"`         // injury_hp_threshold
	CriticalBleedHpThreshold float32 `json:"critical_bleed_hp_threshold"` // critical_bleed_hp_threshold
}

type SimpleFactionComponent struct {
	Factions              []enum.FactionType `json:"factions"`
	TargetingNode         string             `json:"targeting_node"`
	UnknownHashes         []string           `json:"unknown_hashes"`
	HalfWidth             float32            `json:"half_width"`
	HalfForwardSize       float32            `json:"half_forward_size"`
	Priority              float32            `json:"priority"`
	UnknownFloat1         float32            `json:"unknown_float_1"`
	UnknownFloat2         float32            `json:"unknown_float_2"`
	ComplexTargetingNodes []string           `json:"complex_targeting_nodes"`
	UnknownBool           bool               `json:"unknown_bool"`
}

type SimpleHealthComponent struct {
	Health                           int32                        `json:"health"`                             // Max health
	HeathChangerate                  float32                      `json:"heath_changerate"`                   // How the health changes when not wounded, units per second
	HealthChangerateDisabled         bool                         `json:"health_changerate_disabled"`         // [bool]If the regeneration is disabled
	HeathChangerateCooldown          float32                      `json:"heath_changerate_cooldown"`          // How long after taking any damage to wait until we start regenerating.
	RegenerationSegments             uint32                       `json:"regeneration_segments"`              // The number of segments for regeneration.
	RegenerationChangerate           float32                      `json:"regeneration_changerate"`            // How health changes in regeneration, units per seconds
	Constitution                     int32                        `json:"constitution"`                       // Negative health (after health is depleted the constitution ticks down until entity is dead)
	ConstitutionChangerate           float32                      `json:"constitution_changerate"`            // The rate at which health is changed in constitution, units per second
	ConstitutionDisablesInteractions bool                         `json:"constitution_disables_interactions"` // [bool]Should interactions be disabled when this goes into constitution
	ZoneBleedoutChangerate           float32                      `json:"zone_bleedout_changerate"`           // The rate at which health is changed in constitution for zones, units per second
	Size                             enum.UnitSize                `json:"size"`                               // The size category of the unit, this is used for systems such as the gib system. Small = Humansized, Medium = Bug Warrior sized, Large = Tunneler, Massive = Even larger
	Mass                             float32                      `json:"mass"`                               // The mass of the unit, this is used for systems such as vehicle collision damage calculations, when the unit is relying on a static or keyframed body.
	KillScore                        uint32                       `json:"kill_score"`                         // The score to accumulate when killing this.
	Wounded                          WoundedState                 `json:"wounded"`                            // The effect wounds has on this character
	DefaultDamageableZoneInfo        SimpleDamageableZoneInfo     `json:"default_damageable_zone_info"`       // Contains information about default damage zone, which is used if no specific damage zone was hit
	DamageableZones                  []SimpleDamageableZone       `json:"damageable_zones,omitempty"`         // Contains all damage zones for the entity.
	ElementDamageValues              []ElementDamage              `json:"element_damage_values,omitempty"`    // Element damage modifiers I guess
	Decay                            DecaySettings                `json:"decay"`                              // At least mode is required, for regular, more info may be needed
	DeathSoundIDs                    []string                     `json:"death_sound_ids,omitempty"`          // [wwise]Sounds to trigger when the entity experiences real death.
	TriggerDeathSoundsOnRemove       bool                         `json:"trigger_death_sounds_on_remove"`     // [bool]Should this entity trigger death sounds if it gets removed?
	OnHitEffect                      SimpleEffectSetting          `json:"on_hit_effect"`                      // Particle effect to play when the entity gets hit by damage that is not dps.
	WhileLivingEffect                []SimpleActiveEffectSetting  `json:"while_living_effect"`                // Particle effects to play while the entity lives and is destroyed on death.
	OnDeathEffect                    SimpleEffectSetting          `json:"on_death_effect"`                    // Particle effect to play when the entity dies.
	BledToDeathEffect                SimpleEffectSetting          `json:"bled_to_death_effect"`               // Particle effect to play when the entity dies from bleeding out(cancels out the on_death_effect in that case).
	UnknownEffect                    SimpleEffectSetting          `json:"unknown_effect"`                     // Unknown, 27 char long name
	RequireDemolition                bool                         `json:"require_demolition"`                 // [bool]Does this entity require demolition damage to be damaged?
	DownedAnim                       string                       `json:"downed_anim"`                        // [string]Animation event that gets called when entering constitution.
	DeadAnim                         string                       `json:"dead_anim"`                          // [string]Animation event that gets called when entering death.
	UnknownFloat                     float32                      `json:"unknown_float"`                      // Not sure, 31 char long name
	UnknownHash1                     string                       `json:"unknown_hash1"`                      // Unsure, 14 char name
	UnknownHash2                     string                       `json:"unknown_hash2"`                      // Unsure, 13 char name
	UnknownHash3                     string                       `json:"unknown_hash3"`                      // Unsure, 14 char name
	OnDownedHideVisibilityGroup      string                       `json:"on_downed_hide_visibility_group"`    // [string]Visibility group to hide when this unit gets downed.
	OnDownedShowVisibilityGroup      string                       `json:"on_downed_show_visibility_group"`    // [string]Visibility group to show when this unit gets downed.
	OnDeadHideVisibilityGroup        string                       `json:"on_dead_hide_visibility_group"`      // [string]Visibility group to hide when this unit dies.
	OnDeadShowVisibilityGroup        string                       `json:"on_dead_show_visibility_group"`      // [string]Visibility group to show when this unit dies.
	UnknownVisibilityGroupHashes     []string                     `json:"unknown_visibility_group_hashes"`    // 29 char name, same as OnDead(Show/Hide)VisibilityGroup
	UnknownVisibilityGroupHashes2    []string                     `json:"unknown_visibility_group_hashes2"`   // 29 char name, same as OnDead(Show/Hide)VisibilityGroup
	UnknownDeathDestructionHash      string                       `json:"unknown_death_destruction_hash"`     // 26 char name, same as OnDeathDestructionLevel
	OnDeathDestructionLevel          enum.DestructionTemplateType `json:"on_death_destruction_level"`         // If this unit dies from the health component, then apply this level of destrction to itself from the destruction system
	CanDieNaturally                  bool                         `json:"can_die_naturally"`                  // [bool]Normally if a unit takes enough damage, they'll die. If this is disabled, it will only go down to constitution and needs to be killed via outside forces, such as behavior.
	DeathPropagation                 enum.DeathPropagation        `json:"death_propagation"`                  // If this unit dies, It'll propagate the death to the selected inheritance direction selected in this field.
	UnknownHashArray                 []string                     `json:"unknown_hash_array"`                 // Name length 17 chars
	UnknownBool1                     bool                         `json:"unknown_bool1"`                      // Name length 33 chars
	UnknownBool2                     bool                         `json:"unknown_bool2"`                      // Name length 18 chars
	UnknownBool3                     bool                         `json:"unknown_bool3"`                      // Name length 30 chars
}

type SimpleHealthEventTrigger struct {
	HealthPercent     float32 `json:"health_percent"`      // Health percent we need to go under in order to trip the event.
	EventName         string  `json:"event_name"`          // [string]Event name that gets fired off to the behavior.
	UnknownEventName1 string  `json:"unknown_event_name1"` // Could be animation, audio, bone, or other event name
	UnknownEventName2 string  `json:"unknown_event_name2"` // Could be animation, audio, bone, or other event name
	UnknownEventName3 string  `json:"unknown_event_name3"` // Could be animation, audio, bone, or other event name
}

type SimpleHeatsinkOverrides struct {
	HeatCapacity float32               `json:"heat_capacity"` // No clue really
	ProjType     enum.ProjectileType   `json:"projectile_type"`
	Particles    string                `json:"particles"`
	MaybeEvent   string                `json:"maybe_event"`
	StatusEffect enum.StatusEffectType `json:"status_effect"`
}

type SimpleHellpodComponent struct {
	HellpodVariant                  enum.HellpodVariant `json:"hellpod_variant"`
	UnknownBool                     bool                `json:"unknown_bool"`
	SpawnHeight                     float32             `json:"spawn_height"`
	UnknownVec                      mgl32.Vec2          `json:"unknown_vec"`
	InitialVelocity                 float32             `json:"initial_velocity"`
	BreakingHeight                  float32             `json:"breaking_height"`
	BreakingVelocity                float32             `json:"breaking_velocity"`
	BreakingVelocityTargetTime      float32             `json:"breaking_velocity_target_time"`
	UnknownBool2                    bool                `json:"unknown_bool2"`
	AudioThrustersIgniteLoop        string              `json:"audio_thrusters_ignite_loop"`
	AudioThrustersIgniteEnd         string              `json:"audio_thrusters_ignite_end"`
	AudioThrustersIgnition          string              `json:"audio_thrusters_ignition"`
	AudioEntryWooshLoop             string              `json:"audio_entry_woosh_loop"`
	AudioEntryWooshEnd              string              `json:"audio_entry_woosh_end"`
	AudioChassiShakeLoop            string              `json:"audio_chassi_shake_loop"`
	AudioChassiShakeEnd             string              `json:"audio_chassi_shake_end"`
	AudioSupersonicBoom             string              `json:"audio_supersonic_boom"`
	AudioImpact                     string              `json:"audio_impact"`
	AudioBoltBlowing                string              `json:"audio_bolt_blowing"`
	AudioLidBlowing                 string              `json:"audio_lid_blowing"`
	AudioThrusterStart              string              `json:"audio_thruster_start"`
	AudioHellpodPreImpactRiser      string              `json:"audio_hellpod_pre_impact_riser"`
	AudioMusicHellpodGroundApproach string              `json:"audio_music_hellpod_ground_approach"`
	AudioMusicHellpodLand           string              `json:"audio_music_hellpod_land"`
	UnknownBool3                    bool                `json:"unknown_bool3"`
}

type SimpleHellpodRackComponent struct {
	Payloads                  []SimpleRackAttach `json:"payloads"`
	LastRetractDelay          float32            `json:"last_retract_delay"`
	DisableRetract            bool               `json:"disable_retract"`
	MapIcon                   string             `json:"map_icon"`
	MapName                   string             `json:"map_name"`
	RackDeployAudioEvent      string             `json:"rack_deploy_audio_event"`
	RackRetractAudioEvent     string             `json:"rack_retract_audio_event"`
	DoorRetractAudioEvent     string             `json:"door_retract_audio_event"`
	DeployAbility             enum.AbilityId     `json:"deploy_ability"`
	LastRetractAbility        enum.AbilityId     `json:"last_retract_ability"`
	RandomPayloadSize         uint32             `json:"random_payload_size"`
	SpawnPayloadSize          uint32             `json:"spawn_payload_size"`
	DisableInitialInteraction bool               `json:"disable_initial_interaction"`
}

type SimpleHudMarkerTypeOverride struct {
	Node                string             `json:"node"`
	MaxHitPosDistance   float32            `json:"max_hit_pos_distance"`
	MaxHitAngDifference float32            `json:"max_hit_ang_difference"`
	MaxFuzzyDistance    float32            `json:"max_fuzzy_distance"`
	MarkerType          enum.HudMarkerType `json:"marker_type"`
}

type SimpleInventoryComponent struct {
	DefaultPrimary     string   `json:"default_primary"`
	DefaultSidearm     string   `json:"default_sidearm"`
	DefaultSupport     string   `json:"default_support"`
	DefaultThrowable   string   `json:"default_throwable"`
	DefaultBackpack    string   `json:"default_backpack"`
	DefaultMeleeWeapon string   `json:"default_melee_weapon"`
	StartAmountStims   uint32   `json:"start_amount_stims"`
	RefillAmountStims  uint32   `json:"refill_amount_stims"`
	MaxAmountStims     uint32   `json:"max_amount_stims"`
	CanDropEquipment   bool     `json:"can_drop_equipment"`
	UnknownHashArray   []string `json:"unknown_hash_array"`
}

type SimpleLoadoutPackageComponent struct {
	BundleTag                    string `json:"bundle_tag"`
	Package                      string `json:"package"`
	AudioResource                string `json:"audio_resource"`
	IncludeDefaultCustomizations bool   `json:"include_default_customizations"`
	UnknownBool                  bool   `json:"unknown_bool"`
}

type SimpleLocalUnitComponent struct {
	UnitPath string  `json:"unit_path"`
	Scale    float32 `json:"scale"`
}

type SimpleMagazinePattern struct {
	Projectiles     []enum.ProjectileType `json:"projectiles"`      // Pattern of projectiles to fire. None denotes end if the full size is not used. Pattern is repeated and aligned so the last projectile in the pattern is always the last in the magazine (should it not divide evenly).
	FirstProjectile enum.ProjectileType   `json:"first_projectile"` // to trigger start/stop event
}

type SimpleMaterialSwap struct {
	Name     string `json:"name"`
	Material string `json:"material"`
}

type SimpleMaterialSwapComponent struct {
	MaterialSlots []SimpleMaterialSwapSlot `json:"material_slots"`
	EnemyNames    []string                 `json:"enemy_names"`
	EnemyTagSwaps []SimpleEnemyTagSwap     `json:"enemy_tag_swaps"`
}

type SimpleMaterialSwapSlot struct {
	MaterialSlotName string               `json:"material_slot_name"`
	SwapSettings     []SimpleMaterialSwap `json:"swap_settings"`
}

type SimpleMaterialVariableAnimation struct {
	Name        string                             `json:"name"`
	TargetValue mgl32.Vec4                         `json:"target_value"`
	Duration    float32                            `json:"duration"`
	Loops       uint32                             `json:"loops"`
	AnimType    enum.MaterialVariableAnimationType `json:"anim_type"`
}

type SimpleMaterialVariableValue struct {
	Name  string     `json:"name"`
	Value mgl32.Vec4 `json:"value"`
}

type SimpleMaterialVariables struct {
	VariableName     string                            `json:"variable_name"`
	MaterialSlotName string                            `json:"material_slot_name"`
	Type             enum.MaterialVariableType         `json:"type"`
	Value            mgl32.Vec4                        `json:"value"`
	Animations       []SimpleMaterialVariableAnimation `json:"animations"`
	Values           []SimpleMaterialVariableValue     `json:"values"`
	UnknownBool1     bool                              `json:"unknown_bool1"`
	UnknownBool2     bool                              `json:"unknown_bool2"`
}

type SimpleMaterialVariablesComponent struct {
	Variables []SimpleMaterialVariables `json:"variables"`
}

type SimpleMountComponent struct {
	Infos []SimpleMountInfo `json:"infos"`
}

type SimpleMountInfo struct {
	Path       string         `json:"path"`
	AttachNode string         `json:"attach_node"`
	MountSide  enum.MountSide `json:"mount_side"`
	Name       string         `json:"name"`
}

type SimpleOpticSetting struct {
	OpticsFunction enum.WeaponFunctionType  `json:"optics_function"`
	SomeHash       string                   `json:"some_hash"`
	CrosshairValue enum.CrosshairWeaponType `json:"crosshair_value"`
}

type SimpleProjectileWeaponComponent struct {
	ProjType                        enum.ProjectileType           `json:"projectile_type"`                      // Type of projectile it fires.
	RoundsPerMinute                 SimpleRPM                     `json:"rounds_per_minute"`                    // Rounds per minute depending on weapon setting. Y is the default ROF.
	ZeroingSlots                    mgl32.Vec3                    `json:"zeroing_slots"`                        // The zeroing distances of the weapon.
	ZeroingHipfire                  float32                       `json:"zeroing_hipfire"`                      // The default zeroing distance while not aiming a weapon
	CurrentZeroingSlot              uint32                        `json:"default_zeroing_slot"`                 // The slot in the zeroing distances to use by default.
	InfiniteAmmo                    bool                          `json:"infinite_ammo"`                        // [bool]True if this projectile weapon can never run out of ammo.
	ProjectileEntity                string                        `json:"projectile_entity"`                    // [adhd]If this is set an entity is spawned when firing instead of adding a projectile to the projectile manager.
	UseFirenodePose                 float32                       `json:"use_fire_node_pose?"`                  // This may not be correct, the type has changed since the last time this member had a name
	HeatBuildup                     WeaponHeatBuildup             `json:"heat_buildup"`                         // Controls visual heat effects on the weapon.
	ScaleDownUsedFireNode           bool                          `json:"scale_down_used_fire_node"`            // [bool]If set, scale down the used fire node to zero (in order to hide a rocket for example)
	OnRoundFiredShakes              SimpleWeaponCameraShakeInfo   `json:"on_round_fired_shakes"`                // Settings for local and in-world camera shakes to play on every round fired.
	NumLowAmmoRounds                uint32                        `json:"num_low_ammo_rounds"`                  // Number of rounds to play the low ammo effects
	LowAmmoAudioEvent               string                        `json:"low_ammo_audio_event"`                 // [string]Audio event to play in addition to the regular firing audio when low on ammo.
	LastBulletAudioEvent            string                        `json:"last_bullet_audio_event"`              // [string]Audio event to play in addition to the regular firing audio for the last bullet.
	LastBulletOwnerVOEvent          string                        `json:"last_bullet_owner_vo_event"`           // [string]VO event to play on the owner of the weapon when the last bullet has been fired.
	WindEffect                      enum.WindEffectTemplate       `json:"wind_effect"`                          // Wind effect template to play when firing.
	SpeedMultiplier                 float32                       `json:"speed_multiplier"`                     // Projectile speed multiplier.
	DamageAddends                   HitZoneClassValues            `json:"damage_addends"`                       // Damage to add to the projectile's value for each damage class. Used by weapon customizaitons.
	APAddends                       HitZoneClassValues            `json:"ap_addends"`                           // Armor penetration to add to the projectile's value for each damage class. Used by weapon customizaitons.
	SpinupTime                      float32                       `json:"spinup_time"`                          // Time from 'start fire' to first projectile firing
	RPCSyncedFireEvents             bool                          `json:"rpc_synced_fire_events"`               // [bool]ONLY USE FOR SINGLE-FIRE/SLOW FIRING WEAPONS. Primarily useful for sniper rifles, explosive one-shots etc. that need the firing event to be highly accurately synced!
	CasingEject                     SimpleWeaponCasingEffectInfo  `json:"casing_eject"`                         // Particle effect of the shellcasing.
	MuzzleFlash                     string                        `json:"muzzle_flash"`                         // [particles]Particle effect of the muzzle flash, played on attach_muzzle.
	ShockwaveType                   enum.SurfaceImpactType        `json:"shockwave_type"`                       // The surface effect to play normal to the ground underneath the muzzle.
	UseFaintShockwave               bool                          `json:"use_faint_shockwave"`                  // [bool]If true, a small shockwave is played when [1m, 2m] from the ground instead of the regular one.
	UseMidiEventSystem              bool                          `json:"use_midi_event_system"`                // [bool]Fire event will be posted using Wwise's MIDI system as a MIDI sequence (cannot be paused/resumed).
	MidiTimingRandomization         mgl32.Vec2                    `json:"midi_timing_randomization"`            // Events posted during the MIDI sequence will have a random time offset, measured in milliseconds.
	MidiStopDelay                   float32                       `json:"midi_stop_delay"`                      // A delay for when to notify Wwise that the MIDI sequence has stopped, measured in milliseconds.
	FireLoopStartAudioEvent         string                        `json:"fire_loop_start_audio_event"`          // [wwise]The looping audio event to start when starting to fire.
	FireLoopStopAudioEvent          string                        `json:"fire_loop_stop_audio_event"`           // [wwise]The looping audio event to play when stopping fire.
	FireSingleAudioEvent            string                        `json:"fire_single_audio_event"`              // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	FireReflectAudioEvent           string                        `json:"fire_reflect_audio_event"`             // [wwise]The audio event to trigger to simulate an early reflection.
	SilencedFireReflectAudioEvent   string                        `json:"silenced_fire_reflect_audio_event"`    // [wwise]The audio event to trigger to simulate an early reflection, with silencer equipped.
	HapticsFireLoopStartAudioEvent  string                        `json:"haptics_fire_loop_start_audio_event"`  // [wwise]The looping audio event to start when starting to fire.
	HapticsFireLoopStopAudioEvent   string                        `json:"haptics_fire_loop_stop_audio_event"`   // [wwise]The looping audio event to play when stopping fire.
	HapticsFireSingleAudioEvent     string                        `json:"haptics_fire_single_audio_event"`      // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	FireLoopCameraShake             string                        `json:"fire_loop_camera_shake"`               // [camera_shake]The camera shake to run when firing
	FireLoopCameraShakeRadius       mgl32.Vec2                    `json:"fire_loop_camera_shake_radius"`        // Inner/outer camera shake radiuses when firing.
	SilencedFireLoopStartAudioEvent string                        `json:"silenced_fire_loop_start_audio_event"` // [wwise]The looping audio event to start when starting to fire with suppressor.
	SilencedFireLoopStopAudioEvent  string                        `json:"silenced_fire_loop_stop_audio_event"`  // [wwise]The looping audio event to play when stopping fire with suppressor.
	SilencedFireSingleAudioEvent    string                        `json:"silenced_fire_single_audio_event"`     // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds) with suppressor.
	FireSourceNode                  string                        `json:"fire_audio_source_node"`               // [string]The node to play the firing audio events at.
	DryFireAudioEvent               string                        `json:"dry_fire_audio_event"`                 // [wwise]The wwise sound id to play when dry firing.
	DryFireRepeatAudioEvent         string                        `json:"dry_fire_repeat_audio_event"`          // [wwise]The wwise sound id to play when repeatedly dry firing.
	HeatPercentageMaterialVariable  string                        `json:"heat_percentage_material_variable"`    // [string]The material variable to try to set on each mesh when heat is updated
	Silenced                        bool                          `json:"silenced"`                             // [bool]If this weapon should use the silenced sound or not. Used by / overridden by customization
	AimZeroingQuality               enum.ProjectileZeroingQuality `json:"aim_zeroing_quality"`                  // How well to attempt to compensate for drag when aiming. Defaults to High (8 iterations). Set to None to ignore drag.
	CasingEjectDisabledOnFire       bool                          `json:"casing_eject_diabled_on_fire"`         // [bool]Turns off casing ejection/effects when firing the weapon.
	BurstFireRate                   float32                       `json:"burst_fire_rate"`                      // If above 0, the fire rate will be changed to this, when the weapon is set to Burst.
	WeaponFunctionMuzzleVelocity    float32                       `json:"weapon_function_muzzle_velocity"`      // If we have the Muzzle Velocity weapon function and we switch to it, what should our projectile velocity be?
	WeaponFunctionProjectileType    enum.ProjectileType           `json:"weapon_function_projectile_type"`      // If we have the Programmable Ammo weapon function and we switch to it, what should our projectile type be?
	UnknownParticleEffect           string                        `json:"unknown_particle_effect"`              // added after strings removed
	UnknownBool                     bool                          `json:"unknown_bool"`                         // added after strings removed
}

type SimpleRPM struct {
	Min     float32 `json:"min"`
	Default float32 `json:"default"`
	Max     float32 `json:"max"`
}

type SimpleRackAttach struct {
	Item                  string        `json:"item"`
	Node                  string        `json:"node"`
	Offset                mgl32.Vec3    `json:"offset"`
	RotationOffset        mgl32.Vec3    `json:"rotation_offset"`
	DeployAnimationEvent  string        `json:"deploy_animation_event"`
	RetractAnimationEvent string        `json:"retract_animation_event"`
	RetractAudioEvent     string        `json:"retract_audio_event"`
	ApplyDeltas           bool          `json:"apply_deltas"`
	RackSide              enum.RackSide `json:"rack_side"`
	UnknownBool           bool          `json:"unknown_bool"`
}

type SimpleSeekingMissileComponent struct {
	TargetingMode                               enum.SeekingMissileTargetingMode      `json:"targeting_mode"`                                    // Determines which targeting mode is used.
	UnknownFloat                                float32                               `json:"unknown_float"`                                     // name length 19, maybe targeting_mode_time?
	AutoplayStartingEffects                     bool                                  `json:"autoplay_starting_effects"`                         // [bool]If disabled, the missile wont play the audio and trail FX.
	TimeToEnableGuidance                        float32                               `json:"time_to_enable_guidance"`                           // Time that it takes to enable guidance, 0 means will be enable from the start, -1 means that we should enable it manually.
	TimeToDisableGuidance                       float32                               `json:"time_to_disable_guidance"`                          // Time that it takes to disable guidance, 0 means will be disable from the start, -1 means that we should disable it manually.
	UnknownFloat2                               float32                               `json:"unknown_float2"`                                    // name length 27
	UnknownFloat3                               float32                               `json:"unknown_float3"`                                    // name length 28
	AngleLostGuidance                           float32                               `json:"angle_lost_guidance"`                               // [0,180] - If the angle between the target and the missile exceeds this, disable guidance
	MovementPredictionAccuracy                  float32                               `json:"movement_prediction_accuracy"`                      // [0,1] - How much the missile is predicting the point of impact depending on current target velocity (1 is best prediction)
	TimeToEnableMovement                        float32                               `json:"time_to_enable_movement"`                           // Time that it takes to enable movement, 0 means will be enable from the start, -1 means that we should enable it manually.
	TimeToEnableExplosive                       float32                               `json:"time_to_enable_explosive"`                          // Time that it takes to enable explosive, 0 means will be enable from the start, -1 means that we should enable it manually.
	MaxLifetime                                 float32                               `json:"max_lifetime"`                                      // Time before the missile blows itself up. Set to 0 or lower to disable and have the missile live forever.
	StartingSpeed                               float32                               `json:"starting_speed"`                                    // The speed at which the missile launches at.
	MinimumSpeed                                float32                               `json:"minimum_speed"`                                     // The minimum speed at which this missile can travel.
	PreferredSpeed                              float32                               `json:"preferred_speed"`                                   // The target speed at which this missile wants to travel.
	Acceleration                                float32                               `json:"acceleration"`                                      // The missile's speed acceleration.
	MaxAngleToTarget                            float32                               `json:"max_angle_to_target"`                               // The missile will be at its slowest but turn the fastest at or above this angle to the target.
	MinTurnSpeed                                float32                               `json:"min_turn_speed"`                                    // How fast this missile can turn while going at its preferred speed.
	MaxTurnSpeed                                float32                               `json:"max_turn_speed"`                                    // How fast this missile can turn while going at its slowest speed.
	PFactor                                     float32                               `json:"p_factor"`                                          // How much of the difference in current and target speed to consider when changing speed.
	IFactor                                     float32                               `json:"i_factor"`                                          // How much of the speed difference over time to consider.
	DFactor                                     float32                               `json:"d_factor"`                                          // How much of the speed delta to consider.
	TargetUpdateInterval                        float32                               `json:"target_update_interval"`                            // How often do we update our target?
	MissileTrail                                SimpleEffectSetting                   `json:"missile_trail"`                                     // Particle effect trail that gets attached to the missile.
	MissileTrailAudioEvent                      string                                `json:"missile_trail_audio_event"`                         // [wwise]What audio event to play when the missile is fired.
	MissileTrailAudioEventStop                  string                                `json:"missile_trail_audio_event_stop"`                    // [wwise]What audio event to play when the missile has exploded.
	TargetDotMinimum                            float32                               `json:"target_dot_minimum"`                                // What's the minimum dot product between the current forward of this entity and its target position before we can update the position? -1 to disable.
	JavelinFiringMode                           bool                                  `json:"javelin_firing_mode"`                               // [bool]When enabled, the missile that is fired will curve up and then down.
	MovementShouldBeProcessedByProjectileSystem bool                                  `json:"movement_should_be_processed_by_projectile_system"` // [bool]If set, the projectile system will handle collision/explosions/damages/vfx/sfx getting that data from the projectile setting.
	ProjectileTypeToProcess                     enum.ProjectileType                   `json:"projectile_type_to_process"`                        // The projectile type that it should process by the projectile manager, if it set to none it should be passed through the spawn context.
	Deviation                                   SimpleSeekingMissileDeviationSettings `json:"deviation"`                                         // A struct containing info about missile deviations
	UnknownFloat4                               float32                               `json:"unknown_float4"`                                    // Name length 31
	UnknownHash                                 string                                `json:"unknown_hash"`                                      // Name length 28
	UnknownBool                                 bool                                  `json:"unknown_bool"`                                      // Name length 23
	UnknownBool2                                bool                                  `json:"unknown_bool2"`                                     // Name length 28
	UnknownFloat5                               float32                               `json:"unknown_float5"`                                    // Name length 35
	UnknownFloat6                               float32                               `json:"unknown_float6"`                                    // Name length 35
}

type SimpleSeekingMissileDeviationSettings struct {
	Enabled             bool       `json:"enabled"`               // [bool] Not 100% sure this is correct, but it matches the name length and would make sense
	MinSeekingDeviation float32    `json:"min_seeking_deviation"` // Not sure, name length 21
	MaxSeekingDeviation float32    `json:"max_seeking_deviation"` // Not sure, name length 21
	UnkFloat3           float32    `json:"unk_float3"`            // Not sure, name length 21
	UnkFloat4           float32    `json:"unk_float4"`            // Not sure, name length 21
	UnkVector           mgl32.Vec3 `json:"unk_vector"`            // Name length 27
	UnkVector2          mgl32.Vec3 `json:"unk_vector2"`           // Name length 27
	UnkBool             bool       `json:"unk_bool"`              // Name length 38
	UnkFloat5           float32    `json:"unk_float5"`            // Name length 29
	UnkFloat6           float32    `json:"unk_float6"`            // Name length 21
	UnkFloat7           float32    `json:"unk_float7"`            // Name length 18
	UnkFloat8           float32    `json:"unk_float8"`            // Name length 22
	UnkFloat9           float32    `json:"unk_float9"`            // Name length 39
}

type SimpleSpottableComponent struct {
	VoLine             string                      `json:"vo_line"`
	Radius             mgl32.Vec2                  `json:"radius"`
	Range              mgl32.Vec2                  `json:"range"`
	MarkerType         enum.HudMarkerType          `json:"marker_type"`
	FindableObjective  bool                        `json:"findable_objective"`
	SpottingNode       string                      `json:"spotting_node"`
	StartActive        bool                        `json:"start_active"`
	MarkerTypeOverride SimpleHudMarkerTypeOverride `json:"marker_type_override"`
	MarkerIcon         string                      `json:"marker_icon"`
	MarkerTextureType  enum.TextureType            `json:"marker_texture_type"`
}

type SimpleSpreadInfo struct {
	Horizontal  float32 `json:"horizontal"`   // The horizontal spread in MRAD.
	Vertical    float32 `json:"vertical"`     // The vertical spread in MRAD.
	UnknownBool bool    `json:"unknown_bool"` // Unknown, probably toggles some kind of spread related thing. Name 17 chars long in snake_case
}

type SimpleTagComponent struct {
	Tags            []enum.Tag `json:"tags,omitempty"`
	OnDestroyedTags []enum.Tag `json:"on_destroyed_tags,omitempty"`
}

type SimpleUnitComponent struct {
	UnitPath                          string         `json:"unit_path"`
	ScaleMin                          float32        `json:"scale_min"`
	ScaleMax                          float32        `json:"scale_max"`
	Radius                            float32        `json:"radius"`
	HiddenVisiblityGroups             []string       `json:"hidden_visibility_groups,omitempty"`
	ShowRandomVisibilityGroup         []string       `json:"show_random_visibility_group,omitempty"`
	OnHotjoinCorpseRepairAbilityPatch enum.AbilityId `json:"on_hotjoin_corpse_repair_ability_patch"`
}

type SimpleUnitCustomizationComponent struct {
	MaterialsTexturesOverrides    []SimpleUnitCustomizationMaterialOverrides `json:"materials_textures_overrides"`
	MountedWeaponTextureOverrides []SimpleUnitCustomizationMaterialOverrides `json:"mounted_weapon_texture_overrides"`
}

type SimpleUnitCustomizationMaterialOverrides struct {
	MaterialID        string `json:"material"`
	MaterialLut       string `json:"material_lut"`
	DecalSheet        string `json:"decal_sheet"`
	PatternLut        string `json:"pattern_lut"`
	PatternMasksArray string `json:"pattern_masks_array"`
}

type SimpleUnitCustomizationSetting struct {
	Name           string                           `json:"name"`
	DebugName      string                           `json:"debug_name"`
	ID             string                           `json:"id"`
	Archive        string                           `json:"archive"`
	Customization  SimpleUnitCustomizationComponent `json:"customization"`
	Thumbnail      string                           `json:"thumbnail"`
	UIWidgetColors []mgl32.Vec3                     `json:"ui_widget_colors"`
}

type SimpleUnitCustomizationSettings struct {
	ParentCollectionType UnitCustomizationCollectionType         `json:"parent_collection_type"`
	CollectionType       UnitCustomizationCollectionType         `json:"collection_type"`
	ObjectName           string                                  `json:"object_name"`
	SkinName             string                                  `json:"skin_name"`
	CategoryType         UnitCustomizationCollectionCategoryType `json:"category_type"`
	Skins                []SimpleUnitCustomizationSetting        `json:"skins,omitempty"`
	ShowroomOffset       mgl32.Vec3                              `json:"showroom_offset"`
	ShowroomRotation     mgl32.Vec3                              `json:"showroom_rotation"`
}