AIAttackComponent

- Members -----------------------------
int use_probability
100 [0, 100] "The probability for using this attack if it's
otherwise possible"
float min_distance
10 [0, 10000] "The minimum distance from enemy at which we can
perform this attack."
float max_distance
160 [0, 10000] "The maximum distance from enemy at which we can
perform this attack."
float angular_range_deg
90 [0, 90] "When looking for threats/prey this is our field of
view around the X axis. 90 means we scan the whole 180 degrees around the X axis,
to the left and right."
int state_duration_frames
45 [0, 1000] "How long do we stay in the attack state, before
other states are allowed?"
int frames_between
180 [0, 1000] "The minimum number of frames we wait between these
attacks"
int frames_between_global
30 [0, 1000] "The minimum number of frames we wait after this
attack before doing any other ranged attack"
std::string animation_name
attack_ranged [0, 1] "The animation to play when performing this attack"
bool attack_landing_ranged_enabled
0 [0, 1] "If 1, we try to land before doing the attack, if
there's ground near nearby under us"
int attack_ranged_action_frame
2 [0, 1000] "The frame of the 'attack_ranged' animation during
which the ranged attack actually occurs"
float attack_ranged_offset_x
0 [-1000, 1000] "'attack_ranged_entity_file' is created here when
performing a ranged attack"
float attack_ranged_offset_y
0 [-1000, 1000] "'attack_ranged_entity_file' is created here when
performing a ranged attack"
float attack_ranged_root_offset_x
0 [-1000, 1000] ""
float attack_ranged_root_offset_y
0 [-1000, 1000] ""
bool attack_ranged_use_message
0 [0, 1] "If 1, we do ranged attacks by sending a
Message_UseItem"
bool attack_ranged_predict
0 [0, 1] "If 1, we attempt to predict target movement and
shoot accordingly"
std::string attack_ranged_entity_file
data/entities/projectiles/spear.xml [0, 1] "File to projectile entity that is
created when performing a ranged attack"
int attack_ranged_entity_count_min
1 [0, 1000] "Minimum number of projectiles shot when performing
a ranged attack"
int attack_ranged_entity_count_max
1 [0, 1000] "Maximum number of projectiles shot when performing
a ranged attack"
bool attack_ranged_use_laser_sight
0 [0, 1] "If 1, we draw a laser sight to our target.
Requires entity to have a sprite with tag 'laser_sight'"
bool attack_ranged_aim_rotation_enabled
0 [0, 1] "If 1, we use a laser sight"
float attack_ranged_aim_rotation_speed
3 [0, 1] "How fast can we rotate our aim to track targets"
float attack_ranged_aim_rotation_shooting_ok_angle_deg
10 [0, 1] "If our aim is closer than this to the target we
shoot"
- Privates -----------------------------
float mRangedAttackCurrentAimAngle
0 [0, 1] "which direction does our gun currently point at,
physically saying?"
int mNextFrameUsable
0 [0, 1] ""

AIComponent
- Members -----------------------------
float TEMP_TEMP_TEMP
0 [0, 3.5] ""
- Privates -----------------------------
AIData* data
- ""

AbilityComponent
- Members -----------------------------
int cooldown_frames
0 [0, 60000] ""
std::string entity_file
- "the projectile entity file"
std::string sprite_file
- ""
int entity_count
1 [0, 60000] ""
bool never_reload
0 [0, 1] ""
int reload_time_frames
0 [0, 1] ""
float mana
0 [0, 1] ""
float mana_max
100 [0, 1] ""
float mana_charge_speed
10 [0, 1] ""
bool rotate_in_hand
1 [0, 1] ""
float rotate_in_hand_amount
1 [0, 1] "[0-1], how much does the item rotate related to
the actual aiming angle"
float rotate_hand_amount
0.7 [0, 1] "[0-1], how much does hand sprite rotate related to
the actual aiming angle"
bool fast_projectile
0 [0, 1] "if 1, then the velocity of the bullet is increased
quite a bit. Lightning requires this"
float swim_propel_amount
0 [-1000, 1000] ""
int max_charged_actions
0 [0, 1] ""
int charge_wait_frames
10 [0, 1] ""
float item_recoil_recovery_speed
15 [0, 1] "How quickly does the item return to resting state
after getting recoil"
float item_recoil_max
1 [0, 1] "Maximum distance moved by recoil"
float item_recoil_offset_coeff
1 [0, 1] "Item distance moved by recoil = mItemRecoil *
item_recoil_offset_coeff"
float item_recoil_rotation_coeff
5 [0, 1] "Item rotation by recoil = mItemRecoil *
item_recoil_rotation_coeff"
std::string base_item_file
data/entities/base_item.xml [0, 1] "when dropping / throwing the item, this is the
base_item that we add the ability component to"
bool use_entity_file_as_projectile_info_proxy
0 [0, 1] ""
bool click_to_use
1 [0, 1] ""
int stat_times_player_has_shot
0 [0, 1] "used to track how many times player has shot this
'ability'"
int stat_times_player_has_edited
0 [0, 1] "used to track how many times this has been edited"
bool shooting_reduces_amount_in_inventory
0 [0, 1] ""
bool throw_as_item
0 [0, 1] ""
bool simulate_throw_as_item
0 [0, 1] "If 1, the item will be work as normal ability, but
throwing animation is played by the user"
int max_amount_in_inventory
1 [0, 1] ""
int amount_in_inventory
1 [0, 1] ""
bool drop_as_item_on_death
1 [0, 1] ""
std::string ui_name
[NOT_SET] [0, 1] "way to name the weapons"
bool use_gun_script
0 [0, 1] "If 1, the default ability behaviour is replaced
with one that uses the lua gun system."
bool is_petris_gun
0 [0, 1] "if 1, TODO( PETRI)"
int gun_level
1 [1, 10] "the level of the wand, set in gun_procedural.lua"
std::string add_these_child_actions
- "e.g. 'bullet,bullet,damage' ... actions are parsed
into a string. These are added as actual entities when the item is initialized"
int current_slot_durability
-1 [0, 1] "After this many slots the last slot of the gun is
removed. -1 means not initialized/infinite."
std_string slot_consumption_function
_get_gun_slot_durability_default [0, 1] "Name of the lua function in 'gun.lua' that
is called to calculate durability of the last slot in the gun"
int mNextFrameUsable
0 [0, 1] "hax, don't touch!"
int mCastDelayStartFrame
0 [0, 1] "hax, don't touch!"
 int mReloadFramesLeft
0 [0, 1] "hax, don't touch!"
int mReloadNextFrameUsable
0 [0, 1] "hax, don't touch!"
int mChargeCount
0 [0, 1] "hax, don't touch!"
bool mIsInitialized
0 [0, 1] ""
- Objects -----------------------------
ConfigGun gun_config
- "Constants for gun script"
ConfigGunActionInfo gunaction_config
- "Constants for gun script"
- Privates -----------------------------
int mAmmoLeft
0 [0, 1] ""
int mNextChargeFrame
0 [0, 1] ""
float mItemRecoil
0 [0, 1] ""

AdvancedFishAIComponent
- Members -----------------------------
float move_check_range_min
16 [0, 2] ""
float move_check_range_max
64 [0, 2] ""
- Privates -----------------------------
bool flock
1 [0, 1] ""
bool avoid_predators
1 [0, 1] ""
bool mHasTargetDirection
0 [0, 1] ""
vec2 mTargetPos
- ""
vec2 mTargetVec
- ""
vec2 mLastFramesMovementAreaMin
- ""
vec2 mLastFramesMovementAreaMax
- ""
uint32 mNumFailedTargetSearches
0 [0, 1] ""
int mNextFrameCheckAreWeStuck
-1 [0, 1] ""
int mNextFrameCheckFlockWants
-1 [0, 1] ""
int mNextFramePredatorAvoidance
-1 [0, 1] ""
float mScared
0 [0, 1] ""
bool mWantsToBeInFlock
1 [0, 1] ""

AltarComponent
- Members -----------------------------
std::string recognized_entity_tags
- ""
 int uses_remaining
3 [0, 1] ""
- Custom data types -------------------
int good_fx_material
0 [0, 1] "String name of material for particles emitted on
successful sacrifice"
int neutral_fx_material
0 [0, 1] "String name of material for particles emitted on
successful sacrifice"
int evil_fx_material
0 [0, 1] "String name of material for particles emitted on
successful sacrifice"
- Privates -----------------------------
EntityTags m_recognized_entity_tags
- ""
uint32 m_recognized_entity_tags_count
0 [0, 1] ""
EntityTags m_current_entity_tags
- ""

AnimalAIComponent
- Members -----------------------------
int ai_state
0 [0, 20] "Current state of ai, defines what the animal is
doing"
int ai_state_timer
0 [0, 1000] "If not 0, then we wait till this frame to pop
current state from our state stack"
bool keep_state_alive_when_enabled
0 [0, 1] "if 1, will ensure state timer keeps current state
alive for a while when Component is Enabled"
std::string preferred_job
- "We always do this job, unless interrupted (i.e. by
taking fire damage)"
int escape_if_damaged_probability
30 [0, 1] "the chance of escaping if someone damages us. only
works if 'can_fly = 0 '"
int attack_if_damaged_probability
100 [0, 1] "the chance of counter-attacking if someone damages
us, and we didn't escape"
int eye_offset_x
0 [-100, 100] "We cast rays from our position + eye_offset to
check if we can see something"
int eye_offset_y
0 [-100, 100] "We cast rays from our position + eye_offset to
check if we can see something"
bool attack_only_if_attacked
0 [0, 1] "If 1, we never attack anyone unless attacked
before by someone"
bool dont_counter_attack_own_herd
0 [0, 1] "If 1, we don't attack members of our herd even if
they accidentally attack us"
float creature_detection_range_x
50 [0, 2000] "When looking for threats/prey this is the max
distance from us on the X axis we scan"
float creature_detection_range_y
20 [0, 2000] "When looking for threats/prey this is the max
distance from us on the Y axis we scan"
 float creature_detection_angular_range_deg
90 [0, 90] "When looking for threats/prey this is our field of
view around the X axis. 90 means we scan the whole 180 degrees around the X axis,
to the left and right"
int creature_detection_check_every_x_frames
120 [0, 5000] "Checks for threats/prey take place at least this
many frames apart from each other"
float max_distance_to_cam_to_start_hunting
300 [0, 2000] "JobDefault idles before we've been once at least
this close to the camera"
int pathfinding_max_depth_no_target
50 [0, 5000] "The maximum depth (in nodes) path search use when
we have not found prey yet"
int pathfinding_max_depth_has_target
120 [0, 5000] "The maximum depth (in nodes) path search use when
we have found prey"
float aggressiveness_min
80 [0, 100] "what's the initial random aggressiveness of this
creature"
float aggressiveness_max
100 [0, 100] "what's the initial random aggressiveness of this
creature"
bool tries_to_ranged_attack_friends
0 [0, 1] "if 1, the AI tries to attack whoever it considers
a friend based on herd_ids, CHARMED and BERSERK status etc. useful e.g. for
healers."
bool attack_melee_enabled
1 [0, 1] "If 1, and melee attack has been configured, we can
perform melee attacks"
bool attack_dash_enabled
0 [0, 1] "If 1, and dash attack has been configured, we can
perform dash attacks (a long-distance melee attack where we dash towards the
enemy)"
bool attack_landing_ranged_enabled
0 [0, 1] "If 1, and ranged attack has been configured, we
can perform ranged attacks"
bool attack_ranged_enabled
0 [0, 1] "If 1, and ranged attack has been configured, we
can perform ranged attacks"
float attack_knockback_multiplier
100 [-100, 100] "If not 0, melee and dash attacks cause knockback
to target"
bool is_static_turret
0 [0, 1] "If 1, we can only attack in one fixed direction"
int attack_melee_max_distance
20 [0, 400] "Maximum distance at which we can perform a melee
attack"
int attack_melee_action_frame
2 [0, 1000] "The animation frame during which the melee attack
damage is inflicted and visual effects are created"
int attack_melee_frames_between
10 [0, 1000] "The minimum number of frames we wait between melee
attacks"
float attack_melee_damage_min
0.4 [0, 100] "Melee attack damage inclusive minimum amount. The
damage is randomized between melee attack_damage_min and attack_melee_damage_max"
float attack_melee_damage_max
0.6 [0, 100] "Melee attack damage inclusive maximum amount. The
damage is randomized between melee attack_damage_min and attack_melee_damage_max"
 float attack_melee_impulse_vector_x
0 [-100, 100] "The x component of the impulse that is applied to
damaged entities"
float attack_melee_impulse_vector_y
0 [-100, 100] "The y component of the impulse that is applied to
damaged entities"
float attack_melee_impulse_multiplier
0 [-100, 100] "A multiplier applied to attack_melee_impulse"
float attack_melee_offset_x
0 [-1000, 1000] "Melee attack particle effects are created here"
float attack_melee_offset_y
0 [-1000, 1000] "Melee attack particle effects are created here"
bool attack_melee_finish_enabled
0 [0, 1] "If 1, we perform a finishing move when our attack
would kill the target using the 'attack_finish' animation"
int attack_melee_finish_action_frame
2 [0, 1000] "The animation frame during which the melee attack
finishing move damage is inflicted and visual effects are created"
float attack_dash_distance
50 [0, 10000] "The maximum distance from enemy at which we can
perform a dash attack. If a normal melee attack is possible we always do that
instead"
int attack_dash_frames_between
120 [0, 1200] "The minimum number of frames we wait between dash
attacks"
float attack_dash_damage
0.25 [0, 20] "The amount of damage inflicted by the dash attack"
float attack_dash_speed
200 [0, 5000] "The speed at which we dash"
float attack_dash_lob
0.9 [0, 6] "The smaller this value is the more curved our dash
attack trajectory is"
float attack_ranged_min_distance
10 [0, 10000] "The minimum distance from enemy at which we can
perform a ranged attack."
float attack_ranged_max_distance
160 [0, 10000] "The maximum distance from enemy at which we can
perform a ranged attack."
int attack_ranged_action_frame
2 [0, 1000] "The frame of the 'attack_ranged' animation during
which the ranged attack actually occurs"
float attack_ranged_offset_x
0 [-1000, 1000] "'attack_ranged_entity_file' is created here when
performing a ranged attack"
float attack_ranged_offset_y
0 [-1000, 1000] "'attack_ranged_entity_file' is created here when
performing a ranged attack"
bool attack_ranged_use_message
0 [0, 1] "If 1, we do ranged attacks by sending a
Message_UseItem"
bool attack_ranged_predict
0 [0, 1] "If 1, we attempt to predict target movement and
shoot accordingly"
std::string attack_ranged_entity_file
data/entities/projectiles/spear.xml [0, 1] "File to projectile entity that is
created when performing a ranged attack"
int attack_ranged_entity_count_min
1 [0, 1000] "Minimum number of projectiles shot when performing
a ranged attack"
 int attack_ranged_entity_count_max
1 [0, 1000] "Maximum number of projectiles shot when performing
a ranged attack"
bool attack_ranged_use_laser_sight
0 [0, 1] "If 1, we draw a laser sight to our target.
Requires entity to have a sprite with tag 'laser_sight'"
bool attack_ranged_laser_sight_beam_kind
0 [0, 1] "0 = red, 1 = blue "
bool attack_ranged_aim_rotation_enabled
0 [0, 1] ""
float attack_ranged_aim_rotation_speed
3 [0, 1] ""
float attack_ranged_aim_rotation_shooting_ok_angle_deg
10 [0, 1] ""
int attack_ranged_state_duration_frames
45 [0, 1000] "How long do we stay in the attack state, before
other states are allowed?"
bool hide_from_prey
0 [0, 1] "If 1, we attempt to hide from our target after a
succesful attack"
float hide_from_prey_target_distance
200 [0, 10000] "The minimum distance from our target where we
should move when hiding"
int hide_from_prey_time
300 [0, 1] "The number of frames we spend hiding and staying
hiding"
bool food_eating_create_particles
1 [0, 1] "If 1, we replace eaten cells with particles made
of this material"
int eating_area_radius_x
3 [-100, 100] "1/2 width of the area from which we eat food"
int eating_area_radius_y
8 [-100, 100] "1/2 height of the area from which we eat food"
int mouth_offset_x
0 [-100, 100] "The center of the area from which we eat food"
int mouth_offset_y
0 [-100, 100] "The center of the area from which we eat food"
bool defecates_and_pees
0 [0, 1] "If 1, we occasionally take a leak or a dump"
int butt_offset_x
0 [-100, 100] "Bodily wastes are created here"
int butt_offset_y
0 [-100, 100] "Bodily wastes are created here"
float pee_velocity_x
0 [-1000, 1000] "The velocity at which our piss gets shot"
float pee_velocity_y
0 [-1000, 1000] "The velocity at which our piss gets shot"
bool needs_food
1 [0, 1] "If 1, we stop to eat if we encounter
'food_material' cells"
bool sense_creatures
1 [0, 1] "If 1, we occasionally search our surroundings for
prey and threats"
bool sense_creatures_through_walls
0 [0, 1] "If 1, will see creatures even if the wall raycast
fails"
bool can_fly
1 [0, 1] "If 1, we can fly. Please set
'PathFindingComponent.can_fly' to 1 as well if this is 1"
 bool can_walk
1 [0, 1] "If 1, we can walk. Please set
'PathFindingComponent.can_walk' to 1 as well if this is 1"
int path_distance_to_target_node_to_turn_around
0 [0, 1000] "If we're further than this from target path
finding node on the X-axis we turn to face it"
float path_cleanup_explosion_radius
6 [0, 1000] "If we get stuck on ground we create an explosion
this big to clear our surroundings a bit"
float max_distance_to_move_from_home
0 [0, 1] ""
- Objects -----------------------------
ConfigExplosion attack_melee_finish_config_explosion
- "If we have explosion, it's the setup for it"
- Custom data types -------------------
LensValue<int> attack_ranged_frames_between
- "The minimum number of frames we wait between
ranged attacks"
int food_material
0 [0, 1] "The cell material we eat if encountering said
material and 'needs_food' is 1"
int food_particle_effect_material
0 [0, 1] "We create particles made of this material when
eating if 'food_eating_create_particles' is 1"
LensValue<float> mAggression
- "the greater this value the more likely we're to
attack creatures from other herds"
- Privates -----------------------------
AI_STATE_STACK mAiStateStack
- "a stack of actions and times they take, we can
push new actions to the front and pop them from there"
int mAiStateLastSwitchFrame
0 [0, 1] "when was the last time we switched a state"
int mAiStatePrev
0 [0, 1] "previous AI state"
int mCreatureDetectionNextCheck
0 [0, 1] "threat/prey check, next time we check for
threat/prey"
EntityID mGreatestThreat
0 [0, 1] "the entity we consider to be our greatest threat"
EntityID mGreatestPrey
0 [0, 1] "the entity we consider to be our most important
prey"
int mSelectedMultiAttack
-1 [0, 1] "which AIAttackComponent attack are we using?"
bool mHasFoundPrey
0 [0, 1] "1, if we have ever found prey"
bool mHasBeenAttackedByPlayer
0 [0, 1] "1, if we have been ever attacked"
bool mHasStartedAttacking
0 [0, 1] "1, if we have ever started attacking anyone"
int mNearbyFoodCount
0 [0, 1] "amount of 'food_material' near us"
int mEatNextFrame
0 [0, 1] "next frame we can eat"
int mEatTime
0 [0, 1] "time we've been constantly eating"
int mFrameNextGiveUp
0 [0, 1] "next frame we consider ourselves to be stuck"
 vec2 mLastFramesMovementAreaMin
- "AABB min of the area where we've been since the
last time we got stuck"
vec2 mLastFramesMovementAreaMax
- "AABB max of the area where we've been since the
last time we got stuck"
int mFoodMaterialId
-1 [0, 1] "cached id of 'food_material'"
int mFoodParticleEffectMaterialId
-1 [0, 1] "cached id of 'food_particle_effect_material'"
float mNextJumpLob
1 [0, 1] "we use this for next jump"
vec2 mNextJumpTarget
- "we use this for next jump"
bool mNextJumpHasVelocity
0 [0, 1] "we use this for next jump"
int mLastFrameJumped
-1 [0, 1] "previous frame we launched into a jump"
int mFramesWithoutTarget
0 [0, 1] ""
int mLastFrameCanDamageOwnHerd
-1 [0, 1] ""
vec2 mHomePosition
- "where our home is located"
int mLastFrameAttackWasDone
0 [0, 1] "when was the last time we did an attack (not
necessarily did damage to anyone though)"
int mNextFrameCanCallFriend
0 [0, 1] ""
int mNextFrameRespondFriend
-1 [0, 1] ""
bool mHasNoticedPlayer
0 [0, 1] "if 1, we have noticed player or player projectile"
float mRangedAttackCurrentAimAngle
0 [0, 1] "which direction does our gun currently point at,
physically saying?"
int mRangedAttackNextFrame
0 [0, 1] "next frame we can perform a ranged attack"
int mMeleeAttackNextFrame
0 [0, 1] "next frame we can perform a melee attack"
float mNextMeleeAttackDamage
0 [0, 1] "the amount of damage our next melee attack will
cause. used by finishing move logic"
bool mMeleeAttacking
0 [0, 1] "1, if we're doing a melee attack"
int mMeleeAttackDashNextFrame
0 [0, 1] "the next frame we can perform a melee attack"
RtsUnitGoal mCurrentJob
- "info about our current job. sorta legacy and could
be simplified because the RTS logic is not used anywhere but doesn't have much
overhead either."

ArcComponent
- Members -----------------------------
int lifetime
60 [0, 1] "remaining number of frames the arc exists"
- Custom data types -------------------
ARC_TYPE::Enum type
- "which implementation the arc should use"
 int material
0 [0, 1] "string name for the material the arc is made of"
- Privates -----------------------------
EntityID mArcTarget
0 [0, 1] "if 'mArcTarget' points to an existing entity a
lighting arc will be created between this entity and 'mArcTarget'"

AreaDamageComponent
- Members -----------------------------
float circle_radius
0 [0, 1] "if > 0, will only damage entities inside the aabb
rectangle which are closer than 'circle_radius' to the aabb center."
float damage_per_frame
10 [0, 256] ""
int update_every_n_frame
1 [0, 60] ""
EntityID entity_responsible
0 [0, 1] "if NULL, will try to figure out who to blame"
std::string death_cause
$damage_curse [0, 60] ""
std::string entities_with_tag
mortal [0, 1] "damage entities with this tag"
- Custom data types -------------------
vec2 aabb_min
- ""
vec2 aabb_max
- ""
DAMAGE_TYPES::Enum damage_type
- "the damage type"

AttachToEntityComponent
- Members -----------------------------
bool only_position
0 [0, 1] "if 1, we only inherit position. it is calculated
as follows: target_position + target_offset * target_scale"
std::string target_hotspot_tag
- "if set, we apply the offset of target HotSpot with
this tag"
int target_sprite_id
-1 [0, 1] "if >= 0, the Nth sprite transform in target entity
is inherited"
bool rotate_based_on_x_scale
0 [0, 1] "if 1, the rotation is set to 0 deg if scale >= 0
else to 180 deg"
bool destroy_component_when_target_is_gone
1 [0, 1] "should probably be on by default"
- Custom data types -------------------
types::xform Transform
- ""
- Privates -----------------------------
EntityID target
0 [0, 1] "EntityID of the entity we're attached to. This
will fail after save/load, unfortunately"
int mUpdateFrame
-1 [0, 1] ""

AudioComponent
- Members -----------------------------
std::string file
- ""
std::string event_root
- ""
std::string audio_physics_material
- ""
bool set_latest_event_position
0 [0, 1] ""
bool remove_latest_event_on_destroyed
0 [0, 1] ""
bool send_message_on_event_dead
0 [0, 1] ""
bool play_only_if_visible
0 [0, 1] "plays sounds only if entity position is on screen
and not covered by fog of war"
- Privates -----------------------------
int m_audio_physics_material
0 [0, 1] ""
AudioSourceHandle m_latest_source
-1 [0, 1] ""

AudioListenerComponent
- Members -----------------------------
float z
0 [-500, 500] ""

AudioLoopComponent
- Members -----------------------------
std::string file
- ""
std::string event_name
- ""
bool auto_play
0 [0, 1] ""
bool auto_play_if_enabled
0 [0, 1] ""
bool play_on_component_enable
0 [0, 1] ""
bool calculate_material_lowpass
1 [0, 1] ""
bool set_speed_parameter
0 [0, 1] ""
bool set_speed_parameter_only_based_on_x_movement
0 [0, 1] ""
bool set_speed_parameter_only_based_on_y_movement
0 [0, 1] ""
float volume_autofade_speed
0 [0, 1] ""
- Privates -----------------------------
float m_volume
0 [0, 1] ""
float m_intensity
1 [0, 1] ""
float m_intensity2
1 [0, 1] ""
AudioSourceHandle m_source
-1 [0, 1] ""
int m_frame_created
-1 [0, 1] ""
BiomeTrackerComponent
- Members -----------------------------
int limit_to_every_n_frame
0 [0, 1] "if > 1, we will only check the biome every n
frames"
- Privates -----------------------------
Biome* unsafe_current_biome
- "DO NOT ACCESS, since this can be in valid"
std::string current_biome_name
- "used to track in which biome we are at"

BlackHoleComponent
- Members -----------------------------
float radius
16 [0, 128] ""
float particle_attractor_force
2 [0, 32] ""
float damage_probability
0.25 [0, 1] ""
float damage_amount
0.1 [0, 10] ""
- Privates -----------------------------
int16 m_particle_attractor_id
-1 [0, 1] ""

BookComponent
- Members -----------------------------
float TEMP_TEMPY
0 [0, 3.5] ""
float TEMP_TEMP_TEMP
0 [0, 3.5] ""

BossDragonComponent
- Members -----------------------------
float speed
1 [0, 10000] ""
float speed_hunt
3 [0, 10000] ""
float acceleration
3 [0, 10000] ""
float direction_adjust_speed
1 [0, 10000] ""
float direction_adjust_speed_hunt
1 [0, 10000] ""
float gravity
3 [0, 10000] ""
float tail_gravity
30 [0, 10000] ""
float part_distance
10 [0, 10000] ""
int ground_check_offset
0 [0, 10000] ""
float eat_ground_radius
1 [0, 1e+006] ""
bool eat_ground
1 [0, 1] "does the worm destroy the ground it moves through
or not?"
float hitbox_radius
1 [0, 1e+006] ""
 float bite_damage
2 [0, 10] "how much damage does this do when it hits an
entity"
float target_kill_radius
1 [0, 1e+006] ""
float target_kill_ragdoll_force
1 [0, 1e+006] ""
float hunt_box_radius
512 [0, 10000] ""
float random_target_box_radius
512 [0, 10000] ""
int new_hunt_target_check_every
30 [0, 10000] ""
int new_random_target_check_every
120 [0, 10000] ""
float jump_cam_shake
20 [0, 10000] ""
float jump_cam_shake_distance
256 [0, 10000] ""
float eat_anim_wait_mult
0.05 [0, 10000] ""
std::string projectile_1
data/entities/projectiles/bossdragon.xml [0, 1] ""
int projectile_1_count
2 [0, 10] ""
std::string projectile_2
data/entities/projectiles/bossdragon_ray.xml [0, 1] ""
int projectile_2_count
5 [0, 10] ""
std::string ragdoll_filename
- ""
- Privates -----------------------------
int mTargetEntityId
0 [0, 1] ""
vec2 mTargetVec
- ""
float mGravVelocity
0 [0, 1] ""
float mSpeed
0 [0, 1] ""
vec2 mRandomTarget
- ""
vec2 mLastLivingTargetPos
- ""
int mNextTargetCheckFrame
0 [0, 1] ""
int mNextHuntTargetCheckFrame
0 [0, 1] ""
bool mOnGroundPrev
0 [0, 1] ""
int mMaterialIdPrev
0 [0, 1] ""
int mPhase
0 [0, 1] ""
int mNextPhaseSwitchTime
0 [0, 1] ""
float mPartDistance
2 [0, 1] ""
 bool mIsInitialized
0 [0, 1] ""

BossHealthBarComponent
- Members -----------------------------
bool gui
1 [0, 1] ""
bool gui_special_final_boss
0 [0, 1] ""
bool in_world
0 [0, 1] ""
float gui_max_distance_visible
600 [0, 1] ""
- Privates -----------------------------
bool mOldSpritesDestroyed
0 [0, 1] ""

CameraBoundComponent
- Members -----------------------------
bool enabled
1 [0, 1] "If enabled, kills this component if it's outside
the camera distance"
float distance
250 [0, 1024] "Distance in pixels from the center of camera, if
outside this distance the entity is destroyed"
float distance_border
20 [0, 1024] "Offset towards camera in pixels from 'distance'
where the entity is respawned if it was frozen"
int max_count
10 [0, 1024] "If more than 'max_count' entities of this type
exist the one furthest from camera is destroyed"
bool freeze_on_distance_kill
1 [0, 1] "If true and the entity went too far - this entity
will be stored so we can later respawn it where it was destroyed because it got too
far from the camera?"
bool freeze_on_max_count_kill
1 [0, 1] "If true and the entity was one too many of its
kind - this entity will be stored so we can later respawn it where it was destroyed
because it got too far from the camera?"

CardinalMovementComponent
- Members -----------------------------
bool horizontal_movement
1 [0, 1] "allow horizontal movement"
bool vertical_movement
1 [0, 1] "allow vertical movement"
bool intercardinal_movement
0 [0, 1] "allow intercardinal movement"
- Privates -----------------------------
vec2 mPrevPos
- ""

CellEaterComponent
- Members -----------------------------
float radius
10 [0, 100] ""
int eat_probability
100 [0, 100] ""
 bool only_stain
0 [0, 1] ""
bool eat_dynamic_physics_bodies
1 [0, 1] ""
bool limited_materials
0 [0, 1] "if true, will only eat the materials defined in
material_list"
std::string ignored_material_tag
- "if set, will not eat any materials with this tag.
please note that this lowers the performance of cell eating by some amount."
- Custom data types -------------------
int ignored_material
0 [0, 1] "String name of a material that shouldn't be eaten
by the component"
VEC_OF_MATERIALS materials
- "is a list of accepted materials sorted"

CharacterCollisionComponent
- Members -----------------------------
int getting_crushed_threshold
5 [0, 100] ""
int moving_up_before_getting_crushed_threshold
3 [0, 100] ""
- Privates -----------------------------
int getting_crushed_counter
0 [0, 1] "1.12.2018 - Is this still used?"
int stuck_in_ground_counter
0 [0, 1] "used this mostly for player to figure out if it's
stuck in ground"
bool mCollidedHorizontally
0 [0, 1] ""

CharacterDataComponent
- Members -----------------------------
int platforming_type
0 [0, 3] "0 = oldest, 1 = newer, 2 = safest"
float mass
1 [0, 10] "1.0 = approx. mass of player"
int buoyancy_check_offset_y
-6 [-1000, 1000] ""
float liquid_velocity_coeff
9 [0, 20] "how much do liquids move this character. e.g. when
standing in a flowing river"
float gravity
100 [0, 250] ""
float fly_recharge_spd
0 [0, 250] ""
float fly_recharge_spd_ground
0 [0, 250] ""
bool flying_needs_recharge
0 [0, 1] "const variable... player has this as true"
int flying_in_air_wait_frames
44 [0, 200] "to fix the tap tap tap flying cheese, we wait this
many frames before recharging in air"
int flying_recharge_removal_frames
8 [0, 20] "another fix to the tap tap - this is how many
frames from pressing down up we'll remove fly charge"
int climb_over_y
3 [0, 10] ""
 int check_collision_max_size_x
5 [0, 50] ""
int check_collision_max_size_y
5 [0, 50] ""
bool is_on_ground
0 [0, 1] ""
bool is_on_slippery_ground
0 [0, 1] ""
float ground_stickyness
0 [0, 1] ""
bool effect_hit_ground
0 [0, 1] ""
int eff_hg_damage_min
0 [0, 1] "if we want to damage ground when hitting it...
this is the place"
int eff_hg_damage_max
0 [0, 1] "if we want to damage ground when hitting it...
this is the place"
float eff_hg_position_x
0 [-15, 15] ""
float eff_hg_position_y
0 [-15, 15] ""
float eff_hg_size_x
0 [-15, 15] ""
float eff_hg_size_y
0 [-15, 15] ""
float eff_hg_velocity_min_x
0 [-65, 65] ""
float eff_hg_velocity_max_x
0 [-65, 65] ""
float eff_hg_velocity_min_y
0 [-65, 65] ""
float eff_hg_velocity_max_y
0 [-65, 65] ""
float eff_hg_offset_y
0 [-15, 15] ""
bool eff_hg_update_box2d
0 [0, 1] "if true, will move physics bodies that it hits"
float eff_hg_b2force_multiplier
0.0035 [0, 1] "multiplies the velocity with this..."
float destroy_ground
0 [0, 1] "how much damage do we do the ground when land on
it"
bool send_transform_update_message
0 [0, 1] "if 1, will send Message_TransformUpdated to
updated entities and their children when the component is processed by
PlayerCollisionSystem or CharacterCollisionSystem"
bool dont_update_velocity_and_xform
0 [0, 1] "might be useful if you want to use
CharacterCollisionSystem to only update on_ground status"
float mFlyingTimeLeft
1000 [0, 1] "How much flying energy do we have left? -
NOTE( Petri ): 1.3.2023 - This used to be a private variable. It was changed to fix
the save/load infinite flying bug."
- Custom data types -------------------
LensValue<float> collision_aabb_min_x
- ""
LensValue<float> collision_aabb_max_x
- ""
 LensValue<float> collision_aabb_min_y
- ""
LensValue<float> collision_aabb_max_y
- ""
LensValue<float> fly_time_max
- "how much flying energy + "
- Privates -----------------------------
int mFramesOnGround
0 [0, 1] ""
int mLastFrameOnGround
0 [0, 1] ""
vec2 mVelocity
- ""
bool mCollidedHorizontally
0 [0, 1] "moved this here from CharacterCollisionComponent -
since that is multithreaded and we needed a non multithreaded version"

CharacterPlatformingComponent
- Members -----------------------------
float jump_velocity_x
0 [0, 500] ""
float jump_velocity_y
-175 [-500, 0] ""
int jump_keydown_buffer
2 [0, 10] ""
float fly_speed_mult
0 [-100, 100] "AI stuff"
float fly_speed_change_spd
5 [0, 1000] "player"
bool fly_model_player
0 [0, 1] "if true, uses player fly model"
bool fly_smooth_y
1 [0, 1] "if true, smooths out the AI fly model"
float accel_x
1 [0, 1000] ""
float accel_x_air
0.1 [0, 1000] ""
float pixel_gravity
600 [0, 1000] ""
float swim_idle_buoyancy_coeff
1.2 [0, 2] ""
float swim_down_buoyancy_coeff
0.7 [0, 2] ""
float swim_up_buoyancy_coeff
0.9 [0, 2] ""
float swim_drag
0.95 [0, 2] "when in water velocity *= swim_drag"
float swim_extra_horizontal_drag
0.9 [0, 2] "when in water velocity.x *=
swim_extra_horizontal_drag"
bool mouse_look
1 [0, 1] ""
float mouse_look_buffer
1 [0, 5] ""
bool keyboard_look
0 [0, 1] "if true, turns based on if left or right has been
pressed down"
float turning_buffer
0.1 [0, 2] ""
 std::string animation_to_play
- ""
std::string animation_to_play_next
- ""
float run_animation_velocity_switching_threshold
45 [0, 1000] ""
bool run_animation_velocity_switching_enabled
0 [0, 1] ""
int turn_animation_frames_between
20 [0, 100] ""
int precision_jumping_max_duration_frames
-1 [0, 1] "maximum duration of precision jump or knockback. -
1 = infinite"
float audio_liquid_splash_intensity
1 [0, 1] ""
- Custom data types -------------------
LensValue<float> velocity_min_x
- ""
LensValue<float> velocity_max_x
- ""
LensValue<float> velocity_min_y
- ""
LensValue<float> velocity_max_y
- ""
LensValue<float> run_velocity
- ""
LensValue<float> fly_velocity_x
- ""
LensValue<float> fly_speed_max_up
- ""
LensValue<float> fly_speed_max_down
- ""
- Privates -----------------------------
vec2 mExAnimationPos
- ""
int mFramesInAirCounter
-1 [0, 1] ""
bool mIsPrecisionJumping
0 [0, 1] ""
int mPrecisionJumpingTime
0 [0, 1] ""
float mPrecisionJumpingSpeedX
0 [0, 1] ""
int mPrecisionJumpingTimeLeft
0 [0, 1] ""
float mFlyThrottle
0 [0, 1] ""
float mSmoothedFlyingTargetY
0 [0, 1] ""
int mJetpackEmitting
-1 [0, 1] "-1 = undefined, 0 = not emitting, 1 = emitting"
int mNextTurnAnimationFrame
0 [0, 1] ""
int mFramesNotSwimming
10 [0, 1] "0 = currently swimming"
int mFramesSwimming
0 [0, 1] "0 = not currently swimming"
bool mShouldCrouch
0 [0, 1] ""
 bool mShouldCrouchPrev
0 [0, 1] ""
int mLastPostureSwitchFrame
-1 [0, 1] ""
int mLookOverrideLastFrame
0 [0, 1] ""
int mLookOverrideDirection
0 [0, 1] ""

CharacterStatsComponent
- Privates -----------------------------
CharacterStatsModifier stats
- ""

CollisionTriggerComponent
- Members -----------------------------
float width
32 [0, 100] ""
float height
32 [0, 100] ""
float radius
32 [0, 100] ""
std::string required_tag
mortal [0, 1] ""
bool remove_component_when_triggered
0 [0, 1] ""
bool destroy_this_entity_when_triggered
1 [0, 1] ""
int timer_for_destruction
0 [0, 60] ""
bool self_trigger
0 [0, 1] "if true, the shooter can trigger it"
int skip_self_frames
60 [0, 1] "skips checks against self during these frames"
- Privates -----------------------------
int mTimer
0 [0, 1] ""

ConsumableTeleportComponent
- Members -----------------------------
bool create_other_end
0 [0, 1] ""
bool is_at_home
0 [0, 1] ""
float collision_radius
10 [0, 20] ""
uint32 target_id
0 [0, 1] ""
uint32 id
0 [0, 1] ""
int mNextUsableFrame
0 [0, 1] ""
bool mHasOtherEnd
0 [0, 1] ""
- Custom data types -------------------
vec2 target_location
- ""

ControllerGoombaAIComponent
 - Members -----------------------------
bool auto_turn_around_enabled
1 [0, 1] "disable this if you don't want creature to 'look
around', while standing still"
int wait_to_turn_around
50 [0, 300] ""
int wall_hit_wait
10 [0, 300] ""
bool check_wall_detection
1 [0, 1] ""
float wall_detection_aabb_min_x
0 [-15, 15] ""
float wall_detection_aabb_max_x
0 [-15, 15] ""
float wall_detection_aabb_min_y
0 [-15, 15] ""
float wall_detection_aabb_max_y
0 [-15, 15] ""
bool check_floor_detection
0 [0, 1] ""
float floor_detection_aabb_min_x
0 [-15, 15] ""
float floor_detection_aabb_max_x
0 [-15, 15] ""
float floor_detection_aabb_min_y
0 [-15, 15] ""
float floor_detection_aabb_max_y
0 [-15, 15] ""
- Privates -----------------------------
int mChangingDirectionCounter
-1 [0, 1] ""

ControlsComponent
- Members -----------------------------
bool polymorph_hax
0 [0, 1] ""
int polymorph_next_attack_frame
0 [0, 1] ""
bool enabled
1 [0, 1] ""
bool gamepad_indirect_aiming_enabled
0 [0, 1] ""
bool gamepad_fire_on_thumbstick_extend
0 [0, 1] ""
float gamepad_fire_on_thumbstick_extend_threshold
0.7 [0, 1] ""
- Privates -----------------------------
bool mButtonDownFire
0 [0, 1] ""
int mButtonFrameFire
0 [0, 1] ""
int mButtonLastFrameFire
-2 [0, 1] ""
bool mButtonDownFire2
0 [0, 1] ""
int mButtonFrameFire2
0 [0, 1] ""
bool mButtonDownAction
0 [0, 1] ""
 int mButtonFrameAction
0 [0, 1] ""
bool mButtonDownThrow
0 [0, 1] ""
int mButtonFrameThrow
0 [0, 1] ""
bool mButtonDownInteract
0 [0, 1] ""
int mButtonFrameInteract
0 [0, 1] ""
bool mButtonDownLeft
0 [0, 1] ""
int mButtonFrameLeft
0 [0, 1] ""
bool mButtonDownRight
0 [0, 1] ""
int mButtonFrameRight
0 [0, 1] ""
bool mButtonDownUp
0 [0, 1] ""
int mButtonFrameUp
0 [0, 1] ""
bool mButtonDownDown
0 [0, 1] ""
int mButtonFrameDown
0 [0, 1] ""
bool mButtonDownJump
0 [0, 1] ""
int mButtonFrameJump
0 [0, 1] ""
bool mButtonDownRun
0 [0, 1] ""
int mButtonFrameRun
0 [0, 1] ""
bool mButtonDownFly
0 [0, 1] ""
int mButtonFrameFly
0 [0, 1] ""
bool mButtonDownDig
0 [0, 1] ""
int mButtonFrameDig
0 [0, 1] ""
bool mButtonDownChangeItemR
0 [0, 1] ""
int mButtonFrameChangeItemR
0 [0, 1] ""
int mButtonCountChangeItemR
0 [0, 1] "note these have special count property"
bool mButtonDownChangeItemL
0 [0, 1] ""
int mButtonFrameChangeItemL
0 [0, 1] ""
int mButtonCountChangeItemL
0 [0, 1] "note these have special count property"
bool mButtonDownInventory
0 [0, 1] ""
int mButtonFrameInventory
0 [0, 1] ""
bool mButtonDownHolsterItem
0 [0, 1] ""
int mButtonFrameHolsterItem
0 [0, 1] ""
bool mButtonDownDropItem
0 [0, 1] ""
int mButtonFrameDropItem
0 [0, 1] ""
bool mButtonDownKick
0 [0, 1] ""
int mButtonFrameKick
0 [0, 1] ""
bool mButtonDownEat
0 [0, 1] ""
int mButtonFrameEat
0 [0, 1] ""
bool mButtonDownLeftClick
0 [0, 1] "NOTE! Ignores gamepad, if mouse is pressed this
will be true."
int mButtonFrameLeftClick
0 [0, 1] "NOTE! Ignores gamepad, if mouse is pressed this
will be true."
bool mButtonDownRightClick
0 [0, 1] "NOTE! Ignores gamepad, if mouse is pressed this
will be true."
int mButtonFrameRightClick
0 [0, 1] "NOTE! Ignores gamepad, if mouse is pressed this
will be true."
bool mButtonDownTransformLeft
0 [0, 1] "NOT IN USE!"
int mButtonFrameTransformLeft
0 [0, 1] "NOT IN USE!"
bool mButtonDownTransformRight
0 [0, 1] "NOT IN USE!"
int mButtonFrameTransformRight
0 [0, 1] "NOT IN USE!"
bool mButtonDownTransformUp
0 [0, 1] "NOT IN USE!"
int mButtonFrameTransformUp
0 [0, 1] "NOT IN USE!"
int mButtonCountTransformUp
0 [0, 1] "NOT IN USE!"
bool mButtonDownTransformDown
0 [0, 1] "NOT IN USE!"
int mButtonFrameTransformDown
0 [0, 1] "NOT IN USE!"
int mButtonCountTransformDown
0 [0, 1] "NOT IN USE!"
float mFlyingTargetY
0 [0, 1] ""
vec2 mAimingVector
- ""
vec2 mAimingVectorNormalized
- "Aiming vector normalized to unit sphere."
vec2 mAimingVectorNonZeroLatest
- ""
vec2 mGamepadAimingVectorRaw
- ""
vec2 mJumpVelocity
- "used mostly by AI only?"
 vec2 mMousePosition
- ""
vec2 mMousePositionRaw
- ""
vec2 mMousePositionRawPrev
- ""
vec2 mMouseDelta
- ""
vec2 mGamepadIndirectAiming
- ""
vec2 mGamePadCursorInWorld
- "where the aiming cursor is in the world, updated
by platformshooterplayer_system "
uint32_t mButtonDownDelayLineFire
0 [0, 1] "Used to delay input for some game effects"
uint32_t mButtonDownDelayLineFire2
0 [0, 1] "Used to delay input for some game effects"
uint32_t mButtonDownDelayLineRight
0 [0, 1] "Used to delay input for some game effects"
uint32_t mButtonDownDelayLineLeft
0 [0, 1] "Used to delay input for some game effects"
uint32_t mButtonDownDelayLineUp
0 [0, 1] "Used to delay input for some game effects"
uint32_t mButtonDownDelayLineDown
0 [0, 1] "Used to delay input for some game effects"
uint32_t mButtonDownDelayLineKick
0 [0, 1] "Used to delay input for some game effects"
uint32_t mButtonDownDelayLineThrow
0 [0, 1] "Used to delay input for some game effects"
uint32_t mButtonDownDelayLineJump
0 [0, 1] "Used to delay input for some game effects"
uint32_t mButtonDownDelayLineFly
0 [0, 1] "Used to delay input for some game effects"
LensValue<int> input_latency_frames
- "Adds latency to some inputs. Used by some game
effects. Max 31."

CrawlerAnimalComponent
- Members -----------------------------
float ray_length
5 [0, 100] ""
int ray_count
16 [0, 64] ""
float gravity
600 [0, 10000] ""
float terminal_velocity
600 [0, 10000] ""
float speed
0.2 [0, 10000] ""
int give_up_area_radius
20 [0, 1000] ""
int give_up_time
45 [0, 1000] ""
float attack_from_ceiling_check_ray_length
128 [0, 1000] ""
int attack_from_ceiling_check_every_n_frames
15 [0, 1000] ""
float collision_damage
0.25 [0, 1000] ""
 float collision_damage_radius
10 [0, 1000] ""
int collision_damage_frames_between
10 [0, 1000] ""
bool animate
1 [0, 1] ""
- Privates -----------------------------
bool mDir
1 [0, 1] ""
int mFrameNextGiveUp
0 [0, 1] ""
int mFrameNextDamage
0 [0, 1] ""
int mFrameNextAttackFromCeilingCheck
0 [0, 1] ""
vec2 mMin
- ""
vec2 mMax
- ""
vec2 mPrevNonSnappedPosition
- ""
ivec2 mPrevCellPosition
- ""
ivec2 mPrevCellPosition2
- ""
ivec2 mPrevCellPosition3
- ""
ivec2 mPrevCellPosition4
- ""
ivec2 mPrevCellPosition5
- ""
ivec2 mPrevCellPosition6
- ""
ivec2 mPrevCellPosition7
- ""
ivec2 mPrevCellPosition8
- ""
ivec2 mLatestPosition
- ""
bool mPrevFalling
0 [0, 1] ""
bool mIsInitialized
0 [0, 1] ""
float mVelocityY
0 [0, 1] ""
float mAngle
0 [0, 1] ""
float mMovementStepAccumulator
0 [0, 1] ""

CutThroughWorldDoneHereComponent
- Members -----------------------------
uint32 id_of_done_cut
0 [0, 1] ""

DamageModelComponent
- Members -----------------------------
double hp
1 [0, 4] "hit points at the moment"
 double max_hp
0 [0, 4] "the maximum hp that this can have, we'll set this
when loading"
double max_hp_cap
0 [0, 12] "the maximum 'max_hp' that this can have, <= 0
means no limits. Used by perks such as GLASS_CANNON"
double max_hp_old
0 [0, 1] "used for UI rendering"
float critical_damage_resistance
0 [0, 1] "0.0 = all critical damage multiplier is applied.
1.0 = no critical damage multiplier is applied"
int invincibility_frames
0 [0, 1024] "if positive, doesn't take damage"
bool falling_damages
1 [0, 1] "do we take fall damage"
float falling_damage_height_min
70 [0, 1] "how far do we need to fall to take damage, we
start with this height, the peasant takes min damage from this"
float falling_damage_height_max
250 [0, 1] "after this the peasant always takes the maximum
fall damage"
float falling_damage_damage_min
0.1 [0, 1] "when we fall over height_min we take this much,
lineary ramping to damage_max"
float falling_damage_damage_max
1.2 [0, 1] "when we fall over height_min we take this much,
lineary ramping to damage_max"
bool air_needed
1 [0, 1] "Do we breath, can we take damage from not
breathing?"
float air_in_lungs
5 [0, 1] "How much air do we have in our lungs? - after the
air runs out we take damage"
float air_in_lungs_max
5 [0, 1] "how much air can we have in our lungs, it's filled
to this point if we're not in water"
float air_lack_of_damage
0.2 [0, 1] "(* dt)... damage in a second if we're in the
water"
float minimum_knockback_force
0 [0, 1] "Minimum knockback force required to do the
knockback"
bool materials_damage
1 [0, 1] "should materials do damage or not?"
int material_damage_min_cell_count
4 [0, 1] "if material damage is received from less than
'material_damage_min_cell_count' this frame, it is ignored"
std::string materials_that_damage
acid [0, 1] "list of materials that do damage, separated by ','
e.g. 'acid, fire, smoke'"
std::string materials_how_much_damage
0.1 [0, 1] "list of damage amount per material in
materials_that_damage, separated by ','"
bool materials_damage_proportional_to_maxhp
0 [0, 1] "if damage from materials is proportional to max
hp, instead of just damage"
bool physics_objects_damage
0 [0, 1] "if true, will take damage from physics objects
that hit it"
 bool materials_create_messages
0 [0, 1] "should collisions with certain materials create
messages or not?"
std::string materials_that_create_messages
meat [0, 1] "list of materials that generate CollisionWithCell
messages, separated by ',' e.g. 'acid, fire, smoke'"
std::string ragdoll_filenames_file
data/temp/ragdoll/filenames.txt [0, 1] "the file from which to load a ragdoll on
death'"
std::string ragdoll_material
meat [0, 1] "what material is the ragdoll made out of"
float ragdoll_offset_x
0 [0, 1] "where should the ragdoll be created relative to
our entity position'"
float ragdoll_offset_y
0 [0, 1] "where should the ragdoll be created relative to
our entity position'"
std::string blood_material
blood_fading [0, 1] "this is the material that gets thrown as particles
when this entity takes damage"
std::string blood_spray_material
- "this is the material that gets thrown as particles
when this entity sprays blood on death"
bool blood_spray_create_some_cosmetic
0 [0, 1] "if true, we force some blood spray particles to be
cosmetic (can be enabled to avoid making a huge mess of blood spray)"
float blood_multiplier
1 [0, 10] "how much blood, this is the multiplier used for
sprouting lots or little blood"
int ragdoll_blood_amount_absolute
-1 [-1, 1000] "if > -1, this is the absolute amount of blood we
share between particle emitters in the ragdoll"
std::string blood_sprite_directional
- "this sprite is loaded at damage position if we
take damage that creates a blood effect"
std::string blood_sprite_large
- "this sprite is loaded at damage position if we
take explosion/heavy damage"
std::string healing_particle_effect_entity
- "if this is set, will load this entity as a child
of this entity, when this entity is healed"
bool create_ragdoll
1 [0, 1] "if 0, we skip ragdoll creation on death"
bool ragdollify_child_entity_sprites
0 [0, 1] "if 1, we ragdollify child entity sprites"
float ragdollify_root_angular_damping
0 [0, 1] "If ragdoll_filenames_file= and > 0, the angular
damping of the first ragdoll body is set to this value."
bool ragdollify_disintegrate_nonroot
0 [0, 1] "If ragdoll_filenames_file= and true, all but the
first sprite on the root entity will be disintegrated instead of being turned into
physics bodies."
bool wait_for_kill_flag_on_death
0 [0, 1] "if 1, we wont kill the entity along with kill fx
and ragdoll until 'kill' is 1"
bool kill_now
0 [0, 1] "if 1, we wont kill the entity along with kill fx
and ragdoll until 'kill_now' is 1"
bool drop_items_on_death
1 [0, 1] "drop the abilities as items on death?"
bool ui_report_damage
1 [0, 1] "If 1, damage numbers are displayed when this
entity is damaged"
bool ui_force_report_damage
0 [0, 1] "If 1, damage numbers are displayed when this
entity is damaged, even if the numbers are disabled in settings"
int in_liquid_shooting_electrify_prob
0 [0, 100] "when shooting underwater how likely are we to
electrify the water"
float wet_status_effect_damage
0 [0, 0.1] "how much damage per 10 frames is done if entity
has 'wet' status effect"
bool is_on_fire
0 [0, 1] "Tells us we're on fire or not"
float fire_probability_of_ignition
0.5 [0, 1] "what is the probability that we'll ignite, 0 means
won't ever ignite"
int fire_how_much_fire_generates
4 [0, 10] "how many fire particles do we generate each frame"
float fire_damage_ignited_amount
0.0003 [0, 2] "how much damage does being ignited do?"
float fire_damage_amount
0.2 [0, 2] "how much damage does fire do?, 0.2 is pretty good"
int mLastElectricityResistanceFrame
-2147483648 [0, 1] "Last frame electricity has no effect. Should not
be private!"
int mLastFrameReportedBlock
-2147483648 [0, 1] "Last frame a damage block message was displayed
for this entity"
int mLastMaxHpChangeFrame
-10000 [0, 1] "used for UI rendering"
- Objects -----------------------------
ConfigDamagesByType damage_multipliers
- "the multipliers applied to different types of
damage"
- Custom data types -------------------
RAGDOLL_FX::Enum ragdoll_fx_forced
- "if set, will force this ragdoll fx to happen
everytime"
- Privates -----------------------------
bool mIsOnFire
0 [0, 1] "private variable to check when we're on fire and
not"
int mFireProbability
100 [0, 1] "this gets decreased if we can't ignite anything
else"
int mFireFramesLeft
0 [0, 1] "this is the remaining frames we're on fire"
int mFireDurationFrames
0 [0, 1] "this is the total duration in frames we're on
fire"
bool mFireTriedIgniting
0 [0, 1] "private variable to check when we could have been
ignited or not"
int mLastCheckX
0 [0, 1] "an optimization, so we don't have to check
everything every frame"
int mLastCheckY
0 [0, 1] "an optimization, so we don't have to check
everything every frame"
int mLastCheckTime
0 [0, 1] "an optimization, so we don't have to check
everything every frame"
int mLastMaterialDamageFrame
0 [0, 1] "this is the last frame we took material damage"
bool mFallIsOnGround
0 [0, 1] "for fall damage, keeps a private variable about if
we're on ground or not"
float mFallHighestY
3.40282e+038 [0, 1] "private var to keep track of how high have we
flown to"
int mFallCount
0 [0, 1] "how many times have we fallen? This is used to
make sure we don't take damage from the first fall"
bool mAirAreWeInWater
0 [0, 1] "a private variable to track our state in drowning"
int mAirFramesNotInWater
0 [0, 1] "how many frames have been with air to breathe"
bool mAirDoWeHave
0 [0, 1] "a private variable to track our state in drowning"
int mTotalCells
0 [0, 1] "how many cells are there total"
int mLiquidCount
0 [0, 1] "how many of the cells are liquid"
int mLiquidMaterialWeAreIn
-1 [0, 1] "stores the liquid material we're in... may not be
the most accurate"
std::vector< int > mDamageMaterials
- "NOTE! Sorted! a list of materials that do damage
(materials_that_damage)"
std::vector< float > mDamageMaterialsHowMuch
- "NOTE! Sorted! a list of materials that do damage
(materials_that_damage)"
std::vector< int > mCollisionMessageMaterials
- "NOTE! Sorted! a list of materials that create
messages (materials_that_create_messages)"
std::vector< int > mCollisionMessageMaterialCountsThisFrame
- "Number of cells per collided with this frame.
Order matches mCollisionMessageMaterials"
std::vector< float > mMaterialDamageThisFrame
- "A list of damage per material that damages us. In
same order as materials"
float mFallDamageThisFrame
0 [0, 1] "Amount of fall damage received this frame"
float mElectricityDamageThisFrame
0 [0, 1] "Amount of electricity damage received this frame"
float mPhysicsDamageThisFrame
0 [0, 1] "max physics damage we have taken this round"
vec2 mPhysicsDamageVecThisFrame
- "direction of physics damage"
int mPhysicsDamageLastFrame
0 [0, 1] "frame number when we took physics damage"
EntityTypeID mPhysicsDamageEntity
0 [0, 1] "the physics entity that hit us"
EntityTypeID mPhysicsDamageTelekinesisCasterEntity
0 [0, 1] "who moved an object that hit us via telekinesis"
 int mLastDamageFrame
-120 [0, 1] "frame number when we took any damage"
double mHpBeforeLastDamage
0 [0, 1] "how much hp did we have a while ago?"
float mFireDamageBuffered
0 [0, 1] "used to optimized cases where lots of entities are
taking fire damage"
int32 mFireDamageBufferedNextDeliveryFrame
0 [0, 1] ""

DamageNearbyEntitiesComponent
- Members -----------------------------
float radius
10 [0, 1] ""
float damage_min
0.1 [0, 1] ""
float damage_max
0.2 [0, 1] ""
float target_vec_max_len
5 [0, 1] ""
float knockback_multiplier
1 [0, 1] ""
int time_between_damaging
20 [0, 1] ""
std::string damage_description
bite [0, 1] ""
std::string target_tag
mortal [0, 1] ""
- Custom data types -------------------
DAMAGE_TYPES::Enum damage_type
- "the damage type"
RAGDOLL_FX::Enum ragdoll_fx
- ""
- Privates -----------------------------
vec2 mVelocity
- ""
int mNextDamageFrame
0 [0, 1] ""

DebugFollowMouseComponent

DebugLogMessagesComponent
- Members -----------------------------
float TEMP_TEMPY
0 [0, 3.5] ""
float TEMP_TEMP_TEMP
0 [0, 3.5] ""

DebugSpatialVisualizerComponent
- Members -----------------------------
float min_x
0 [0, 1] ""
float min_y
0 [0, 1] ""
float max_x
0 [0, 1] ""
float max_y
0 [0, 1] ""
unsigned int color
4294967295 [0, 1] ""

DieIfSpeedBelowComponent
- Members -----------------------------
float min_speed
1 [0, 1000] "The entity that owns this component is killed if
its speed (via VelocityComponent) falls below this value."
float mMinSpeedSquared
0 [0, 1] ""

DroneLauncherComponent
- Members -----------------------------
std::string drone_entity_file
data/entities/misc/player_drone.xml [0, 1] ""

DrugEffectComponent
- Objects -----------------------------
ConfigDrugFx drug_fx_target
- ""
ConfigDrugFx m_drug_fx_current
- ""

DrugEffectModifierComponent
- Objects -----------------------------
ConfigDrugFx fx_add
- ""
ConfigDrugFx fx_multiply
- ""

ElectricChargeComponent
- Members -----------------------------
int charge_time_frames
120 [0, 240] ""
float fx_velocity_max
120 [0, 240] ""
int electricity_emission_interval_frames
5 [0, 10] ""
int fx_emission_interval_min
2 [0, 20] ""
int fx_emission_interval_max
15 [0, 30] ""
int charge
0 [0, 1] ""

ElectricityComponent
- Members -----------------------------
int energy
1000 [0, 10000] ""
float probability_to_heat
0 [0, 1] ""
int speed
32 [0, 10000] ""
int splittings_min
0 [0, 10000] ""
int splittings_max
0 [0, 10000] ""
int splitting_energy_min
0 [0, 10000] ""
int splitting_energy_max
0 [0, 10000] ""
bool hack_is_material_crack
0 [0, 1] ""
bool hack_crack_ice
0 [0, 1] ""
bool hack_is_set_fire
0 [0, 1] "if set will set the thing on fire where this is
located at"
- Privates -----------------------------
int mSplittingsLeft
0 [0, 1] ""
int mSplittingEnergy
0 [0, 1] ""
vec2 mAvgDir
- ""
ivec2 mPrevPos
- ""
int mPrevMaterial
0 [0, 1] ""
bool mShouldPlaySound
1 [0, 1] ""

ElectricityReceiverComponent
- Members -----------------------------
int offset_x
0 [1, 3] ""
int offset_y
0 [1, 3] ""
int radius
1 [1, 3] ""
int active_time_frames
1 [1, 15] ""
int switch_on_msg_interval_frames
0 [0, 60] ""
int electrified_msg_interval_frames
-1 [0, 15] ""
- Privates -----------------------------
int mLastFrameElectrified
-1000 [0, 1] ""
int mNextElectrifiedMsgFrame
0 [0, 1] ""
int mNextSwitchOnMsgFrame
0 [0, 1] ""

ElectricitySourceComponent
- Members -----------------------------
int radius
5 [1, 16] ""
int emission_interval_frames
15 [1, 10] ""
- Privates -----------------------------
int mNextFrameEmitElectricity
0 [0, 1] ""

EndingMcGuffinComponent
- Members -----------------------------
float TEMP_TEMPY
0 [0, 3.5] ""
float TEMP_TEMP_TEMP
0 [0, 3.5] ""

EnergyShieldComponent
- Members -----------------------------
float radius
16 [0, 100] ""
float damage_multiplier
1.5 [0, 10] ""
float max_energy
1 [0, 10] ""
float energy_required_to_shield
0.2 [0, 10] ""
float recharge_speed
1 [0, 10] ""
float sector_degrees
360 [0, 360] "if less than 180 we only provide partial cover to
the current direction of the entity"
float energy
0 [0, 3] ""
- Privates -----------------------------
vec2 mPrevPosition
- ""

ExplodeOnDamageComponent
- Members -----------------------------
float explode_on_death_percent
1 [0, 1] "rolls a dice (0 - 1) if we explode on death"
float explode_on_damage_percent
1 [0, 1] "rolls a dice (0 - 1) if we explode on damage"
float physics_body_modified_death_probability
0 [0, 1] "if we get message about the physics body being
modified, do we explode on what percent"
float physics_body_destruction_required
0.5 [0, 1] "how big of percent of our body, do we need to lose
before we explode"
- Objects -----------------------------
ConfigExplosion config_explosion
- "if we have explosion, it's the setup for it"
- Privates -----------------------------
bool mDone
0 [0, 1] ""

ExplosionComponent
- Members -----------------------------
int timeout_frames
0 [0, 180] "for timer"
int timeout_frames_random
0 [0, 180] "a random value between 0 and
'timout_frames_random' is added to timer"
bool kill_entity
1 [0, 1] "if 1, we kill the entity when exploding"
int mTimerTriggerFrame
-1 [0, 1] ""
- Objects -----------------------------
ConfigExplosion config_explosion
- "setup for out explosion"
- Custom data types -------------------
EXPLOSION_TRIGGER_TYPE::Enumtrigger
- "what triggers the explosion"
FishAIComponent
- Members -----------------------------
int direction
0 [-1, 1] ""
float speed
100 [1, 1000] ""
- Custom data types -------------------
vec2 aabb_min
- ""
vec2 aabb_max
- ""
- Privates -----------------------------
vec2 velocity
- ""
int stuck_counter
0 [0, 1] ""
vec2 mLastCheckPos
- ""

FlyingComponent
- Members -----------------------------
int type
0 [0, 1] "type of flight, 1 = perlin noise"
float perlin_freq
0.2 [0, 1] "frequency of the perlin noise sampling"
float perlin_time_freq
0.3 [0, 1] "t *= perlin_time_freq"
float perlin_wind_x
0 [-1, 1] "wind velocity that gets added to the samples"
float perlin_wind_y
0 [-1, 1] "wind velocity that gets added to the samples"

FogOfWarRadiusComponent
- Members -----------------------------
float radius
256 [0, 1024] "256 is the default player has"

FogOfWarRemoverComponent
- Members -----------------------------
float radius
140 [0, 2000] ""

GameAreaEffectComponent
- Members -----------------------------
float radius
0 [0, 3.5] "what's the radius (in pixels) of the area effect"
std::string collide_with_tag
hittable [0, 1] "the tags we're looking for"
int frame_length
-1 [0, 1] "if not 0 will reapply this effect after this many
frames have gone by"
- Custom data types -------------------
VECTOR_STR game_effect_entitities
- "just a vector of the game_effect entities"
- Privates -----------------------------
VECTOR_ENTITYID mEntitiesAppliedOutTo
- ""
VECTOR_INT mEntitiesAppliedFrame
- ""

GameEffectComponent
- Members -----------------------------
std::string custom_effect_id
- "if 'effect' is set to 'CUSTOM', this will define
effect uniqueness."
int frames
-1 [0, 1] "how many frames does it affect -1 = forever"
int exclusivity_group
0 [0, 1] "if > 0, previous game effects with the same
exclusivity group as new one will be removed when calling LoadGameEffectEntityTo"
bool report_block_msg
1 [0, 1] "to disable the block message that rises"
bool disable_movement
0 [0, 1] "if set, will disable movement"
std::string ragdoll_effect_custom_entity_file
- "an entity that is loaded to each ragdoll part if
'ragdoll_effect' is set to 'CUSTOM_RAGDOLL_ENTITY'"
bool ragdoll_fx_custom_entity_apply_only_to_largest_body
0 [0, 1] "if 1, 'ragdoll_effect_custom_entity_file' is
loaded only to the largest piece in the ragdoll "
std::string polymorph_target
- "when doing a polymorph, this is what we convert it
to"
USTRING mSerializedData
- "polymorph stores the serialized entity here..."
EntityID mCaster
0 [0, 1] "Contains a handle to the caster of this
GameEffect"
int mCasterHerdId
0 [0, 1] "Contains the herd if of the caster of this
GameEffect"
int teleportation_probability
600 [0, 1] "How likely is it that we teleport, larger = less
often"
int teleportation_delay_min_frames
30 [0, 1] "Never teleports more often that this"
float teleportation_radius_min
128 [0, 1] ""
float teleportation_radius_max
1024 [0, 1] ""
int teleportations_num
0 [0, 1] "How many times has this GameEffectComponent
teleported the owner?"
double no_heal_max_hp_cap
3.40282e+038 [0, 1] "If current hp is less than this, we store it here.
Then we make sure the hp never exceeds this."
bool caused_by_ingestion_status_effect
0 [0, 1] "Did this effect occur because someone ate
something?"
bool caused_by_stains
0 [0, 1] "was this caused by stains"
bool mCharmDisabledCameraBound
0 [0, 1] "When charmed, will try to disable CameraBound.
This keeps track if we've done it, so we can enable it back"
bool mCharmEnabledTeleporting
0 [0, 1] "When charmed, will try to enable teleporting
(tag:teleportable_NOT). This keeps track if we've done it, so we can disable it
again"
bool mInvisible
0 [0, 1] "Are we invisible?"
int mCounter
0 [0, 1] "Counts stuff"
int mCooldown
0 [0, 1] "Counts cooldown"
bool mIsExtension
0 [0, 1] "If 1, this is an effect extension and shouldn't
create an extension when removed"
bool mIsSpent
0 [0, 1] "NOTE( Petri ): 29.4.2024 - this is used internally
to make RESPAWN perk disabled in the UI"
- Custom data types -------------------
GAME_EFFECT::Enum effect
- "GAME_EFFECT"
RAGDOLL_FX::Enum ragdoll_effect
- "if set, will use this for ragdoll effect"
int ragdoll_material
0 [0, 1] "converts to string name of the material that
ragdoll is made out of"
StatusEffectType causing_status_effect
0 [0, 1] "Status effect that caused this game effect, if
any"

GameLogComponent
- Members -----------------------------
bool report_death
1 [0, 1] "switches on reporting things"
bool report_damage
0 [0, 1] "if set, will report when receiving damage"
bool report_new_biomes
1 [0, 1] "if false, won't report when player enters new
biomes"
- Custom data types -------------------
VISITED_VEC mVisitiedBiomes
- "list of visited biomes"
- Privates -----------------------------
int mNewBiomeCheckFrame
0 [0, 1] ""

GameStatsComponent
- Members -----------------------------
std::string name
- "no one uses the name variable on entity, so we
have to do this to make it happen"
std::string stats_filename
- "also generated from the gunk"
bool is_player
0 [0, 1] "if true, will use the session file for loading
stats"
std::string extra_death_msg
- "set when e.g. polymorphed"
bool dont_do_logplayerkill
0 [0, 1] "if 1, StatsLogPlayerKill must be manually called
from lua"
int player_polymorph_count
0 [0, 1] "skip loading of stats if this higher than 0 and
decrament this by one"
GasBubbleComponent
- Members -----------------------------
float acceleration
-1 [-100, 0] ""
float max_speed
20 [0, 20] ""
- Privates -----------------------------
float mVelocity
0 [0, 1] ""

GenomeDataComponent
- Members -----------------------------
bool is_predator
0 [0, 1] "Predators are considered threats by other species
and hunt for food."
float food_chain_rank
0 [0, 200] "0 means king of the hill. Greater number = more
likely to get eaten by other species."
bool berserk_dont_attack_friends
0 [0, 1] "if 1, this animal will not try to attack player
who would normally be its friend"
- Custom data types -------------------
LensValue<int> herd_id
- "This is used for example to separate people in
different tribes."
- Privates -----------------------------
LensValue<bool> friend_thundermage
- "if 1, thunder mage doesn't attack this"
LensValue<bool> friend_firemage
- "if 1, fire mage doesn't attack this"

GhostComponent
- Members -----------------------------
float speed
5 [0, 1] "pixels per second"
int new_hunt_target_check_every
0 [0, 1] "how often do we look for targets"
float hunt_box_radius
512 [0, 1] ""
float aggressiveness
100 [0, 1] "if higher than relations then will attack"
float max_distance_from_home
300 [0, 1] "how far from home can we go?"
bool die_if_no_home
1 [0, 1] "if set to false will die, if it can't find home"
std::string target_tag
player_unit [0, 1] "if something else (like mortal), will attack the
home"
- Custom data types -------------------
vec2 velocity
- ""
- Privates -----------------------------
EntityID mEntityHome
0 [0, 1] "where is our home?"
int mFramesWithoutHome
0 [0, 1] ""
vec2 mTargetPosition
- ""
 int mTargetEntityId
0 [0, 1] ""
vec2 mRandomTarget
- ""
int mNextTargetCheckFrame
0 [0, 1] ""

GodInfoComponent
- Members -----------------------------
float mana_current
0 [0, 1000] "How much mana the player now has to use"
float mana_max
500 [0, 1000] "Max size of the mana pool"
float gold
0 [0, 1000] "How much gold the player has"
- Privates -----------------------------
Entity* god_entity
- ""

GunComponent
- Privates -----------------------------
LuaManager* mLuaManager
- ""

HealthBarComponent

HitEffectComponent
- Members -----------------------------
int value
0 [0, 100] "Usage depends on selected 'effect_hit'"
std::string value_string
- "Usage depends on selected 'effect_hit'"
- Custom data types -------------------
GAME_EFFECT::Enum condition_effect
- "Hit entity needs to have this 'GAME_EFFECT' for
effects to apply. If both 'condition_effect' and 'condition_status' are set, they
are combined with AND logic"
StatusEffectType condition_status
0 [0, 1] "Hit entity needs to have this 'STATUS_EFFECT' for
effects to apply"
HIT_EFFECT::Enum effect_hit
- "What kind of 'HIT_EFFECT' is applied to hit entity
if condition is true"

HitboxComponent
- Members -----------------------------
bool is_player
0 [0, 1] ""
bool is_enemy
1 [0, 1] ""
bool is_item
0 [0, 1] ""
float aabb_min_x
-5 [-15, 15] ""
float aabb_max_x
5 [-15, 15] ""
float aabb_min_y
-5 [-15, 15] ""
float aabb_max_y
5 [-15, 15] ""
float damage_multiplier
1 [0, 1] "All damage from hits to this hitbox is multiplied
with this value before applying it."
- Custom data types -------------------
vec2 offset
- ""
- Privates -----------------------------
bool dead
0 [0, 1] ""

HomingComponent
- Members -----------------------------
std::string target_tag
homing_target [0, 1] ""
bool target_who_shot
0 [0, 1] "If 1, targets who shot the projectile, ignores
'target_tag'."
float detect_distance
150 [0, 1000] ""
float homing_velocity_multiplier
0.9 [-100, 100] ""
float homing_targeting_coeff
160 [0, 1000] ""
bool just_rotate_towards_target
0 [0, 1] "the default accelerates towards a target. If true
will only rotate towards the target."
float max_turn_rate
0.05 [0, 6.283] "radians. If just_rotate_towards_target then this
is the maximum radians it can turn per frame"
EntityID predefined_target
0 [0, 1] "If set, we track this entity"
bool look_for_root_entities_only
0 [0, 1] "if set, will only look for entities that are _not_
child entities."

HotspotComponent
- Members -----------------------------
bool transform_with_scale
1 [0, 1] ""
std::string sprite_hotspot_name
- ""
- Custom data types -------------------
vec2 offset
- ""

IKLimbAttackerComponent
- Members -----------------------------
float radius
54 [0, 1] ""
float leg_velocity_coeff
15 [0, 1] ""
float targeting_radius
120 [0, 1] ""
bool targeting_raytrace
1 [0, 1] ""
std::string target_entities_with_tag
mortal [0, 1] ""
- Custom data types -------------------
 vec2 mTarget
- ""
- Privates -----------------------------
EntityID mTargetEntity
0 [0, 1] ""
IKLimbAttackerState mState
- ""
float mStateTimer
0 [0, 1] ""

IKLimbComponent
- Members -----------------------------
float length
40 [0, 1] ""
float thigh_extra_lenght
2 [0, 1] ""
float mJointSideInterpolation
0 [0, 1] ""
- Custom data types -------------------
vec2 end_position
- ""
vec2 mJointWorldPos
- ""
vec2 mEndPrevPos
- ""
- Privates -----------------------------
vec2 mPart0PrevPos
- ""
float mPart0PrevRotation
0 [0, 1] ""
vec2 mPart1PrevPos
- ""
float mPart1PrevRotation
0 [0, 1] ""

IKLimbWalkerComponent
- Members -----------------------------
float ground_attachment_min_spread
16 [0, 1] ""
int ground_attachment_max_tries
10 [0, 1] ""
float ground_attachment_max_angle
0.8 [0, 1] ""
float ground_attachment_ray_length_coeff
1.15 [0, 1] ""
float leg_velocity_coeff
15 [0, 1] ""
bool affect_flying
0 [0, 1] "if set, will cause the mFlyingTime (in
CharacterDataComponent) of the parent to be 0 or 1 depending on if we're touching
anything"
int mState
0 [0, 1] "0 = detached, 1 = attached"
- Custom data types -------------------
int ray_skip_material
0 [0, 1] "String name of material to not cast rays against.
Defaults to 'aluminium'"
vec2 mTarget
- ""
 vec2 mPrevTarget
- ""
vec2 mPrevCenterPosition
- ""

IKLimbsAnimatorComponent
- Members -----------------------------
int future_state_samples
10 [0, 1] "The number of future animation states evaluated to
find the next state"
float ground_attachment_ray_length_coeff
1.15 [0, 1] "Limb raycast length is
(ground_attachment_ray_length_coeff * limb length)"
float leg_velocity_coeff
15 [0, 1] "Limbs are moved towards target position at a pace
affected by this value."
bool affect_flying
0 [0, 1] "If set, will cause the mFlyingTime (in
CharacterDataComponent) of the entity to be 0 or 1 depending on if the limbs are
touching ground"
float large_movement_penalty_coeff
0.25 [0, 1] "The movement score is multiplied by this value if
a large move would occur"
float no_ground_attachment_penalty_coeff
0.75 [0, 1] "If a limb movement would make it not collide with
ground, the movement score is multiplied with this value. Use lower values to make
the limbs prioritize attaching to walls."
bool is_limp
0 [0, 1] "If 1, will apply verlet animation to simulate
ragdoll-like limbs"
- Custom data types -------------------
int ray_skip_material
0 [0, 1] "String name of material to not cast rays against.
Defaults to 'aluminium'"
vec2 mPrevBodyPosition
- ""
- Privates -----------------------------
IKLimbStateVec mLimbStates
- ""
bool mHasGroundAttachmentOnAnyLeg
0 [0, 1] "Will be set to true if at least one leg is
attached to ground."

IngestionComponent
- Members -----------------------------
int64 ingestion_size
0 [0, 1] "How many units of material we currently store"
int64 ingestion_capacity
7500 [0, 1] "How many units of material we can store"
uint32 ingestion_cooldown_delay_frames
600 [0, 1] "How many frames is ingestion_size retained after
last time eating?"
uint32 ingestion_reduce_every_n_frame
5 [0, 1] "One unit of ingestion_size is removed every N
frame"
float overingestion_damage
0.002 [0, 1] "How much damage per overingested cell is applied"
float blood_healing_speed
0.0008 [0, 1000] "affects healing speed if entity has HEALING_BLOOD
game effect. The amount of hp restored per one blood cell."
std::string ingestion_satiation_material_tag
- "If set, only materials with this tag will increase
satiation level"
int32 m_ingestion_cooldown_frames
0 [0, 1] "Next frame ingestion_size cooldown can occur"
- Privates -----------------------------
int32 m_next_overeating_msg_frame
0 [0, 1] ""
std::string m_ingestion_satiation_material_tag_cached
- ""
std::set<int32> m_ingestion_satiation_material_cache
- ""
int32 m_damage_effect_lifetime
0 [0, 1] ""

InheritTransformComponent
- Members -----------------------------
bool use_root_parent
0 [0, 1] "if 1, we use the root of our entity hierarchy
instead of the immediate parent"
bool only_position
0 [0, 1] "if 1, we only inherit position. it is calculated
as follows: parent_position + parent_offset * parent_scale"
std::string parent_hotspot_tag
- "if set, we apply the offset of parent HotSpot with
this tag"
int parent_sprite_id
-1 [0, 1] "if >= 0, the Nth sprite transform in parent entity
is inherited"
bool always_use_immediate_parent_rotation
0 [0, 1] "if 1, we use the immediate parent for rotation, no
matter what other properties say"
bool rotate_based_on_x_scale
0 [0, 1] "if 1, the rotation is set to 0 deg if scale >= 0
else to 180 deg"
- Custom data types -------------------
types::xform Transform
- ""
- Privates -----------------------------
int mUpdateFrame
-1 [0, 1] ""

InteractableComponent
- Members -----------------------------
float radius
10 [0, 1] "Distance from entity position where interaction is
possible"
std::string ui_text
- "key or string for the text to display"
std::string name
- "this name is called to the on_interacted function
on LuaComponents"
int exclusivity_group
0 [0, 1] "If > 0, only 1 instance of this interaction can be
display at the same time"

Inventory2Component
- Members -----------------------------
 int quick_inventory_slots
10 [0, 30] ""
int full_inventory_slots_x
8 [0, 30] ""
int full_inventory_slots_y
8 [0, 30] ""
uint32 mSavedActiveItemIndex
0 [0, 1] "Used to retain active item across save/load. Don't
touch this unless you know what you're doing!"
- Privates -----------------------------
EntityID mActiveItem
0 [0, 1] "NOTE: Don't attempt to directly change the value
of this field via lua code. It will probably break the game logic in obvious or
subtle ways."
EntityID mActualActiveItem
0 [0, 1] "NOTE: Don't attempt to directly change the value
of this field via lua code. It will probably break the game logic in obvious or
subtle ways."
EntityID mActiveStash
0 [0, 1] ""
EntityID mThrowItem
0 [0, 1] "Is used to store the item that is being thrown,
instead of mActiveItem, since the player can switch items (mActiveItem) during the
throwing animation"
bool mItemHolstered
0 [0, 1] ""
bool mInitialized
0 [0, 1] ""
bool mForceRefresh
0 [0, 1] ""
bool mDontLogNextItemEquip
0 [0, 1] ""
float mSmoothedItemXOffset
0 [0, 1] ""
int mLastItemSwitchFrame
0 [0, 1] ""
float mIntroEquipItemLerp
1 [0, 1] ""
vec2 mSmoothedItemAngleVec
- ""

InventoryComponent
- Members -----------------------------
int ui_container_type
1 [0, 1] "UI_CONTAINER_TYPES enum"
std::string ui_element_sprite
data/ui_gfx/inventory/inventory_box.png [0, 1] "ui back sprite"
std::string actions
- "list of actions, used for serialization"
- Custom data types -------------------
ivec2 ui_container_size
- "ui size, how many items x*y we can fit in"
ivec2 ui_element_size
- "ui size"
ivec2 ui_position_on_screen
- "where do we load this on screen"
- Privates -----------------------------
InvenentoryUpdateListener*update_listener
- "listener to keep ui up with ability changes"
 INVENTORYITEM_VECTOR items
- ""

InventoryGuiComponent
- Members -----------------------------
bool has_opened_inventory_edit
0 [0, 1] ""
int wallet_money_target
0 [0, 1] ""
bool mDisplayFireRateWaitBar
0 [0, 1] "hax, don't touch!"
- Privates -----------------------------
ImGuiContext* imgui
- ""
int mLastFrameInteracted
-100 [0, 1] ""
int mLastFrameActionsVisible
-1 [0, 1] ""
Entity* mLastPurchasedAction
- ""
bool mActive
0 [0, 1] ""
float mAlpha
1 [0, 1] ""
float mBackgroundOverlayAlpha
0 [0, 1] ""
int mFrameShake_ReloadBar
0 [0, 1] "for animations of shaking them bars"
int mFrameShake_ManaBar
0 [0, 1] "for animations of shaking them bars"
int mFrameShake_FlyBar
0 [0, 1] "for animations of shaking them bars"
int mFrameShake_FireRateWaitBar
0 [0, 1] "for animations of shaking them bars"

ItemAIKnowledgeComponent
- Members -----------------------------
bool is_ranged_weapon
0 [0, 1] ""
bool is_throwable_weapon
0 [0, 1] ""
bool is_melee_weapon
0 [0, 1] ""
bool is_self_healing
0 [0, 1] ""
bool is_other_healing
0 [0, 1] ""
bool is_self_buffing
0 [0, 1] ""
bool is_other_buffing
0 [0, 1] ""
bool is_weapon
0 [0, 1] ""
bool is_known
0 [0, 1] ""
bool is_safe
1 [0, 1] ""
bool is_consumed
0 [0, 1] ""
 bool never_use
0 [0, 1] ""
float ranged_min_distance
0 [0, 1] ""

ItemActionComponent
- Members -----------------------------
std::string action_id
- "the name ID of the action"

ItemAlchemyComponent
- Custom data types -------------------
int material_make_always_cast
0 [0, 1] ""
int material_remove_shuffle
0 [0, 1] ""
int material_animate_wand
0 [0, 1] ""
int material_animate_wand_alt
0 [0, 1] ""
int material_increase_uses_remaining
0 [0, 1] ""
int material_sacrifice
0 [0, 1] ""

ItemChestComponent
- Members -----------------------------
int item_count_min
0 [0, 1e+006] ""
int item_count_max
0 [0, 1e+006] ""
int level
0 [0, 1e+006] ""
bool enemy_drop
0 [0, 1] "enemy_drop, if set will modify the item_count_min,
item_count_max..."
std::string actions
- "e.g. 'bullet,bullet,damage' ... actions are parsed
into a string"
std::string action_uses_remaining
- "e.g. '10,10,-1' ... action uses remaining counts
are parsed into a string"
std::string other_entities_to_spawn
- "file names of other entities we should spawn from
this chest, comma separated"
unsigned int mSeed
0 [0, 1] "this is used to figure out what we spawn from this
chest"

ItemComponent
- Members -----------------------------
std::string item_name
- "the name of the item"
bool is_stackable
0 [0, 1] "does this item stack on other items the same
'item_name' in the inventory?"
bool is_consumable
0 [0, 1] "if 1, using this item will reduce
'uses_remaining'. When it reaches zero the item is destroyed"
 bool stats_count_as_item_pick_up
1 [0, 1] "does this count as an item that was picked up in
the stats"
bool auto_pickup
0 [0, 1] "if 1, item will be automatically picked up, no
pickup hint is shown"
bool permanently_attached
0 [0, 1] "if 1, this item can't be removed from a container
once it is put inside one"
int uses_remaining
-1 [0, 1] "how many times can this item be used? -1 =
unlimited, will be reset to gun_actions.lua max_uses by inventorygui_system, -2 =
unlimited unlimited"
bool is_identified
1 [0, 1] "is it known what this item does?"
bool is_frozen
0 [0, 1] "if 1, this item can't be modified or moved from a
wand"
bool collect_nondefault_actions
0 [0, 1] "does player keep this item when respawning?"
bool remove_on_death
0 [0, 1] "is this entity destroyed when it's in an inventory
and the inventory owner dies?"
bool remove_on_death_if_empty
0 [0, 1] "is this entity destroyed when it's in an
inventory, empty and the inventory owner dies?"
bool remove_default_child_actions_on_death
0 [0, 1] "if true, the default
AbilityComponent.child_actions in this items will be removed when it dies"
bool play_hover_animation
0 [0, 1] "if 1, the item will play a hovering animation"
bool play_spinning_animation
1 [0, 1] "if 1, the item will play a spinning animation, if
player_hover_animation is 0"
bool is_equipable_forced
0 [0, 1] "if 1, the default logic for determining if an item
can be equiped in inventory is overridden and this can be always equipped"
bool play_pick_sound
1 [0, 1] "if 1, plays a default sound when picked"
bool drinkable
1 [0, 1] "if 0 you cannot drink this, default is 1, because
that's how it was implemented and backwards compatibility"
int max_child_items
0 [0, 1] "number of items this can hold inside itself. TODO:
get rid of all uses of 'ability->gun_config.deck_capacity' and replace them with
this!"
std::string ui_sprite
- "sprite displayed for the item in various UIs. If
not empty overrides sprites declared by Ability and ItemAction"
std::string ui_description
- "item description displayed in various UIs"
bool enable_orb_hacks
0 [0, 1] ""
bool is_all_spells_book
0 [0, 1] ""
bool always_use_item_name_in_ui
0 [0, 1] ""
std::string custom_pickup_string
- "if set, this is used for the 'Press $0 to pick $1'
message"
bool ui_display_description_on_pick_up_hint
0 [0, 1] ""
int next_frame_pickable
0 [0, 1] ""
int npc_next_frame_pickable
0 [0, 1] "NPC have their own next_frame_pickable, because
this is used to make NPCs not pick up gold, which also meant player couldn't pick
up that gold"
bool is_pickable
1 [0, 1] "can this be picked up and placed on someone's
inventory"
bool is_hittable_always
0 [0, 1] "to override the weirdness that is is_pickable,
which affects if this is hittable or not. If true, will always be hittable
regardless of is_pickable"
float item_pickup_radius
14.1 [0, 1] "how many pixels away can this item be picked up
from"
float camera_max_distance
50 [0, 1] "how far can we move the camera from the player
when this item is equipped"
float camera_smooth_speed_multiplier
1 [0, 1] "how quickly does the camera follow player?"
bool has_been_picked_by_player
0 [0, 1] ""
int mFramePickedUp
0 [0, 1] ""
- Custom data types -------------------
vec2 spawn_pos
- "the position where this item spawned"
INVENTORY_KIND::Enum preferred_inventory
- "Which inventory do we go to when we're picked up,
if it's not full."
ivec2 inventory_slot
- "our preferred slot (x,y) in the inventory"
- Privates -----------------------------
int mItemUid
0 [0, 1] ""
bool mIsIdentified
1 [0, 1] ""

ItemCostComponent
- Members -----------------------------
int64 cost
100 [0, 3500] ""
bool stealable
0 [0, 1] "if set - will check that it's within an area
called shop"
- Privates -----------------------------
int64 mExCost
-1 [0, 1] "used to change the text on the sprite"

ItemPickUpperComponent
- Members -----------------------------
bool is_in_npc
0 [0, 1] ""
bool pick_up_any_item_buggy
0 [0, 1] "If true, will pick up _any_ item. Breaks all kinds
of things, but maybe mods will find this fun to mess around with"
bool is_immune_to_kicks
0 [0, 1] "if set, won't drop the wand if kicked. Mainly used
by wand ghosts."
EntityID only_pick_this_entity
0 [0, 1] "picks up this entity and only this entity.
Overrides the is_in_npc checks that try to limit things to pickuppable wands"
bool drop_items_on_death
1 [0, 1] "if true, will drop all items. E.g. if true for
player, player drops their wands"
- Custom data types -------------------
vec2 mLatestItemOverlapInfoBoxPosition
- ""

ItemRechargeNearGroundComponent
- Members -----------------------------
float TEMP_TEMPY
0 [0, 3.5] ""
float TEMP_TEMP_TEMP
0 [0, 3.5] ""

ItemStashComponent
- Members -----------------------------
int throw_openable_cooldown_frames
30 [0, 180] ""
bool init_children
1 [0, 1] ""
- Privates -----------------------------
int mNextFrameOpenable
0 [0, 1] ""
int mFrameOpened
-1 [0, 1] ""

KickComponent
- Members -----------------------------
bool can_kick
1 [0, 1] "e.g. telekinetic kick disables this"
float kick_radius
3 [0, 3.5] ""
float telekinesis_throw_speed
25 [0, 1] "this is here, so that STRONG_KICK -perk can affect
telekinetic kick as well"
std::string kick_entities
- "comma separated list of entities that are loaded
when player kicks"
- Custom data types -------------------
LensValue<float> max_force
- ""
LensValue<float> player_kickforce
- ""
LensValue<float> kick_damage
- "( 1.f / 25.f )"
LensValue<float> kick_knockback
- "knockback force for entities"

LaserEmitterComponent
- Members -----------------------------
bool is_emitting
1 [0, 1] "If 1, will emit all the time"
 int32 emit_until_frame
-1 [0, 1] "Can be used to activate a laser temporarily"
float laser_angle_add_rad
0 [0, 1] "Beam angle = entity angle + laser_angle_add_rad"
- Objects -----------------------------
ConfigLaser laser
- ""

LevitationComponent
- Members -----------------------------
float radius
20 [1, 50] "the radius in which we look for entities / bodies
to float"
float entity_force
0.3 [0, 1] "how much do we apply the mouse movements to the
entitiy"
float box2d_force
0.3 [0, 1] "how much do we apply the mouse movements to the
entitiy"
int effect_lifetime_frames
600 [1, 600] ""

LifetimeComponent
- Members -----------------------------
int lifetime
-1 [0, 1] "if anything else than -1 will kill this entity
when this many frames have passed"
bool fade_sprites
0 [0, 1] "if 1, sprites will be faded as lifetime gets
lower"
bool kill_parent
0 [0, 1] "if 1, will kill the parent entity"
bool kill_all_parents
0 [0, 1] "if 1, will kill all the parents entity"
bool serialize_duration
0 [0, 1] "if 1, will retain kill_frame and creation_frame
over serialization"
int kill_frame_serialized
0 [0, 1] "frame that this is killed at"
int creation_frame_serialized
0 [0, 1] "frame that this is killed at"
- Custom data types -------------------
ValueRange randomize_lifetime
- "this is added to the lifetime"
- Privates -----------------------------
int creation_frame
0 [0, 1] "we'll set this to GG.GetFrameNum() when this
component is created"
int kill_frame
0 [0, 1] "frame that this is killed at"

LightComponent
- Members -----------------------------
bool update_properties
0 [0, 1] "turn this on if you expect this to function like
the other components"
float radius
0 [0, 3000] "The radius of the light in world pixels."
unsigned int r
255 [0, 255] "Color red 0-255"
unsigned int g
178 [0, 255] "Color green 0-255"
unsigned int b
118 [0, 255] "Color blue 0-255"
float offset_x
0 [-3000, 3000] "Offset from the center of entity."
float offset_y
0 [-3000, 3000] "Offset from the center of entity."
float fade_out_time
0 [0, 5] "time in seconds, if not 0, this is how long this
takes to die, when the component is destroyed"
float blinking_freq
1 [0, 1] "if less than 1, will blink randomly when rand() <
blinking_freq"
- Privates -----------------------------
float mAlpha
1 [0, 1] ""
as::Sprite* mSprite
- ""

LightningComponent
- Members -----------------------------
std::string sprite_lightning_file
data/particles/lightning_ray.png [0, 1] "particle effect, from where the file is
loaded that lightning is generated from"
bool is_projectile
0 [0, 1] "if this is true, it's a projectile lightning and
looks for ProjectileComponent and uses the data from there to move it"
int explosion_type
1 [0, 1] "1 = lightning trail"
int arc_lifetime
60 [0, 1] "remaining number of frames the arc exists"
- Objects -----------------------------
ConfigExplosion config_explosion
- ""
- Privates -----------------------------
vec2 mExPosition
- "stores the ex position of this entity"
EntityID mArcTarget
0 [0, 1] "if 'mArcTarget' points to an existing entity a
lighting arc will be created between this entity and 'mArcTarget'"

LimbBossComponent
- Members -----------------------------
int state
0 [0, 1] ""
- Privates -----------------------------
int mStatePrev
-1 [0, 1] ""
float mMoveToPositionX
0 [0, 1] ""
float mMoveToPositionY
0 [0, 1] ""

LiquidDisplacerComponent
- Members -----------------------------
int radius
1 [0, 20] ""
 float velocity_x
30 [0, 100] ""
float velocity_y
30 [0, 100] ""
- Privates -----------------------------
int mPrevX
0 [0, 1] ""
int mPrevY
0 [0, 1] ""

LoadEntitiesComponent
- Members -----------------------------
std::string entity_file
- "path to the entity file we should load"
bool kill_entity
1 [0, 1] "if 1, we kill our entity when it is created"
int timeout_frames
0 [0, 180] "for timer"
int mTimerTriggerFrame
-1 [0, 1] ""
- Custom data types -------------------
ValueRangeInt count
- "how many entities should be loaded (random range)"

LocationMarkerComponent
- Members -----------------------------
int id
0 [0, 3] ""

LooseGroundComponent
- Members -----------------------------
float probability
0 [0, 1] "how often do we do this... shoots a ray in random
direction and does the loosening"
int max_durability
2147483647 [0, 1] "if material durability > max_durability, it is not
loosened"
float max_distance
256 [0, 1] "how far raytraces to find things to loosen up"
float max_angle
1.57 [0, 1] "how much raytraces go to different directions
around the up-vector. pi=full circle"
int min_radius
3 [0, 1] "the minimum radius of our loosening of pixels"
int max_radius
8 [0, 1] "the maximum radius of our loosening of pixels"
float chunk_probability
0 [0, 1] "if > 0, will drop box2d chunks of the ceiling"
float chunk_max_angle
0.7 [0, 1] "how much raytraces go to different directions
around the up-vector. pi=full circle"
int chunk_count
-1 [0, 1] "how many chunks are we allowed to do, -1 =
infinite"
std::string collapse_images
data/procedural_gfx/collapse_big/$[0-14].png [0, 1] "loads these files randomly to
do the collapse shapes"
- Custom data types -------------------
int chunk_material
0 [0, 1] "String name of chunk material"
- Privates -----------------------------
int mChunkCount
0 [0, 1] "how many chunks are we allowed to do, -1 =
infinite"

LuaComponent
- Members -----------------------------
std::string script_source_file
- ""
bool execute_on_added
0 [0, 1] ""
bool execute_on_removed
0 [0, 1] ""
int execute_every_n_frame
1 [1, 150] "1 = execute every frame. 2 = execute every second
frame. 3 = execute every third frame and so on. -1 = execute only on
add/remove/event"
int execute_times
0 [0, 1] "How many times should the script be executed? < 1
means infinite"
int limit_how_many_times_per_frame
-1 [0, 1] "-1 = infinite. Use this to limit how many times
this can be executed per frame. Currently only used to limit script_shot from being
executed forever."
int limit_to_every_n_frame
-1 [0, 1] "-1 = no limit. Currently only used to limit
script_shot from being executed every frame."
bool limit_all_callbacks
0 [0, 1] "NOTE( Petri ): 19.8.2023 - by default
limit_how_many_times_per_frame and limit_to_every_n_frame only works for
script_shot. If this is set to true, will limit all callbacks. Also note that this
limit is shared within this component. So if this is true and both script_shot and
script_damage_received and both are called within limit_to_every_n_frame frames,
only one of them will be called."
bool remove_after_executed
0 [0, 1] ""
bool enable_coroutines
0 [0, 1] ""
bool call_init_function
0 [0, 1] " if 1, calls function init( entity_id:int ) after
running the code in the file scope of script_source_file along with all mod
appends. Does nothing if execute_on_added is 0"
std::string script_enabled_changed
- "if set, calls function
'enabled_changed( entity_id:int, is_enabled:bool )' when the IsEnabled status of
this LuaComponent is changed"
std::string script_damage_received
- "if set, calls function
'damage_received( damage:number, message:string, entity_thats_responsible:int,
is_fatal:bool, projectile_thats_responsible:int )' when we receive a message about
damage (Message_DamageReceived)"
std::string script_damage_about_to_be_received
- "if set, calls function
'damage_about_to_be_received( damage:number, x:number, y:number,
entity_thats_responsible:int, critical_hit_chance:int )' when we receive a message
(Message_DamageAboutToBeReceived) -> new_damage:number,new_critical_hit_chance:int"
std::string script_item_picked_up
- "if set, calls function 'item_pickup( int
entity_item, int entity_pickupper, string item_name )' when message
'Message_ItemPickUp' is called"
std::string script_shot
- "if set, calls function 'shot( projectile_entity_id
)' when we receive Message_Shot"
std::string script_collision_trigger_hit
- "if set, calls function
'collision_trigger( colliding_entity_id )' when we receive
Message_CollisionTriggerHit"
std::string script_collision_trigger_timer_finished
- "if set, calls function
'collision_trigger_timer_finished()' when we receive
Message_CollisionTriggerTimerFinished"
std::string script_physics_body_modified
- "if set, calls function
'physics_body_modified( is_destroyed )' when physics body has been modified"
std::string script_pressure_plate_change
- "if set, calls function
'pressure_plate_change( new_state )' when PressurePlateComponent decides that
things have change"
std::string script_inhaled_material
- "if set, calls function
'inhaled_material( material_name, count )' once per second for each inhaled
material"
std::string script_death
- "if set, calls function 'death( int
damage_type_bit_field, string damage_message, int entity_thats_responsible, bool
drop_items )' when we receive message Message_Death"
std::string script_throw_item
- "if set, calls function 'throw_item( from_x,
from_y, to_x, to_y )' when we receive message Message_ThrowItem"
std::string script_material_area_checker_failed
- "if set, calls function
'material_area_checker_failed( pos_x, pos_y, )' when we receive message
Message_MaterialAreaCheckerFailed"
std::string script_material_area_checker_success
- "if set, calls function
'material_area_checker_success( pos_x, pos_y, )' when we receive message
Message_MaterialAreaCheckerSuccess"
std::string script_electricity_receiver_switched
- "if set, calls function
'electricity_receiver_switched( bool is_electrified )' when we receive message
Message_ElectricityReceiverSwitched"
std::string script_electricity_receiver_electrified
- "if set, calls function
'electricity_receiver_electrified()' when we receive message
Message_ElectricityReceiverElectrified"
std::string script_kick
- "if set, calls function 'kick( entity_who_kicked )'
when we receive message Message_Kick"
std::string script_interacting
- "if set, calls function
'interacting( entity_who_interacted, entity_interacted, interactable_name )' when
we receive message Message_Interaction"
std::string script_audio_event_dead
- "if set, calls function
'audio_event_dead( bank_file, event_root )' when we receive message
Message_AudioEventDead"
std::string script_wand_fired
- "if set, calls function
'wand_fired( gun_entity_id )' when we receive Message_WandFired"
std::string script_teleported
- "if set, calls function 'teleported( from_x,
from_y, to_x, to_y, bool portal_teleport )' when we receive Message_Teleported"
std::string script_portal_teleport_used
- "if set, calls function
'portal_teleport_used( entity_that_was_teleported, from_x, from_y, to_x, to_y )'
when we receive Message_PortalTeleportUsed"
std::string script_polymorphing_to
- "if set, calls function
'polymorphing_to( string_entity_we_are_about_to_polymorph_to )' when we receive
Message_PolymorphingTo"
std::string script_biome_entered
- "if set, calls function
'biome_entered( string_biome_name, string_biome_old_name )' when this entity
changes biomes. Requires BiomeTrackerComponent"
int mLastExecutionFrame
-1 [0, 1] ""
int mTimesExecutedThisFrame
0 [0, 1] "tracks how many times we've executed this frame.
This will linger on and store the old value of the old frames. Used internally."
bool mModAppendsDone
0 [0, 1] ""
- Custom data types -------------------
LUA_VM_TYPE::Enum vm_type
- "Do we share a single Lua virtual machine for
everyone who runs 'script_source_file' ('SHARED_BY_MANY_COMPONENTS'), create one VM
per one LuaComponent and reuse the VM in case the component runs the script
multiple times ('ONE_PER_COMPONENT_INSTANCE'), or create a new VM every time the
script is executed ('CREATE_NEW_EVERY_EXECUTION', deprecated)?"
- Privates -----------------------------
int mNextExecutionTime
-1 [0, 1] ""
int mTimesExecuted
0 [0, 1] ""
LuaManager* mLuaManager
- ""
ValueMap mPersistentValues
- ""

MagicConvertMaterialComponent
- Members -----------------------------
int radius
256 [0, 512] ""
int min_radius
0 [0, 512] "allows for convert to happen from x pixels from
the center"
bool is_circle
0 [0, 1] ""
int steps_per_frame
10 [0, 512] ""
std::string from_material_tag
- "the tag of material, e.g. [liquid]"
bool from_any_material
0 [0, 1] "if 1, converts any cells of any material to
'to_materia'"
bool clean_stains
0 [0, 1] ""
 bool extinguish_fire
0 [0, 1] ""
int fan_the_flames
0 [0, 1] "if > 0, will call UpdateFire() fan_the_flames
times"
int32 temperature_reaction_temp
0 [0, 1] "if != 0, will use the 'cold_freezes_to_materials'
and 'warmth_melts_to_materials' in CellData to convert cells different materials"
int ignite_materials
0 [0, 1] "if > 0, will call Ignite() with ingite_materials
as probability_of_fire"
bool loop
0 [0, 1] ""
bool kill_when_finished
1 [0, 1] ""
bool convert_entities
0 [0, 1] "if 1, kills entities with a damagemodel and
converts them to 'to_material'"
bool stain_frozen
0 [0, 1] "petri hax"
float reaction_audio_amount
0 [0, 1] "if > 0, will generate chemical reaction audio at
converted cells"
bool convert_same_material
1 [0, 1] "9.10.2020 - added this because at the end this
caused the 'white ring' to appear, set it to false if you don't want constant
whiteout"
std::string from_material_array
- ""
std::string to_material_array
- ""
int mRadius
0 [0, 512] ""
- Custom data types -------------------
int from_material
0 [0, 1] ""
int to_material
0 [0, 1] ""
- Privates -----------------------------
bool mUseArrays
0 [0, 1] ""
std::vector<int> mFromMaterialArray
- ""
std::vector<int> mToMaterialArray
- ""

MagicXRayComponent
- Members -----------------------------
int radius
256 [0, 512] ""
int steps_per_frame
10 [0, 512] ""
int mStep
0 [0, 1] ""
int mRadius
0 [0, 1] ""

ManaReloaderComponent
MaterialAreaCheckerComponent
- Members -----------------------------
int update_every_x_frame
0 [0, 1] "if something other than 0 or 1, will only
update_every_x_frames "
bool look_for_failure
1 [0, 1] "if true, will send message
Message_MaterialAreaCheckerFailed if the material doesn't exist. If false, will
send a message Message_MaterialAreaCheckerSuccess if the aabb is full of material
and material2"
int count_min
0 [0, 1] "If > 0, and look_for_failure=0, will send message
if material count exceeds this number of cells"
bool always_check_fullness
0 [0, 1] "if 1, and look_for_failure=0, will always check
the whole area for cells"
bool kill_after_message
1 [0, 1] "will kill this entity after sending the message"
- Custom data types -------------------
types::aabb area_aabb
- "aabb offset, we check that this aabb contains only
material"
int material
0 [0, 1] "String name of material that we check that the
aabb contains"
int material2
0 [0, 1] "String name of material2 that we check that the
aabb contains"
- Privates -----------------------------
int mPosition
0 [0, 1] "keeps track where we are"
int mLastFrameChecked
0 [0, 1] "keeps track of how often we've checked"

MaterialInventoryComponent
- Members -----------------------------
bool drop_as_item
1 [0, 1] "if true, drops a bag that the player can big up"
bool on_death_spill
0 [0, 1] "if true, on the death this will explode all the
materials into air"
bool leak_gently
1 [0, 1] "NOTE( Petri ): 11.8.2023 - set this to false for
old style leaky hidden piles situation."
float leak_on_damage_percent
0 [0, 1] "if higher than 0 then it might leak when
projectile damage happens"
float leak_pressure_min
0.7 [0, 1] "leak pressure coefficient"
float leak_pressure_max
1.1 [0, 1] "leak pressure coefficient"
float min_damage_to_leak
0.09 [0, 1] "the minimum damage that has to be done in order
for a leak to occur"
float b2_force_on_leak
0 [0, 10] "if 0, nothing happens, elsewise will add a b2
force to the particleemitter which will push the b2body"
float death_throw_particle_velocity_coeff
1 [0, 1] "how far do we throw material particles on death?"
 bool kill_when_empty
0 [0, 1] "if set, will send MessageDeath when materials are
drained"
bool halftime_materials
0 [0, 1] "if true, will multiply the materials with the
given halftimes"
int do_reactions
0 [0, 100] "NOTE( Petri ): 15.8.2023 - if > 0, will do
CellReactions between the materials. Value is the percent chance of how often. 100
= every frame "
bool do_reactions_explosions
0 [0, 1] "requires do_reactions > 0 - are we allowed to do
reaction explosions?"
bool do_reactions_entities
0 [0, 1] "requires do_reactions > 0 - are we allowed to load
entities when doing reactions?"
int reaction_speed
5 [0, 1] "Note( Petri ): 17.8.2023 - how 'fast' do we let
reactions happen. How many pixels of material do we convert at one time (5-10)
seems like a nice speed."
bool reactions_shaking_speeds_up
1 [0, 1] "Note( Petri ): 17.8.2023 - added the ability of
shaking the bottle to cause reactions to happen quicker. "
double max_capacity
-1 [0, 1] "how much materials we can store in total. < 0 =
infinite"
float audio_collision_size_modifier_amount
0 [0, 1] "if > 0, 'fullness of this container' *
'audio_collision_size_modifier_amount' is added to collision audio event size"
int32 last_frame_drank
-100 [0, 1] "last frame someone ingested from this via
IngestionSystem"
- Custom data types -------------------
MATERIAL_VEC_DOUBLES count_per_material_type
- "Count of each material indexed by material type
ID"
- Privates -----------------------------
bool is_death_handled
0 [0, 1] ""
vec2 ex_position
- "used to figure out movement velocity"
float ex_angle
0 [0, 1] "used to figure out movement velocity"

MaterialSeaSpawnerComponent
- Members -----------------------------
int speed
10 [1, 100] "How many pixels to cover per one direction per one
frame"
float sine_wavelength
10 [0, 2] "Parameters for sine wave that affects material
spawn pattern"
float sine_amplitude
5 [0, 2] "Parameters for sine wave that affects material
spawn pattern"
double noise_scale
0.1 [0, 1] "Parameters for noise that affects material spawn
pattern"
double noise_threshold
0.05 [0, 1] "Parameters for noise that affects material spawn
pattern"
int m_position
0 [0, 1] ""
int frames_run
0 [0, 1] "to help keep the effect"
- Custom data types -------------------
int material
0 [0, 1] "String name of material this creates"
ivec2 size
- "Size of the area to cover"
ivec2 offset
- "Offset of the center of the area to cover"

MaterialSuckerComponent
- Members -----------------------------
int material_type
0 [0, 3] "0 = liquid, 1 = sand, 2 = gas (arbitary order)"
int barrel_size
50 [0, 1024] "how many pixels can we suck up"
int num_cells_sucked_per_frame
1 [0, 5] "How many cells at max can we suck per frame?"
bool set_projectile_to_liquid
0 [0, 1] "if set, will set the projectile what ever we're
sucking...?"
int last_material_id
0 [0, 1] "hax... this is set if we use
set_projectile_to_liquid"
bool suck_gold
0 [0, 1] "if set will just suck gold and update wallet"
bool suck_health
0 [0, 1] "if set will just suck healthium material and add 1
hp every sucked healthium"
bool suck_static_materials
0 [0, 1] "will suck static materials from the world"
std::string suck_tag
- "if set, will only suck materials with this tag.
NOTE, will also require the correct material_type to be set"
int mAmountUsed
0 [0, 1] "how full are we"
- Custom data types -------------------
types::iaabb randomized_position
- "random offset for pos, where we look for pixels"
- Privates -----------------------------
int mGoldAccumulator
0 [0, 1] "accumulates amount of gold picked during
consecutive frames"
int mLastFramePickedGold
-2 [0, 1] "last frame we picked gold"

MoveToSurfaceOnCreateComponent
- Members -----------------------------
float lookup_radius
64 [0, 64] ""
float offset_from_surface
2 [0, 10] ""
int ray_count
4 [0, 8] ""
float verlet_min_joint_distance
32 [0, 128] ""
- Custom data types -------------------
MOVETOSURFACE_TYPE::Enumtype
- ""

MusicEnergyAffectorComponent
- Members -----------------------------
float energy_target
0.5 [0, 1] "the energy this makes music go towards"
float fade_range
0 [0, 256] "if > 0, fade between 0 and energy_target based on
distance to this entity"
bool trigger_danger_music
1 [0, 1] "if 1, attempts to trigger danger music no matter
what energy level is reached"
int fog_of_war_threshold
200 [0, 255] "if fog of war at position of this entity is
greater than 'fog_of_war_threshold', this has no effect"
bool is_enemy
1 [0, 1] ""
float energy_lerp_up_speed_multiplier
0 [0, 1] ""

NinjaRopeComponent
- Members -----------------------------
float max_length
356 [0, 2000] ""
float mLength
0 [0, 2000] ""
- Privates -----------------------------
NINJA_ROPE_SEGMENT_VECTORmSegments
- ""

NullDamageComponent
- Members -----------------------------
float null_chance
1 [0, 1] "if less than 1, then will roll the die to see if
it will NULL all damage. Stick this into your projectile entity"

OrbComponent
- Members -----------------------------
int orb_id
0 [0, 20] "must be unique for every orb in the world"

ParticleEmitterComponent
- Members -----------------------------
std::string emitted_material_name
blood [0, 1] ""
bool create_real_particles
0 [0, 1] "used to be emit_real_particles - creates these
particles in the grid, if that happens velocity and lifetime are ignored"
bool emit_real_particles
0 [0, 1] "this creates particles that will behave like
particles, but work outside of the screen"
bool emit_cosmetic_particles
0 [0, 1] "particle does have collisions, but no other
physical interactions with the world. the particles are culled outside camera
region"
bool cosmetic_force_create
1 [0, 1] "cosmetic particles are created inside grid cells"
bool render_back
1 [0, 1] "for cosmetic particles, if they are rendered on
front or in the back..."
bool render_ultrabright
0 [0, 1] "if 1, particles made of a glowing material will be
3x as bright as usually"
bool collide_with_grid
1 [0, 1] "for cosmetic particles, if 1 the particles collide
with grid and only exist in screen space"
bool collide_with_gas_and_fire
1 [0, 1] "does it collide with gas and fire, works with
create_real_particles and raytraced images "
bool particle_single_width
1 [0, 1] "for cosmetic particles, forces them (gas,fire) to
be only 1 pixel wide "
bool emit_only_if_there_is_space
0 [0, 1] "This is turned for potions after they take some
damage and start leaking"
int emitter_lifetime_frames
-1 [0, 1] "emitter lifetime in frames. -1 = infinite"
bool fire_cells_dont_ignite_damagemodel
0 [0, 1] "if set, and fire cells are created, this changes
their default behaviour of igniting DamageModels"
bool color_is_based_on_pos
0 [0, 1] "if true, will get the particle color based on the
world position (instead of randomizing it)"
float custom_alpha
-1 [0, 1] "if >= 0, will use this as particle alpha"
float x_pos_offset_min
0 [-20, 20] ""
float y_pos_offset_min
0 [-20, 20] ""
float x_pos_offset_max
0 [-20, 20] ""
float y_pos_offset_max
0 [-20, 20] ""
float area_circle_sector_degrees
360 [0, 360] ""
float x_vel_min
0 [-100, 100] ""
float x_vel_max
0 [-100, 100] ""
float y_vel_min
0 [-100, 100] ""
float y_vel_max
0 [-100, 100] ""
float direction_random_deg
0 [0, 90] ""
float velocity_always_away_from_center
0 [-256, 256] "if set, will make the velocity's rotation always
away from center of randomized aabb"
float lifetime_min
5 [0, 10] ""
float lifetime_max
10 [0, 10] ""
float airflow_force
0 [0, 6] ""
float airflow_time
1 [0, 2] ""
float airflow_scale
1 [0, 2] ""
float friction
0 [0, 10] ""
float attractor_force
0 [0, 100] "If > 0, an attractor is created at the position of
the entity that owns this component"
int emission_interval_min_frames
5 [0, 120] ""
int emission_interval_max_frames
10 [0, 120] ""
int emission_chance
100 [0, 100] ""
int delay_frames
0 [0, 1] "if set will delay this many frames until starts"
bool is_emitting
1 [0, 1] ""
bool use_material_inventory
0 [0, 1] "if set, it'll use MaterialInventoryComponent as
the source of the particles emitted"
bool is_trail
0 [0, 1] "if set, will do a trail based on the previous
position and current position"
float trail_gap
0 [0, 1] "if > 0, trail particles will be generated this far
from each other between our old and new position, else [count_min-count_max]
particles will be generated on the line"
bool render_on_grid
0 [0, 1] "if set, particle render positions will be snapped
to cell grid"
bool fade_based_on_lifetime
0 [0, 1] "if set, particle's position in its lifetime will
determine the rendering alpha"
bool draw_as_long
0 [0, 1] "if set, particle will rendered as a trail along
it's movement vector"
float b2_force
0 [0, 10] "if 0 nothing happens, if 1 will apply a force to
the physics body (if has one), also requires that we use the material inventory"
bool set_magic_creation
0 [0, 1] "if set will set the magic creation 1 in the cells
and do the white glow effect"
std::string image_animation_file
- "file to use for image-based animation"
std::string image_animation_colors_file
- "file to use for image-based animation"
float image_animation_speed
1 [0, 255] "how long do we stay on one frame of image-based
animation. 0.5 means two game frames per one animation frame. 2.0 means two
animation frames per one game frame, and so on. 0 means we always emit at time 0 of
the animation."
bool image_animation_loop
1 [0, 1] "does image-based animation keep looping while this
component is active?"
float image_animation_phase
0 [0, 1] "the point in time [0,1] where the image-based
animation will start the first cycle"
float image_animation_emission_probability
1 [0, 1] "[0,1], probability of emitting image based
particles is multiplied with this"
bool image_animation_raytrace_from_center
0 [0, 1] "enable this to disable image_animations (from the
center) going through the world"
bool image_animation_use_entity_rotation
0 [0, 1] "if 1, image animation emission will be rotated
based on entity rotation"
bool ignore_transform_updated_msg
0 [0, 1] "if 1, mExPosition and m_last_emit_position will
not be updated when receiving Message_TransformUpdated"
- Custom data types -------------------
uint32 color
0 [0, 1] ""
vec2 offset
- ""
ValueRange area_circle_radius
- "If > 0, the particles will be emitted inside a
circular area defined by the min and max bounds of 'area_circle_radius'."
vec2 gravity
- ""
LensValue<int> count_min
- ""
LensValue<int> count_max
- ""
PARTICLE_EMITTER_CUSTOM_STYLE::Enumcustom_style
- "NONE or FIRE"
- Privates -----------------------------
vec2 mExPosition
- "is used with is_trail"
int mMaterialInventoryMax
1024 [0, 1] "this is how we figure out the pressure, when using
material_inventory"
LensValue<int> m_material_id
- ""
int m_next_emit_frame
0 [0, 1] ""
bool m_has_emitted
0 [0, 1] ""
ivec2 m_last_emit_position
- ""
ParticleEmitter_Animation*m_cached_image_animation
- ""
float m_image_based_animation_time
0 [0, 1] ""
float* m_collision_angles
- ""
int16 m_particle_attractor_id
-1 [0, 1] ""

PathFindingComponent
- Members -----------------------------
int search_depth_max_no_goal
20 [0, 1e+006] "TODO: Comment"
int iterations_max_no_goal
1500 [0, 1e+006] "TODO: Comment"
int search_depth_max_with_goal
2500 [0, 1e+006] "TODO: Comment"
int iterations_max_with_goal
1500 [0, 1e+006] "TODO: Comment"
float cost_of_flying
20 [0, 100000] "TODO: Comment"
int distance_to_reach_node_x
2 [0, 200] "TODO: Comment"
int distance_to_reach_node_y
6 [0, 200] "TODO: Comment"
int frames_to_get_stuck
60 [0, 600] "TODO: Comment"
int frames_between_searches
30 [0, 300] "TODO: Comment"
float y_walking_compensation
0 [-100, 100] "TODO: Comment"
bool can_fly
1 [0, 1] "TODO: Comment"
bool can_walk
1 [0, 1] "TODO: Comment"
bool can_jump
0 [0, 1] "TODO: Comment"
bool can_dive
0 [0, 1] "TODO: Comment"
bool can_swim_on_surface
0 [0, 1] "TODO: Comment"
bool never_consider_line_of_sight
0 [0, 1] "if 1, we require a path to have an entity at the
goal, having line of sight to the entity is not enough"
float space_required
0 [0, 20] "how far (in cells) must a point on our route be
from the nearest wall to consider it passable?"
float max_jump_distance_from_camera
400 [0, 400] "TODO: Comment"
float jump_speed
200 [0, 1000] "TODO: Comment"
float initial_jump_lob
1 [0, 5] "TODO: Comment"
float initial_jump_max_distance_x
100 [0, 1000] "TODO: Comment"
float initial_jump_max_distance_y
80 [0, 1000] "TODO: Comment"
int read_state
0 [0, 1] "Read only value to get mState as an integer. Used
to detect when the worst cheesers are trying to cheese our beloved squidward."
- Custom data types -------------------
VECTOR_JUMPPARAMS jump_trajectories
- "TODO: Comment"
- Privates -----------------------------
PathFindingInput input
- "TODO: Comment"
MSG_QUEUE_PATH_FINDING_RESULTjob_result_receiver
- "TODO: Comment"
bool waiting_for
0 [0, 1] "TODO: Comment"
int next_search_frame
0 [0, 1] "TODO: Comment"
VECTOR_PATHNODE path
- "TODO: Comment"
PathFindingResultNode path_next_node
- "TODO: Comment"
vec2 path_next_node_vector_to
- "TODO: Comment"
float path_next_node_distance_to
0 [0, 1] "TODO: Comment"
PathFindingNodeHandle path_previous_node
- "TODO: Comment"
int path_frames_stuck
0 [0, 1] "TODO: Comment"
bool path_is_stuck
0 [0, 1] "TODO: Comment"
int path_last_frame_with_job
0 [0, 1] "TODO: Comment"
PathFindingLogic* mLogic
- "this defines what is an acceptable path"
PathFindingLogic* mFallbackLogic
- "we use this to define an acceptable path if mLogic
doesn't return one"
PathFindingLogic* mSelectedLogic
- "TODO: Comment"
bool mEnabled
0 [0, 1] "TODO: Comment"
PathFindingComponentState::EnummState
- "TODO: Comment"
int mTimesStuck
0 [0, 1] "TODO: Comment"
int mNextClearDontApproachListFrame
0 [0, 1] "TODO: Comment"
float mNodeProximityCheckCorrectionY
0 [0, 1] "TODO: Comment"
VECTOR_PATHNODE debug_path
- "TODO: Comment"
LensValue<float> jump_velocity_multiplier
- "TODO: Comment"

PathFindingGridMarkerComponent
- Members -----------------------------
int marker_work_flag
0 [0, 255] ""
float marker_offset_x
0 [-1000, 1000] ""
float marker_offset_y
0 [-1000, 1000] ""
float player_marker_radius
0 [0, 128] ""
- Privates -----------------------------
PathFindingNodeHandle mNode
- "we change the work state of this node. thus we
need to keep a reference to it"

PhysicsAIComponent
- Members -----------------------------
float target_vec_max_len
5 [0, 1] ""
float force_coeff
30 [0, 1] ""
float force_balancing_coeff
1.5 [0, 1] ""
float force_max
100 [0, 1] ""
float torque_coeff
50 [0, 1] ""
float torque_balancing_coeff
0.2 [0, 1] ""
float torque_max
50 [0, 1] ""
float torque_damaged_max
100 [0, 1] ""
float torque_jump_random
0 [0, 1] ""
int damage_deactivation_probability
80 [0, 1] ""
int damage_deactivation_time_min
30 [0, 1] ""
int damage_deactivation_time_max
60 [0, 1] ""
float die_on_remaining_mass_percentage
0.3 [0, 1] ""
bool levitate
1 [0, 1] ""
bool v0_jump_logic
1 [0, 1] ""
bool v0_swim_logic
1 [0, 1] ""
bool v0_body_id_logic
1 [0, 1] ""
int swim_check_y_min
-2 [0, 1] ""
int swim_check_y_max
2 [0, 1] ""
int swim_check_side_x
4 [0, 1] ""
int swim_check_side_y
-2 [0, 1] ""
bool keep_inside_world
1 [0, 1] "fix to the bug in which the spiders spawned inside
the holy mountain, if set will try not to go into places which aren't loaded "
bool free_if_static
0 [0, 1] "set true for the boss, because box2d might turn
this body into a static body, if it thinks it's glitching out. "
- Privates -----------------------------
float rotation_speed
0 [0, 1] ""
float mStartingMass
1 [0, 1] ""
bool mMainBodyFound
0 [0, 1] ""
int mNextFrameActive
0 [0, 1] ""
float mRotationTarget
0 [0, 1] ""
vec2 mLastPositionWhenHadPath
- ""
bool mHasLastPosition
0 [0, 1] ""

PhysicsBody2Component
- Members -----------------------------
b2ObjectID mBodyId
0 [0, 1] "this is mBody->GetBodyId() - not to be confused
with uid, has to be tracked separately, since the mBody pointer is not unique"
float linear_damping
0 [0, 1] ""
float angular_damping
0 [0, 1] ""
bool allow_sleep
1 [0, 1] ""
bool fixed_rotation
0 [0, 1] ""
bool is_bullet
0 [0, 1] ""
bool is_static
0 [0, 1] ""
float buoyancy
0.7 [0, 1] ""
bool hax_fix_going_through_ground
0 [0, 1] "if 1, will lift the body upwards if it is inside
ground"
bool hax_fix_going_through_sand
0 [0, 1] "hax_fix_going_through_ground has to be set, if set
will lift the body upwards if it is inside sand"
bool hax_wait_till_pixel_scenes_loaded
0 [0, 1] ""
bool go_through_sand
0 [0, 1] "if 1, will go through sand
PhysicsBridge::mGoThroughSand = 1"
bool auto_clean
1 [0, 1] "if 1, the simulation might destroy this body if
it's hidden under sand. Problematic if you have a small piece with joint attached
to something like the wheels of minecart. Set to 0 in cases like that"
bool force_add_update_areas
1 [0, 1] "if 1, we will mark our predicted aabb as a box2d
update area."
bool update_entity_transform
1 [0, 1] ""
bool kill_entity_if_body_destroyed
1 [0, 1] "if 1, will kill the entity when physics body is
destroyed"
bool kill_entity_after_initialized
0 [0, 1] "if 1, will destroy the entity after initialization
has been done based the entity's PhysicsBodyComponents and JointComponents"
bool manual_init
0 [0, 1] "if 1, initialization occurs only when done via for
example lua component and Physic2InitFromComponents()"
bool destroy_body_if_entity_destroyed
0 [0, 1] "if 1, root body is destroyed if the entity is
destroyed"
float root_offset_x
0 [0, 1] "TODO"
float root_offset_y
0 [0, 1] "TODO"
float init_offset_x
0 [0, 1] "TODO"
float init_offset_y
0 [0, 1] "TODO"
bool mActiveState
0 [0, 1] "private variable, please don't mess around with
this"
uint32 mPixelCountOrig
0 [0, 1] "the number of pixels the body had when it was
originally created"
- Custom data types -------------------
vec2 mLocalPosition
- "private variable, please don't mess around with
this"
- Privates -----------------------------
b2Body* mBody
- ""
bool mInitialized
0 [0, 1] "private variable, please don't mess around with
this"
uint32 mPixelCount
0 [0, 1] "if set, tracks the number of csolidcells the body
has"
bool mRefreshed
0 [0, 1] "this is sure the bodies are only parsed once"

PhysicsBodyCollisionDamageComponent
- Members -----------------------------
float speed_threshold
60 [0, 100] ""
float damage_multiplier
0.016667 [0, 1] ""

PhysicsBodyComponent
- Members -----------------------------
bool is_external
0 [0, 1] "if mBody is set from outside, will ignore all the
things"
bool hax_fix_going_through_ground
0 [0, 1] "if set will lift the body upwards if it is inside
ground"
bool hax_fix_going_through_sand
0 [0, 1] "hax_fix_going_through_ground has to be set, if set
will lift the body upwards if it is inside sand"
bool hax_wait_till_pixel_scenes_loaded
0 [0, 1] ""
int uid
0 [0, 1000] "if the entity has multiple physics bodies and has
specific shapes for those and possible joints, you should use this. 0 is default
for shapes"
bool is_enabled
1 [0, 1] "Use this to kill the physics body of. if
is_enabled is set to false, will destroy the physics body"
float linear_damping
0 [0, 1] ""
float angular_damping
0 [0, 1] ""
bool allow_sleep
1 [0, 1] ""
bool fixed_rotation
0 [0, 1] ""
float buoyancy
0.7 [0, 1] ""
float gravity_scale_if_has_no_image_shapes
1 [0, 1] ""
bool is_bullet
0 [0, 1] ""
 bool is_static
0 [0, 1] ""
bool is_kinematic
0 [0, 1] ""
bool is_character
0 [0, 1] "if it is a character, then we need to few
interesting things from time to time"
bool go_through_sand
0 [0, 1] "if set, will go through sand
PhysicsBridge::mGoThroughSand = 1"
bool gridworld_box2d
1 [0, 1] "default is 1. You should only change this if you
know the body isn't going to touch gridworld"
bool auto_clean
1 [0, 1] "if set, the simulation might destroy this body if
it's hidden under sand. Problematic if you have a small piece with joint attached
to something like the wheels of minecart. Set to 0 in cases like that"
bool on_death_leave_physics_body
0 [0, 1] "if set, will leave the b2body into the world, even
if the entity is killed"
bool on_death_really_leave_body
0 [0, 1] "camera bound... god damn... we need something
special when we want to leave the body"
bool update_entity_transform
1 [0, 1] "WARNING! Don't touch this unless you know what
you're doing. If false, doesn't update the entitys transform to match the physics
body. This is used with multi body entities, to use the correct body to update the
entity, e.g. minecart"
bool force_add_update_areas
0 [0, 1] "if 1, we will mark our predicted aabb as a box2d
update area."
bool kills_entity
1 [0, 1] "if set, will kill the entity when physics body is
destroyed"
bool projectiles_rotate_toward_velocity
0 [0, 1] "for physics projectiles, if true will initially
rotate the body based on the velocity"
bool randomize_init_velocity
0 [0, 1] "randomizes the init velocity"
bool mActiveState
0 [0, 1] "private variable, please don't mess around with
this"
- Custom data types -------------------
vec2 initial_velocity
- "if you want a velocity at the start, set it here"
- Privates -----------------------------
b2Body* mBody
- ""
b2ObjectID mBodyId
0 [0, 1] "this is mBody->GetBodyId() - not to be confused
with uid shit, has to be tracked separately, since the mBody pointer is not unique"
int mPixelCount
0 [0, 1] "if set, tracks the number of csolidcells the body
has"
b2Vec2 mLocalPosition
- ""
bool mRefreshed
0 [0, 1] "this is sure the bodies are only parsed once"
PhysicsImageShapeComponent
- Members -----------------------------
bool is_root
0 [0, 1] "if 1, PhysicsBody2Component will use this to
figure out where the entity is located"
int body_id
0 [0, 1000] "used to figure out which bodies are attached to
each other when creating joints"
bool use_sprite
0 [0, 1] "will try to find the SpriteComponent and use that"
bool is_circle
0 [0, 1] "tries to fit this into a circle, looks at bounding
box of the pixels and sets the circle to the center of that with radius being the
line from there to a straight edge"
bool centered
0 [0, 1] "if this is true, moves offset to be in the center
of the image, overwrites the offset_x, offset_y"
float offset_x
0 [0, 1] "offset x in pixels"
float offset_y
0 [0, 1] "offset y in pixels"
float z
0 [0, 1] "offset in the z direction"
std::string image_file
- "the png file from which the body is created from"
- Custom data types -------------------
int material
0 [0, 1] "the material from which the body is created"
- Privates -----------------------------
b2Body* mBody
- "used in joint creation phase"

PhysicsJoint2Component
- Members -----------------------------
uint16 joint_id
0 [0, 1000] "Use this to create a relation between
PhysicsJointMutator and a joint. The PhysicsJointMutator must exist when the
physics objects are initialized for the first time. This id should be unique inside
one entity. Defaults to 0"
float break_force
1.3 [0, 1] "if > 0, will break if theres a force too strong."
float break_distance
1.4142 [0, 1] "if > 0, will break if the anchors on the bodies
get further than this."
bool break_on_body_modified
0 [0, 1] "if > 1, will break if an attached body is
modified"
float break_on_shear_angle_deg
0 [0, 1] "if > 0, will break if the angle between the linked
bodies becomes greater than this"
int body1_id
0 [0, 1] ""
int body2_id
0 [0, 1] ""
float offset_x
0 [0, 1] ""
float offset_y
0 [0, 1] ""
float ray_x
0 [0, 1] ""
float ray_y
-10 [0, 1] ""
float surface_attachment_offset_x
0 [0, 1] ""
float surface_attachment_offset_y
2.5 [0, 1] ""
- Custom data types -------------------
JOINT_TYPE::Enum type
- "Enum - REVOLUTE_JOINT, WELD_JOINT,
REVOLUTE_JOINT_ATTACH_TO_NEARBY_SURFACE or WELD_JOINT_ATTACH_TO_NEARBY_SURFACE"

PhysicsJoint2MutatorComponent
- Members -----------------------------
uint16 joint_id
0 [0, 1000] "Use this to create a relation between
PhysicsJointMutator and a joint created by PhysicsJoint2Component. The
PhysicsJoint2Mutator must exist when the physics objects are initialized for the
first time."
bool destroy
0 [0, 1] "if 1, the joint will break and this component will
be destroyed."
float motor_speed
0 [0, 1] "if != 0 and this is linked to a revolute joint,
the joint motor will be enabled at this speed"
float motor_max_torque
1 [0, 1] "max torque for motor"
uint64 mBox2DJointId
0 [0, 1] "Private, don't touch this! Stores the joint's id
in the physics engine."
- Privates -----------------------------
float mPreviousMotorSpeed
0 [0, 1] ""
float mPreviousMotorMaxTorque
0 [0, 1] ""

PhysicsJointComponent
- Members -----------------------------
bool nail_to_wall
0 [0, 1] ""
bool grid_joint
0 [0, 1] "if 1, will do a grid joint that works correctly
with a body when it is destroyed / chipped away"
bool breakable
0 [0, 1] "if 1, will break if theres a force too strong"
int body1_id
0 [0, 1] ""
int body2_id
0 [0, 1] ""
float pos_x
0 [0, 3.5] ""
float pos_y
0 [0, 3.5] ""
float delta_x
0 [-10, 10] "For mouse joint only ... moves the mouse joint by
*dt "
float delta_y
0 [-10, 10] "For mouse joint only ... moves the mouse joint by
*dt "
 bool mMotorEnabled
0 [0, 1] "enable motor, by setting this to true"
float mMotorSpeed
0 [0, 20] "if enabled this gets set to speed"
float mMaxMotorTorque
1 [0, 1] "max torque for motor"
- Custom data types -------------------
JOINT_TYPE::Enum type
- "Enum - JOINT_TYPE"
- Privates -----------------------------
b2Joint* mJoint
- ""

PhysicsKeepInWorldComponent
- Members -----------------------------
bool check_whole_aabb
0 [0, 1] "All that is needed is to include one of the
components with PhysicsBodyComponent or PhysicsBody2Component and it will be frozen
when it hits outer edges of the world. NOTE! This will override the auto_clean
variable, auto_clean will be set to false. If this is true, will check all the 4
corners of the bounding box"
bool predict_aabb
0 [0, 1] "Will add the velocity * 1.5 to the aabb to predict
where the body will end up at. This will greatly help keep the body inside
simulated world."
bool keep_at_last_valid_pos
0 [0, 1] "Will try to keep the object at the latest valid
position"
- Privates -----------------------------
vec2 mExPosition
- ""
float mExRotation
0 [0, 1] ""

PhysicsPickUpComponent
- Members -----------------------------
float pick_up_strength
200 [0, 1] ""
- Custom data types -------------------
types::xform transform
- ""
vec2 original_left_joint_pos
- ""
vec2 original_right_joint_pos
- ""
- Privates -----------------------------
bool isBroken
0 [0, 1] ""
vec2 leftJointPos
- ""
vec2 rightJointPos
- ""
b2WeldJoint* leftJoint
- ""
b2WeldJoint* rightJoint
- ""

PhysicsRagdollComponent
- Members -----------------------------
 std::string filename
- "file that should include just a list of other
files, that have all the parts"
std::string filenames
- "a list of body parts as png images, separate the
files by ','. e.g. 'data/temp/ragdoll/leg.png, data/temp/ragdoll/head.png,...'"
float offset_x
0 [0, 20] "offset of where the ragdoll will be created"
float offset_y
0 [0, 20] "offset of where the ragdoll will be created"
- Privates -----------------------------
std::vector<b2Body*>* bodies
- ""

PhysicsShapeComponent
- Members -----------------------------
bool recreate
0 [0, 1] ""
bool is_circle
0 [0, 1] ""
bool is_box
1 [0, 1] ""
bool is_capsule
0 [0, 1] ""
bool is_based_on_sprite
0 [0, 1] "if set, will use sprite component to figure out a
box that fits this"
float friction
0.75 [0, 1] ""
float restitution
0.1 [0, 1] ""
float density
0.75 [0, 5] ""
float local_position_x
0 [-5, 5] ""
float local_position_y
0 [-5, 5] ""
float radius_x
1 [0, 10] ""
float radius_y
1 [0, 10] ""
float capsule_x_percent
0.25 [0, 1] ""
float capsule_y_percent
0.3 [0, 1] ""
- Custom data types -------------------
int material
0 [0, 1] "the material to use for collision audio"

PhysicsThrowableComponent
- Members -----------------------------
float throw_force_coeff
1 [0, 2] ""
float max_throw_speed
180 [0, 256] ""
float min_torque
0.5 [0, 20] ""
float max_torque
8 [0, 20] ""
 float tip_check_offset_min
3 [0, 20] ""
float tip_check_offset_max
5 [0, 20] ""
float tip_check_random_rotation_deg
9 [0, 180] ""
float attach_min_speed
70 [0, 180] ""
bool attach_to_surfaces_knife_style
0 [0, 1] ""
int hp
100 [0, 200] "WIP WIP"
- Privates -----------------------------
bool mHasJoint
0 [0, 1] ""

PixelSceneComponent
- Members -----------------------------
std::string pixel_scene
- "loads this pixel scene file"
std::string pixel_scene_visual
- "this is the colors that get used for the pixels,
if empty will use material colors"
std::string pixel_scene_background
- "this is the background file that gets loaded, if
empty won't do anything"
int background_z_index
50 [0, 1] "the standard z_index of pixel scene backgrounds"
float offset_x
0 [-30, 30] "how much off from the entity x,y will this be. Top
left corner is where it loads the pixel scene"
float offset_y
0 [-30, 30] ""
bool skip_biome_checks
0 [0, 1] "biome check is on by default - it will check that
pixel scene is loaded so that every corner is in the same biome"
bool skip_edge_textures
0 [0, 1] "if on - won't do the edge textures for the pixel
scene"

PixelSpriteComponent
- Members -----------------------------
std::string image_file
- "loads pixelsprite based on this file"
int anchor_x
0 [0, 3.5] "the anchor and center_offset"
int anchor_y
0 [0, 3.5] "the anchor and center_offset"
std::string material
wood_loose [0, 1] "what's the material that things are made out of,
TODO - change this into MetaCustom"
bool diggable
1 [0, 1] "if 1, this can be broken with digger"
bool clean_overlapping_pixels
1 [0, 1] "cleans up the pixels that are ovelapping in the
world"
bool kill_when_sprite_dies
1 [0, 1] "kills the entity, if the pixel sprite is dead
(empty)"
 bool create_box2d_bodies
0 [0, 1] "if true, will create new pixel sprites with box2d
bodies, instead of gridworld cells"
- Custom data types -------------------
PixelSprite* mPixelSprite
- ""

PlatformShooterPlayerComponent
- Members -----------------------------
float aiming_reticle_distance_from_character
40 [0, 1000] ""
float camera_max_distance_from_character
25 [0, 1000] ""
float alcohol_drunken_speed
0.005 [0, 1000] ""
float blood_fungi_drunken_speed
0.006 [0, 1000] ""
float blood_worm_drunken_speed
0.006 [0, 1000] ""
int eating_cells_per_frame
1 [0, 100] ""
int eating_probability
5 [0, 100] ""
int eating_delay_frames
30 [0, 100] ""
float stoned_speed
0.1 [0, 1000] ""
bool center_camera_on_this_entity
1 [0, 1] ""
bool move_camera_with_aim
1 [0, 1] "if true, moves camera with the aim."
- Custom data types -------------------
ivec2 eating_area_min
- ""
ivec2 eating_area_max
- ""
- Privates -----------------------------
vec2 mSmoothedCameraPosition
- ""
vec2 mSmoothedAimingVector
- ""
float mCameraRecoil
0 [0, 1] ""
float mCameraRecoilTarget
0 [0, 1] ""
bool mCrouching
0 [0, 1] ""
float mCameraDistanceLerped
0 [0, 1] ""
bool mRequireTriggerPull
0 [0, 1] ""
int mWarpDelay
0 [0, 1] ""
int mItemTemporarilyHidden
0 [0, 1] ""
vec2 mDesiredCameraPos
- ""
bool mHasGamepadControlsPrev
0 [0, 1] ""
 bool mForceFireOnNextUpdate
0 [0, 1] ""
float mFastMovementParticlesAlphaSmoothed
0 [0, 1] ""
uint64 mTeleBoltFramesDuringLastSecond
0 [0, 1] ""
float mCamCorrectionTeleSmoothed
0 [0, 1] ""
vec2 mCamCorrectionGainSmoothed
- ""
Vec2ArrayInline mCameraErrorPrev
- ""
vec2 mCamErrorAveraged
- ""
bool mCamMovingFastPrev
0 [0, 1] ""
int mCamFrameStartedMovingFast
0 [0, 1] ""
int mCamFrameLastMovingFastExplosion
0 [0, 1] ""
bool mCessationDo
0 [0, 1] ""
int mCessationLifetime
0 [0, 1] ""

PlayerCollisionComponent
- Members -----------------------------
int getting_crushed_threshold
5 [0, 100] ""
int moving_up_before_getting_crushed_threshold
3 [0, 100] ""
- Privates -----------------------------
int getting_crushed_counter
0 [0, 1] "1.12.2018 - Is this still used?"
int stuck_in_ground_counter
0 [0, 1] "used this mostly for player to figure out if it's
stuck in ground"
int DEBUG_stuck_in_static_ground
0 [0, 1] "used to report error + also to free the player in
case something horrible has gone wrong"
bool mCollidedHorizontally
0 [0, 1] ""
b2Body* mPhysicsCollisionHax
- "hax"

PlayerStatsComponent
- Members -----------------------------
int lives
1 [0, 1] ""
float max_hp
4 [0, 1] ""
float speed
1 [0, 1] ""

PositionSeedComponent
- Members -----------------------------
float pos_x
0 [0, 3.5] ""
float pos_y
0 [0, 3.5] ""

PotionComponent
- Members -----------------------------
float spray_velocity_coeff
1 [0, 2] ""
float spray_velocity_normalized_min
0.5 [0, 1] ""
bool body_colored
0 [0, 1] ""
bool throw_bunch
0 [0, 1] ""
int throw_how_many
5 [0, 1] ""
bool dont_spray_static_materials
0 [0, 1] "NOTE( Petri ): 15.8.2023 - if this is set to true,
will only spray dynamic materials, that dont cause bugs (i.e. will not spray hard
rock, box2d materials)"
bool dont_spray_just_leak_gas_materials
0 [0, 1] "NOTE( Petri ): 15.8.2023 - if this is set to true,
will only leak gas materials instead of 'spraying' them."
bool never_color
0 [0, 1] "Petri: body_colored didn't seem to work, so I
added never_color. It can be set to true if you never want the potion to be
colored"
- Custom data types -------------------
int custom_color_material
0 [0, 1] "if set, will always use the color from this
material"

PressurePlateComponent
- Members -----------------------------
int check_every_x_frames
30 [0, 1] "how often do we check the world"
int state
0 [0, 1] "0 is up, 1 is down"
float material_percent
0.75 [0, 1] "how much material should there be in the aabbs
that we go down "
- Custom data types -------------------
vec2 aabb_min
- ""
vec2 aabb_max
- ""
- Privates -----------------------------
int mNextFrame
0 [0, 1] ""

ProjectileComponent
- Members -----------------------------
int lifetime
-1 [0, 1] "lifetime, -1 means it's endless, otherwise it's
the frame count"
int lifetime_randomness
0 [0, 1] "final lifetime will be lifetime + random(-
lifetime_randomness,lifetime_randomness)"
bool on_lifetime_out_explode
0 [0, 1] "when lifetime runs out, should we explode?"
bool collide_with_world
1 [0, 1] "true by default. Some projectiles you don't want
to collide with the world, e.g. blackholes"
float speed_min
60 [0, 60000] ""
float speed_max
60 [0, 60000] ""
float friction
0 [0, 60000] ""
float direction_random_rad
0 [0, 3.14151] "when fired, randomizes the velocity -this, this"
float direction_nonrandom_rad
0 [-3.14, 3.14] "when fired, multiplies this with projectile_i and
adds it to direction"
float lob_min
0.5 [0, 60000] ""
float lob_max
0.8 [0, 60000] ""
float camera_shake_when_shot
0 [0, 60000] ""
float shoot_light_flash_radius
0 [0, 60000] ""
unsigned int shoot_light_flash_r
255 [0, 255] ""
unsigned int shoot_light_flash_g
180 [0, 255] ""
unsigned int shoot_light_flash_b
150 [0, 255] ""
bool create_shell_casing
0 [0, 1] "should we create shell casings?"
std::string shell_casing_material
brass [0, 1] "material of the shell casing"
std::string muzzle_flash_file
- "this entity is created along with the projectile,
oriented along the projectile's path"
int bounces_left
0 [0, 1e+008] ""
float bounce_energy
0.5 [0, 1] "when bouncing, velocity is multiplied by this"
bool bounce_always
0 [0, 1] "if true, will do a fake bounce if can't do the
proper bounce, but will always try to bounce"
bool bounce_at_any_angle
0 [0, 1] "if true, will bounce at any reflection angle"
bool attach_to_parent_trigger
0 [0, 1] "if true, will attach to the projectile entity that
created this projectile via a trigger"
std::string bounce_fx_file
- "this entity is created at the bounce position. it
gets the bounce angle as rotation."
float angular_velocity
0 [-3.1415, 3.1415] "this is only applied if velocity_sets_rotation ==
false"
bool velocity_sets_rotation
1 [0, 1] "whether we set the rotation based on velocity, as
in spear or if we update the rotation with angular_velocity"
bool velocity_sets_scale
0 [0, 1] "if true, the sprite width is made equal to the
distance traveled since last frame"
float velocity_sets_scale_coeff
1 [0, 1] "Larger value means velocity affects the scale
more"
bool velocity_sets_y_flip
0 [0, 1] "if true, the sprite is flipped based on which side
the projectile is currently traveling"
float velocity_updates_animation
0 [0, 1] "updates the animation based on far the sprite
moved"
float ground_penetration_coeff
0 [0, 5] "if > 0, this, along with VelocityComponent.mass
affects how far we penetrate in materials"
int ground_penetration_max_durability_to_destroy
0 [0, 1] "if 0, will not penetrate into materials with
durability greater than this"
std::string go_through_this_material
- "if set, we never collide with this material"
bool do_moveto_update
1 [0, 1] "this should probably be true, to get normal
projectile behaviour, but you might want to disable this for some physics-based
projectiles, like bombs"
int on_death_duplicate_remaining
0 [0, 1] "if greater than 0, the projectile creates two
clones of itself on death. 'on_death_duplicate_remaining' on the clones is reduced
by one"
bool on_death_gfx_leave_sprite
1 [0, 1] "if true, finds all the sprites and leaves as sand
cells into the grid"
bool on_death_explode
0 [0, 1] "if true, does explosion with config_explosion"
bool on_death_emit_particle
0 [0, 1] "if true, emits on_death_emit_particle_type on
death"
int on_death_emit_particle_count
1 [0, 1] "how many particles should we emit"
bool die_on_liquid_collision
0 [0, 1] "if true, dies on collision with liquids"
bool die_on_low_velocity
0 [0, 1] "if true, dies when speed goes below
die_on_low_velocity_limit"
float die_on_low_velocity_limit
50 [0, 1] "please see die_on_low_velocity"
std::string on_death_emit_particle_type
- ""
bool on_death_particle_check_concrete
0 [0, 1] "if you want it to stick as concrete, you should
enable this"
bool ground_collision_fx
1 [0, 1] "if 1, spurt some particles when colliding with
mortals"
bool explosion_dont_damage_shooter
0 [0, 1] "if true, explosion doesn't damage the entity who
shot this"
float on_death_item_pickable_radius
0 [0, 1] "if > 0, makes items closer than this radius
pickable on death"
bool penetrate_world
0 [0, 1] "if true, the projectile doesn't collide with
ground, liquids, physical objects etc"
float penetrate_world_velocity_coeff
0.6 [0, 1] "if 'penetrate_world' is true, the projectile moves
with a velocity multiplied by this value when inside world"
bool penetrate_entities
0 [0, 1] "if true, the projectile doesn't stop when it
collides with entities. damages each entity only once"
bool on_collision_die
1 [0, 1] "if true, this is killed as soon as it hits the
ground"
bool on_collision_remove_projectile
0 [0, 1] "if true, ProjectileComponent is removed from the
entitiy"
bool on_collision_spawn_entity
1 [0, 1] "if true, spawns the spawn_entity"
std::string spawn_entity
- "this is spawned if hit something an
on_collision_spawn_entity = 1"
bool spawn_entity_is_projectile
0 [0, 1] "if true, will use ShootProjectile instead of
LoadEntity()"
float physics_impulse_coeff
300 [0, 1] "projectile applies an impulse to physics bodies it
hits. Impulse = physics_impulse_coeff * velocity"
int damage_every_x_frames
-1 [0, 1] "if set != -1, will only do damage every x frames,
used for fields and such, which would otherwise do damage every frame"
bool damage_scaled_by_speed
0 [0, 1] "if 1, damage is multiplied by (projectile speed /
original projectile speed) ratio"
float damage_scale_max_speed
0 [0, 1] "if > 0 and damage_scaled_by_speed = 1, will use
this instead of mInitialSpeed when calculating the damage"
bool collide_with_entities
1 [0, 1] "if 1, looks for entities with tag,
collide_with_tag and collides with them, giving them damage"
std::string collide_with_tag
hittable [0, 1] "default: mortal, if you needed can be changed to
something more specific"
std::string dont_collide_with_tag
- "if set will ignore entities with this tag"
int collide_with_shooter_frames
-1 [0, 1] "remember friendly_fire 1, if -1 won't collide with
shooter at all, otherwise uses the value as frame count and while it's running
won't damage the shooter "
bool friendly_fire
0 [0, 1] "if true, will damage same herd id"
float damage
1 [0, 1] "how much Projectile damage does this do when it
hits something"
float knockback_force
0 [0, 1] "How far do entities get thrown if a knockback
occurs. final_knockback = ProjectileComponent.knockback_force *
VelocityComponent.mVelocity * VelocityComponent.mass / who_we_hit.mass"
float ragdoll_force_multiplier
0.025 [0, 1] "velocity * ragdoll_force_multiplier is applied to
any ragdolls that are created by entities killed by this"
float hit_particle_force_multiplier
0.1 [0, 1] "hit particle velocity = projectile_velocity *
hit_particle_force_multiplier * some randomness"
float blood_count_multiplier
1 [0, 1] "how much blood does this projectile cause"
std::string damage_game_effect_entities
- "a list of game_effects entities separated with
','. e.g.
'data/entities/misc/effect_electrocution.xml,data/entities/misc/effect_on_fire.xml'
"
bool never_hit_player
0 [0, 1] "If 1, does not hit player no matter what herds
this and player belong to"
bool collect_materials_to_shooter
0 [0, 1] "if 1, looks up the 'who_shot' entity and its
MaterialInventoryComponent on destruction and updates it based on the cells
destroyed on our explosion."
bool play_damage_sounds
1 [0, 1] ""
int mLastFrameDamaged
-1024 [0, 1] ""
- Objects -----------------------------
ConfigGunActionInfo config
- ""
ConfigExplosion config_explosion
- "if we have explosion, it's the setup for it"
ConfigDamagesByType damage_by_type
- "the amounts of different types of damage this
does"
ConfigDamageCritical damage_critical
- "config for critical hit"
- Custom data types -------------------
PROJECTILE_TYPE::Enum projectile_type
- ""
vec2 shell_casing_offset
- "where the shell casing will be created relative to
projectile, y is flipped if projectile direction is to the left."
RAGDOLL_FX::Enum ragdoll_fx_on_collision
- "if not NORMAL, do a special ragdoll"
- Privates -----------------------------
EntityID mWhoShot
0 [0, 1] "entity (creature) that shot this"
EntityTypeID mWhoShotEntityTypeID
0 [0, 1] "used for stats"
int mShooterHerdId
0 [0, 1] "the herdid of mWhoShot, unless friendly fire"
int mStartingLifetime
0 [0, 1] ""
EntityID mEntityThatShot
0 [0, 1] "for triggers, if shot from a trigger this should
point to the projectile entity that shot this. Otherwise this should be the same as
mWhoShot. NOTE! Not really tested properly so might break."
ProjectileTriggers mTriggers
- ""
VEC_ENTITY mDamagedEntities
- ""
float mInitialSpeed
-1 [0, 1] ""

RotateTowardsComponent
- Members -----------------------------
std::string entity_with_tag
player_unit [0, 1] "will rotate this entity towards the closest entity
with tag"

SetLightAlphaFromVelocityComponent
- Members -----------------------------
float max_velocity
50 [1, 150] ""
- Privates -----------------------------
vec2 mPrevPosition
- ""

SetStartVelocityComponent
- Custom data types -------------------
vec2 velocity
- "This is added together with random velocity"
ValueRange randomize_angle
- "Random angle min max range in radians, clockwise.
0.0 points directly rightward."
ValueRange randomize_speed
- "Random speed min max range"

ShotEffectComponent
- Members -----------------------------
std::string extra_modifier
- "name of modifier function executed per projectile
from 'gun_extra_modifiers.lua'"
- Custom data types -------------------
GAME_EFFECT::Enum condition_effect
- "Shooting entity needs to have this 'GAME_EFFECT'
for effects to apply. If both 'condition_effect' and 'condition_status' are set,
they are combined with AND logic"
StatusEffectType condition_status
0 [0, 1] "Shooting entity needs to have this 'STATUS_EFFECT'
for effects to apply"

SimplePhysicsComponent
- Members -----------------------------
bool can_go_up
1 [0, 1] "if set, will not try to move this upwards"
- Privates -----------------------------
vec2 mOldPosition
- "used for box2d simple physics"

SineWaveComponent
- Members -----------------------------
float sinewave_freq
1 [0, 1] "sinewave_m * sinf( sinewave_freq * lifetime++)"
float sinewave_m
0.6 [0, 1] "sinewave_m * sinf( sinewave_freq * lifetime++)"
int lifetime
-1 [0, 1] "-1 seems to fix some problems with this...
sinewave_m * sinf( sinewave_freq * lifetime++)"

SpriteAnimatorComponent
- Members -----------------------------
std::string target_sprite_comp_name
character [0, 1] ""
bool rotate_to_surface_normal
0 [0, 1] ""
- Privates -----------------------------
 STACK_ANIMATIONSTATE mStates
- ""
ComponentTags mCachedTargetSpriteTag
- ""
std::string mSendOnFinishedMessageName
- ""

SpriteComponent
- Members -----------------------------
std::string image_file
data/temp/temp_gun.png [0, 1] ""
bool ui_is_parent
0 [0, 1] "Adds this to the GG.GetUISprite() as a child,
instead of the mSpriteContainer"
bool is_text_sprite
0 [0, 1] "if you want to load a text sprite, set this to
true and image_file to a font file"
float offset_x
0 [-24, 24] ""
float offset_y
0 [-24, 24] ""
float alpha
1 [0, 1] ""
bool visible
1 [0, 1] ""
bool emissive
0 [0, 1] ""
bool additive
0 [0, 1] ""
bool fog_of_war_hole
0 [0, 1] "if 1, the alpha channel of this texture punctures
a hole in the fog of war"
bool smooth_filtering
0 [0, 1] ""
std::string rect_animation
- ""
std::string next_rect_animation
- ""
std::string text
- ""
float z_index
1 [-256, 256] "0 = world grid, -1 = enemies, -1.5 = items in
world, player = 0.6"
bool update_transform
1 [0, 1] ""
bool update_transform_rotation
1 [0, 1] ""
bool kill_entity_after_finished
0 [0, 1] ""
bool has_special_scale
0 [0, 1] "if this is set, sets special_scale_x and _y to
scale"
float special_scale_x
1 [0, 1] "this overrides the scale of the entity, if
has_special_scale"
float special_scale_y
1 [0, 1] "this overrides the scale of the entity, if
has_special_scale"
bool never_ragdollify_on_death
0 [0, 1] ""
- Custom data types -------------------
vec2 transform_offset
- ""
vec2 offset_animator_offset
- "used by SpriteOffsetAnimator"
- Privates -----------------------------
as::Sprite* mSprite
- ""
SpriteRenderList* mRenderList
- ""
int32 mRenderListHandle
-1 [0, 1] ""

SpriteOffsetAnimatorComponent
- Members -----------------------------
float x_amount
0 [0, 5] ""
float x_speed
0 [0, 5] ""
float y_amount
2 [0, 5] ""
float y_speed
2 [0, 5] ""
int sprite_id
0 [0, 8] ""
float x_phase
16 [0, 32] ""
float x_phase_offset
0 [0, 1] ""

SpriteParticleEmitterComponent
- Members -----------------------------
std::string sprite_file
- "filepath to the sprite(s), supports the $[0-3]
syntax"
bool sprite_centered
0 [0, 1] "sets the offset to the center of the image"
bool sprite_random_rotation
0 [0, 1] "rotates the sprite randomly in 90 degree angles"
bool render_back
0 [0, 1] "if true, will set this particle to be behind
entities (won't emit light)"
float delay
0 [0, 1] "delay in seconds..."
float lifetime
0 [0, 1] "lifetime in seconds..."
bool additive
0 [0, 1] "if 1, the sprites will be rendered using additive
blending"
bool emissive
0 [0, 1] "if 1, the sprites will be rendered onto the
emissive render target"
float velocity_slowdown
0 [0, 1] "what percent of the velocity is slowed by *dt"
float rotation
0 [0, 1] "original rotation in rads"
float angular_velocity
0 [0, 1] "how much rotation there is in a second"
 bool use_velocity_as_rotation
0 [0, 1] "do we rotate the sprite based on the velocity"
bool use_rotation_from_velocity_component
0 [0, 1] "if set, will set the initial rotation based on the
velocity component's velocity"
bool use_rotation_from_entity
0 [0, 1] "if set, will 'inherit' rotation from the entity"
float entity_velocity_multiplier
0 [0, 1] "0 = doesn't use the velocity from spawning entity
at all, 1 = uses all"
float z_index
0 [0, 1] "Depth of created particles"
bool randomize_position_inside_hitbox
0 [0, 1] "if set, will randomize position inside the hitbox
aabb"
bool velocity_always_away_from_center
0 [0, 1] "if set, will make the velocity's rotation always
away from center of randomized aabb"
bool camera_bound
1 [0, 1] "if true, will be culled if not near the camera"
float camera_distance
75 [0, 1] "if the distance from camera (edges) is higher than
this, this will be culled"
bool is_emitting
1 [0, 1] "disable this from emitting..."
int count_min
0 [0, 1] "how many particles do we spawn at one time"
int count_max
1 [0, 1] "how many particles do we spawn at one time"
int emission_interval_min_frames
5 [0, 200] "how often do we emit particles"
int emission_interval_max_frames
10 [0, 200] "how often do we emit particles"
std::string entity_file
- "if set, this entity is loaded to the emission
position by the emitter when it emits"
- Custom data types -------------------
types::fcolor color
- "original color"
types::fcolor color_change
- "how much the color changes in a second"
vec2 velocity
- "original velocity"
vec2 gravity
- "gravity"
vec2 scale
- "original scale"
vec2 scale_velocity
- "scale velocity per second"
ValueRange randomize_lifetime
- "this is added to the lifetime"
types::aabb randomize_position
- "random offset for pos"
types::aabb randomize_velocity
- "add this randomized velocity inside this o the
velocity"
types::aabb randomize_scale
- "add this randomized vector2 to scale"
ValueRange randomize_rotation
- "this is added to the rotation "
ValueRange randomize_angular_velocity
- "this is added to angular_velocity"
ValueRange randomize_alpha
- "this is added to the alpha"
ValueRange randomize_animation_speed_coeff
- "if set, animation speed is multiplied by a random
value inside this range"
vec2 expand_randomize_position
- "will add dt*this to randomize_position_aabb every
frame"
- Privates -----------------------------
int mNextEmitFrame
0 [0, 1] ""

SpriteStainsComponent
- Members -----------------------------
int sprite_id
0 [0, 10] "which sprite (in the order in which they appear in
the entity) are we going to stain?"
bool fade_stains_towards_srite_top
1 [0, 1] "if 1, shades get less opaque near the top of the
sprite"
- Custom data types -------------------
LensValue<int> stain_shaken_drop_chance_multiplier
- "how quickly stains are dropped relative to normal
drop speed"
SpriteStains* mData
- ""
- Privates -----------------------------
VirtualTextureHandle mTextureHandle
- ""
SpriteStainsState mState
- ""

StatusEffectDataComponent
- Custom data types -------------------
VECTOR_FLOAT stain_effects
- ""
VECTOR_INT32 stain_effect_cooldowns
- ""
VECTOR_FLOAT effects_previous
- ""
VECTOR_FLOAT ingestion_effects
- ""
VEC_OF_MATERIALS ingestion_effect_causes
- ""
VECTOR_INT32 ingestion_effect_causes_many
- ""
- Privates -----------------------------
int mLastAttackingPlayerFrame
-99999 [0, 1] ""
VECTOR_FLOAT mStainEffectsSmoothedForUI
- ""
bool mHasChildIconsCached
0 [0, 1] ""

StreamingKeepAliveComponent
- Members -----------------------------
 float TEMP_TEMPY
0 [0, 3.5] ""
float TEMP_TEMP_TEMP
0 [0, 3.5] ""

TelekinesisComponent
- Members -----------------------------
uint32 min_size
7 [0, 1] "Minimum size of physics body that can be grabbed,
in cells/pixels"
uint32 max_size
1500 [0, 1] "Maximum size of physics body that can be grabbed,
in cells/pixels"
float radius
250 [0, 300] "Maximum object search distance"
float throw_speed
25 [0, 300] "Affects object speed when it is thrown"
float target_distance
6 [0, 30] "Affects how far objects float from owner when
held. Object size will also affect the floating distance."
bool kick_to_use
1 [0, 1] "If 1, telekinesis interaction will occur when kick
input is detected in root entity's ControlsComponent"
int32 mState
0 [0, 1] ""
uint64 mBodyID
0 [0, 1] ""
float mStartBodyMaxExtent
0 [0, 1] ""
float mStartAimAngle
0 [0, 1] ""
float mStartBodyAngle
0 [0, 1] ""
float mStartBodyDistance
0 [0, 1] ""
float mStartTime
0 [0, 1] ""
float mMinBodyDistance
3.40282e+038 [0, 1] ""
bool mInteract
0 [0, 1] "If set to true, telekinesis interaction will
occur. Will automatically turn to false at the end of component update."

TeleportComponent
- Members -----------------------------
bool target_x_is_absolute_position
0 [0, 1] "If set, target position x is in world coordinates,
otherwise it's an offset"
bool target_y_is_absolute_position
0 [0, 1] "If set, target position y is in world coordinates,
otherwise it's an offset"
std::string source_particle_fx_file
data/entities/particles/teleportation_source.xml [0, 1] "This entity is loaded at
the source position when teleportation occurs"
std::string target_particle_fx_file
data/entities/particles/teleportation_target.xml [0, 1] "This entity is loaded at
the target position when teleportation occurs"
bool load_collapse_entity
1 [0, 1] "if we don't want things to collapse after the
teleport"
- Custom data types -------------------
vec2 target
- "Where should we teleport"
- Privates -----------------------------
int safety_counter
0 [0, 1] "used to keep track that we're not stuck in waiting
for a pixel scene to load, that is not going to be loaded"
TeleportComponentState::Enumstate
- ""
ENTITY_VEC teleported_entities
- ""
types::aabb source_location_camera_aabb
- ""

TeleportProjectileComponent
- Members -----------------------------
float min_distance_from_wall
16 [0, 16] ""
int actionable_lifetime
3 [0, 20] ""
bool reset_shooter_y_vel
1 [0, 1] "If 1, will set shooter y velocity to 0 on
teleport"
- Privates -----------------------------
EntityID mWhoShot
0 [0, 1] ""

TextLogComponent
- Members -----------------------------
std::string key
- ""
std::string image_filename
- ""
- Privates -----------------------------
std::string mCachedName
- ""

TorchComponent
- Members -----------------------------
int probability_of_ignition_attempt
15 [0, 100] "how likely are we to ignite colliding cells"
float suffocation_check_offset_y
-2 [-10, 10] "check offset in world coordinates from our
position"
int frames_suffocated_to_extinguish
5 [0, 30] "how many frames the torch needs to be suffocated
before it stops emitting fire"
bool extinguishable
1 [0, 1] "if 1, the torch needs to be re-ignited in case it
is turned off"
float fire_audio_weight
0 [0, 2] "how loud is the sound of our fire? 0 = no sound"
- Privates -----------------------------
float mFlickerOffset
0 [0, 1] ""
int mFramesSuffocated
0 [0, 1] ""
bool mIsOn
1 [0, 1] ""
bool mFireIsBurningPrev
0 [0, 1] ""

UIIconComponent
- Members -----------------------------
std::string icon_sprite_file
- ""
std::string name
- ""
std::string description
- ""
bool display_above_head
0 [0, 1] ""
bool display_in_hud
1 [0, 1] ""
bool is_perk
1 [0, 1] ""

UIInfoComponent
- Members -----------------------------
std::string name
- ""

VariableStorageComponent
- Members -----------------------------
std::string name
- ""
std::string value_string
- ""
int value_int
0 [0, 1] ""
bool value_bool
0 [0, 1] ""
float value_float
0 [0, 1] ""

VelocityComponent
- Members -----------------------------
float gravity_x
0 [0, 1] ""
float gravity_y
400 [0, 1] ""
float mass
0.05 [0, 10] ""
float air_friction
0.55 [0, 1] ""
float terminal_velocity
1000 [0, 1] ""
bool apply_terminal_velocity
1 [0, 1] ""
bool updates_velocity
1 [0, 1] ""
bool displace_liquid
1 [0, 1] ""
bool affect_physics_bodies
0 [0, 1] "if true, will move the physics body by the
difference of mVelocity to the previous frame"
bool limit_to_max_velocity
1 [0, 1] "if true will limit the velocity to 61440. You can
turn this off, but it's not recommended, since there are some nasty bugs that can
happen with extremely high velocities."
int liquid_death_threshold
0 [0, 1] "if > 0, entity will die if liquid hit count is
greater than this."
float liquid_drag
1 [0, 1] "1 = slows down in liquid, 0 = doesn't slow down at
all"
- Custom data types -------------------
vec2 mVelocity
- ""
- Privates -----------------------------
vec2 mPrevVelocity
- "used to update physics bodies"
int mLatestLiquidHitCount
0 [0, 1] ""
int mAverageLiquidHitCount
0 [0, 1] ""
ivec2 mPrevPosition
- ""

VerletPhysicsComponent
- Members -----------------------------
int num_points
2 [0, 1] ""
int num_links
2 [0, 1] ""
int width
1 [0, 1] ""
float resting_distance
2 [0, 16] ""
float mass_min
0.8 [0.03, 2] ""
float mass_max
1 [0.03, 2] ""
float stiffness
1 [0, 1] ""
float velocity_dampening
0.99 [0.2, 1] ""
float liquid_damping
0.7 [0, 1] "how much we dampen when in liquid"
float gets_entity_velocity_coeff
0 [0, 10] ""
bool collide_with_cells
1 [0, 1] ""
bool simulate_gravity
1 [0, 1] ""
bool simulate_wind
1 [0, 1] ""
float wind_change_speed
1 [0, 1] ""
bool constrain_stretching
0 [0, 1] ""
bool pixelate_sprite_transforms
1 [0, 1] ""
bool scale_sprite_x
1 [0, 1] ""
bool follow_entity_transform
1 [0, 1] ""
float animation_amount
2 [0, 1] ""
float animation_speed
5 [0, 1] ""
float animation_energy
0.6 [0, 1] ""
float cloth_sprite_z_index
1 [0, 1] ""
int stain_cells_probability
0 [0, 1] "0 = never, 1 = most likely, 10 = less likely - and
so on"
bool m_is_culled_previous
0 [0, 1] "Developer note: this needs to be serialized in
case we serialize SpriteComponent.is_visible"
- Custom data types -------------------
VERLET_TYPE::Enum type
- ""
vec2 animation_target_offset
- ""
uint32 cloth_color_edge
4288376730 [0, 1] ""
uint32 cloth_color
4286534774 [0, 1] ""
vec2 m_position_previous
- ""
UintArrayInline colors
- ""
UintArrayInline materials
- ""
- Privates -----------------------------
FloatArrayInline masses
- ""
Vec2ArrayInline positions
- ""
Vec2ArrayInline positions_prev
- ""
Vec2ArrayInline velocities
- ""
FloatArrayInline dampenings
- ""
FloatArrayInline freedoms
- ""
VerletLinkArrayInline links
- ""
VerletSprite* sprite
- ""

VerletWeaponComponent
- Members -----------------------------
float damage_radius
5 [0, 10] ""
float physics_force_radius
3 [0, 10] ""
float damage_min_step
0.01 [0, 3.5] ""
float damage_max
1 [0, 3.5] ""
float damage_coeff
1 [0, 3.5] ""
float impulse_coeff
1 [0, 3.5] ""
int fade_duration_frames
10 [0, 100] ""
float physics_impulse_coeff
1 [0, 3.5] ""
- Privates -----------------------------
int mPlayerCooldownEnd
-1 [0, 1] ""

VerletWorldJointComponent
- Members -----------------------------
int verlet_point_index
0 [0, 32] "Index of the verlet point we attach"
- Custom data types -------------------
vec2 world_position
- "Where we attach the verlet point"
- Privates -----------------------------
bool mUpdated
0 [0, 1] ""
grid::ICell* mCell
- ""

WalletComponent
- Members -----------------------------
int64 money
0 [0, 10000] ""
int64 money_spent
0 [0, 1] "tracks how much money the player has spent"
int64 mMoneyPrevFrame
0 [0, 1] "HAX to give player towards infinite moneys"
bool mHasReachedInf
0 [0, 1] "once it hits this value... keep it there"

WalletValuableComponent
- Members -----------------------------
int money_value
10 [0, 100] ""

WorldStateComponent
- Members -----------------------------
bool is_initialized
0 [0, 1] ""
float time
0 [0, 1] ""
float time_total
0 [0, 1000] ""
float time_dt
1 [0, 1000] "to make the time go really fast or slow?"
int day_count
0 [0, 3.5] ""
float rain
0 [0, 1] "should be called clouds, controls amount of cloud
cover in the sky"
float rain_target
0 [0, 1] "should be called clouds_target, controls amount of
cloud cover in the sky"
float fog
0 [0, 1] ""
float fog_target
0 [0, 1] ""
bool intro_weather
0 [0, 1] "if set, will set the weather to be nice all the
time"
float wind
0 [0, 1] ""
float wind_speed
2 [-50, 50] ""
float wind_speed_sin_t
10 [0, 1] ""
float wind_speed_sin
3 [-50, 50] ""
float clouds_01_target
0 [-27, 100] ""
float clouds_02_target
0 [-100, 185] ""
float gradient_sky_alpha_target
0 [0, 1] ""
float sky_sunset_alpha_target
1 [0, 1] ""
int lightning_count
0 [0, 100] "this gets decreased to 0, this is the frame count
of how many times do we do our awesome lightning effect"
uint32 next_portal_id
1 [0, 1] ""
std::string session_stat_file
- "if empty, we'll create one. This tracks the play
time, death, kills... etch"
int player_polymorph_count
0 [0, 1] "how many times player has been polymorphed"
int player_polymorph_random_count
0 [0, 1] "how many times player has been random polymorphed"
int player_did_infinite_spell_count
0 [0, 1] "how many times player has done a secret trick"
int player_did_damage_over_1milj
0 [0, 1] "how many times player has player done damage of
over 1000000"
int player_living_with_minus_hp
0 [0, 1] "how many times player has been detected with minus
health"
float global_genome_relations_modifier
0 [0, 1] "Genome_GetHerdRelation adds this value to the
results. 100 = good relations, 0 is bad "
bool mods_have_been_active_during_this_run
0 [0, 1] ""
bool twitch_has_been_active_during_this_run
0 [0, 1] ""
uint32 next_cut_through_world_id
0 [0, 1] ""
bool perk_infinite_spells
0 [0, 1] "if true, almost all spells will have unlimited
uses. (black holes, matter eater, heals excluded"
bool perk_trick_kills_blood_money
0 [0, 1] "if true, trick kills will produce blood money
(heals player)"
int perk_hp_drop_chance
0 [0, 1] "if > 0, then there's chance that killing an enemy
will drop bloodmoney_50"
bool perk_gold_is_forever
0 [0, 1] "drop_money.lua - checks if this is true and
removes Lifetime_Component from gold nuggets"
bool perk_rats_player_friendly
0 [0, 1] "if 1, rats don't attack player herd and the other
way round. this is a persistent change"
bool EVERYTHING_TO_GOLD
0 [0, 1] "if true everything will be gold + used to track if
the wallet should go to infinite"
std::string material_everything_to_gold
gold [0, 1] ""
std::string material_everything_to_gold_static
gold_static [0, 1] ""
bool INFINITE_GOLD_HAPPENING
0 [0, 1] "the secret ending with infinite gold"
bool ENDING_HAPPINESS_HAPPENING
0 [0, 1] "if true, will do the animations for happiness
ending"
int ENDING_HAPPINESS_FRAMES
0 [0, 1] "to keep track of the animation"
bool ENDING_HAPPINESS
0 [0, 1] "this is set if ending happiness has happened"
float mFlashAlpha
0 [0, 1] "to keep track of the animation"
int DEBUG_LOADED_FROM_AUTOSAVE
0 [0, 1] "how many times have loaded from autosaves"
int DEBUG_LOADED_FROM_OLD_VERSION
0 [0, 1] "how many times have we loaded from an old version
of the game"
- Custom data types -------------------
vec2 player_spawn_location
- ""
MAP_STRING_STRING lua_globals
- ""
VEC_PENDINGPORTAL pending_portals
- ""
VECTOR_INT32 apparitions_per_level
- ""
VEC_NPCPARTY npc_parties
- ""
VECTOR_INT32 orbs_found_thisrun
- ""
VECTOR_STRING flags
- ""
VECTOR_STRING changed_materials
- "pairs of materials changed via
ConvertMaterialEverywhere(). stored so these can be restored when loading a save"
VEC_CUTTHROUGHWORLD cuts_through_world
- ""
LensValue<int> gore_multiplier
- ""
LensValue<int> trick_kill_gold_multiplier
- ""
LensValue<float> damage_flash_multiplier
- ""
LensValue<bool> open_fog_of_war_everywhere
- "same as the trailer mode, open fog of war
everywhere"
 LensValue<bool> consume_actions
- "same as the trailer mode, spells with limited uses
are not consumed if this is false"
- Privates -----------------------------
float rain_target_extra
0 [0, 1] ""
float fog_target_extra
0 [0, 1] ""
bool perk_rats_player_friendly_prev
0 [0, 1] ""

WormAIComponent
- Members -----------------------------
float speed
1 [0, 10000] ""
float speed_hunt
3 [0, 10000] ""
float direction_adjust_speed
1 [0, 10000] ""
float direction_adjust_speed_hunt
1 [0, 10000] ""
float random_target_box_radius
512 [0, 10000] ""
int new_hunt_target_check_every
30 [0, 10000] ""
int new_random_target_check_every
120 [0, 10000] ""
float hunt_box_radius
512 [0, 10000] ""
int cocoon_food_required
30 [0, 1] "how much food do we need to consume before we can
cocoon"
std::string cocoon_entity
- "if empty, won't cocoon, if set it'll spawn this
after it's eaten enough"
float give_up_area_radius
50 [0, 10000] ""
int give_up_time_frames
300 [0, 10000] ""
bool debug_follow_mouse
0 [0, 1] ""
- Privates -----------------------------
vec2 mRandomTarget
- ""
int mTargetEntityId
0 [0, 1] ""
int mNextTargetCheckFrame
0 [0, 1] ""
int mNextHuntTargetCheckFrame
0 [0, 1] ""
int mGiveUpStarted
0 [0, 1] ""
int mGiveUpAreaMinX
0 [0, 1] ""
int mGiveUpAreaMinY
0 [0, 1] ""
int mGiveUpAreaMaxX
0 [0, 1] ""
int mGiveUpAreaMaxY
0 [0, 1] ""

WormAttractorComponent
- Members -----------------------------
int direction
1 [-1, 1] "1 = attracts worms, -1 detracts worms"
float radius
50 [0, 100] "radius of detracting worms"

WormComponent
- Members -----------------------------
float speed
1 [0, 10000] ""
float acceleration
3 [0, 10000] ""
float gravity
3 [0, 10000] ""
float tail_gravity
30 [0, 10000] ""
float part_distance
10 [0, 10000] ""
int ground_check_offset
0 [0, 10000] ""
float hitbox_radius
1 [0, 1e+006] ""
float bite_damage
1 [0, 10] "how much damage does this do when it hits an
entity"
float target_kill_radius
1 [0, 1e+006] ""
float target_kill_ragdoll_force
1 [0, 1e+006] ""
float jump_cam_shake
4 [0, 10000] ""
float jump_cam_shake_distance
256 [0, 10000] ""
float eat_anim_wait_mult
0.05 [0, 10000] ""
std::string ragdoll_filename
- ""
bool is_water_worm
0 [0, 1] "if true, tries to stay in liquids"
float max_speed
25 [0, 1] "max speed, used when attracted to a point"
- Custom data types -------------------
LensValue<float> ground_decceleration
- ""
- Privates -----------------------------
vec2 mTargetVec
- ""
float mGravVelocity
0 [0, 1] ""
float mSpeed
0 [0, 1] ""
vec2 mTargetPosition
- ""
float mTargetSpeed
0 [0, 1] ""
bool mOnGroundPrev
0 [0, 1] ""
int mMaterialIdPrev
0 [0, 1] ""
int mFrameNextDamage
0 [0, 1] ""
float mDirectionAdjustSpeed
1 [0, 1] ""
WormPartPositions mPrevPositions
- ""

WormPlayerComponent
- Privates -----------------------------
vec2 mPrevPosition
- ""
vec2 mDirection
- "if mDirection == 0,0 nothings works"