Rotation

Rotation (also known as perspective, viewpoint or viewing angle) is the direction an entity is facing. Rotation in Minecraft consists of Y-rotation or yaw and X-rotation, declination or pitch, each affecting the directions of the body and the head of the entity. For entities without heads, they can sometimes rotate entirely around the X-axis. The "X" and "Y" refers to the axis about which they rotate. Rotation can limit what a mob or player can see, but other entities (e.g. boats and item frames) also have a rotation.

Representation

Entity hitbox

Rotation is visualized by entity_hitboxes debug renderer as a long blue tint placed in-line with the (red) eye height hitbox and shows which direction the entities are looking.

Entity format

Rotation is internally represented with two float values in degrees.

• Y-rotation varies from -180° (facing due north) to -90° (facing due east) to 0° (facing due south) to +90° (facing due west) to +180° (facing due north again).
• For X-rotation, horizontal is 0°, with positive values looking downward and negative values looking upward. It does not exceed positive or negative 90°.

Debug screen

The player's own rotation can be seen in the debug screen under Facing. This can be toggled in the debug options menu under player_position. First the nearest cardinal direction and horizontal axis are specified, followed by the player's yaw and pitch in the brackets to one digit of precision.

When entity hitboxes are shown using F3 + B, their rotation is also visualized as a blue line pointing in their facing direction starting from the center of their hitbox at eye level.

Y-rotation (Yaw Angle)

An entity turning to the right or left corresponds to a positive or negative change in their Y-rotation.

Here, "anticlockwise angle from +X in a 2D system" denotes the angle measured counterclockwise starting from the positive X-axis. These angles also have values from the interval (-180°, 180°].

Algorithm for the Y-rotation angle

Explanation

The angle transformation to get the correct Y-rotation angle not only requires rotating the Y-rotation circle, but also reflecting the yaw table horizontally or vertically through the diameter.

Initial and Desired

This part can be thought of as the top half of a semicircle standing on the +X axis. The circle is to be rotated for getting the outputs as in the yaw table. It is also checked whether reflecting the circle along the diameter (or flipping the circle) is necessary.

Adding 90°

Reflecting the semicircle along the (imaginary) horizontal diameter produces the desired angles (Top changes to bottom and vice-versa).

Subtracting 90°

Reflecting the semicircle along the vertical diameter produces the desired angles (Right changes to left and vice-versa).

Wrapping back

For the yaw, the range is (-180°, 180°], which means that anything greater than the absolute value of 180 degrees must be wrapped back inside the yaw table. However, after the angle transformations, all the angles beyond the range are to be wrapped.

There can be many more approaches for wrapping other than the ones stated below.

Approach 1: Using the modulus

Required: the size and the minimum and the maximum values.

The size is 360° because the whole circle is being considered.

Therefore,

In various programming languages, the mod(a, n) operator is used. When exactly one of the operands is negative, the basic definition breaks down, and programming languages differ in how these values are defined.^[1] Here, n = 360. Therefore, 'a' should be changed to a positive value before performing the modulo operation.

Approach 2: Adding or subtracting by 360 degrees

360 degrees is a full revolution. Moving by positive or negative 360 degrees is the same thing as not moving inside the orbit.

Thus, the following method can be used:

This has been achieved through the following code in JavaScript:

angle = -360 * Math.sign(angle) + angle;
if (angle === -180)
    return "180.0";
return angle;

Here, angle is the variable x.

The final code

The final code in JavaScript is as follows. Two coordinates are used, namely (xcurrent, zcurrent) and (xdest, zdest).^[2]

function getYawAngle(xcurrent, zcurrent, xdest, zdest) {

  // z is negated here (equivalent to -(zdest - zcurrent))
  let slope = Math.atan2(zcurrent - zdest, xdest - xcurrent) * (180 / Math.PI);

  slope += 90;   // Adding 90 degrees
  slope *= -1;   // Reflecting along the horizontal diameter

  // Wraps into the (-180, 180] range (Approach 2)
  if (Math.abs(slope) > 180) {
    slope = -360 * Math.sign(slope) + slope;
  }

  // Rounding to a single decimal place
  slope = Math.round(slope * 10) / 10;

  // Mimicking the Java special‑case string outputs
  if (slope === 0)       return "-0.0";
  if (slope === -180)    return "180.0";

  // Default path – always keeping one decimal digit like Java’s “‑123.4”
  return slope.toFixed(1);
}

The function in Approach 2 has not been replicated one-to-one.

Place blocks

The viewing angle affects the placement of some blocks: depending on how the player look, for example, a banner or a sign rotated accordingly. The viewing angle also plays a role when placing stairs or scaffolding.

Target selection

Target selection properties allow entities to be selected that have a specific viewing angle:

Angle ranges are specified with two points, e.g. B. 43..47.

/title @a[y_rotation=<view angle>] actionbar {"text":"View direction (compass direction)"}

/title @a[x_rotation=<head tilt angle>] actionbar {"text":"head tilt (up)"}

Examples of the cardinal directions:

/execute if entity @p[y_rotation=135..-135] run say North
/execute if entity @p[y_rotation=-135..-45] run say East
/execute if entity @p[y_rotation=-45..45] run say South
/execute if entity @p[y_rotation=45..135] run say West

Save perspective

Blinking angles can be read out and saved in a score: This is done by creating a score target for the direction and the inclination.

/scoreboard objectives add direction dummy "viewing angle direction" 
/scoreboard objectives add tilt dummy "viewing angle inclination"

The direction and inclination are then read out using the command /data and save them in the respective score.

/execute as @a store result score @s direction run data get entity @s Rotation[0]
/execute as @a store result score @s tilt run data get entity @s Rotation[1]

Set perspective

The commands /teleport and /rotate can be used to set the perspective of entities. The entities can move freely after teleportation if they have AI, but they start with the fixed viewing angle.

Additionally, all entities except players can be realigned using the command /data via the property Rotation

Viewpoint coordinates

Circumflexes (^) allow the position to be determined depending on the rotation of an entity.

History

Java Edition

Bedrock Edition

Data History

Java Edition

References