######################################################################
# Custom Entity Model Animations
# Reference configuration for OptiFine's feature Custom Entity Models
######################################################################
# Each model variable which is to be animated is assigned an expression. 
# The expression is evaluated every time the model is rendered and its value is assigned to the variable.
# The variables and expressions are defined in the "animation" section of the json entity model (JEM).
#  
#  "animations":
#  [
#    {
#      "variable1": "expression1",    
#      "variable2": "expression2,
#      ...
#    }
#  ]
# 
# 
# Variables
#
# Model variables are specified in the format 
#   "<model>.<variable_name>"
#
# The model can be:
#  "this" - current custom model
#  "part" - the original part model to which the custom model is attached
#  "<part>" - original model by part name  
#  "<id>" - custom model by ID
#  "<part>:<sub_id>:<sub_sub_id>:..." - (hierarchical) start with original model by part name, then find children by ID
#  "<id>:<sub_id>:<sub_sub_id>:..." - (hierarchical) start with model by ID, then find children by ID
#
# The first model found by part name or ID is used if there are duplicates.
# The model search by ID is deep, also when used in a hierarchical specification. 
#
# The hierarchical specification allows model groups (json part models) to be reused for different parts. 
# For example one hand model ("shoulder:upper_arm:elbow:forearm:palm:finger[1.5]" can be used for both left and right hand.
# The animation can use "left_hand:finger1" for the left thumb and "right_hand:finger1" for the right thumb. 
# The intermediate parents in the hierarchical specification can be skipped. 
#
# Variable names
#   tx, ty, tz    - Translation x, y, z
#   rx, ry, rz    - Rotation x, y, z
#   sx, sy, sz    - Scale x, y, z
#   visible       - Show model and submodels (boolean)
#   visible_boxes - Show model only, does not affect submodels (boolean)
#
# Entity variables
#
# Entity variables are specified in the format "var.<name>" (float) or "varb.<name>" (boolean) 
# The name can be any string, for example "var.xyz", "var.last_rx", etc.
# The variable is attached to the rendered entity and has a default value 0 or false.
# Entity variables are useful for storing animation data between frames.
# Not supported for block entities.
#
# Render variables
#   render.shadow_size                                                  - The size of the shadow underneath an entity
#   render.shadow_opacity                                               - How transparent the shadow is
#   render.shadow_offset_x, render.shadow_offset_z                      - The location of the shadow
#   render.leash_offset_x, render.leash_offset_y, render.leash_offset_z - The position of the point the leash attaches to
# 
# Expressions
#
# Expressions are general mathematical expressions with brackets, constants, variables, operators and functions.
#
# Constants
#   <number> - Floating point number
#   pi       - 3.1415926
#   true
#   false
#
# Variables
#   <model>.<var> - Model variable, see the model variable specification
#   time          - The total game time in ticks, not related to the daylight cycle (0-720720)
#   day_time      - The current day time in ticks (0-24000)
#   day_count     - The current day count
#
# Render parameters
#   limb_swing                               - Limb animation counter. Counts up in ticks when the entity moves
#   limb_speed                               - Limb movement speed. Ranges from 0 to 1 (still = 0, sprinting = 1)
#   age                                      - Age in ticks
#   head_pitch                               - Head pitch (x Rotation)
#   head_yaw                                 - Head yaw   (y rotation)
#   player_pos_x, player_pos_y, player_pos_z - The players current world position
#   player_rot_x, player_rot_y               - The entities current world rotation. North is 0
#   frame_time                               - The time in seconds since the last frame
#   dimension                                - The current dimension. Overworld: 0, Nether: -1, End: 1
#   rule_index                               - The index of the current matching random models rule. Defaults to 0
#
# Entity parameters (float)
#   health              - The entity's current health
#   hurt_time           - The time the entity is hurt for. Counts down from 10 to 0
#   death_time          - The time the entity is dead. Counts up from 0 to 20
#   anger_time          - The remaining entity angry time in ticks. Starts with 400-780 while agressive, and then counts down to 0 when the target is lost
#   anger_time_start    - The start value of anger_time 
#   max_health          - The entity's maximum health
#   move_forward        - Currently broken
#   move_strafing       - Currently broken
#   pos_x, pos_y, pos_z - The entities current world position
#   rot_x, rot_y        - The entities current world rotation. North is 0
#   swing_progress      - How far through an attack the entity is. Counts up from 0 to 1
#   id                  - A unique numeric identifier for the entity
#
# Entity parameters (boolean)
#   is_aggressive    - If the entity is aggressive towards a player or another entity
#   is_alive         - If the entity is alive
#   is_burning       - If the entity is on fire
#   is_child         - If the entity is in its baby state
#   is_glowing       - If the entity has the Glowing effect
#   is_hurt          - If the entity is taking damage
#   is_in_hand       - If the entity is being held in your hand
#   is_in_item_frame - If the entity is in an item frame
#   is_in_ground     - If a trident is impaled in the ground
#   is_in_gui        - If the entity is inside the GUI
#   is_in_lava       - If the entity is touching lava
#   is_in_water      - If the entity is touching water
#   is_invisible     - If the entity has the Invisibility effect/NBT tag
#   is_on_ground     - If the entity is touching the ground
#   is_on_head       - If the entity is worn on another entity's head
#   is_on_shoulder   - If a parrot is sitting on your shoulder
#   is_ridden        - If the entity is being ridden by another entity
#   is_riding        - If the entity is riding another entity
#   is_sitting       - If a cat/wolf/parrot is sitting
#   is_sneaking      - If a cat/ocelot is sneaking
#   is_sprinting     - If a cat/ocelot is sprinting
#   is_tamed         - If a cat/wolf/parrot is tamed
#   is_wet           - If the entity is inside water/rain
#
# Operators
#   +, -, *, /, %
#   !, &&, || 
#   >, >=, <, <=, ==, !=
#
# Functions
#   sin(x)                                      - Get the sine of x
#   cos(x)                                      - Get the cosine of c
#   asin(x)                                     - Get the arc sine of x
#   acos(x)                                     - Get the arc cosine of x
#   tan(x)                                      - Get the tangent of x
#   atan(x)                                     - Get the arc tangent of x
#   atan2(y, x)                                 - Get the angle between the positive x-axis and the point (x, y)
#   torad(deg)                                  - Convert degrees to radians
#   todeg(rad)                                  - Convert radians to degrees
#   min(x, y ,...)                              - Get the smallest number from a list of numbers
#   max(x, y, ...)                              - Get the largest number from a list of numbers
#   clamp(x, min, max)                          - Limits a number to be between min and max values
#   abs(x)                                      - Get the absolute value of a number. Will turn negative numbers positive
#   floor(x)                                    - Round x down to the nearest whole number
#   ceil(x)                                     - Round x up to the nearest whole number
#   exp(x)                                      - Get e (Euler's constant) raised to the power of x
#   frac(x)                                     - Get the fractional part of x (what's behind the decimal point)
#   log(x)                                      - Get the natural logarithm of x
#   pow(x, y)                                   - Get x raised to the power of y
#   random(seed)                                - Random number from 0 to 1. Providing a seed will always return the same result. The seed is optional
#   round(x)                                    - Round x to nearest whole number
#   signum(x)                                   - Get the sign of x (positive or negative)
#   sqrt(x)                                     - Get the square root of x
#   fmod(x, y)                                  - Similar to the % operator, but the returned value always has the same sign as the divisor
#   lerp(k, x, y)                               - Linear interpolation between X and Y
#   if(cond, val, [cond2, val2, ...], val_else) - Select a value based one or more conditions
#   print(id, n, x)                             - Prints the value "x" every N-th frame
#   printb(id, n, x)                            - Prints the boolean value "x" every N-th frame
#
# Boolean functions                 
#   between(x, min, max)   - Check if a value is between min and max values
#   equals(x, y, epsilon)  - Compare two float values with error margin
#   in(x, val1, val2, ...) - Check if a value equals one of several values
#
# Examples:
#    ...
#    "animations":
#    [
#      {
#        "this.rx": "clamp(-0.5 * part.rx, 0, 90)",
#        "this.tx": "3 * sin(limb_swing / 4) - 2",
#        "this:Hoof.rx": "if(leg4:Hoof.rx > 90, leg4:Hoof.rx - 90, 0)"
#        ...
#      }
#    ]
#    
# Walking animation:
#    x is a multipler to control how fast the leg swings back and forth, and y is a multiplier to control how far it swings back and forth
#
#    "left_leg.rx": "sin(limb_swing*x)*limb_speed*y"
# 
# Attack animation:
#    x is a multipler for how much it rotates
#
#    "head.rx": "sin(swing_progress*pi)*x"
#
# Hurt animation:
#    x is a multipler for how much it rotates
#
#    "head.rx": "-sin(hurt_time/pi)*x"
#
# Custom counter:
#    This is a counter that will count up while an entity is in water, and count down again when it leaves
#
#    "var.counter": "if(is_in_water, min(20, var.counter + 0.1 * frame_time * 20), max(0, var.counter - 0.1 * frame_time * 20))"
