Poser

Preface

The poser JSON controls all the animations of a Pokémon just as the old Poser did. It contains the same information for when the Pokémon will perform certain animations, but has received many requested upgrades. Some of these upgrades include multi-bone look animations, support for move animations, and even selecting from a pool of animations for quirks. Functionality of the new Poser will always be maintained and should let addon creators have the same options as the hard-coded Kotlin Posers.

Poser Properties

Before breaking down each section of the Poser file, let's take a look at all its different properties and how to use them. This section includes all of the different functions of the poser, any configurable options for said function, and how to write each function. You will notice that the poser now includes something in the format of q.<function>. These are molang functions which allow you to do many new things. The q stands for query and its just part of the standard format for these new functions. Some functions can even go inside of other functions. It's not terribly complicated once you read what each one does. They allow addon creators to do many things they couldn't before!

Rootbone

The rootBone property specifies what bone in the model will act as the root bone for generic animations not assigned in the poser such as the evolution animation. If the model was made following the standard bone format, then it should simply be the name of the Pokémon in lower case. Punctuation and capitalization matter! So make sure it matches the root bone of your model exactly.

You are required to assign this root bone properly or else it will break the model in certain generic animations! These animations animate the root bone and do not reset it to its original position when it finishes. This can cause model displacement after evolutions.

Below is a breakdown of the simple rootBone property:

 "rootBone": "charizard",

Portraits and Profiles & Scale and Translation

Portrait and Profile are the poses that are used when rendering any Pokémon in a GUI or Menu. Portrait is used for the left hand party screen, or Party Overlay, and Profile is used for the Party Menu. The poser file assigns some Scale and Translation values to these poses which control the camera location for rendering the Pokémon. There is a dev tool that you can enable in the Config which allows you to use some customizable keys to move the camera around the Pokémon in these menus. This tool will print the Scale and Translation values when the associated hotkey is pressed.

Scale values control the amount of zoom for the Portrait or Profile. A value less than one should make it zoom out and a value greater than one will zoom in. Sometimes with larger models, the camera cannot render the whole Pokémon no matter how far you zoom out. The back side of the Pokémon may not be rendered. This means you need to increase the Translation z value.

Translation values control the location of the camera for the Portrait or Profile. Translation is a set of 3 values which represent xyz coordinates. You will mainly be changing the first 2 values, or the x and y axis values. X for left and right, and Y for up and down. The Z value is rarely used, but is important for really big models that are not being fully rendered in the menus. It often needs a negative Z value that is some multiple of 5.

Below is a short breakdown of the previously mentioned properties:

   "portraitScale": 1.65,
   "portraitTranslation": [0, -0.6, 0],
   "profileScale": 1,
   "profileTranslation": [0, 0.15, 0],

Poses & Animations

There's a handful of Pose types and Animation types that you can make animations for. Poses are the states a Pokémon is in, like idle or moving. Poses are for assigning animations like your ground idles, ground walks, water idles, etc. The animation types are the different events in battles that you can assign animations to for each Pokémon.

For the sake of clarity, you should always refer to animations like faints, cries, or physicals as Named Animations. This is to help everyone distinguish them from the animations that are applied to poses. This distinction is important because you can assign both animations and namedAnimations to a pose. This is to allow you to assign different cries, faints, or attack animations to different poses like your floating or flying poses. This allows for water attack animations if you make the animation to support it. This process will be detailed later. Below is a list of currently available Named Animation types and Poses to choose from.

Animations & Named Animations

• faint: animation.<pokemon>.faint - The animation that plays when a Pokémon faints.
• cry: animation.<pokemon>.cry - The animation that plays when a Pokémon is called out or when it starts battle.
• recoil: animation.<pokemon>.recoil - The animation that plays when a Pokémon takes damage in battle.
• physical: animation.<pokemon>.physical - The animation that plays when a Pokémon uses a physical move in battle.
• special: animation.<pokemon>.special - The animation that plays when a Pokémon uses a special move in battle.
• status: animation.<pokemon>.status - The animation that plays when a pokemon uses a status move in battle.
• <battle_move>: animation.<pokemon>.<battle_move_name> - The animation that plays when a pokemon uses a specific move in battle. This animation property would assign a pokemon's animation to an existing action effect. Something like a custom flamethrower animation for Charizard or a Pokémon's signature move for example.

Poses

• "STAND": animation.<pokemon>.ground_idle - The animation that plays when a Pokémon is idle on land.
  • This pose type is also used for battle-idles: animation.<pokemon>.battle_idle
• "PORTRAIT": animation.<pokemon>.portrait - The animation that plays in the Party Overlay, or left hand party GUI
  • This pose often uses the ground_idle instead of a dedicated animation.
• "PROFILE": animation.<pokemon>.profile - The animation that plays in the Party Menu, or when you press M.
  • This pose often uses the ground_idle instead of a dedicated animation.
• "WALK": animation.<pokemon>.ground_walk - The animation that plays when a Pokémon is moving on land
• "HOVER": animation.<pokemon>.air_idle - The animation that plays when a Pokémon is idle in the air.
• "FLY": animation.<pokemon>.air_fly - The animation that plays when a Pokémon is moving in the air.
• "FLOAT": animation.<pokemon>.water_idle - The animation that plays when a Pokémon is idle in or on water.
• "SWIM": animation.<pokemon>.water_swim - The animation that plays when a Pokémon is moving in or on water.
• "SLEEP": animation.<pokemon>.sleep - The animation that plays when a Pokémon is asleep. Usually on land.
• "SHOULDER_LEFT": animation.<pokemon>.shoulder_left - The animation that plays when the Pokémon is on the player's left shoulder.
• "SHOULDER_RIGHT": animation.<pokemon>.shoulder_right - The animation that plays when the Pokémon is on the player's right shoulder.

Basic Animation Calling Functions

Below are the 3 methods to call a Pose or namedAnimation animation. Each of them serve a purpose in layering animations on the Pokémon. Pose animations must always use q.bedrock() to serve as the base animation that can be overwritten by other animations when called. NamedAnimations can either use q.bedrock_stateful() to layer over the base animation or use q.bedrock_primary() to overwrite the base animation while it is playing. The default function used in each named animation type can be changed if your animation supports it. If you want the cry to overwrite rather than layer, then just be sure to animate it properly.

q.bedrock

The q.bedrock() function is the familiar animation calling format from the old poser which got converted into a molang function. It's the same thing as before, just in a new look. You are still just listing your Pokémon and then the animation in the parenthesis. This function is mainly used to assign poses their animations. These animations are meant to be overwritten by Primary or Stateful animations whenever convenient.
Below is an example of the q.bedrock function assigning a walk animation to the "WALK" pose type:

   "walking": {
     "poseTypes": ["WALK"],
     "animations": [
       "q.bedrock('blastoise', 'ground_walk')"
     ]
   },

q.bedrock_stateful

The function q.bedrock_stateful() allows you to assign a stateful animation to an animation type. Stateful animations are meant to animate just a few bones of the Pokémon and get overlaid on the current pose. An example would be cries only animating the mouth or head of the Pokémon. A stateful animation won't take control of the whole model to play its animation.

Here is an example of the 2 stateful animations, cry and recoil, in the poser:

   "cry": "q.bedrock_stateful('blastoise', 'cry')",
   "recoil": "q.bedrock_stateful('blastoise', 'recoil')",

q.bedrock_primary

The function q.bedrock_primary() allows you to assign a primary animation to an animation type. Primary animations are meant to take control of the entire model to play its animation and will clear any previous animations it was doing. An example would be a Pokémon's physical attack animation. When a Pokémon uses a physical move, it should clear the battle idle animation and play its physical animation instead. These animations often move the whole body and many of its limbs. When the physical animation is done, it returns control of the model to the battle idle after the physical animation has finished and should play a short transition animation in between.

q.bedrock_primary comes with a couple of extra properties and they should be written in the following order:

1. group: 'blastoise' - The animation JSON that the game will search for the following animation. This should always be the name of a Pokémon.
2. animation: 'status' - The animation the game will call from the previously mentioned animation JSON. Primary animations are usually your attack animations or faints, but you can assign it to other named animations if desired.
3. (optional) excluded labels: 'look' - Exclusive labeled animations that wont get overwritten by this primary animation. The only reasonable use of excluded labels is to exclude the look animation from being overwritten. This is so they can keep looking at a target when using an animation.
4. curve: 'q.curve('symmetrical_wide')' - The interpolation curve that this primary animation will use to transition to and from the pose it is written under.

Since Primary animations behave in a similar way to swapping poses, they can use special interpolation curve types via the q.curve property written within its sub properties. These provide different types of smoothness to the interpolation and will be explained in the next section.

Below is an example of the 4 common primary animations in the poser:

   "faint": "q.bedrock_primary('blastoise', 'faint', q.curve('one'))",
   "physical": "q.bedrock_primary('blastoise', 'physical', q.curve('symmetrical_wide'))",
   "special": "q.bedrock_primary('blastoise', 'special', q.curve('symmetrical_wide'))",
   "status": "q.bedrock_primary('blastoise', 'status', 'look', q.curve('symmetrical_wide'))"

q.curve

The function q.curve() is a sub function for q.bedrock_primary() which allows the animation to interpolate back into the main pose. This allows the transition between animations to behave similarly to linear keyframes and smooth keyframes when animating.

The q.curve function comes with 3 options for now which are:

• one: Does not interpolate at all. Just jumps from one animation to the next. Preferred for faint animations.
• symmetric: Interpolates in a similar fashion to 2 smooth keyframes in blockbench. Not preferable, but is an option.
• symmetrical_wide: Interpolates in a similar fashion to 2 smooth keyframes in blockbench, but with a wider margin. The preferred choice when transitioning from moves.
  

Below is an example of the 2 main q.curve types:

   "faint": "q.bedrock_primary('blastoise', 'faint', q.curve('one'))",
   "physical": "q.bedrock_primary('blastoise', 'physical', q.curve('symmetrical_wide'))",

q.array, q.random, and math.random

Whenever one of the previously mentioned functions calls the parameter for the animation type, such as 'faint', in the function, you can substitute the value with another function that can call one of multiple animations instead. These 3 functions can help create the illusion of randomized animations if you have enough animations to support the pose, named animation, or quirk.

• q.array() - This function selects one of the listed animation types when the function is called. Commonly used to create a pool of quirk animations where each option has equal weights.
  • The following example allows Porygon-z to use one of 6 different twitch animations every 1-10 seconds as a quirk.

"q.bedrock_quirk('porygon-z', q.array('twitch1', 'twitch2', 'twitch3', 'twitch4', 'twitch5', 'twitch6'), 1, 10, 1)"

• q.random() - This function selects one of the listed animation types when resources are loaded. This means the animation would be selected on game start or on an asset refresh when using F3+T as observed through testing. This seems to be a bug according to devs.
  • The following example limits Porygon-z to using one of two different twitch animations every 1-10 seconds as a quirk until assets are refreshed.

"q.bedrock_quirk('porygon-z', q.random('twitch1', 'twitch2'), 1, 10, 1)"

• math.random(0, 1) <  ?  : - You can combine the math.random function with a trinary conditional operator(the ? and : bits) to have the game roll a number and determine what animation or set of animations to play. This option is great for when you want an animation to have a weighted chance to play. You can also add another math.random function or a q.random function as one of the options to keep stacking the odds and options if you wanted a set of common, uncommon, and rare animations in one scenario. You need a minimum of 2 animations to use this function properly, and you can theoretically have it call as many animations as you want. You probably shouldn't. An example is provided below with the underlined sections detailing what each value is doing.

"faint": "q.bedrock_primary('porygon-z', math.random(0, 1) < 0.1 ? 'faint2' : 'faint', q.curve('one'))"

Conditions

You can expand the amount of animations a Pokémon can have and when they should be played by using conditions. Conditions are what allow for battle animations despite the standing and battle-idle poses both using the "STAND" pose type. Typically, if you want different animations using the same pose types, then you must set one pose's condition to true, and the other pose's matching condition to false. You can mix and match these conditions to make something like an animation that only plays in battle, if it is raining while the sun is setting.

There are two methods for conditions that you can use. There is the old true or false conditions where each condition has a property named after it and then there is the new Molang conditions. Molang conditions can use one or more molang functions to have the game check certain properties of the pokemon like what stats it has or even what it is standing on. A list of Cobblemon's custom molang functions can be found here with some usable functions highlighted in red. Due to the complexity of molang and it being so new to cobblemon, it's difficult to explain its potentially unlimited possibilities. There will be many examples to borrow from in the future. You can even use Molang's operators to extend your string if needed.

How to write a Molang condition:

• "condition": "<insert molang function(s)>"
  • One of the few examples:

"condition": "q.is_standing_on_blocks(2, 'minecraft:sand', 'minecraft:red_sand')"

Below is an example inside of Lunatone's poser where it uses molang conditions to assign its 2 different sleeping animations: one where it checks for sand so it can lodge itself in the sand, and the other where it floats while it sleeps. By using the ! operator in front of the second pose's molang condition, the game makes sure that the conditions are false in order to play the animation.

   "sand-sleep": {
     "poseTypes": ["SLEEP"],
     "condition": "q.is_standing_on_blocks(2, 'minecraft:sand', 'minecraft:red_sand')",
     "namedAnimations": {
       "cry": "q.bedrock_stateful('dummy', 'cry')"
     },
     "animations": ["q.bedrock('lunatone', 'sleep')"]
   },
   "sleep": {
     "poseTypes": ["SLEEP"],
     "condition": "!q.is_standing_on_blocks(2, 'minecraft:sand', 'minecraft:red_sand')",
     "namedAnimations": {
       "cry": "q.bedrock_stateful('dummy', 'cry')"
     },
     "animations": ["q.bedrock('lunatone', 'sleep_alt')"]
   }

List of Currently Implemented True or False Conditions:

• "isBattle": The Pokémon must be in a battle.
• "isTouchingWater": The Pokémon must be touching water. Not necessarily underwater.
• "isInWaterOrRain": The Pokémon must be touching water or in rain. Again, not necessarily underwater.
• "isUnderWater": The Pokémon must be underwater. The red line on the hitbox must be below the surface.
• "isStandingOnRedSand": The Pokémon must be standing on red sand.
• "isStandingOnSand": The Pokémon must be standing on sand
• "isStandingOnSandOrRedSand": The Pokémon must be standing on either sand or red sand.
• "isDusk": It must be "Dusk" time in the world, or roughly at sunset.

Below is an example of 2 poses using the "STAND" pose type and Conditions to separate the battle-idle animation from the ground idle animation:

• In these scenarios, you want one pose to have the condition set to true, and any other pose that shares the same pose type to have the condition set to false.

   "battle-standing": {
     "poseTypes": ["STAND"],
     "isBattle": true,
     "animations": [
       "q.bedrock('blastoise', 'battle_idle')"
     ]
   },
   "standing": {
     "poseTypes": ["STAND", "NONE", "PORTRAIT", "PROFILE"],
     "isBattle": false,
     "animations": [
       "q.bedrock('blastoise', 'ground_idle')"
     ]
   },

Transformed Parts

This function allows you to transform parts of the model when the Pokémon is in a certain pose. You can change the location, rotation, and visibility of bones for each pose. This allows you to make some slight adjustments to an in-game animation without having to edit the animation itself. While there aren't many examples of this function, it's most common use is to hide model parts when a Pokémon is not in its battle idle. This is the case with Rillaboom and its drum.

A great use for location and rotation transformation is to adjust shoulder animations. You don't have to account for the model location on the player shoulder when making the animation. If it doesn't line up in the game, you can move the whole model using this function.

The visibility transformation allows you to hide a specific bone in the model when the Pokémon is currently in a pose. This can be used to hide certain bones if needed. This allows you to do things like making Rillaboom use its drum for its battle-idle. It also allows Typhlosion to have its flames ignited only during battle. Something to keep in mind is that if you want a bone to be visible only during battle, then you must set this bone as invisible for all other poses. This is why transformedParts is written under every pose in the poser file breakdown.

Below is an example of all the transformed part properties being used. This is mostly a demonstration of your options when using this function. If this example was applied in game, Charizard's wings would be detached from its body, but only the left wing would be invisible. Realistically, you would never want to do something like that.

"transformedParts": [
         {
           "part": "wing_right",
           "position": [10, 0, 0],
           "rotation": [0, 0, 0],
           "isVisible": true
         },
         {
           "part": "wing_left",
           "position": [-10, 0, 0],
           "rotation": [0, 0, 0],
           "isVisible": false
         }
        ]

Look Animation(s)

The new Poser allows you to manipulate the look animation in a number of ways. Creators can now list multiple look animations where each one can define its own head bone and edit some of the properties of the look animation. Changing the properties allows you to manipulate the sight cone of the Pokémon if desired. This can help prevent some odd clipping or extend/shorten how far it can look up and down or left and right. Having multiple look animations allows for Pokémon with multiple heads to turn each head individually. You could even assign the torso and head bones to look at the same time while limiting the range for each. This can be helpful for Pokémon with little to no neck and they have to look with their body more than their head.

The q.look() function is the format of this new look animation. When using this function, all the properties must be listed in a specific order and the name of the bone must be in single quotes. (the apostrophe key)

• Please refer to the image below to visualize pitch, yaw, and the origin.
• Pressing F3+B in game can show the hitboxes. That blue line shows where the pokemon is looking at and if its looking at nothing, it is centered at 0 pitch and yaw. You can call this the origin.
  

The properties of q.look must be in the following order:

• With the exception of the bone name, these are also the default values for each property

1. Bone name: 'head_ai' - The name of the bone on the model which will perform the look animation
2. Pitch Multiplier - 1 - Multiplies the amount of pitch gained by this amount. Can use -1 to invert the pitch!
3. Yaw Multiplier - 1 - Multiplies the amount of yaw gained by this amount. Can use -1 to invert the yaw!
4. Max Pitch - 70 - How many degrees the Pokémon can look down from origin.
5. Min Pitch - -45 - How many degrees the Pokémon can look up from origin.
6. Max Yaw - 45 - How many degrees the Pokémon can look right from origin.
7. Min Yaw - -45 - How many degrees the Pokémon can look left from origin.

A look animation using the previously listed values would look something like this inside of the standing pose:

   "standing": {
     "poseTypes": ["STAND", "NONE", "PORTRAIT", "PROFILE"],
     "animations": [
       "q.look('head_ai', 1, 1, 70, -45, 45, -45)",
       "q.bedrock('riolu', 'ground_idle')"
     ],

If you want to use the default values and keep it short, you can also write it like this:

   "standing": {
     "poseTypes": ["STAND", "NONE", "PORTRAIT", "PROFILE"],
     "animations": [
       "q.look('head_ai')",
       "q.bedrock('riolu', 'ground_idle')"
     ],

If you want to list multiple head bones, you can write the q.look function multiple times:

   "standing": {
     "poseTypes": ["STAND", "NONE", "PORTRAIT", "PROFILE"],
     "animations": [
       "q.look('head_ai')",
       "q.look('torso')",
       "q.bedrock('riolu', 'ground_idle')"
     ],

Quirks

Quirk animations are typically stateful animations that you can have play over the main animation for a pose. The new poser format introduced primary quirk animations and a shorthand method to writing in your quirk animations in the q.bedrock_quirk() format. The old Poser method for quirks can be condensed into one line using this function. When using this function, all the properties must be listed in specific order, placed inside of single quotes (the apostrophe key) unless its a number, and separated by commas.

If your poser and animations are made just right, then you can have a single Pokémon running so many quirk animations at once. Remember that you can combine any of the following quirk examples if you have lots of animations like Blastoise.

Stateful Quirks

Stateful quirks are animations that will be layered on top of the idle animation currently playing.

The properties of q.bedrock_quirk must be in the following order:

1. Animation Group: 'blastoise' - the name of the Pokémon
2. Animation Name(s): 'quirk_ground_idle' - the name of the animation. Supports a pool of animations using the q.array function
3. Minimum seconds between occurences: 20 - The decimal-friendly number of seconds that is the minimum between the quirk playing once and it playing a second time.
4. Maximum seconds between occurences: 60 - What do you think?
5. Loop times: 1 - The number of times the animation should play for the quirk

The previously listed properties would get written as a quirk like so:

     "quirks": [
       "q.bedrock_quirk('blastoise', 'quirk_ground_idle', 20, 60, 1)"
     ]

You don't need to include all the properties if you just want to use the default values of 8-30 seconds between quirks. You can write it like so to use the default values and keep it short:

     "quirks": [
       "q.bedrock_quirk('blastoise', 'blink')"
     ]

q.array

You can replace your animation name with the q.array() function to have the quirk pick from a list of animations to play. This can be helpful if you have a lot of quirks that you want to play under one pose. You simply need to put the list of animations inside of the parenthesis, include each animation name inside of single quotes, and separate them with a comma.

• Example: q.array('quirk_battle_idle', 'quirk_battle_idle2')
  • These quirks are for Blastoise adjusting each of its cannons. Writing it this way lets Blastoise adjust only one cannon at a time, but it's a random cannon each time.

So if you were to make that into a quirk, it would look like this:

     "quirks": [
       "q.bedrock_quirk('blastoise', q.array('quirk_battle_idle', 'quirk_battle_idle2'), 30, 60, 1)"
     ]

Primary Quirks

Primary quirks are animations that will play over the idle animation for its entire animation length. Primary quirk animations can control the entire model during its duration so you can have the Pokémon do full flips or something and then interpolate back into the idle pose using a q.curve function.

The properties of q.bedrock_primary_quirk must be in the following order:

1. Animation Group: 'porygon2' - the name of the Pokémon
2. Animation Name(s): 'idle_quirk' - the name of the animation. Supports a pool of animations using the q.array function
3. Minimum seconds between occurences: 20 - The decimal-friendly number of seconds that is the minimum between the quirk playing once and it playing a second time.
4. Maximum seconds between occurences: 40 - What do you think?
5. Loop times: 1 - The number of times the animation should play for the quirk
6. (optional) excluded labels: 'look' - Exclusive labeled animations that wont get overwritten by this primary animation. The only reasonable use of excluded labels is to exclude the look animation from being overwritten. This is so they can keep looking at a target when using an animation.
7. Curve: q.curve('symmetrical') - The type of curved sin wave used to transition back into the idle animation of the pose.

So if you were to make that into a quirk, it would look like this:

     "quirks": [
       "q.bedrock_primary_quirk('porygon2', q.array('idle_quirk', 'idle_quirk2'), 20, 40, 1, q.curve('symmetrical'))"
     ]

This example allows porygon2 to use one of 2 quirks as a primary animation. It will either flip or spin before transitioning back into its idle animation.

Placeholder Animations

The new poser allows creators to use the placeholder animations which the JSON poser could not access before. These placeholder animations are based on the body type or limb features of the Pokémon. Each placeholder features a very simple animation that swings a limb back and forth.

Below is a list of current placeholder animations, their default values, and an example you can copy into your animations list directly:

• q.quadruped_walk - A basic walk animation for Pokémon with 4 legs.
  

"q.quadruped_walk(0.66, 1.4, 'leg_front_left', 'leg_front_right', 'leg_back_left', 'leg_back_right')"

• q.biped_walk - A basic walking animation for Pokémon who stand on 2 legs.
  

"q.biped_walk(0.66, 1.4, 'leg_left', 'leg_right')"

• q.bimanual_swing - A basic arm swinging animation for Pokémon with 2 arms that usually stand on 2 legs.

"q.bimanual_swing(0.66, 1.4, 'arm_left', 'arm_right')"

• q.sine_wing_flap - A basic wing flap animation for a pair of wings on a Pokémon. This animation allows you to control a few more aspects of the specified bones. It's important to note what axis these "wings" should be rotating in to give the illusion of flapping. So be sure to reference your model.

"q.sine_wing_flap(0.9, 0.9, 25, 'z', 'wing_left', 'wing_right')"

With the exception of the wing flap placeholder, the first value mentioned in these functions controls how fast the limbs will swing, also called the period value. The second value is the amplitude, or how far a limb will swing. These are both multiplier values to a cosine wave that the author of this post can't seem to find at this moment. Be sure to tune these values if the limbs don't work with the defaults.

Poser File Breakdown

Soon™

Poser File Example

Instead of making poser files from scratch each time, you can use other custom Pokémon posers as a template. Just be aware of the animations each Pokémon has. Also be aware that not all Pokémon have a bone called head.

Here is an example of a poser file for a custom riolu that includes all currently implemented poses and their appropriate animations.

• Riolu obviously can't fly. This is just an example as no Pokémon can do everything currently.
• Blink animations are not applied to the sleep pose. This is because you don't blink when you sleep!

{
 "portraitScale": 1,
 "portraitTranslation": [0, 0, 0],
 "profileScale": 1,
 "profileTranslation": [0, 0, 0],
 "animations": {
   "faint": "q.bedrock_primary('riolu', 'faint', q.curve('one'))",
   "cry": "q.bedrock_stateful('riolu', 'cry')",
   "recoil": "q.bedrock_stateful('riolu', 'recoil')",
   "physical": "q.bedrock_primary('riolu', 'physical', q.curve('symmetrical_wide'))",
   "special": "q.bedrock_primary('riolu', 'special', q.curve('symmetrical_wide'))",
   "status": "q.bedrock_primary('riolu', 'status', q.curve('symmetrical_wide'))"
 },
 "poses": {
   "battle-standing": {
     "poseTypes": ["STAND"],
     "isBattle": true,
     "animations": [
       "q.look('head')",
       "q.bedrock('riolu', 'battle_idle')"
     ],
     "quirks": ["q.bedrock_quirk('riolu', 'blink')"]
   },
   "standing": {
     "poseTypes": ["STAND", "NONE", "PORTRAIT", "PROFILE"],
     "isBattle": false,
     "animations": [
       "q.look('head')",
       "q.bedrock('riolu', 'ground_idle')"
     ],
     "quirks": [
       "q.bedrock_quirk('riolu', 'blink')"
     ]
   },
   "walking": {
     "poseTypes": ["WALK"],
     "animations": [
       "q.look('head')",
       "q.bedrock('riolu', 'ground_walk')"
     ],
     "quirks": ["q.bedrock_quirk('riolu', 'blink')"]
   },
   "hover": {
     "poseTypes": ["HOVER"],
     "animations": [
       "q.look('head')",
       "q.bedrock('riolu', 'air_idle')"
     ],
     "quirks": ["q.bedrock_quirk('riolu', 'blink')"]
   },
   "fly": {
     "poseTypes": ["FLY"],
     "animations": [
       "q.look('head')",
       "q.bedrock('riolu', 'air_fly')"
     ],
     "quirks": ["q.bedrock_quirk('riolu', 'blink')"]
   },
   "float": {
     "poseTypes": ["FLOAT"],
     "animations": [
       "q.look('head')",
       "q.bedrock('riolu', 'water_idle')"
     ],
     "quirks": ["q.bedrock_quirk('riolu', 'blink')"]
   },
   "swim": {
     "poseTypes": ["SWIM"],
     "animations": [
       "q.look('head')",
       "q.bedrock('riolu', 'water_swim')"
     ],
     "quirks": ["q.bedrock_quirk('riolu', 'blink')"]
   },
   "sleep": {
     "poseTypes": ["SLEEP"],
     "animations": ["q.bedrock('riolu', 'sleep')"]
   },
   "shoulder_left": {
     "poseTypes": ["SHOULDER_LEFT"],
     "animations": [
       "q.look('head')",
       "q.bedrock('riolu', 'shoulder_left')"
     ],
     "quirks": ["q.bedrock_quirk('riolu', 'blink')"]
   },
   "shoulder_right": {
     "poseTypes": ["SHOULDER_RIGHT"],
     "animations": [
       "q.look('head')",
       "q.bedrock('riolu', 'shoulder_right')"
     ],
     "quirks": ["q.bedrock_quirk('riolu', 'blink')"]
   }
 }
}