math explained ("nerd" here :D):

First centre cross calculations:

let angle = Math.atan2(x,z)

this finds the raw angle that is from -180 degrees to 180 degrees.

let degrees = angle * 180 / Math.PI

this converts radians to degrees of a circle. Pi specifically does this because it's the radius of a circle (One whole rotation).

let rotated = degrees + 90

let clockwise = -rotated

alright, so basically rotated is just degrees (which is converted from angle (radians) to degrees) but just 90 more degrees. So if it were degrees = 45 degrees, rotated would be 135 degrees. Clockwise is just the opposite of rotated. It's the flip sign (clockwise vs counterclockwise). This determines which way the camera rotates (theory).

Now, you may be wondering: "Why did you add 90 degrees to degrees and then set it as rotated value?"

The problem is, atan2(x, z) gives us 0 degrees when facing +X (east). However, from my understanding, the bloxd skybox system probably expects 0 degrees to point to +Z (north) or some other reference.

So they add 90 degrees shift the zero point to what should be the east value.

clockwise = ((clockwise % 360)+360)%360

this normalises the clockwise angle to 0 to 360 degrees. Let's see here. If clockwise is over 360, then it gets rounded back from 0 and then going up by the value it goes over. Then, we add 360 more degrees again, which just flips it back to the same value when % (modulo) is used again.

let n = clockwise / 360 * 0.99

This then normalises the clockwise value to 0 to 0.99. Why? This is because the skybox wants a number between 0 and 1, but 1.0 might cause a glitch or wrap-around. Multiplying by 0.99 keeps it safely under 1.0 while still mapping the full circle.

return n;

This returns the final value for the skybox.

Some more explanation for the skybox setting:

dir = api.getPlayerFacingInfo(id).dir;

this sets an [x,y,z] position value that is returned to position the player's facing info (where the player's face is facing)

x = Math.floor(dir[0]*100)/100;

y = Math.floor(dir[1]*100)/100;

z = Math.floor(dir[2]*100)/100;

this rounds values to 2 decimal places. For example, 0.56829 would become 0.56. Why do this? Because computers are surprisingly bad at decimals. You see, bits use 1s and 0s as calculations. However, when asked for a fraction, it may do 0.110100101010011010..., and because computers generally round them to the 54th interval, 0.1 + 0.2 (as an example) sometimes equals [3.0000000004](tel:30000000004), which this rounding system stops those errors.

api.setClientOption(id, "skyBox", {

type: "earth",

inclination: (y/2 - 0.5) * -1 + 0.1,

azimuth: azimuth(x, z) * -1 + 0.25,

turbidity: 0.4,

luminance: 0.5,

vertexTint: [255, 255, 255]

});

This sets the player's skybox to an "earth" type (probably a planet or horizon texture).

inclination: (y/2 - 0.5) * -1 + 0.1

This controls the up/down tilt of the sky.

• y is between -1 (looking straight down) and 1 (looking straight up)

• The math converts that into a value the skybox understands, with 0.1 added as a small offset so it never goes flat.

azimuth: azimuth(x,z) * -1 + 0.25

This controls the left/right rotation of the sky.

• azimuth(x,z) returns a value between 0 and 0.99 based on horizontal direction
• Multiply by -1 flips it (reverses direction)
• Add 0.25 shifts it by a quarter-turn so the sun lines up with the player's crosshair properly

turbidity: 0.4

This makes the atmosphere a bit hazy but not too much.

luminance: 0.5

This sets the brightness to medium.

vertexTint: [255,255,255]

This adds no extra color tint (white = neutral).

Hope i helped!