Mask off the bottom three bits of the vischar's (isometric projected) x position and treat it as a signed field. This tells us how far we need to shift the sprite left or right. -4..-1 => left shift by 4..1px; 0..3 => right shift by 0..3px.

Right shifting case.

A is 0..3 here: the amount by which we want to shift the sprite right. The following op turns that into a jump table distance. e.g. It turns (0,1,2,3) into (3,2,1,0) then scales it by the length of each rotate sequence (8 bytes) to obtain the jump offset.

Start loop

Note: This instruction is moved compared to the other routines.

Shift the bitmap right.

Our 24px wide bitmap has three bytes to shift (B,C,E) but we'll need an extra byte to capture any shifted-out bits (D).

Rotate the bitmap bytes (B,C,E,D) right by one pixel.

Shift out the leftmost byte's bottom pixel into the carry flag.

Shift out the next byte's bottom pixel into the carry flag while shifting in the previous carry at the top. (x3)

Shift the mask right.

This follows the same process as the bitmap shifting above, but the mask and a carry flag are set by default.

Rotate the mask bytes (B,C,E,D) right by one pixel.

Plot using the foreground mask.

In TGE the bitmap pixels are set to 0 for black and 1 for white, and the mask pixels are set to 0 for opaque and 1 for transparent.

TGE uses "AND-OR" type masks. In this type of mask the screen contents are ANDed with the mask (preserving only those pixels set in the mask) then the bitmap is ORed into place, like so: result = (mask & screen) | bitmap

Bitmap	Mask	Result
0	0	Set to black
0	1	Set to background (transparent)
1	0	Set to white
1	1	Set to white

See also https://skoolkit.ca/docs/skoolkit-6.2/skool-macros.html#masks

However TGE also has a foreground layer to consider. This allows objects to be in front of a sprite too. The foreground mask removes from a sprite the pixels of objects in front of it. This gives us our final expression: result = ((~foreground_mask | mask) & screen) | (bitmap & foreground_mask)

In the left term: ((~foreground_mask | mask) & screen) :: The foreground mask is first inverted so that it will preserve the foreground layer's pixels. It's then ORed with the vischar's mask so that it preserves the transparent pixels around the vischar. The result is ANDed with the screen (buffer) pixels, creating a "hole" into which we will insert the bitmap pixels.

In the right term: (bitmap & foreground_mask) :: We take the vischar's bitmap pixels and mask them against the foreground mask. This means that we retain the parts of the vischar outside of the foreground mask.

Finally the OR merges the result with the screen-with-a-hole-cut-out.

Foreground	Bitmap	Mask	Result
0	any	any	Set to foreground
1	0	0	Set to black
1	0	1	Set to background (transparent)
1	1	0	Set to white
1	1	1	Set to white

Left shifting case.

A is 4..7 here, which we intepret as -4..-1: the amount by which we want to shift the sprite left.

Start loop

Shift the bitmap left.

Our 24px wide bitmap has three bytes to shift (B,C,E) but we'll need an extra byte to capture any shifted-out bits (D).

Rotate the bitmap bytes (D,B,C,E) left by one pixel.

Shift out the rightmost byte's top pixel into the carry flag.

Shift out the next byte's top pixel into the carry flag while shifting in the previous carry at the bottom. (x3)

Shift the mask left.

Rotate the mask bytes (D,B,C,E) left by one pixel.

Plot, using the foreground mask.