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"

