datalib

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 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 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"`
	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"`
	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"`
	Flags     DLTypeFlags    `json:"flags"`
	Size      uint32         `json:"size"`
	Alignment uint32         `json:"alignment"`
	Members   []DLMemberDesc `json:"members,omitempty"`
	Comment   string         `json:"comment,omitempty"`
}

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 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 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 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 ErrorComponent struct {
	// 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 HitZoneClassValues struct {
	Normal  float32 `json:"normal"`
	Durable float32 `json:"durable"`
}

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 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 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).
	UnknownFireLoopStartAudioEvent  stingray.ThinHash // Unknown, added after strings were removed
	UnknownFireLoopStopAudioEvent   stingray.ThinHash // Unknown, added after strings were removed
	UnknownFireSingleAudioEvent     stingray.ThinHash // Unknown, added after strings were removed
	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 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 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 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 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 SimpleEntity struct {
	GameObjectID string         `json:"game_object_id"`
	Components   map[string]any `json:"components"`
}

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 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 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).
	UnknownFireLoopStartAudioEvent  string                        `json:"unknown_fire_loop_start_audio_event"`  // Unknown, added after strings were removed
	UnknownFireLoopStopAudioEvent   string                        `json:"unknown_fire_loop_stop_audio_event"`   // Unknown, added after strings were removed
	UnknownFireSingleAudioEvent     string                        `json:"unknown_fire_single_audio_event"`      // Unknown, added after strings were removed
	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 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 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"`
}

type SimpleUnitNodeScale struct {
	NodeID string
	Scale  mgl32.Vec3
}

type SimpleVisibilityMaskComponent struct {
	MaskInfos      []SimpleVisibilityMaskInfo      `json:"mask_infos,omitempty"`
	Randomizations []SimpleVisibilityRandomization `json:"randomizations,omitempty"`
}

type SimpleVisibilityMaskInfo struct {
	Name        string `json:"name"`
	Index       uint16 `json:"index"`
	StartHidden bool   `json:"default_hidden"`
}

type SimpleVisibilityRandomization struct {
	Identifier     string   `json:"id"`
	MaskIndexNames []string `json:"mask_index_names,omitempty"`
}

type SimpleWeaponCameraShakeInfo struct {
	WorldShakeEffect string  `json:"world_shake_effect"`
	LocalShakeEffect string  `json:"local_shake_effect"`
	FPVShakeEffect   string  `json:"fpv_shake_effect"`
	InnerRadius      float32 `json:"inner_radius"`
	OuterRadius      float32 `json:"outer_radius"`
}

type SimpleWeaponCasingEffectInfo struct {
	EjectionEvent    string                 `json:"ejection_event"`
	EjectionEffect   string                 `json:"ejection_effect"`
	EjectionNode     string                 `json:"ejection_node"`
	CasingEffect     string                 `json:"casing_effect"`
	CasingNode       [4]string              `json:"casing_nodes"`
	LinkEffect       string                 `json:"link_effect"`
	LinkNode         string                 `json:"link_node"`
	CasingImpactType enum.SurfaceImpactType `json:"casing_impact_type"`
	CasingAudioEvent string                 `json:"casing_audio_event"`
	NumPlaybacks     uint32                 `json:"num_playbacks"`
}

type SimpleWeaponChargeComponent struct {
	ChargeStateSettings     [3]ChargeStateSetting `json:"charge_state_settings"`       // Min-, Full-, and Over-Charged states
	ProjMultipliers         ProjectileMultipliers `json:"proj_multipliers"`            // Multipliers of the setting values for the projectile based on the charge amount.
	ChargeStartSoundID      string                `json:"charge_start_sound_id"`       // [string]Sound to start playing when the chargeup starts.
	ChargeStopSoundID       string                `json:"charge_stop_sound_id"`        // [string]Sound id to play when the chargeup ends.
	ReadyToFireSoundID      string                `json:"ready_to_fire_sound_id"`      // [string]Sound id to play when the weapon can fire.
	DangerOverchargeSoundID string                `json:"danger_overcharge_sound_id"`  // [string]Sound id to play when the chargeup enters the danger zone.
	ChargeMesh              string                `json:"charge_mesh"`                 // [string]Mesh to set charge value on.
	ChargeMaterial          string                `json:"charge_material"`             // [string]Material to set charge value on.
	ChargeVariable          string                `json:"charge_variable"`             // [string]Material variable to set charge value on.
	ChargeUpMuzzleFlash     string                `json:"charge_up_muzzle_flash"`      // [particles]Particle effect of the muzzle flash while charging.
	ChargeUpMuzzleFlashLoop string                `json:"charge_up_muzzle_flash_loop"` // [particles]Looping particle effect of the muzzle flash while charging.
	ChargeAnimID            string                `json:"charge_anim_id"`              // [string]What the animation variable is for rotating the barrel.
	ChargeEndAnimID         string                `json:"charge_end_anim_id"`          // [string]What the animation variable is for rotating the barrel.
	ChargeRateAnimID        string                `json:"charge_rate_anim_id"`         // [string]What the animation variable is for rotating the barrel.
	SpinSpeedAnimID         string                `json:"spin_speed_anim_id"`          // [string]What the animation variable is for rotating the barrel.
	AutoFireInSafety        bool                  `json:"auto_fire_in_safety"`         // [bool]If disabled, will allow the user to keep the charge as long as they are holding the trigger.
	ExplodesOnOvercharged   bool                  `json:"explodes_on_overcharged"`     // Unknown bool, name length 24 chars
	ExplosionAudioEvent     string                `json:"explosion_audio_event"`       // Unknown, name length 22 chars
	UnknownFloat            float32               `json:"unknown_float"`               // Unknown, probably related to the above
	DryFireAudioEvent       string                `json:"dry_fire_audio_event"`        // [string].
	ExplodeType             enum.ExplosionType    `json:"explosion_type"`
	StateValue              UnknownChargeStruct   `json:"state_value"`
}

type SimpleWeaponCustomizableItem struct {
	NameCased      string                             `json:"name_cased"`
	DebugName      string                             `json:"debug_name"`
	ID             stingray.ThinHash                  `json:"id"`
	NameUpper      string                             `json:"name_upper"`
	Description    string                             `json:"description"`
	Fluff          string                             `json:"fluff"`
	Archive        string                             `json:"archive"`
	AddPath        string                             `json:"add_path"`
	Icon           string                             `json:"icon"`
	Slots          []enum.WeaponCustomizationSlot     `json:"slots,omitempty"`
	UIWidgetColors []mgl32.Vec3                       `json:"ui_widget_colors,omitempty"`
	SortGroups     enum.WeaponCustomizationSortGroups `json:"sort_groups"`
}

type SimpleWeaponCustomizationComponent struct {
	DefaultCustomizations                   []SimpleWeaponDefaultAttachment     `json:"default_customizations,omitempty"`
	CustomizationSlots                      []enum.WeaponCustomizationSlot      `json:"customization_slots,omitempty"`
	OpticsPath                              string                              `json:"optics_path"`
	MagazinePath                            string                              `json:"magazine_path"`
	MagazineSecondaryPath                   string                              `json:"magazine_secondary_path"`
	MuzzlePath                              string                              `json:"muzzle_path"`
	OpticsCrosshairParams                   mgl32.Vec2                          `json:"optics_crosshair_params"`
	Unknown0Path                            string                              `json:"unknown0_path"`
	Unknown1Path                            string                              `json:"unknown1_path"`
	UnderbarrelPath                         string                              `json:"underbarrel_path"`
	MaterialOverride                        SimpleWeaponMaterialOverride        `json:"material_override"`
	TriggerSettings                         SimpleWeaponTriggerSettings         `json:"trigger_settings"`
	HideMagazineOnStart                     bool                                `json:"hide_magazine_on_start"`
	MagazineAdjustingNodes                  []string                            `json:"magazine_adjusting_nodes,omitempty"`
	MagazineAdjustingNodesVisibleChambering bool                                `json:"magazine_adjusting_nodes_visible_chambering"`
	UnknownEnum                             enum.WeaponCustomizationUnknownEnum `json:"unknown_enum"`
	UnknownBool                             bool                                `json:"unknown_bool"`
	MagazineAdjustingAnimation              string                              `json:"magazine_adjusting_animation"`
	MagazineAdjustingAnimationVariable      string                              `json:"magazine_adjusting_animation_variable"`
	IKAttachSetting                         enum.WeaponCustomizationIKAttach    `json:"ik_attach_setting"`
	IKAttachAnimationEvent                  string                              `json:"ik_attach_animation_event"`
	UnknownThinHash                         string                              `json:"unknown_thin_hash"`
}

type SimpleWeaponCustomizationSettings struct {
	Items []SimpleWeaponCustomizableItem `json:"items"`
}

type SimpleWeaponDataComponent struct {
	RecInfo                                RecoilInfo                     `json:"recoil_info"`      // Information about the recoil.
	RecModifiers                           RecoilModifiers                `json:"recoil_modifiers"` // Alterations to the base recoil
	Spread                                 SimpleSpreadInfo               `json:"spread"`           // Information about the spread.
	SpreadMods                             SpreadModifiers                `json:"spread_modifiers"` // Alterations to the base spread
	SwayMultiplier                         float32                        `json:"sway_multiplier"`  // Multiplier applied to all sway, changing its magnitude
	AimBlockLength                         float32                        `json:"aim_block_length"` // The length of the weapon, used to block the user from aiming when obstructed.
	IsSuppressed                           bool                           `json:"is_suppressed"`
	AimZoom                                mgl32.Vec3                     `json:"aim_zoom"` // The zoom of the weapon 1 = standard fov, 2 = half fov, 4 = quarter fov
	ScopeSway                              float32                        `json:"scope_sway"`
	NoiseTemp                              enum.NoiseTemplate             `json:"noise_temp"`                                  // The noise noise template settings to use when firing the weapon.
	VisibilityModifier                     float32                        `json:"visibility_modifier"`                         // When firing the weapon, the visibility will be set to this value, and the cone angle will be multiplied by this factor.
	NumBurstRounds                         uint32                         `json:"num_burst_rounds"`                            // Number of rounds fired for a burst shot.
	PrimaryFireMode                        enum.FireMode                  `json:"primary_fire_mode"`                           // The primary fire mode (0 = ignored, 1 = auto, 2 = single, 3 = burst, 4 = charge safety on, 5 = charge safety off.)
	SecondaryFireMode                      enum.FireMode                  `json:"secondary_fire_mode"`                         // The secondary fire mode
	TertiaryFireMode                       enum.FireMode                  `json:"tertiary_fire_mode"`                          // The tertiary fire mode
	FunctionInfo                           WeaponFunctionInfo             `json:"function_info"`                               // Settings for the different functions this weapon has.
	Crosshair                              string                         `json:"crosshair"`                                   // [material]The crosshair material.
	AlwaysShowCrosshair                    bool                           `json:"always_show_crosshair"`                       // [bool]Should we always show the crosshair when wielding this weapon?)
	FireNodes                              []string                       `json:"fire_nodes,omitempty"`                        // [string]The nodes from where to spawn weapon output. If more than one, it will cycle through them.
	AimSourceNode                          string                         `json:"aim_source_node"`                             // [string]The node from where we check for blocked aim. On mounted weapons, this is usually the muzzle, while on carried weapons it is usually the root. This is because the muzzle moves a lot as part of the block animation, leading to oscillations.
	SimultaneousFire                       bool                           `json:"simultaneous_fire"`                           // [bool]If set, it fires one round from each fire node on single fire.
	ScopeResponsiveness                    float32                        `json:"scope_responsiveness"`                        // How quickly the scope/sight follows changes in aim and movement.
	ScopeCrosshair                         mgl32.Vec2                     `json:"scope_crosshair"`                             // Crosshair position on screen in [-1, 1] range.
	ScopeOffset                            mgl32.Vec3                     `json:"scope_offset"`                                // X=Right, Y=Up, Z=Forward. Offset of the sight node relative to the default. Is added to the customization settings for applied customizations that affect it.
	ScopeZeroing                           mgl32.Vec3                     `json:"scope_zeroing"`                               // What are the different stages of zeroing we are allowed to have?
	ScopeLensHidesWeapon                   bool                           `json:"scope_lens_hides_weapon"`                     // [bool]Should we hide the weapon when looking through the scope lens? Should be applied for optics that have high zoom.
	Ergonomics                             float32                        `json:"ergonomics"`                                  // How responsive is the weapon when turning, aiming and shooting?
	ConstrainedAimLeading                  bool                           `json:"constrained_aim_leading"`                     // [bool]If set, the camera may not get too far away from the aim direction.
	AllowFPV                               bool                           `json:"allow_fpv"`                                   // [bool]Allow First Person View on this weapon
	AllowAiming                            bool                           `json:"allow_aiming"`                                // [bool]Allow aiming on this weapon
	CrosshairType                          enum.CrosshairWeaponType       `json:"crosshair_type"`                              // What does this weapons crosshair look like.
	FirstPersonSightNodes                  []SimpleOpticSetting           `json:"first_person_sight_nodes,omitempty"`          // [string]The chain of bones to the sight of the weapon for first person view.
	FirstPersonCameraNode                  string                         `json:"first_person_camera_node"`                    // Not sure. name length should be 23 chars in snake_case
	FirstPersonOpticAttachNode             string                         `json:"first_person_optic_attach_node"`              // [string]The chain of bones to the attach_optic bone of the weapon for first person view.
	AutoDropAbility                        enum.AbilityId                 `json:"auto_drop_ability"`                           // The ability to play when dropping the weapon due to no ammo. Only used for un-realoadable weapons.
	ShouldWeaponScream                     bool                           `json:"should_weapon_scream"`                        // [bool]Should Play Weapon Scream.
	EnterFirstPersonAimAudioEvent          string                         `json:"enter_first_person_aim_audio_event"`          // [wwise]Sound id to play when entering first person aim
	ExitFirstPersonAimAudioEvent           string                         `json:"exit_first_person_aim_audio_event"`           // [wwise]Sound id to play when exiting first person aim
	FirstPersonAimAudioEventNodeID         string                         `json:"first_person_aim_audio_event_node_id"`        // [string]Node at where the on/exit aim down sights sounds are played.
	EnterThirdPersonAimAudioEvent          string                         `json:"enter_third_person_aim_audio_event"`          // [wwise]Sound id to play when entering third person aim
	ExitThirdPersonAimAudioEvent           string                         `json:"exit_third_person_aim_audio_event"`           // [wwise]Sound id to play when exiting third person aim
	ThirdPersonAimAudioEventNodeID         string                         `json:"third_person_aim_audio_event_node_id"`        // [string]Node at where the on/exit aim down sights sounds are played.
	FireModeChangedAudioEvent              string                         `json:"fire_mode_changed_audio_event"`               // [wwise]Sound id to play when changing fire mode
	OnFireRoundsRemainingAnimationVariable string                         `json:"on_fire_rounds_remaining_animation_variable"` // [string]Animation variable to set to the normalized value of the remaining amount of rounds every time we fire our weapon.
	OnFireRoundEffects                     []SimpleEffectSetting          `json:"on_fire_round_effects,omitempty"`             // Extra particle effect to play when firing a round for this weapon. This effect is fire-and-forget.
	OnFireRoundNodeScales                  []SimpleUnitNodeScale          `json:"on_fire_round_node_scales,omitempty"`         // Node to be scaled firing a round for this weapon.
	OnFireRoundAnimEvent                   string                         `json:"on_fire_round_anim_event"`                    // [string]Animation event to trigger every time we fire a round.
	OnFireLastRoundAnimEvent               string                         `json:"on_fire_last_round_anim_event"`               // [string]Animation event to trigger when we fire the last round, replaces the normal animation event at that case.
	OnFireRoundWielderAnimEvent            string                         `json:"on_fire_round_wielder_anim_event"`            // [string]Animation event to trigger on the wielder every time we fire a round.
	OnFireModeChangedAnimVariable          string                         `json:"on_fire_mode_changed_anim_variable"`          // [string]The animation variable to set with the new fire mode.
	OnFireModeChangedWielderAnimEvent      string                         `json:"on_fire_mode_changed_wielder_anim_event"`     // [string]Animation event to trigger on the wielder / fp wielder every time we change fire mode.
	FireAbility                            enum.AbilityId                 `json:"fire_ability"`                                // The ability to play on the weapon when it fires
	Unk1Ability                            enum.AbilityId                 `json:"unk1_ability"`                                // idk
	Unk2Ability                            enum.AbilityId                 `json:"unk2_ability"`                                // idk
	InfiniteAmmo                           bool                           `json:"infinite_ammo"`                               // [bool]Should this weapon have infinite ammo
	WeaponStatModifiers                    []WeaponStatModifierSetting    `json:"weapon_stat_modifiers,omitempty"`             // Used by attachments to specify what stat they modify and not override via normal ADD formatting.
	AmmoIconInner                          string                         `json:"ammo_icon_inner"`                             // [material]The inner icon for the magazine that shows up on the HUD.
	AmmoIconOuter                          string                         `json:"ammo_icon_outer"`                             // [material]The outer icon for the magazine that shows up on the HUD.
	WeaponFunctionFireModes                []SimpleWeaponFireModeFunction `json:"weapon_function_fire_modes,omitempty"`        // Unknown
	Unk3Ability                            enum.AbilityId                 `json:"unk3_ability"`                                // Maybe related to the array above?
	UnkHash1                               string                         `json:"unk_hash1"`
	UnkHash2                               string                         `json:"unk_hash2"`
	UnkHash3                               string                         `json:"unk_hash3"`
	UnkHash4                               string                         `json:"unk_hash4"`
}

type SimpleWeaponDefaultAttachment struct {
	Slot          enum.WeaponCustomizationSlot `json:"slot"`          // Full customization slot (not unique).
	Customization string                       `json:"customization"` // [string]Name of the default customization to use.
}

type SimpleWeaponFireModeFunction struct {
	Function         enum.WeaponFunctionType `json:"function"`
	SomeHash         string                  `json:"unk_hash"`
	SomeOtherHash    string                  `json:"unk_hash2"`
	FunctionFireMode enum.FireMode           `json:"function_fire_mode"`
	SomeBool         bool                    `json:"some_bool"`
}

type SimpleWeaponHeatComponent struct {
	HSOverrides                   []SimpleHeatsinkOverrides `json:"heatsink_overrides,omitempty"`
	UnknownFloat                  float32                   `json:"unknown_float"`
	UnknownFloat2                 float32                   `json:"unknown_float2"`
	UnknownBool                   bool                      `json:"unknown_bool"`
	Magazines                     uint32                    `json:"magazines"`                       // Starting number of magazines.
	MagazinesRefill               uint32                    `json:"magazines_refill"`                // Number of magazines given on refill.
	MagazinesMax                  uint32                    `json:"magazines_max"`                   // Maximum number of magazines.
	OverheatTemperature           float32                   `json:"overheat_temperature"`            // Temperature at which the weapon overheats.
	UnknownFloat3                 float32                   `json:"unknown_float3"`                  // Name length 28 chars
	WarningTemperature            float32                   `json:"warning_temperature"`             // Temperature at which the weapon cues an audible warning.
	EmissionTemperature           float32                   `json:"emission_temperature"`            // Temperature at which the weapon begins emitting smoke/steam particles.
	RTPCTemperature               float32                   `json:"rtpc_temperature"`                // Temperature at which the weapon starts altering the laser RTPC.
	TempGainPerShot               float32                   `json:"temp_gain_per_shot"`              // Amount of temperature added to the weapon per shot when firing.
	TempGainPerSecond             float32                   `json:"temp_gain_per_second"`            // Amount of temperature added to the weapon per second when firing.
	TempGainPerSecondModifier     float32                   `json:"temp_gain_per_second_modifier"`   // Multiplier on .the base temperature gain used by customizations.
	TempLossPerSecond             float32                   `json:"temp_loss_per_second"`            // Amount of temperature removed from the weapon per second when not firing.
	TempLossPerSecondOverheated   float32                   `json:"temp_loss_per_second_overheated"` // Amount of temperature removed from the weapon per second after it's overheated.
	UnknownFloat4                 float32                   `json:"unknown_float4"`                  // idk, name length should be 31 chars
	UnknownFloat5                 float32                   `json:"unknown_float5"`                  // idk, name length should be 31 chars
	NeedsReloadAfterOverheat      bool                      `json:"needs_reload_after_overheat"`     // [bool]Should the weapon require a new magazine after an overheat.
	FiringCharge                  float32                   `json:"firing_charge"`                   // Charge required to fire.
	ChargeGainPerSecond           float32                   `json:"charge_gain_per_second"`          // Amount of charge added to the weapon per second while holding the trigger.
	ChargeLossPerSecond           float32                   `json:"charge_loss_per_second"`          // Amount of charge removed from the weapon per second while not holding the trigger.
	ResetChargeAfterShot          bool                      `json:"reset_charge_after_shot"`         // [bool]Should set the charge to 0 after each shot?.
	SomeOtherBool                 bool                      `json:"some_other_bool"`
	OwnerWarningVOEvent           string                    `json:"owner_warning_vo_event"`           // [string]The VO Event to play on owner when the beam weapon reaches warning level.
	OwnerOverheatVOEvent          string                    `json:"owner_overheat_vo_event"`          // [string]The VO Event to play on owner when the beam weapon gets overheated.
	MinReloadTemperature          float32                   `json:"min_reload_temperature"`           // How much temperature do we need before we can reload
	ChargingStartAudioEvent       string                    `json:"charging_start_audio_event"`       // [wwise]The audio event to play on start charging
	ChargingCompleteAudioEvent    string                    `json:"charging_complete_audio_event"`    // [wwise]The audio event to play when charging complete.
	DischargingStartAudioEvent    string                    `json:"discharging_start_audio_event"`    // [wwise]The audio event to play on start discharging
	DischargingCompleteAudioEvent string                    `json:"discharging_complete_audio_event"` // [wwise]The audio event to play when discharging complete.
	ChargeSourceNode              string                    `json:"charge_source_node"`               // [string]The node to play the charge/discharge audio events at.
	OnOverheatStartSoundEvent     string                    `json:"on_overheat_start_sound_event"`    // [wwise]The wwise sound id to play when overheating starts.
	OnOverheatStopSoundEvent      string                    `json:"on_overheat_stop_sound_event"`     // [wwise]The wwise sound id to play when overheating stops.
	OnTempYellowStartSoundEvent   string                    `json:"on_temp_yellow_start_sound_event"` // [wwise]The wwise sound id to play when yellow temperature starts.
	UnknownSoundEvent             string                    `json:"unknown_sound_event"`              // Its probably an intermediate sound effect. Length 18 chars
	OnTempYellowStopSoundEvent    string                    `json:"on_temp_yellow_stop_sound_event"`  // [wwise]The wwise sound id to play when yellow temperature stops.
	UnknownSoundEvent2            string                    `json:"unknown_sound_event2"`
	UnknownSoundEvent3            string                    `json:"unknown_sound_event3"`
	UnknownSoundEvent4            string                    `json:"unknown_sound_event4"`
	UnknownSoundEvent5            string                    `json:"unknown_sound_event5"`
	UnknownSoundEvent6            string                    `json:"unknown_sound_event6"`
	UnknownSoundEvent7            string                    `json:"unknown_sound_event7"`
	CameraShakeOnChargingStart    string                    `json:"camera_shake_on_charging_start"`     // [camera_shake]The shake effect to play when the laser weapon starts charging. This ends when the charging is complete.
	CameraShakeOnFiringStart      string                    `json:"camera_shake_on_firing_start"`       // [camera_shake]The shake effect to play when the laser weapon starts discharging. This ends when the discharging is complete.
	CameraShakeOnYellowTempStart  string                    `json:"camera_shake_on_yellow_temp_start"`  // [camera_shake]The shake effect to play when the laser weapon enters yellow temperature. This ends when it exits out of yellow temperature.
	CameraShakeOnRedTempStart     string                    `json:"camera_shake_on_red_temp_start"`     // [camera_shake]The shake effect to play when the laser weapon enters red temperature. This ends when it exits out of red temperature.
	CameraShakeOnFireStopConstant string                    `json:"camera_shake_on_fire_stop_constant"` // [camera_shake]The exiting constant effect for when you stop firing the weapon.
	CameraShakeOnFireStopKick     string                    `json:"camera_shake_on_fire_stop_kick"`     // [camera_shake]The exiting kick effect for when you stop firing the weapon.
	OverheatAbility               enum.AbilityId            `json:"overheat_ability"`                   // The ability to play when this weapon overheats.
}

type SimpleWeaponMagazineAnimEvent struct {
	Type                  enum.WeaponReloadEventType `json:"type"`                    // Type of reload.
	AnimationEventWeapon  string                     `json:"animation_event_weapon"`  // [string]Animatiom event to trigger.
	AnimationEventWielder string                     `json:"animation_event_wielder"` // [string]Animatiom event to trigger.
}

type SimpleWeaponMagazineComponent struct {
	Type            enum.MagazineType     `json:"magazine_type"`    // Type of magazine.
	Pattern         SimpleMagazinePattern `json:"magazine_pattern"` // Only used if magazine type is Pattern.
	Capacity        uint32                `json:"capacity"`         // Number of rounds in one magazine.
	Magazines       uint32                `json:"magazines"`        // Starting number of magazines
	MagazinesRefill uint32                `json:"magazines_refill"` // Number of magazines given on refill.
	MagazinesMax    uint32                `json:"magazines_max"`    // Maximum number of magazines.
	ReloadThreshold uint32                `json:"reload_threshold"` // Reload is allowed when less than this amount of rounds are left in the clip. Defaults to 0 which means 'Same as clip capacity'.
	Chambered       bool                  `json:"chambered"`        // [bool]Can this weapon hold a round in the chamber while reloading. This makes the max amount of bullets capacity + 1 after reload when weapon has rounds remaining
	UnknownBool     bool                  `json:"unknown_bool"`
}

type SimpleWeaponMaterialOverride struct {
	DefaultWeaponSlotMaterial       []UnitCustomizationMaterialOverrides     `json:"default_weapon_slot_material,omitempty"` // Default material overrides per slot
	WeaponSlotMaterialCustomization []SimpleWeaponSlotCustomizationMaterials `json:"weapon_slot_material_customization,omitempty"`
}

type SimpleWeaponReloadComponent struct {
	ManualClearing           bool                            `json:"manual_clearing"`               // [bool]If this is true, the rules for fast/slow reload change
	ReloadAllowMove          bool                            `json:"reload_allow_move"`             // [bool]Whether or not the player can move while reloading this weapon.
	Ability                  enum.AbilityId                  `json:"ability"`                       // The ability to play on the wielder when reloading this weapon.
	ReloadAnimEvents         []SimpleWeaponMagazineAnimEvent `json:"reload_anim_events,omitempty"`  // The animation event that will be triggered, depending on the reload type
	Duration                 float32                         `json:"duration"`                      // The duration of the reload. We scale the reload ability to match this duration. If 0, use the default ability duration (no scaling).
	HasSharedDeposit         bool                            `json:"has_shared_deposit"`            // [bool]Should this unit look for a (shared) deposit on the entity it it mounted on when checking for ammo?
	ReloadVONormal           string                          `json:"reload_vo_normal"`              // [string]VO event to play when doing a normal reload.
	ReloadVOLastmag          string                          `json:"reload_vo_lastmag"`             // [string]VO event to play when doing a reload while being on your last mag (1 mag left).
	ReloadVONoMags           string                          `json:"reload_vo_no_mags"`             // [string]VO event to play when trying to reload but have no mags.
	ReloadVONoMagsNoBackpack string                          `json:"reload_vo_no_mags_no_backpack"` // [string]If VO event is present we play this when trying to reload but have no mags and no backpack.
}

type SimpleWeaponRoundsComponent struct {
	AmmoInfo             WeaponRoundsAmmoInfo `json:"ammo_info"`              // Ammo info for recoil and spread per magazine.
	AmmoType             WeaponRoundsAmmoType `json:"ammo_type"`              // Ammo types per magazine.
	MagazineCapacity     mgl32.Vec2           `json:"magazine_capacity"`      // Capacity in rounds for each magazine.
	AmmoCapacity         uint32               `json:"ammo_capacity"`          // Maximum number of rounds.
	AmmoRefill           uint32               `json:"ammo_refill"`            // Number of rounds given on refill.
	Ammo                 uint32               `json:"ammo"`                   // Starting number of rounds.
	ReloadAmount         uint32               `json:"reload_amount"`          // Number of rounds to add to the magazine per reload.
	ReloadThresholds     mgl32.Vec2           `json:"reload_thresholds"`      // Reload is allowed when less than this amount of rounds are left in the magazine (set per magazine). Defaults to 0 which means 'Same as magazine capacity'.
	Chambered            bool                 `json:"chambered"`              // [bool]Can this weapon hold a round in the chamber while reloading. This makes the max amount of bullets capacity + 1 after reload when weapon has rounds remaining
	MagazineSwitchAudio  string               `json:"magazine_switch_audio"`  // [wwise]What audio to play when the magazines are switched
	Magazine0WeaponAnim  string               `json:"magazine0_weapon_anim"`  // [string]What weapon animation to play when switched to magazine 0
	Magazine0WielderAnim string               `json:"magazine0_wielder_anim"` // [string]What wielder animation to play when switched to magazine 0
	Magazine1WeaponAnim  string               `json:"magazine1_weapon_anim"`  // [string]What weapon animation to play when switched to magazine 1
	Magazine1WielderAnim string               `json:"magazine1_wielder_anim"` // [string]What wielder animation to play when switched to magazine 1
	MagazineAnimVariable string               `json:"magazine_anim_variable"` // [string]Do we have an animation variable that we care about?
}

type SimpleWeaponSlotCustomizationMaterials struct {
	Slot      enum.WeaponCustomizationSlot         `json:"slot"`
	Overrides []UnitCustomizationMaterialOverrides `json:"overrides"`
}

type SimpleWeaponTriggerSettings struct {
	TriggerThreshold                 uint32 `json:"trigger_threshold"`                    // The input value that causes the weapon to fire. Range is 0-9 for the inputs, but only 3-8 are valid for trigger resistance.
	TriggerThresholdRelease          uint32 `json:"trigger_threshold_release"`            // The input value that causes the weapon to stop firing (Should be equal or less than the regular threshold).
	ResistanceStrengthStart          uint32 `json:"resistance_strength_start"`            // The amount of resistance in the beginning.
	ResistanceStrengthEnd            uint32 `json:"resistance_strength_end"`              // The amount of resistance at the end. 0 means no trigger effect!
	VibrationAmplitude               uint32 `json:"vibration_amplitude"`                  // The vibration strength once the trigger is past the threshold. 0 means off.
	VibrationFrequency               uint32 `json:"vibration_frequency"`                  // The vibration frequency once the trigger is past the threshold.
	VibrationFrequencyVariance       uint32 `json:"vibration_frequency_variance"`         // The vibration frequency variance once the trigger is past the threshold.
	ChargeUpVibrationFrequencyStart  uint32 `json:"charge_up_vibration_frequency_start"`  // (Used by weapons that have spin up, charge, beam, etc) Replace the initial trigger resist with a vibration. This determines the vibration at 0% charge. 0 means off.
	ChargeUpVibrationFrequencyEnd    uint32 `json:"charge_up_vibration_frequency_end"`    // (Used by weapons that have spin up, charge, beam, etc) Replace the initial trigger resist with a vibration strength. This determines the vibration at 100% charge.
	WeightResistance                 uint32 `json:"weight_resistance"`                    // The amount of maximum resistance when aiming a weapon.
	DoubleActionTrigger              uint32 `json:"double_action_trigger"`                // If above 0, will activate the single shot trigger. Number determines by how much to offset the regular trigger.
	DoubleActionTriggerRegularOffset uint32 `json:"double_action_trigger_regular_offset"` // If double action is enabled, but we aren't in Full Auto, how much should the trigger threshold be offsetted by.
	OnFireEvent                      string `json:"on_fire_event"`                        // [string]The name of the audio event to send to the trigger on every fire event (for rumble + controller audio).
}

type SpreadInfo struct {
	Horizontal  float32 // The horizontal spread in MRAD.
	Vertical    float32 // The vertical spread in MRAD.
	UnknownBool uint8   // Unknown, probably toggles some kind of spread related thing. Name 17 chars long in snake_case
	// contains filtered or unexported fields
}

type SpreadModifiers struct {
	Horizontal float32 `json:"horizontal"` // Multiplier applied to the horizontal spread.
	Vertical   float32 `json:"vertical"`   // Multiplier applied to the vertical spread.
}

type StringsLookup func(uint32) string

type ThinHashLookup func(stingray.ThinHash) string

type UnimplementedComponent struct{}

type UnitComponent struct {
	UnitPath                          stingray.Hash         // [unit]Path to the unit for this entity.
	ScaleMin                          float32               // Min scale value.
	ScaleMax                          float32               // Max scale value.
	Radius                            float32               // The radius of the unit as used by e.g. motion and navigation
	HiddenVisibilityGroups            [20]stingray.ThinHash // [string]What groups to hide when this unit spawns?
	ShowRandomVisibilityGroup         [8]stingray.ThinHash  // [string]Upon spawn, picks a random visibility group and sets it visible.
	OnHotjoinCorpseRepairAbilityPatch enum.AbilityId        // This ability gets ran on hot joining players when the entity is a corpse.
}

type UnitCustomizationCollectionCategoryType uint32

type UnitCustomizationCollectionType uint32

type UnitCustomizationComponent struct {
	MaterialsTexturesOverrides    []UnitCustomizationMaterialOverrides `json:"materials_textures_overrides"`
	MountedWeaponTextureOverrides []UnitCustomizationMaterialOverrides `json:"mounted_weapon_texture_overrides"`
}

type UnitCustomizationMaterialOverrides struct {
	MaterialID stingray.ThinHash `json:"material_id"`

	MaterialLut       stingray.Hash `json:"material_lut,omitzero"`
	DecalSheet        stingray.Hash `json:"decal_sheet,omitzero"`
	PatternLut        stingray.Hash `json:"pattern_lut,omitzero"`
	PatternMasksArray stingray.Hash `json:"pattern_masks_array,omitzero"`
	// contains filtered or unexported fields
}

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

type UnitCustomizationSettings 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                []UnitCustomizationSetting              `json:"skins,omitempty"`
	ShowroomOffset       mgl32.Vec3                              `json:"showroom_offset"`
	ShowroomRotation     mgl32.Vec3                              `json:"showroom_rotation"`
}

type UnitData struct {
	Slot              CustomizationKitSlot
	Type              CustomizationKitPieceType
	Weight            CustomizationKitWeight
	BodyType          CustomizationKitBodyType
	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 UnitNodeScale struct {
	NodeID stingray.ThinHash
	Scale  mgl32.Vec3
}

type UnitSkinOverride struct {
	Name      string
	ID        stingray.ThinHash
	Overrides map[stingray.ThinHash][]UnitCustomizationMaterialOverrides
}

type UnitSkinOverrideGroup struct {
	CollectionType UnitCustomizationCollectionType
	Skins          []UnitSkinOverride
}

type UnknownChargeStruct struct {
	State enum.ChargeState `json:"charge_state"`
	Value float32          `json:"value"`
}

type VisibilityMaskComponent struct {
	MaskInfos      [64]VisibilityMaskInfo
	Randomizations [4]VisibilityRandomization
}

type VisibilityMaskInfo struct {
	Name        stingray.ThinHash
	Index       uint16
	StartHidden uint8
	// contains filtered or unexported fields
}

type VisibilityRandomization struct {
	Identifier     stingray.ThinHash
	MaskIndexNames [7]stingray.ThinHash
}

type WeaponCameraShakeInfo struct {
	WorldShakeEffect stingray.Hash // [camera_shake]The shake effect to play in world. This is _not_ played if a local shake is played!
	LocalShakeEffect stingray.Hash // [camera_shake]The shake effect to play on the local player's camera (that is the camera of the player firing this weapon, if and only if the weapon is being fired by a player).
	FPVShakeEffect   stingray.Hash // [camera_shake]The shake effect to play on the local player's camera while firing this weapon in FPV.
	InnerRadius      float32       // Inner radius of the world shake
	OuterRadius      float32       // Outer radius of the world shake
}

type WeaponCasingEffectInfo struct {
	EjectionEvent stingray.ThinHash // [string]Animation event that triggers the casing ejection. If none is specified it happens on fire.

	EjectionEffect stingray.Hash     // [particles]Particle effect of the shellcasing.
	EjectionNode   stingray.ThinHash // [string]Node on the weapon to play the ejection port effect.

	CasingEffect     stingray.Hash          // [particles]Particle effect of the shellcasing.
	CasingNode       [4]stingray.ThinHash   // [string]Nodes on the weapon to play the casing effect. Cycles through them if there is more than one.
	LinkEffect       stingray.Hash          // [particles]Particle effect of the link.
	LinkNode         stingray.ThinHash      // [string]Node on the weapon to play the link effect.
	CasingImpactType enum.SurfaceImpactType // Surface impact type to use for effects on shellcasing bounces.
	CasingAudioEvent stingray.ThinHash      // [string]If set, use this audio event instead of the default for the impact type.
	NumPlaybacks     uint32                 // How many collisions are audible
	// contains filtered or unexported fields
}

type WeaponChargeComponent struct {
	ChargeStateSettings     [3]ChargeStateSetting // Min-, Full-, and Over-Charged states
	ProjMultipliers         ProjectileMultipliers // Multipliers of the setting values for the projectile based on the charge amount.
	ChargeStartSoundID      stingray.ThinHash     // [string]Sound to start playing when the chargeup starts.
	ChargeStopSoundID       stingray.ThinHash     // [string]Sound id to play when the chargeup ends.
	ReadyToFireSoundID      stingray.ThinHash     // [string]Sound id to play when the weapon can fire.
	DangerOverchargeSoundID stingray.ThinHash     // [string]Sound id to play when the chargeup enters the danger zone.
	ChargeMesh              stingray.ThinHash     // [string]Mesh to set charge value on.
	ChargeMaterial          stingray.ThinHash     // [string]Material to set charge value on.
	ChargeVariable          stingray.ThinHash     // [string]Material variable to set charge value on.

	ChargeUpMuzzleFlash     stingray.Hash     // [particles]Particle effect of the muzzle flash while charging.
	ChargeUpMuzzleFlashLoop stingray.Hash     // [particles]Looping particle effect of the muzzle flash while charging.
	ChargeAnimID            stingray.ThinHash // [string]What the animation variable is for rotating the barrel.
	ChargeEndAnimID         stingray.ThinHash // [string]What the animation variable is for rotating the barrel.
	ChargeRateAnimID        stingray.ThinHash // [string]What the animation variable is for rotating the barrel.
	SpinSpeedAnimID         stingray.ThinHash // [string]What the animation variable is for rotating the barrel.
	AutoFireInSafety        uint8             // [bool]If disabled, will allow the user to keep the charge as long as they are holding the trigger.
	ExplodesOnOvercharged   uint8             // Unknown bool, name length 24 chars

	ExplosionAudioEvent stingray.ThinHash // Unknown, name length 22 chars
	UnknownFloat        float32           // Unknown, probably related to the above
	DryFireAudioEvent   stingray.ThinHash // [string].
	ExplodeType         enum.ExplosionType
	StateValue          UnknownChargeStruct
	// contains filtered or unexported fields
}

type WeaponCustomizableItem struct {
	NameCased      string
	DebugName      string
	ID             stingray.ThinHash
	NameUpper      string
	Description    string
	Fluff          string
	Archive        stingray.Hash
	AddPath        stingray.Hash
	Icon           stingray.Hash
	Slots          []enum.WeaponCustomizationSlot
	UIWidgetColors []mgl32.Vec3
	SortGroups     enum.WeaponCustomizationSortGroups
}

type WeaponCustomizationComponent struct {
	DefaultCustomizations [10]WeaponDefaultAttachment      // For each unique customization slot, the default attachment.
	CustomizationSlots    [10]enum.WeaponCustomizationSlot // Which slots can we use to customize the weapon?
	OpticsPath            stingray.Hash                    // [unit]Path to the optics/scope unit.
	MagazinePath          stingray.Hash                    // [unit]Path to the magazine unit.
	MagazineSecondaryPath stingray.Hash                    // [unit]Path to the second magazine unit.
	MuzzlePath            stingray.Hash                    // [unit]Path to the muzzle unit.
	OpticsCrosshairParams mgl32.Vec2                       // Offset and scale applied to the crosshair node in the optics unit. X=Forward offset, Y=Scale.
	Unknown0Path          stingray.Hash                    // Paintscheme path? 26 chars long
	Unknown1Path          stingray.Hash                    // Some other path - 31 chars long
	UnderbarrelPath       stingray.Hash                    // [adhd]Path to the underbarrel entity.
	MaterialOverride      WeaponMaterialOverride           // Overrides the base material of the weapon.
	TriggerSettings       WeaponTriggerSettings            // Set trigger settings
	HideMagazineOnStart   uint8

	MagazineAdjustingNodes                  [20]stingray.ThinHash // [string]Do we have any magazine nodes that need to be autoadjusted based on rounds left?
	MagazineAdjustingNodesVisibleChambering uint8                 // [bool]The very first node in the list will only be hidden if there isn't a chambered round

	UnknownEnum enum.WeaponCustomizationUnknownEnum // Not sure what this enum is. The type name should be 22 characters long and probably starts with Weapon
	UnknownBool uint8                               // [bool]No clue what this controls, maybe something to do with the unknown enum

	MagazineAdjustingAnimation         stingray.ThinHash                // [string]Animation to play on the magazine when adjusting the rounds (outside of the initial spawn).
	MagazineAdjustingAnimationVariable stingray.ThinHash                // [string]Animation variable to adjust with the rounds on the magazine.
	IKAttachSetting                    enum.WeaponCustomizationIKAttach // What unit should we attach our left hand to? If set to None, it will default to the weapon
	IKAttachAnimationEvent             stingray.ThinHash                // [string]Animation event to call, if an attachment is specified for altering our left hand.
	UnknownThinHash                    stingray.ThinHash                // No clue. Name should be 22 characters long in snake_case
	// contains filtered or unexported fields
}

type WeaponCustomizationSettings struct {
	Items []WeaponCustomizableItem
}

type WeaponDataComponent struct {
	RecInfo        RecoilInfo      // Information about the recoil.
	RecModifiers   RecoilModifiers // Alterations to the base recoil
	Spread         SpreadInfo      // Information about the spread.
	SpreadMods     SpreadModifiers // Alterations to the base spread
	SwayMultiplier float32         // Multiplier applied to all sway, changing its magnitude
	AimBlockLength float32         // The length of the weapon, used to block the user from aiming when obstructed.
	IsSuppressed   uint8

	AimZoom            mgl32.Vec3 // The zoom of the weapon 1 = standard fov, 2 = half fov, 4 = quarter fov
	ScopeSway          float32
	NoiseTemp          enum.NoiseTemplate // The noise noise template settings to use when firing the weapon.
	VisibilityModifier float32            // When firing the weapon, the visibility will be set to this value, and the cone angle will be multiplied by this factor.
	NumBurstRounds     uint32             // Number of rounds fired for a burst shot.
	PrimaryFireMode    enum.FireMode      // The primary fire mode (0 = ignored, 1 = auto, 2 = single, 3 = burst, 4 = charge safety on, 5 = charge safety off.)
	SecondaryFireMode  enum.FireMode      // The secondary fire mode
	TertiaryFireMode   enum.FireMode      // The tertiary fire mode
	FunctionInfo       WeaponFunctionInfo // Settings for the different functions this weapon has.

	Crosshair           stingray.Hash // [material]The crosshair material.
	AlwaysShowCrosshair uint8         // [bool]Should we always show the crosshair when wielding this weapon?)

	FireNodes        [24]stingray.ThinHash // [string]The nodes from where to spawn weapon output. If more than one, it will cycle through them.
	AimSourceNode    stingray.ThinHash     // [string]The node from where we check for blocked aim. On mounted weapons, this is usually the muzzle, while on carried weapons it is usually the root. This is because the muzzle moves a lot as part of the block animation, leading to oscillations.
	SimultaneousFire uint8                 // [bool]If set, it fires one round from each fire node on single fire.

	ScopeResponsiveness  float32    // How quickly the scope/sight follows changes in aim and movement.
	ScopeCrosshair       mgl32.Vec2 // Crosshair position on screen in [-1, 1] range.
	ScopeOffset          mgl32.Vec3 // X=Right, Y=Up, Z=Forward. Offset of the sight node relative to the default. Is added to the customization settings for applied customizations that affect it.
	ScopeZeroing         mgl32.Vec3 // What are the different stages of zeroing we are allowed to have?
	ScopeLensHidesWeapon uint8      // [bool]Should we hide the weapon when looking through the scope lens? Should be applied for optics that have high zoom.

	Ergonomics            float32 // How responsive is the weapon when turning, aiming and shooting?
	ConstrainedAimLeading uint8   // [bool]If set, the camera may not get too far away from the aim direction.
	AllowFPV              uint8   // [bool]Allow First Person View on this weapon
	AllowAiming           uint8   // [bool]Allow aiming on this weapon

	CrosshairType              enum.CrosshairWeaponType // What does this weapons crosshair look like.
	FirstPersonSightNodes      [4]OpticSetting          // [string]The chain of bones to the sight of the weapon for first person view.
	FirstPersonCameraNode      stingray.ThinHash        // Not sure. name length should be 23 chars in snake_case
	FirstPersonOpticAttachNode stingray.ThinHash        // [string]The chain of bones to the attach_optic bone of the weapon for first person view.
	AutoDropAbility            enum.AbilityId           // The ability to play when dropping the weapon due to no ammo. Only used for un-realoadable weapons.
	ShouldWeaponScream         uint8                    // [bool]Should Play Weapon Scream.

	EnterFirstPersonAimAudioEvent          stingray.ThinHash // [wwise]Sound id to play when entering first person aim
	ExitFirstPersonAimAudioEvent           stingray.ThinHash // [wwise]Sound id to play when exiting first person aim
	FirstPersonAimAudioEventNodeID         stingray.ThinHash // [string]Node at where the on/exit aim down sights sounds are played.
	EnterThirdPersonAimAudioEvent          stingray.ThinHash // [wwise]Sound id to play when entering third person aim
	ExitThirdPersonAimAudioEvent           stingray.ThinHash // [wwise]Sound id to play when exiting third person aim
	ThirdPersonAimAudioEventNodeID         stingray.ThinHash // [string]Node at where the on/exit aim down sights sounds are played.
	FireModeChangedAudioEvent              stingray.ThinHash // [wwise]Sound id to play when changing fire mode
	OnFireRoundsRemainingAnimationVariable stingray.ThinHash // [string]Animation variable to set to the normalized value of the remaining amount of rounds every time we fire our weapon.
	OnFireRoundEffects                     [8]EffectSetting  // Extra particle effect to play when firing a round for this weapon. This effect is fire-and-forget.
	OnFireRoundNodeScales                  [2]UnitNodeScale  // Node to be scaled firing a round for this weapon.
	OnFireRoundAnimEvent                   stingray.ThinHash // [string]Animation event to trigger every time we fire a round.
	OnFireLastRoundAnimEvent               stingray.ThinHash // [string]Animation event to trigger when we fire the last round, replaces the normal animation event at that case.
	OnFireRoundWielderAnimEvent            stingray.ThinHash // [string]Animation event to trigger on the wielder every time we fire a round.
	OnFireModeChangedAnimVariable          stingray.ThinHash // [string]The animation variable to set with the new fire mode.
	OnFireModeChangedWielderAnimEvent      stingray.ThinHash // [string]Animation event to trigger on the wielder / fp wielder every time we change fire mode.
	FireAbility                            enum.AbilityId    // The ability to play on the weapon when it fires
	Unk1Ability                            enum.AbilityId    // idk
	Unk2Ability                            enum.AbilityId    // idk
	InfiniteAmmo                           uint8             // [bool]Should this weapon have infinite ammo

	WeaponStatModifiers [8]WeaponStatModifierSetting // Used by attachments to specify what stat they modify and not override via normal ADD formatting.

	AmmoIconInner           stingray.Hash             // [material]The inner icon for the magazine that shows up on the HUD.
	AmmoIconOuter           stingray.Hash             // [material]The outer icon for the magazine that shows up on the HUD.
	WeaponFunctionFireModes [8]WeaponFireModeFunction // Unknown
	Unk3Ability             enum.AbilityId            // Maybe related to the array above?
	UnkHash1                stingray.ThinHash
	UnkHash2                stingray.ThinHash
	UnkHash3                stingray.ThinHash
	UnkHash4                stingray.ThinHash
	// contains filtered or unexported fields
}

type WeaponDefaultAttachment struct {
	Slot          enum.WeaponCustomizationSlot // Full customization slot (not unique).
	Customization stingray.ThinHash            // [string]Name of the default customization to use.
}

type WeaponFireModeFunction struct {
	Function         enum.WeaponFunctionType
	SomeHash         stingray.ThinHash
	SomeOtherHash    stingray.ThinHash
	FunctionFireMode enum.FireMode
	SomeBool         uint8
	// contains filtered or unexported fields
}

type WeaponFunctionInfo struct {
	Left  enum.WeaponFunctionType `json:"left"`  // What weapon function is related to this input.
	Right enum.WeaponFunctionType `json:"right"` // What weapon function is related to this input.
}

type WeaponHeatBuildup struct {
	HeatBuildPerShot float32 `json:"heat_build_per_shot"`
	MaximumHeat      float32 `json:"maximum_heat"`
	HeatBleedSpeed   float32 `json:"heat_bleed_speed"`
	HeatBleedDelay   float32 `json:"heat_bleed_delay"`
}

type WeaponHeatComponent struct {
	HSOverrides   [3]HeatsinkOverrides
	UnknownFloat  float32
	UnknownFloat2 float32
	UnknownBool   uint8

	Magazines                   uint32  // Starting number of magazines.
	MagazinesRefill             uint32  // Number of magazines given on refill.
	MagazinesMax                uint32  // Maximum number of magazines.
	OverheatTemperature         float32 // Temperature at which the weapon overheats.
	UnknownFloat3               float32 // Name length 28 chars
	WarningTemperature          float32 // Temperature at which the weapon cues an audible warning.
	EmissionTemperature         float32 // Temperature at which the weapon begins emitting smoke/steam particles.
	RTPCTemperature             float32 // Temperature at which the weapon starts altering the laser RTPC.
	TempGainPerShot             float32 // Amount of temperature added to the weapon per shot when firing.
	TempGainPerSecond           float32 // Amount of temperature added to the weapon per second when firing.
	TempGainPerSecondModifier   float32 // Multiplier on .the base temperature gain used by customizations.
	TempLossPerSecond           float32 // Amount of temperature removed from the weapon per second when not firing.
	TempLossPerSecondOverheated float32 // Amount of temperature removed from the weapon per second after it's overheated.
	UnknownFloat4               float32 // idk, name length should be 31 chars
	UnknownFloat5               float32 // idk, name length should be 31 chars
	NeedsReloadAfterOverheat    uint8   // [bool]Should the weapon require a new magazine after an overheat.

	FiringCharge         float32 // Charge required to fire.
	ChargeGainPerSecond  float32 // Amount of charge added to the weapon per second while holding the trigger.
	ChargeLossPerSecond  float32 // Amount of charge removed from the weapon per second while not holding the trigger.
	ResetChargeAfterShot uint8   // [bool]Should set the charge to 0 after each shot?.
	SomeOtherBool        uint8

	OwnerWarningVOEvent           stingray.ThinHash // [string]The VO Event to play on owner when the beam weapon reaches warning level.
	OwnerOverheatVOEvent          stingray.ThinHash // [string]The VO Event to play on owner when the beam weapon gets overheated.
	MinReloadTemperature          float32           // How much temperature do we need before we can reload
	ChargingStartAudioEvent       stingray.ThinHash // [wwise]The audio event to play on start charging
	ChargingCompleteAudioEvent    stingray.ThinHash // [wwise]The audio event to play when charging complete.
	DischargingStartAudioEvent    stingray.ThinHash // [wwise]The audio event to play on start discharging
	DischargingCompleteAudioEvent stingray.ThinHash // [wwise]The audio event to play when discharging complete.
	ChargeSourceNode              stingray.ThinHash // [string]The node to play the charge/discharge audio events at.
	OnOverheatStartSoundEvent     stingray.ThinHash // [wwise]The wwise sound id to play when overheating starts.
	OnOverheatStopSoundEvent      stingray.ThinHash // [wwise]The wwise sound id to play when overheating stops.
	OnTempYellowStartSoundEvent   stingray.ThinHash // [wwise]The wwise sound id to play when yellow temperature starts.
	UnknownSoundEvent             stingray.ThinHash // Its probably an intermediate sound effect. Length 18 chars
	OnTempYellowStopSoundEvent    stingray.ThinHash // [wwise]The wwise sound id to play when yellow temperature stops.
	UnknownSoundEvent2            stingray.ThinHash
	UnknownSoundEvent3            stingray.ThinHash
	UnknownSoundEvent4            stingray.ThinHash
	UnknownSoundEvent5            stingray.ThinHash
	UnknownSoundEvent6            stingray.ThinHash
	UnknownSoundEvent7            stingray.ThinHash
	CameraShakeOnChargingStart    stingray.Hash  // [camera_shake]The shake effect to play when the laser weapon starts charging. This ends when the charging is complete.
	CameraShakeOnFiringStart      stingray.Hash  // [camera_shake]The shake effect to play when the laser weapon starts discharging. This ends when the discharging is complete.
	CameraShakeOnYellowTempStart  stingray.Hash  // [camera_shake]The shake effect to play when the laser weapon enters yellow temperature. This ends when it exits out of yellow temperature.
	CameraShakeOnRedTempStart     stingray.Hash  // [camera_shake]The shake effect to play when the laser weapon enters red temperature. This ends when it exits out of red temperature.
	CameraShakeOnFireStopConstant stingray.Hash  // [camera_shake]The exiting constant effect for when you stop firing the weapon.
	CameraShakeOnFireStopKick     stingray.Hash  // [camera_shake]The exiting kick effect for when you stop firing the weapon.
	OverheatAbility               enum.AbilityId // The ability to play when this weapon overheats.
	// contains filtered or unexported fields
}

type WeaponMagazineAnimEvent struct {
	Type                  enum.WeaponReloadEventType // Type of reload.
	AnimationEventWeapon  stingray.ThinHash          // [string]Animatiom event to trigger.
	AnimationEventWielder stingray.ThinHash          // [string]Animatiom event to trigger.
}

type WeaponMagazineComponent struct {
	Type            enum.MagazineType // Type of magazine.
	Pattern         MagazinePattern   // Only used if magazine type is Pattern.
	Capacity        uint32            // Number of rounds in one magazine.
	Magazines       uint32            // Starting number of magazines
	MagazinesRefill uint32            // Number of magazines given on refill.
	MagazinesMax    uint32            // Maximum number of magazines.
	ReloadThreshold uint32            // Reload is allowed when less than this amount of rounds are left in the clip. Defaults to 0 which means 'Same as clip capacity'.
	Chambered       uint8             // [bool]Can this weapon hold a round in the chamber while reloading. This makes the max amount of bullets capacity + 1 after reload when weapon has rounds remaining
	UnknownBool     uint8
	// contains filtered or unexported fields
}

type WeaponMaterialOverride struct {
	DefaultWeaponSlotMaterial       [10]UnitCustomizationMaterialOverrides // Default material overrides per slot
	WeaponSlotMaterialCustomization [10]WeaponSlotCustomizationMaterials
}

type WeaponReloadComponent struct {
	ManualClearing  uint8 // [bool]If this is true, the rules for fast/slow reload change
	ReloadAllowMove uint8 // [bool]Whether or not the player can move while reloading this weapon.

	Ability          enum.AbilityId             // The ability to play on the wielder when reloading this weapon.
	ReloadAnimEvents [4]WeaponMagazineAnimEvent // The animation event that will be triggered, depending on the reload type
	Duration         float32                    // The duration of the reload. We scale the reload ability to match this duration. If 0, use the default ability duration (no scaling).
	HasSharedDeposit uint8                      // [bool]Should this unit look for a (shared) deposit on the entity it it mounted on when checking for ammo?

	ReloadVONormal           stingray.ThinHash // [string]VO event to play when doing a normal reload.
	ReloadVOLastmag          stingray.ThinHash // [string]VO event to play when doing a reload while being on your last mag (1 mag left).
	ReloadVONoMags           stingray.ThinHash // [string]VO event to play when trying to reload but have no mags.
	ReloadVONoMagsNoBackpack stingray.ThinHash // [string]If VO event is present we play this when trying to reload but have no mags and no backpack.
	// contains filtered or unexported fields
}

type WeaponRoundsAmmoInfo struct {
	PrimaryRecoilModifiers   RecoilModifiers // Information about the recoil for the primary magazine.
	PrimarySpreadModifiers   SpreadModifiers // Information about the spread for the primary magazine.
	SecondaryRecoilModifiers RecoilModifiers // Information about the recoil for the secondary magazine.
	SecondarySpreadModifiers SpreadModifiers // Information about the spread for the secondary magazine.
}

type WeaponRoundsAmmoType struct {
	PrimaryProjectileType   enum.ProjectileType // Projectile type the first magazine contains.
	AlternateProjectileType enum.ProjectileType // Projectile type the second magazine contains.
}

type WeaponRoundsComponent struct {
	AmmoInfo         WeaponRoundsAmmoInfo // Ammo info for recoil and spread per magazine.
	AmmoType         WeaponRoundsAmmoType // Ammo types per magazine.
	MagazineCapacity mgl32.Vec2           // Capacity in rounds for each magazine.
	AmmoCapacity     uint32               // Maximum number of rounds.
	AmmoRefill       uint32               // Number of rounds given on refill.
	Ammo             uint32               // Starting number of rounds.
	ReloadAmount     uint32               // Number of rounds to add to the magazine per reload.
	ReloadThresholds mgl32.Vec2           // Reload is allowed when less than this amount of rounds are left in the magazine (set per magazine). Defaults to 0 which means 'Same as magazine capacity'.
	Chambered        uint8                // [bool]Can this weapon hold a round in the chamber while reloading. This makes the max amount of bullets capacity + 1 after reload when weapon has rounds remaining

	MagazineSwitchAudio  stingray.ThinHash // [wwise]What audio to play when the magazines are switched
	Magazine0WeaponAnim  stingray.ThinHash // [string]What weapon animation to play when switched to magazine 0
	Magazine0WielderAnim stingray.ThinHash // [string]What wielder animation to play when switched to magazine 0
	Magazine1WeaponAnim  stingray.ThinHash // [string]What weapon animation to play when switched to magazine 1
	Magazine1WielderAnim stingray.ThinHash // [string]What wielder animation to play when switched to magazine 1
	MagazineAnimVariable stingray.ThinHash // [string]Do we have an animation variable that we care about?
	// contains filtered or unexported fields
}

type WeaponSlotCustomizationMaterials struct {
	Slot enum.WeaponCustomizationSlot

	Overrides [10]UnitCustomizationMaterialOverrides
	// contains filtered or unexported fields
}

type WeaponStatModifierSetting struct {
	Type  enum.WeaponStatModifierType `json:"type"` // Modifier type
	Value float32                     `json:"value"`
}

type WeaponTriggerSettings struct {
	TriggerThreshold                 uint32            // The input value that causes the weapon to fire. Range is 0-9 for the inputs, but only 3-8 are valid for trigger resistance.
	TriggerThresholdRelease          uint32            // The input value that causes the weapon to stop firing (Should be equal or less than the regular threshold).
	ResistanceStrengthStart          uint32            // The amount of resistance in the beginning.
	ResistanceStrengthEnd            uint32            // The amount of resistance at the end. 0 means no trigger effect!
	VibrationAmplitude               uint32            // The vibration strength once the trigger is past the threshold. 0 means off.
	VibrationFrequency               uint32            // The vibration frequency once the trigger is past the threshold.
	VibrationFrequencyVariance       uint32            // The vibration frequency variance once the trigger is past the threshold.
	ChargeUpVibrationFrequencyStart  uint32            // (Used by weapons that have spin up, charge, beam, etc) Replace the initial trigger resist with a vibration. This determines the vibration at 0% charge. 0 means off.
	ChargeUpVibrationFrequencyEnd    uint32            // (Used by weapons that have spin up, charge, beam, etc) Replace the initial trigger resist with a vibration strength. This determines the vibration at 100% charge.
	WeightResistance                 uint32            // The amount of maximum resistance when aiming a weapon.
	DoubleActionTrigger              uint32            // If above 0, will activate the single shot trigger. Number determines by how much to offset the regular trigger.
	DoubleActionTriggerRegularOffset uint32            // If double action is enabled, but we aren't in Full Auto, how much should the trigger threshold be offsetted by.
	OnFireEvent                      stingray.ThinHash // [string]The name of the audio event to send to the trigger on every fire event (for rumble + controller audio).
}

type WoundedState struct {
	SwayMultiplier      float32 `json:"sway_multiplier"`       // How much the sway should increase when wounded.
	MoveSpeedMultiplier float32 `json:"move_speed_multiplier"` // How much the move speed should be reduced when wounded
}