Poser

Preface

The poser JSON controls all the animations of a Pokémon. It contains information on when the Pokémon will perform certain animations. You can set your Pokémon to only ever perform one animation if you’d like, or you can give it different animations for just about every action it performs! It can even be used to adjust certain properties of an animation so you don't have to edit the animation itself.

Due to the way the official models are implemented, there are no official posers for them. Poser data for custom Pokémon is often shared amongst different addon creators. Help and techniques for poser files can be found in the Cobblemon Discord server.

Poser File Breakdown

The poser file requires an animation JSON to assign animations to a model. You're always going to want to be familiar with all the animations that were made for a model. If you assign an animation type that doesn't exist in the animation JSON then the game will crash! Also, if a bone you listed in the poser doesn't exist on the model then the game will crash! Once you figure out what animations were made for your target Pokémon model, you can simply apply the existing animations to appropriate poses.

Sometimes there may be animations that don't seem to have a matching pose, such as blink animations. These can be applied using the quirk animation system. This system allows you to layer certain animations over an animation that is already playing in game. Making use of the quirk system can really help your Pokémon feel more alive!

Here is a breakdown of an example poser file which includes all the different properties that can be assigned. Hover over the underlined text to see more information. Every kind of possible poser function is included in this example at least once! So make sure that you review the whole file to see why some things are written the way they are. This example is not meant to be used as a template.

{
   "head": "head",
   "portraitScale": 1.65,
   "portraitTranslation": [0, -0.6, 0],
   "profileScale": 1,
   "profileTranslation": [0, 0.15, 0],
   "faint": "bedrock(charizard, faint, true)",
   "cry":  "bedrock(charizard, cry)",
   "poses": {
     "battle-idle": {
       "poseName": "battle-idle",
       "transformTicks": 10,
       "poseTypes": ["STAND"],
       "isBattle": true,
       "isTouchingWater": false,
       "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
         }
       ],
       "animations": ["bedrock(charizard, battle_idle)"],
       "quirks": [
         {
           "name": "blink",
           "loopTimes": 5,
           "minSecondsBetweenOccurrences": 8,
           "maxSecondsBetweenOccurrences": 20,
           "animations": ["bedrock(charizard, blink)"]
         },
         {
           "name": "wing_flap",
           "animations": ["bedrock(charizard, wing_flap)"]
         }
       ]
     },
     "standing": {
       "poseName": "standing",
       "transformTicks": 10,
       "poseTypes": ["STAND", "NONE", "PORTRAIT", "PROFILE" ],
       "isBattle": false,
       "transformedParts": [
         {
           "part": "wing_right",
           "position": [0, 0, 0],
           "isVisible": true
         },
         {
           "part": "wing_left",
           "position": [0, 0, 0],
           "isVisible": true
         }
       ],
       "animations": [
         "look",
         "bedrock(charizard, ground_idle)"
       ],
       "quirks": [
         {
           "name": "blink",
           "animations": ["bedrock(charizard, blink)"]
         }
       ]
     },
     "walking": {
       "poseName": "walking",
       "poseTypes": ["WALK"],
       "transformedParts": [
         {
           "part": "wing_right",
           "position": [0, 0, 0],
           "isVisible": true
         },
         {
           "part": "wing_left",
           "position": [0, 0, 0],
           "isVisible": true
         }
       ],
       "animations": [
         "look",
         "bedrock(charizard, ground_walk)",
         "bedrock(charizard, ground_idle)"
       ],
       "quirks": [
         {
           "name": "blink",
           "animations": ["bedrock(charizard, blink)"]
         }
       ]
     }
   }
  }

Advanced Poser Functions And When to Use Them

Posers can do a lot more than just assign one animation to a pose. Certain things can be tweaked in the poser to make your Pokémon livelier in game. If you enjoy making many different animations for Pokémon, then this section will help you implement them in game. Using these advanced feature can help you make custom Pokémon that are on the same level of quality as the official Pokémon!

Remember that you can have an unzipped copy of your addon as a resourcepack in the game for easier editing. Since the poser file is a part of the resources of an addon, it can be refreshed in game by pressing F3 + T. This reloads all your resourcepacks and allows you to see the changes you've made to the poser only if the poser you are editing is in the resourcepack folder. It is highly recommended to use unzipped folders to test addon stuff when implementing them into the game! You can simply make your file edits, save the file, and then refresh your resourcepack in game to see the changes immediately!

Layered Animations

Layered animations are two or more animations that are listed together in your animations list. The most common example would be adding the look animation on top of your ground_idle animation for your standing pose. You're able to list more than two animations and your main limit would be running out of bones to animate.

The first animation listed should have priority control over the bones of the model. This is how Pokémon are able to look at you while walking around. The look animation has priority over the head bone, or whatever bone is listed as the head. This head bone will always attempt to look at a player if the player approaches.

Another example of layering animations would be having 2 kinds of animations that are meant to be played together and separate. A great example of this is charizard's walk animation. The walking animation itself only moves the legs for when it's walking. It combines the ground idle and the ground walk animations for its walking pose. The walk animation only controls the bottom half of the body, while the ground idle only controls the top half of the body. If you only listed its walk animation and it started walking, then the top half of charizard would t-pose whenever it walks.
Charizard's walking animation list for its walking pose:

     "animations": [
        "look",
        "bedrock(charizard, ground_walk)",
        "bedrock(charizard, ground_idle)"
       ]

Animation Overwrites

This function is mostly used for cases where you want an animation to be played exclusively for certain situations. You simply write , true after your animation type in your animations list. The most common use for this function would be writing it into your faint so the faint animation should always be playing when a Pokémon faints. Sometimes animations don't change properly and this can fix it most of the time.

Below is an example of the faint using this overwrite function. What's going to happen in game is that when charizard faints, it will always play the faint animation over other animations it was already doing. This is fine because the faint animation animates the whole model. The cry animation does not contain this function because we want the cry to play over the idle animation, but not completely overwrite everything! If it did, then charizard would t-pose whenever it tried to do it's cry animation because it only animates the head bone.

"faint": "bedrock(charizard, faint, true)",
  "cry":  "bedrock(charizard, cry)",

Quirks

Quirk animations are extra animations that you can have play over the main animation list. What makes them different from the previous animation overwrite function is that these quirks can have extra properties applied to them. You can make them loop a certain number of times and include timers for these quirks. The most common example of a quirk animation would be the blink animations. By default, a quirk animation should play once every 8-20 seconds!

Making a quirk in your poser file would largely depend on an animator making these quirky little animations to play in game. You can do more than just blinking animations. You can make a Pokémon roar, sneeze, or dance and have it play as a quirk for its standing pose or any other pose. A timer can then be applied to these quirk animations so you could end up with something like charizard doing a roar every 30-60 seconds when its idle. It's a very flexible sub system for animations that is only limited by your creativity.

Here is a list of properties that can affect quirks:

"loopTimes": Int = 1 // The number of times the animation should play for the quirk
"minSecondsBetweenOccurrences": Float = 8 // The decimal-friendly number of seconds that is the 
minimum between the quirk playing once and it playing a second time
"maxSecondsBetweenOccurrences": Float = 30 // What do you think
"animations": List<Animation> = [] // The list of animations to play (together) when this quirk runs
"name": String // The name of the quirk

Below is an example of a modified quirk animation. What this will do is eventually make charizard play the blink animation 5 times in a row. Then after the animation plays, an 8-20 second timer begins to play this quirk again. The quirk timer starts after the quirk animations end.

"quirks": [
        {
          "name": "blink",
          "loopTimes": 5,
          "minSecondsBetweenOccurrences": 8,
          "maxSecondsBetweenOccurrences": 20,
          "animations": ["bedrock(charizard, blink)"]
         }

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],
           "rotationrotation": [0, 0, 0],
           "isVisible": false
         }
        ]

Animation Conditions

This function allows you to have more control over when an animation is allowed to play. The current conditions we can use are for battle and for touching water. This can be used to make animations specific to being in battle or in water. You can also mix and match the battle and water conditions if you really want more specific animations. This can result in having a ground idle, ground battle idle, water idle, and water battle idle!

This function is mostly for helping you organize your animations for each pose. Setting a condition to true will only allow the animation to play when this condition is met. Setting it to false will prevent the animation from being played when this condition is met. This allows you to set 2 or more animations per poseType. This basic fundamental is what allows us to have battle animations that can only play in battle!

Transformed parts work really well with this function! Combining these 2 functions is what allows Rillaboom to use its drum only when in battle. You can allow certain model parts to appear visible only when these conditions are met. Keep these functions in mind the next time you make a custom Pokémon model. You can create livelier animations using this system!

Below is an example of these animation conditions being used. In this example, the battle idle will only play when charizard is in battle, but never while charizard is in water.

    "poses": {
     "battle-idle": {
       "poseName": "battle-idle",
       "transformTicks": 10,
       "poseTypes": ["STAND"],
       "isBattle": true,
       "isTouchingWater": false,
       "animations": ["bedrock(charizard, battle_idle)"]
      },

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 some Pokémon don't use a head bone.

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

• Blink animations are not applied to the sleep pose. This is because you don't blink when you sleep!

{
 "head": "head",
 "portraitScale": 2.3,
 "portraitTranslation": [ -0.1, -0.9, 0 ],
 "profileScale": 1.1,
 "profileTranslation": [ -0.05, 0.15, 0 ],
 "faint": "bedrock(starly, faint, true)",
 "cry": "bedrock(starly, cry)",
 "poses": {
   "battle-idle": {
     "poseName": "battle-idle",
     "transformTicks": 10,
     "poseTypes": ["STAND"],
     "isBattle": true,
     "animations": ["bedrock(starly, battle_idle)"],
     "quirks": [
       {
         "name": "blink",
         "animations": ["bedrock(starly, blink)"]
       }
     ]
   },
   "standing": {
     "poseName": "standing",
     "transformTicks": 10,
     "poseTypes": [
       "STAND",
       "NONE",
       "PORTRAIT",
       "PROFILE"
     ],
     "isBattle": false,
     "animations": [
       "bedrock(starly, ground_idle)"
     ],
     "quirks": [
       {
         "name": "blink",
         "animations": [
           "bedrock(starly, blink)"
         ]
       }
     ]
   },
   "walking": {
     "poseName": "walking",
     "transformTicks": 10,
     "poseTypes": [
       "WALK"
     ],
     "animations": [
       "bedrock(starly, ground_walk)"
     ],
     "quirks": [
       {
         "name": "blink",
         "animations": [
           "bedrock(starly, blink)"
         ]
       }
     ]
   },
   "hovering": {
     "poseName": "hovering",
     "transformTicks": 10,
     "poseTypes": [
       "HOVER"
     ],
     "animations": [
       "bedrock(starly, air_idle)"
     ],
     "quirks": [
       {
         "name": "blink",
         "animations": [
           "bedrock(starly, blink)"
         ]
       }
     ]
   },
   "flying": {
     "poseName": "flying",
     "transformTicks": 10,
     "poseTypes": [
       "FLY"
     ],
     "animations": [
       "bedrock(starly, air_fly)"
     ],
     "quirks": [
       {
         "name": "blink",
         "animations": [
           "bedrock(starly, blink)"
         ]
       }
     ]
   },
   "sleeping": {
     "poseName": "sleeping",
     "transformTicks": 10,
     "poseTypes": [
       "SLEEP"
     ],
     "animations": [
       "bedrock(starly, sleep)"
     ]
   },
   "leftshoulder": {
     "poseName": "leftshoulder",
     "transformTicks": 10,
     "poseTypes": [
       "SHOULDER_LEFT"
     ],
     "animations": [
       "bedrock(starly, left_shoulder)",
       "look"
     ],
     "quirks": [
       {
         "name": "blink",
         "animations": [
           "bedrock(starly, blink)"
         ]
       }
     ]
   },
   "rightshoulder": {
     "poseName": "rightshoulder",
     "transformTicks": 10,
     "poseTypes": [
       "SHOULDER_RIGHT"
     ],
     "animations": [
       "bedrock(starly, right_shoulder)",
       "look"
     ],
     "quirks": [
       {
         "name": "blink",
         "animations": [
           "bedrock(starly, blink)"
         ]
       }
     ]
   },
   "swimming": {
     "poseName": "swimming",
     "transformTicks": 10,
     "poseTypes": [
       "SWIM"
     ],
     "animations": [
       "bedrock(starly, water_swim)"
     ],
     "quirks": [
       {
         "name": "blink",
         "animations": [
           "bedrock(starly, blink)"
         ]
       }
     ]
   },
   "floating": {
     "poseName": "floating",
     "transformTicks": 10,
     "poseTypes": [
       "FLOAT"
     ],
     "animations": [
       "bedrock(starly, water_idle)"
     ],
     "quirks": [
       {
         "name": "blink",
         "animations": [
           "bedrock(starly, blink)"
         ]
       }
     ]
   }
 }
}