Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-demo-wolf3d

Source of release 0.4.1

0.4.1 / src / wl_draw.lucb

## 3D refresh from WOLFSRC/WL_DRAW.C and the C translation of AsmRefresh in Wolf4SDL.
import c
from luce_std import files, math
import pal
import wl_def
import wl_types
import id_graph
from wl_types import Game, Actor
from luce_ui import ui
from luce_gpu import gpu

pub struct Refresh:
    var fine: i64[900]
    var sintable: i64[450]
    var pixelangle: i64[320]
    var horizwall: i64[64]
    var vertwall: i64[64]
    var wallheight: i64[320]
    var vbuf: u8[64000]
    var built: bool
    var focallength: i64
    var scale: i64
    var heightnumerator: i64
    var viewx: i64
    var viewy: i64
    var viewsin: i64
    var viewcos: i64
    var midangle: i64
    var postx: i64
    var postwidth: i64
    var postpic: i64
    var postoff: i64
    var lastside: i64
    var lastintercept: i64
    var lasttilehit: i64
    var pixx: i64
    var xtile: i64
    var ytile: i64
    var xtilestep: i64
    var ytilestep: i64
    var xintercept: i64
    var yintercept: i64
    var xstep: i64
    var ystep: i64
    var tilehit: u8
    var xpartialup: i64
    var xpartialdown: i64
    var ypartialup: i64
    var ypartialdown: i64
    var focaltx: i64
    var focalty: i64
    var xinttile: i64
    var yinttile: i64
    var texdelta: i64
    var vga_lin: f64[64]
    var vga_ready: bool

## WL_MAIN.C BuildTables + CalcProjection + SetupWalls
pub func build_tables(r: Refresh*):
    if r.built:
        return
    let radtoint = (f64)wl_def.fine_angles / 2.0 / math.pi
    for i in 0..<(wl_def.fine_angles // 8):
        let tang = math.tan(((f64)i + 0.5) / radtoint)
        r.fine[(usize)i] = (i64)(tang * (f64)wl_def.tile_global)
        r.fine[(usize)(wl_def.fine_angles // 4 - 1 - i)] = (i64)((1.0 / tang) * (f64)wl_def.tile_global)
    var angle = 0.0
    let anglestep = math.pi / 2.0 / (f64)wl_def.angle_quad
    for i in 0..<wl_def.angle_quad:
        let value = (i64)((f64)wl_def.tile_global * math.sin(angle))
        r.sintable[(usize)i] = value
        r.sintable[(usize)(i + wl_def.angles)] = value
        r.sintable[(usize)(wl_def.angles // 2 - i)] = value
        r.sintable[(usize)(wl_def.angles - i)] = 0 - value
        r.sintable[(usize)(wl_def.angles // 2 + i)] = 0 - value
        angle += anglestep
    r.sintable[(usize)wl_def.angle_quad] = 65536
    r.sintable[(usize)(3 * wl_def.angle_quad)] = 0 - 65536
    r.horizwall[0] = 0
    r.vertwall[0] = 0
    for i in 1..<wl_def.max_wall_tiles:
        r.horizwall[(usize)i] = ((i - 1) * 2)
        r.vertwall[(usize)i] = ((i - 1) * 2 + 1)
    r.focallength = wl_def.focal_length
    let facedist = (f64)(r.focallength + wl_def.min_dist)
    let halfview = wl_def.view_width // 2
    r.scale = (i64)((f64)halfview * facedist / ((f64)wl_def.tile_global / 2.0))
    r.heightnumerator = (wl_def.tile_global * r.scale) >> 6
    for i in 0..<halfview:
        let tang = (f64)((i64)i * wl_def.tile_global // wl_def.view_width) / facedist
        let intang = (i64)(math.atan(tang) * radtoint)
        r.pixelangle[(usize)(halfview - 1 - i)] = intang
        r.pixelangle[(usize)(halfview + i)] = 0 - intang
    r.built = true

## costable = sintable + ANGLES/4
func costable(r: Refresh*, angle: i64) -> i64:
    var a = angle
    while a < 0:
        a += wl_def.angles
    while a >= wl_def.angles:
        a -= wl_def.angles
    return r.sintable[(usize)(a + wl_def.angle_quad)]

pub func three_d_refresh(game: Game*, r: Refresh*, raster: ui.Raster*) -> !:
    build_tables(r)
    for i in 0..<4096:
        game.spotvis[i] = 0
    let player_tile = game.tilemap[wl_def.cell(game.player.tilex, game.player.tiley)]
    if player_tile == 0 or (player_tile & wl_def.bit_door) != 0:
        game.spotvis[wl_def.cell(game.player.tilex, game.player.tiley)] = 1
    setup_3d_view(game, r)
    clear_view(game, r)
    wall_refresh(game, r)
    draw_scaleds(game, r)
    draw_weapon(game, r)
    draw_play_screen(game, r)
    try blit(r, raster)

## WL_DRAW.C Setup3DView
func setup_3d_view(game: Game*, r: Refresh*):
    var viewangle = game.player.angle
    while viewangle < 0:
        viewangle += wl_def.angles
    while viewangle >= wl_def.angles:
        viewangle -= wl_def.angles
    r.midangle = viewangle * wl_def.fine_angles // wl_def.angles
    r.viewsin = r.sintable[(usize)viewangle]
    r.viewcos = costable(r, viewangle)
    r.viewx = game.player.x - wl_def.fixed_mul(r.focallength, r.viewcos)
    r.viewy = game.player.y + wl_def.fixed_mul(r.focallength, r.viewsin)
    r.focaltx = r.viewx >> wl_def.tile_shift
    r.focalty = r.viewy >> wl_def.tile_shift
    r.xpartialdown = r.viewx & (wl_def.tile_global - 1)
    r.xpartialup = wl_def.tile_global - r.xpartialdown
    r.ypartialdown = r.viewy & (wl_def.tile_global - 1)
    r.ypartialup = wl_def.tile_global - r.ypartialdown

## WL_DRAW.C vgaCeiling[] episode 1
func ceiling_color(mapon: i64) -> u8:
    if mapon == 9:
        return 0xbf
    return 0x1d

func clear_view(game: Game*, r: Refresh*):
    let ceil = ceiling_color(game.mapon)
    let floor: u8 = 0x19
    for y in 0..<wl_def.view_height // 2:
        let row = (usize)(y * wl_def.view_width)
        for x in 0..<wl_def.view_width:
            r.vbuf[row + (usize)x] = ceil
    for y in (wl_def.view_height // 2)..<wl_def.view_height:
        let row = (usize)(y * wl_def.view_width)
        for x in 0..<wl_def.view_width:
            r.vbuf[row + (usize)x] = floor
    for y in wl_def.view_height..<wl_def.screen_height:
        let row = (usize)(y * wl_def.view_width)
        for x in 0..<wl_def.view_width:
            r.vbuf[row + (usize)x] = 8

## Wolf4SDL wl_draw.c WallRefresh. dest is vertentry/horizentry/passvert/passhoriz (no goto).
func wall_refresh(game: Game*, r: Refresh*):
    let vertloop: i64 = 1
    let vertentry: i64 = 2
    let passvert: i64 = 3
    let horizloop: i64 = 4
    let horizentry: i64 = 5
    let passhoriz: i64 = 6
    let done: i64 = 7
    for pixx in 0..<wl_def.view_width:
        r.pixx = pixx
        r.wallheight[(usize)pixx] = 0
        r.texdelta = 0
        var angle = r.midangle + r.pixelangle[(usize)pixx]
        if angle < 0:
            angle += wl_def.ang360
        if angle >= wl_def.ang360:
            angle -= wl_def.ang360
        var xpartial: i64 = 0
        var ypartial: i64 = 0
        if angle < wl_def.ang90:
            r.xtilestep = 1
            r.ytilestep = -1
            r.xstep = r.fine[(usize)(wl_def.ang90 - 1 - angle)]
            r.ystep = 0 - r.fine[(usize)angle]
            xpartial = r.xpartialup
            ypartial = r.ypartialdown
        elif angle < wl_def.ang180:
            r.xtilestep = -1
            r.ytilestep = -1
            r.xstep = 0 - r.fine[(usize)(angle - wl_def.ang90)]
            r.ystep = 0 - r.fine[(usize)(wl_def.ang180 - 1 - angle)]
            xpartial = r.xpartialdown
            ypartial = r.ypartialdown
        elif angle < wl_def.ang270:
            r.xtilestep = -1
            r.ytilestep = 1
            r.xstep = 0 - r.fine[(usize)(wl_def.ang270 - 1 - angle)]
            r.ystep = r.fine[(usize)(angle - wl_def.ang180)]
            xpartial = r.xpartialdown
            ypartial = r.ypartialup
        else:
            r.xtilestep = 1
            r.ytilestep = 1
            r.xstep = r.fine[(usize)(angle - wl_def.ang270)]
            r.ystep = r.fine[(usize)(wl_def.ang360 - 1 - angle)]
            xpartial = r.xpartialup
            ypartial = r.ypartialup
        r.yintercept = wl_def.fixed_mul(r.ystep, xpartial) + r.viewy
        r.yinttile = r.yintercept >> wl_def.tile_shift
        r.xtile = r.focaltx + r.xtilestep
        r.xintercept = wl_def.fixed_mul(r.xstep, ypartial) + r.viewx
        r.xinttile = r.xintercept >> wl_def.tile_shift
        r.ytile = r.focalty + r.ytilestep
        var dest = vertloop
        var steps: i64 = 0
        while dest != done and steps < 256:
            steps += 1
            if dest == vertloop:
                if r.xtile - r.xtilestep == r.xinttile and r.ytile - r.ytilestep == r.yinttile:
                    r.yinttile = r.ytile
                if (r.ytilestep == -1 and r.yinttile <= r.ytile) or (r.ytilestep == 1 and r.yinttile >= r.ytile):
                    dest = horizentry
                else:
                    dest = vertentry
            elif dest == vertentry:
                if r.xtile < 0 or r.xtile >= wl_def.map_size or r.yinttile < 0 or r.yinttile >= wl_def.map_size:
                    dest = done
                    continue
                r.tilehit = game.tilemap[wl_def.cell(r.xtile, r.yinttile)]
                if r.tilehit != 0:
                    if (r.tilehit & wl_def.bit_door) != 0:
                        let doornum = (i64)(r.tilehit & ~wl_def.bit_door)
                        if doornum < 0 or doornum >= game.door_count:
                            dest = passvert
                            continue
                        let door = game.doors[(usize)doornum]
                        if door.action == wl_def.dr_open:
                            dest = passvert
                            continue
                        let yinttemp = r.yintercept + (r.ystep >> 1)
                        if yinttemp >> wl_def.tile_shift != r.yinttile:
                            dest = passvert
                            continue
                        if door.action != wl_def.dr_closed and (yinttemp & 0xffff) < door.position:
                            dest = passvert
                            continue
                        r.yintercept = yinttemp
                        r.xintercept = (r.xtile << wl_def.tile_shift) + wl_def.tile_global // 2
                        hit_vert_door(game, r)
                        dest = done
                    elif r.tilehit == wl_def.bit_wall:
                        if hit_vert_pwall(game, r):
                            dest = done
                        else:
                            dest = passvert
                            continue
                    else:
                        r.xintercept = r.xtile << wl_def.tile_shift
                        hit_vert_wall(game, r)
                        dest = done
                else:
                    dest = passvert
            elif dest == passvert:
                game.spotvis[wl_def.cell(r.xtile, r.yinttile)] = 1
                r.xtile += r.xtilestep
                r.yintercept += r.ystep
                r.yinttile = r.yintercept >> wl_def.tile_shift
                dest = vertloop
            elif dest == horizloop:
                if r.xtile - r.xtilestep == r.xinttile and r.ytile - r.ytilestep == r.yinttile:
                    r.xinttile = r.xtile
                if (r.xtilestep == -1 and r.xinttile <= r.xtile) or (r.xtilestep == 1 and r.xinttile >= r.xtile):
                    dest = vertentry
                else:
                    dest = horizentry
            elif dest == horizentry:
                if r.xinttile < 0 or r.xinttile >= wl_def.map_size or r.ytile < 0 or r.ytile >= wl_def.map_size:
                    dest = done
                    continue
                r.tilehit = game.tilemap[wl_def.cell(r.xinttile, r.ytile)]
                if r.tilehit != 0:
                    if (r.tilehit & wl_def.bit_door) != 0:
                        let doornum = (i64)(r.tilehit & ~wl_def.bit_door)
                        if doornum < 0 or doornum >= game.door_count:
                            dest = passhoriz
                            continue
                        let door = game.doors[(usize)doornum]
                        if door.action == wl_def.dr_open:
                            dest = passhoriz
                            continue
                        let xinttemp = r.xintercept + (r.xstep >> 1)
                        if xinttemp >> wl_def.tile_shift != r.xinttile:
                            dest = passhoriz
                            continue
                        if door.action != wl_def.dr_closed and (xinttemp & 0xffff) < door.position:
                            dest = passhoriz
                            continue
                        r.xintercept = xinttemp
                        r.yintercept = (r.ytile << wl_def.tile_shift) + wl_def.tile_global // 2
                        hit_horiz_door(game, r)
                        dest = done
                    elif r.tilehit == wl_def.bit_wall:
                        if hit_horiz_pwall(game, r):
                            dest = done
                        else:
                            dest = passhoriz
                            continue
                    else:
                        r.yintercept = r.ytile << wl_def.tile_shift
                        hit_horiz_wall(game, r)
                        dest = done
                else:
                    dest = passhoriz
            else:
                game.spotvis[wl_def.cell(r.xinttile, r.ytile)] = 1
                r.ytile += r.ytilestep
                r.xintercept += r.xstep
                r.xinttile = r.xintercept >> wl_def.tile_shift
                dest = horizloop

func calc_height(r: Refresh*) -> i64:
    let gx = r.xintercept - r.viewx
    let gxt = wl_def.fixed_mul(gx, r.viewcos)
    let gy = r.yintercept - r.viewy
    let gyt = wl_def.fixed_mul(gy, r.viewsin)
    var nx = gxt - gyt
    if nx < wl_def.min_dist:
        nx = wl_def.min_dist
    return r.heightnumerator // (nx >> 8)

func hit_vert_wall(game: Game*, r: Refresh*):
    var texture = ((r.yintercept - r.texdelta) >> 4) & 0xfc0
    if r.xtilestep == -1:
        texture = 0xfc0 - texture
        r.xintercept += wl_def.tile_global
    r.wallheight[(usize)r.pixx] = calc_height(r)
    var wallpic: i64 = 0
    if (r.tilehit & wl_def.bit_wall) != 0:
        let side_x = r.xtile - r.xtilestep
        if side_x >= 0 and side_x < wl_def.map_size and r.yinttile >= 0 and r.yinttile < wl_def.map_size and (game.tilemap[wl_def.cell(side_x, r.yinttile)] & wl_def.bit_door) != 0:
            wallpic = game.pages.door_wall() + 3
        else:
            wallpic = vert_wall_pic(r, (i64)(r.tilehit & ~wl_def.bit_wall))
    else:
        wallpic = vert_wall_pic(r, (i64)r.tilehit)
    finish_post(game, r, true, r.xtile, wallpic, texture)

func hit_horiz_wall(game: Game*, r: Refresh*):
    var texture = ((r.xintercept - r.texdelta) >> 4) & 0xfc0
    if r.ytilestep == -1:
        r.yintercept += wl_def.tile_global
    else:
        texture = 0xfc0 - texture
    r.wallheight[(usize)r.pixx] = calc_height(r)
    var wallpic: i64 = 0
    if (r.tilehit & wl_def.bit_wall) != 0:
        let side_y = r.ytile - r.ytilestep
        if r.xinttile >= 0 and r.xinttile < wl_def.map_size and side_y >= 0 and side_y < wl_def.map_size and (game.tilemap[wl_def.cell(r.xinttile, side_y)] & wl_def.bit_door) != 0:
            wallpic = game.pages.door_wall() + 2
        else:
            wallpic = horiz_wall_pic(r, (i64)(r.tilehit & ~wl_def.bit_wall))
    else:
        wallpic = horiz_wall_pic(r, (i64)r.tilehit)
    finish_post(game, r, false, r.ytile, wallpic, texture)

func vert_wall_pic(r: Refresh*, wall: i64) -> i64:
    var w = wall
    if w <= 0 or w >= wl_def.max_wall_tiles:
        w = 1
    return r.vertwall[(usize)w]

func horiz_wall_pic(r: Refresh*, wall: i64) -> i64:
    var w = wall
    if w <= 0 or w >= wl_def.max_wall_tiles:
        w = 1
    return r.horizwall[(usize)w]

## WL_DRAW.C HitVertDoor — texture = ((word)yintercept - doorposition) >> 4
func hit_vert_door(game: Game*, r: Refresh*):
    let doornum = (i64)(r.tilehit & ~wl_def.bit_door)
    var pos: i64 = 0
    if doornum >= 0 and doornum < game.door_count:
        pos = game.doors[(usize)doornum].position
    let texture = door_texture(r.yintercept, pos)
    r.wallheight[(usize)r.pixx] = calc_height(r)
    finish_post(game, r, true, r.xtile, door_pic(game, doornum, true), texture)

## WL_DRAW.C HitHorizDoor
func hit_horiz_door(game: Game*, r: Refresh*):
    let doornum = (i64)(r.tilehit & ~wl_def.bit_door)
    var pos: i64 = 0
    if doornum >= 0 and doornum < game.door_count:
        pos = game.doors[(usize)doornum].position
    let texture = door_texture(r.xintercept, pos)
    r.wallheight[(usize)r.pixx] = calc_height(r)
    finish_post(game, r, false, r.ytile, door_pic(game, doornum, false), texture)

func door_texture(intercept: i64, position: i64) -> i64:
    let frac = intercept & 0xffff
    var delta = frac - (position & 0xffff)
    if delta < 0:
        delta += 0x10000
    return (delta >> 4) & 0xfc0

func door_pic(game: Game*, doornum: i64, vertical: bool) -> i64:
    var page = game.pages.door_wall()
    if vertical:
        page += 1
    var lock: i64 = 0
    if doornum >= 0 and doornum < game.door_count:
        lock = game.doors[(usize)doornum].lock
    if lock >= 1 and lock <= 4:
        page += 6
    elif lock == 5:
        page += 4
    return page

## Wolf4SDL WallRefresh sliding vertical pushwall. true = drew, false = passvert.
func hit_vert_pwall(game: Game*, r: Refresh*) -> bool:
    let pwalldir = game.pwalldir
    let pwallpos = game.pwallpos
    if pwalldir == wl_def.west or pwalldir == wl_def.east:
        var pwallposnorm = pwallpos
        var pwallposinv = 64 - pwallpos
        if pwalldir == wl_def.west:
            pwallposnorm = 64 - pwallpos
            pwallposinv = pwallpos
        let at_pwall = r.xtile == game.pwallx and r.yinttile == game.pwally
        if (pwalldir == wl_def.east and at_pwall) or (pwalldir == wl_def.west and not at_pwall):
            let yinttemp = r.yintercept + ((r.ystep * pwallposnorm) >> 6)
            if yinttemp >> wl_def.tile_shift != r.yinttile:
                return false
            r.yintercept = yinttemp
            r.xintercept = ((r.xtile << wl_def.tile_shift) + wl_def.tile_global) - (pwallposinv << 10)
            r.yinttile = r.yintercept >> wl_def.tile_shift
            r.tilehit = (u8)game.pwalltile
            hit_vert_wall(game, r)
            return true
        let yinttemp = r.yintercept + ((r.ystep * pwallposinv) >> 6)
        if yinttemp >> wl_def.tile_shift != r.yinttile:
            return false
        r.yintercept = yinttemp
        r.xintercept = (r.xtile << wl_def.tile_shift) - (pwallposinv << 10)
        r.yinttile = r.yintercept >> wl_def.tile_shift
        r.tilehit = (u8)game.pwalltile
        hit_vert_wall(game, r)
        return true
    var pwallposi = pwallpos
    if pwalldir == wl_def.north:
        pwallposi = 64 - pwallpos
    let yword = r.yintercept & 0xffff
    let edge = pwallposi << 10
    if (pwalldir == wl_def.south and yword < edge) or (pwalldir == wl_def.north and yword > edge):
        if r.xtile == game.pwallx and r.yinttile == game.pwally:
            if (pwalldir == wl_def.south and yword + r.ystep < edge) or (pwalldir == wl_def.north and yword + r.ystep > edge):
                return false
            if pwalldir == wl_def.south:
                r.yintercept = (r.yinttile << wl_def.tile_shift) + edge
            else:
                r.yintercept = ((r.yinttile << wl_def.tile_shift) - wl_def.tile_global) + edge
            r.xintercept -= (r.xstep * (64 - pwallpos)) >> 6
            r.xinttile = r.xintercept >> wl_def.tile_shift
            r.tilehit = (u8)game.pwalltile
            hit_horiz_wall(game, r)
            return true
        r.texdelta = edge
        r.xintercept = r.xtile << wl_def.tile_shift
        r.tilehit = (u8)game.pwalltile
        hit_vert_wall(game, r)
        return true
    if r.xtile == game.pwallx and r.yinttile == game.pwally:
        r.texdelta = edge
        r.xintercept = r.xtile << wl_def.tile_shift
        r.tilehit = (u8)game.pwalltile
        hit_vert_wall(game, r)
        return true
    if (pwalldir == wl_def.south and yword + r.ystep > edge) or (pwalldir == wl_def.north and yword + r.ystep < edge):
        return false
    if pwalldir == wl_def.south:
        r.yintercept = (r.yinttile << wl_def.tile_shift) - ((64 - pwallpos) << 10)
    else:
        r.yintercept = (r.yinttile << wl_def.tile_shift) + ((64 - pwallpos) << 10)
    r.xintercept -= (r.xstep * pwallpos) >> 6
    r.xinttile = r.xintercept >> wl_def.tile_shift
    r.tilehit = (u8)game.pwalltile
    hit_horiz_wall(game, r)
    return true

func hit_horiz_pwall(game: Game*, r: Refresh*) -> bool:
    let pwalldir = game.pwalldir
    let pwallpos = game.pwallpos
    if pwalldir == wl_def.north or pwalldir == wl_def.south:
        var pwallposnorm = pwallpos
        var pwallposinv = 64 - pwallpos
        if pwalldir == wl_def.north:
            pwallposnorm = 64 - pwallpos
            pwallposinv = pwallpos
        let at_pwall = r.xinttile == game.pwallx and r.ytile == game.pwally
        if (pwalldir == wl_def.south and at_pwall) or (pwalldir == wl_def.north and not at_pwall):
            let xinttemp = r.xintercept + ((r.xstep * pwallposnorm) >> 6)
            if xinttemp >> wl_def.tile_shift != r.xinttile:
                return false
            r.xintercept = xinttemp
            r.yintercept = ((r.ytile << wl_def.tile_shift) + wl_def.tile_global) - (pwallposinv << 10)
            r.xinttile = r.xintercept >> wl_def.tile_shift
            r.tilehit = (u8)game.pwalltile
            hit_horiz_wall(game, r)
            return true
        let xinttemp = r.xintercept + ((r.xstep * pwallposinv) >> 6)
        if xinttemp >> wl_def.tile_shift != r.xinttile:
            return false
        r.xintercept = xinttemp
        r.yintercept = (r.ytile << wl_def.tile_shift) - (pwallposinv << 10)
        r.xinttile = r.xintercept >> wl_def.tile_shift
        r.tilehit = (u8)game.pwalltile
        hit_horiz_wall(game, r)
        return true
    var pwallposi = pwallpos
    if pwalldir == wl_def.west:
        pwallposi = 64 - pwallpos
    let xword = r.xintercept & 0xffff
    let edge = pwallposi << 10
    if (pwalldir == wl_def.east and xword < edge) or (pwalldir == wl_def.west and xword > edge):
        if r.xinttile == game.pwallx and r.ytile == game.pwally:
            if (pwalldir == wl_def.east and xword + r.xstep < edge) or (pwalldir == wl_def.west and xword + r.xstep > edge):
                return false
            r.yintercept -= (r.ystep * (64 - pwallpos)) >> 6
            r.yinttile = r.yintercept >> wl_def.tile_shift
            if pwalldir == wl_def.east:
                r.xintercept = (r.xinttile << wl_def.tile_shift) + edge
            else:
                r.xintercept = ((r.xinttile << wl_def.tile_shift) - wl_def.tile_global) + edge
            r.tilehit = (u8)game.pwalltile
            hit_vert_wall(game, r)
            return true
        r.texdelta = edge
        r.yintercept = r.ytile << wl_def.tile_shift
        r.tilehit = (u8)game.pwalltile
        hit_horiz_wall(game, r)
        return true
    if r.xinttile == game.pwallx and r.ytile == game.pwally:
        r.texdelta = edge
        r.yintercept = r.ytile << wl_def.tile_shift
        r.tilehit = (u8)game.pwalltile
        hit_horiz_wall(game, r)
        return true
    if (pwalldir == wl_def.east and xword + r.xstep > edge) or (pwalldir == wl_def.west and xword + r.xstep < edge):
        return false
    r.yintercept -= (r.ystep * pwallpos) >> 6
    r.yinttile = r.yintercept >> wl_def.tile_shift
    if pwalldir == wl_def.east:
        r.xintercept = (r.xinttile << wl_def.tile_shift) - ((64 - pwallpos) << 10)
    else:
        r.xintercept = (r.xinttile << wl_def.tile_shift) + ((64 - pwallpos) << 10)
    r.tilehit = (u8)game.pwalltile
    hit_vert_wall(game, r)
    return true

func finish_post(game: Game*, r: Refresh*, vertical: bool, intercept: i64, pic: i64, texture: i64):
    _ = vertical
    _ = intercept
    r.postx = r.pixx
    r.postwidth = 1
    r.postpic = pic
    r.postoff = texture
    scale_post(game, r)

func scale_post(game: Game*, r: Refresh*):
    if r.postwidth <= 0 or r.postx < 0:
        return
    let page = game.pages.wall(r.postpic) else return
    var ywcount = r.wallheight[(usize)r.postx] >> 3
    var yd = ywcount
    if yd <= 0:
        yd = 100
    let centery = wl_def.view_height // 2
    var yoffs = centery - ywcount
    if yoffs < 0:
        yoffs = 0
    var yendoffs = centery + ywcount - 1
    var yw = wl_def.texture_size - 1
    while yendoffs >= wl_def.view_height:
        ywcount -= wl_def.texture_size // 2
        while ywcount <= 0:
            ywcount += yd
            yw -= 1
        yendoffs -= 1
    if yw < 0:
        return
    let src = (usize)r.postoff + (usize)yw
    var col: u8 = 0
    if src < page.length:
        col = page[src]
    let x = r.postx
    if x < 0 or x >= wl_def.view_width:
        return
    while yoffs <= yendoffs:
        r.vbuf[(usize)(yendoffs * wl_def.view_width + x)] = col
        ywcount -= wl_def.texture_size // 2
        if ywcount <= 0:
            while ywcount <= 0:
                ywcount += yd
                yw -= 1
            if yw < 0:
                break
            let src2 = (usize)r.postoff + (usize)yw
            if src2 < page.length:
                col = page[src2]
        yendoffs -= 1

struct Vis:
    var viewx: i64
    var viewheight: i64
    var shapenum: i64

func draw_scaleds(game: Game*, r: Refresh*):
    ## WL_DRAW.C DrawScaleds — collect, then draw farthest (smallest viewheight) first.
    var vis: Vis[50]
    var n: i64 = 0
    for i in 0..<game.static_count:
        let obj = game.statics[(usize)i]
        if obj.shapenum < 0:
            continue
        if game.spotvis[wl_def.cell(obj.tilex, obj.tiley)] == 0:
            continue
        let proj = project_tile(r, obj.tilex, obj.tiley)
        if proj.viewheight == 0:
            continue
        if n < wl_def.max_visable:
            vis[(usize)n] = Vis(viewx = proj.viewx, viewheight = proj.viewheight, shapenum = obj.shapenum)
            n += 1
    for i in 0..<game.actor_count:
        let actor = &game.actors[(usize)i]
        if let st = actor.state:
            if st.shapenum <= 0:
                actor.flags = actor.flags & ~wl_def.fl_visable
                continue
            if not tile_spotted(game, actor.tilex, actor.tiley):
                actor.flags = actor.flags & ~wl_def.fl_visable
                continue
            transform_actor(r, actor)
            if actor.viewheight == 0:
                actor.flags = actor.flags & ~wl_def.fl_visable
                continue
            actor.flags = actor.flags | wl_def.fl_visable
            var shape = st.shapenum
            if st.rotate != 0:
                shape += calc_rotate(game, game.actors[(usize)i], st.rotate)
            if n < wl_def.max_visable:
                vis[(usize)n] = Vis(viewx = actor.viewx, viewheight = actor.viewheight, shapenum = shape)
                n += 1
        else:
            actor.flags = actor.flags & ~wl_def.fl_visable
    var left = n
    while left > 0:
        var farthest: i64 = 0
        var least = vis[0].viewheight
        var v: i64 = 1
        while v < left:
            if vis[(usize)v].viewheight < least:
                least = vis[(usize)v].viewheight
                farthest = v
            v += 1
        let draw = vis[(usize)farthest]
        scale_shape(game, r, draw.viewx, draw.shapenum, draw.viewheight)
        left -= 1
        vis[(usize)farthest] = vis[(usize)left]

func project_tile(r: Refresh*, tilex: i64, tiley: i64) -> Vis:
    let gx = (tilex << wl_def.tile_shift) + wl_def.tile_global // 2 - r.viewx
    let gy = (tiley << wl_def.tile_shift) + wl_def.tile_global // 2 - r.viewy
    let gxt = wl_def.fixed_mul(gx, r.viewcos)
    let gyt = wl_def.fixed_mul(gy, r.viewsin)
    var nx = gxt - gyt - 0x2000
    let ny = wl_def.fixed_mul(gx, r.viewsin) + wl_def.fixed_mul(gy, r.viewcos)
    if nx < wl_def.min_dist:
        return Vis()
    return Vis(viewx = wl_def.view_width // 2 + ny * r.scale // nx,
               viewheight = r.heightnumerator // (nx >> 8))

func tile_spotted(game: Game*, tilex: i64, tiley: i64) -> bool:
    var dx: i64 = -1
    while dx <= 1:
        var dy: i64 = -1
        while dy <= 1:
            let x = tilex + dx
            let y = tiley + dy
            if x >= 0 and y >= 0 and x < wl_def.map_size and y < wl_def.map_size:
                if game.spotvis[wl_def.cell(x, y)] != 0:
                    return true
            dy += 1
        dx += 1
    return false

## WL_DRAW.C TransformActor
func transform_actor(r: Refresh*, actor: Actor*):
    let gx = actor.x - r.viewx
    let gy = actor.y - r.viewy
    let gxt = wl_def.fixed_mul(gx, r.viewcos)
    let gyt = wl_def.fixed_mul(gy, r.viewsin)
    var nx = gxt - gyt - wl_def.actor_size
    let ny = wl_def.fixed_mul(gx, r.viewsin) + wl_def.fixed_mul(gy, r.viewcos)
    actor.transx = nx
    if nx < wl_def.min_dist:
        actor.viewheight = 0
        return
    actor.viewx = wl_def.view_width // 2 + ny * r.scale // nx
    actor.viewheight = r.heightnumerator // (nx >> 8)

func calc_rotate(game: Game*, actor: Actor, rotate: i64) -> i64:
    ## WL_DRAW.C CalcRotate. dirangle[dir] = dir*45 with east=0.
    ## rotate==2 is the 2-way pain layout (PAIN_1 and PAIN_2 are 4 shapes apart).
    var viewangle = game.player.angle + (wl_def.view_width // 2 - actor.viewx) // 8
    var angle = viewangle - 180
    if actor.dir != wl_def.nodir:
        angle = viewangle - 180 - actor.dir * 45
    angle += wl_def.angles // 16
    while angle >= wl_def.angles:
        angle -= wl_def.angles
    while angle < 0:
        angle += wl_def.angles
    if rotate == 2:
        return 4 * (angle // (wl_def.angles // 2))
    return angle // (wl_def.angles // 8)

func draw_sprite(game: Game*, r: Refresh*, tilex: i64, tiley: i64, shapenum: i64, tile_center: bool):
    let gx = (tilex << wl_def.tile_shift) + wl_def.tile_global // 2 - r.viewx
    let gy = (tiley << wl_def.tile_shift) + wl_def.tile_global // 2 - r.viewy
    let gxt = wl_def.fixed_mul(gx, r.viewcos)
    let gyt = wl_def.fixed_mul(gy, r.viewsin)
    var nx = gxt - gyt - 0x2000
    let nx2 = wl_def.fixed_mul(gx, r.viewsin) + wl_def.fixed_mul(gy, r.viewcos)
    if nx < wl_def.min_dist:
        return
    let height = r.heightnumerator // (nx >> 8)
    let viewx = wl_def.view_width // 2 + nx2 * r.scale // nx
    scale_shape(game, r, viewx, shapenum, height)
    _ = tile_center

func scale_shape(game: Game*, r: Refresh*, xcenter: i64, shapenum: i64, height: i64):
    let scale = height >> 3
    if scale <= 0:
        return
    let linesrc = game.pages.sprite(shapenum) else return
    if linesrc.length < 8:
        return
    var leftpix = (i64)wl_def.u16le(linesrc, 0)
    var rightpix = (i64)wl_def.u16le(linesrc, 2)
    if leftpix < 0:
        leftpix = 0
    if rightpix > 63:
        rightpix = 63
    if leftpix > rightpix:
        return
    let fracstep = (scale << 16) // 32
    if fracstep <= 0:
        return
    var frac = leftpix * fracstep
    let actx = xcenter - scale
    let toppix = wl_def.view_height // 2 - scale
    var x2 = (frac >> 16) + actx
    var i = leftpix
    while i <= rightpix:
        let x1 = x2
        frac += fracstep
        x2 = (frac >> 16) + actx
        if x1 >= wl_def.view_width:
            break
        if x2 >= 0:
            var xa = x1
            if xa < 0:
                xa = 0
            var xb = x2
            if xb > wl_def.view_width:
                xb = wl_def.view_width
            let idx = (usize)((i - leftpix) * 2 + 4)
            if idx + 1 < linesrc.length:
                let cmd = (usize)wl_def.u16le(linesrc, idx)
                var x = xa
                while x < xb:
                    if x >= 0 and x < wl_def.view_width and r.wallheight[(usize)x] < height:
                        scale_line(r, x, toppix, fracstep, linesrc, cmd)
                    x += 1
        i += 1

## WL_SCALE.C ScaleLine — end/start are signed pixel*2; 0 terminates the column.
func i16le(data: const u8[], off: usize) -> i64:
    let u = (i64)wl_def.u16le(data, off)
    if u >= 32768:
        return u - 65536
    return u

func scale_line(r: Refresh*, x: i64, toppix: i64, fracstep: i64, linesrc: const u8[], cmd: usize):
    var off = cmd
    var segs: i64 = 0
    while off + 5 < linesrc.length and segs < 64:
        segs += 1
        let endy = i16le(linesrc, off) >> 1
        if endy == 0:
            return
        let top = i16le(linesrc, off + 2)
        var pix = i16le(linesrc, off + 4) >> 1
        if pix < 0:
            pix = 0
        var frac = pix * fracstep
        var steps: i64 = 0
        while pix != endy and steps < 64:
            steps += 1
            let startpix = (frac >> 16) + toppix
            frac += fracstep
            var endpix = (frac >> 16) + toppix
            if startpix < wl_def.view_height and endpix > 0:
                var a = startpix
                if a < 0:
                    a = 0
                var b = endpix
                if b > wl_def.view_height:
                    b = wl_def.view_height
                let src = top + pix
                if src >= 0 and src < (i64)linesrc.length:
                    let col = linesrc[(usize)src]
                    var y = a
                    while y < b:
                        r.vbuf[(usize)(y * wl_def.view_width + x)] = col
                        y += 1
            if pix < endy:
                pix += 1
            else:
                pix -= 1
        off += 6

func draw_weapon(game: Game*, r: Refresh*):
    ## WL_DRAW.C DrawPlayerWeapon / weaponscale[]
    var ready = wl_def.spr_knife_ready
    if game.weapon == wl_def.wp_pistol:
        ready = wl_def.spr_pistolready
    elif game.weapon == wl_def.wp_machinegun:
        ready = wl_def.spr_machinegun_ready
    elif game.weapon == wl_def.wp_chaingun:
        ready = wl_def.spr_chain_ready
    var frame = game.weaponframe
    if frame < 0:
        frame = 0
    if frame > 4:
        frame = 4
    simple_scale_shape(game, r, wl_def.view_width // 2, ready + frame, wl_def.view_height + 1)

func simple_scale_shape(game: Game*, r: Refresh*, xcenter: i64, shapenum: i64, height: i64):
    let scale = height >> 1
    if scale <= 0:
        return
    let linesrc = game.pages.sprite(shapenum) else return
    if linesrc.length < 8:
        return
    var leftpix = (i64)wl_def.u16le(linesrc, 0)
    var rightpix = (i64)wl_def.u16le(linesrc, 2)
    if leftpix < 0:
        leftpix = 0
    if rightpix > 63:
        rightpix = 63
    if leftpix > rightpix:
        return
    let fracstep = (scale << 16) // 32
    if fracstep <= 0:
        return
    var frac = leftpix * fracstep
    let actx = xcenter - scale
    let toppix = wl_def.view_height // 2 - scale
    var x2 = (frac >> 16) + actx
    var i = leftpix
    while i <= rightpix:
        let x1 = x2
        frac += fracstep
        x2 = (frac >> 16) + actx
        var x = x1
        while x < x2:
            if x >= 0 and x < wl_def.view_width:
                let idx = (usize)((i - leftpix) * 2 + 4)
                if idx + 1 < linesrc.length:
                    let cmd = (usize)wl_def.u16le(linesrc, idx)
                    scale_line(r, x, toppix, fracstep, linesrc, cmd)
            x += 1
        i += 1

## WL_GAME.C DrawPlayScreen — status bar is latched in DOS; we composite into vbuf.
func draw_play_screen(game: Game*, r: Refresh*):
    vwb_draw_pic(r, 0, wl_def.screen_height - wl_def.status_lines, &game.statusbar)
    draw_face(game, r)
    latch_number(game, r, 21, 16, 3, game.health)
    latch_number(game, r, 14, 16, 1, game.lives)
    latch_number(game, r, 2, 16, 2, game.mapon + 1)
    latch_number(game, r, 27, 16, 2, game.ammo)
    latch_number(game, r, 6, 16, 6, game.score)
    status_draw_pic(game, r, 32, 8, wl_def.knife_pic + game.weapon)
    if (game.keys & 1) != 0:
        status_draw_pic(game, r, 30, 4, wl_def.gold_key_pic)
    else:
        status_draw_pic(game, r, 30, 4, wl_def.no_key_pic)
    if (game.keys & 2) != 0:
        status_draw_pic(game, r, 30, 20, wl_def.silver_key_pic)
    else:
        status_draw_pic(game, r, 30, 20, wl_def.no_key_pic)

func draw_face(game: Game*, r: Refresh*):
    if game.gatling_face > 0:
        status_draw_pic(game, r, 17, 4, wl_def.got_gatling_pic)
    elif game.health > 0:
        var face = 100 - game.health
        if face < 0:
            face = 0
        status_draw_pic(game, r, 17, 4, wl_def.face1a_pic + 3 * (face // 16) + game.faceframe)
    else:
        status_draw_pic(game, r, 17, 4, wl_def.face8a_pic)

func latch_number(game: Game*, r: Refresh*, x: i64, y: i64, width: i64, number: i64):
    var n = number
    if n < 0:
        n = 0
    var digits: i64[12]
    var length: i64 = 0
    if n == 0:
        digits[0] = 0
        length = 1
    else:
        var rev: i64[12]
        var rl: i64 = 0
        var tmp = n
        while tmp > 0:
            rev[(usize)rl] = tmp % 10
            rl += 1
            tmp = tmp // 10
        var i: i64 = 0
        while i < rl:
            digits[(usize)i] = rev[(usize)(rl - 1 - i)]
            i += 1
        length = rl
    var cx = x
    var w = width
    while length < w:
        status_draw_pic(game, r, cx, y, wl_def.n_blank_pic)
        cx += 1
        w -= 1
    var index = 0 if length <= w else length - w
    while index < length:
        status_draw_pic(game, r, cx, y, wl_def.n_0_pic + digits[(usize)index])
        cx += 1
        index += 1

func status_draw_pic(game: Game*, r: Refresh*, x: i64, y: i64, chunk: i64):
    vwb_draw_pic(r, x * 8, wl_def.screen_height - wl_def.status_lines + y, wl_types.latch_pic(game, chunk))

pub func vwb_bar(r: Refresh*, x: i64, y: i64, w: i64, h: i64, color: u8):
    var row = y
    while row < y + h:
        var col = x
        while col < x + w:
            plot(r, col, row, color)
            col += 1
        row += 1

pub func vwb_hlin(r: Refresh*, x1: i64, x2: i64, y: i64, color: u8):
    var x = x1
    while x <= x2:
        plot(r, x, y, color)
        x += 1

pub func vwb_vlin(r: Refresh*, y1: i64, y2: i64, x: i64, color: u8):
    var y = y1
    while y <= y2:
        plot(r, x, y, color)
        y += 1

pub func vwb_pic(r: Refresh*, x: i64, y: i64, pic: id_graph.Pic*):
    vwb_draw_pic(r, x, y, pic)

func plot(r: Refresh*, x: i64, y: i64, color: u8):
    if x < 0 or y < 0 or x >= wl_def.view_width or y >= wl_def.screen_height:
        return
    r.vbuf[(usize)(y * wl_def.view_width + x)] = color

pub func draw_outline(r: Refresh*, x: i64, y: i64, w: i64, h: i64, c1: u8, c2: u8):
    vwb_hlin(r, x, x + w, y, c2)
    vwb_vlin(r, y, y + h, x, c2)
    vwb_hlin(r, x, x + w, y + h, c1)
    vwb_vlin(r, y, y + h, x + w, c1)

pub func draw_window(r: Refresh*, x: i64, y: i64, w: i64, h: i64, fill: u8):
    vwb_bar(r, x, y, w, h, fill)
    draw_outline(r, x, y, w, h, wl_def.bord2_color, wl_def.deactive_color)

pub func font_height(font: id_graph.Pic*) -> i64:
    if font.pixels.length < 2:
        return 8
    return (i64)wl_def.u16le(font.pixels, 0)

pub func font_width(font: id_graph.Pic*, ch: i64) -> i64:
    let off = 514 + ch
    if ch < 0 or ch > 255 or off >= (i64)font.pixels.length:
        return 0
    return (i64)font.pixels[(usize)off]

pub func draw_char(r: Refresh*, font: id_graph.Pic*, x: i64, y: i64, ch: i64, color: u8) -> i64:
    let w = font_width(font, ch)
    let h = font_height(font)
    if w <= 0 or font.pixels.length < 4:
        return w
    let loc = (i64)wl_def.u16le(font.pixels, (usize)(2 + ch * 2))
    var col: i64 = 0
    while col < w:
        var row: i64 = 0
        while row < h:
            let src = loc + row * w + col
            if src >= 0 and src < (i64)font.pixels.length and font.pixels[(usize)src] != 0:
                plot(r, x + col, y + row, color)
            row += 1
        col += 1
    return w

pub func draw_text(r: Refresh*, font: id_graph.Pic*, x: i64, y: i64, text: const u8[], color: u8) -> i64:
    var cx = x
    var cy = y
    var i: usize = 0
    while i < text.length:
        let ch = (i64)text[i]
        if ch == 10:
            cx = x
            cy += font_height(font)
        else:
            cx += draw_char(r, font, cx, cy, ch, color)
        i += 1
    return cx

pub func measure_text(font: id_graph.Pic*, text: const u8[]) -> i64:
    var w: i64 = 0
    var i: usize = 0
    while i < text.length:
        w += font_width(font, (i64)text[i])
        i += 1
    return w

## WL_MENU.C Message() string size: max line width (last line +10) and stacked font height.
pub func measure_message(font: id_graph.Pic*, text: const u8[]) -> (i64, i64):
    var h = font_height(font)
    var w: i64 = 0
    var mw: i64 = 0
    var i: usize = 0
    while i < text.length:
        let ch = (i64)text[i]
        if ch == 10:
            if w > mw:
                mw = w
            w = 0
            h += font_height(font)
        else:
            w += font_width(font, ch)
        i += 1
    if w + 10 > mw:
        mw = w + 10
    return (mw, h)

func vwb_draw_pic(r: Refresh*, x: i64, y: i64, pic: id_graph.Pic*):
    if pic.pixels.length == 0 or pic.width <= 0 or pic.height <= 0:
        return
    let px = x & ~7
    let py = y
    var row: i64 = 0
    while row < pic.height:
        var col: i64 = 0
        while col < pic.width:
            let sx = px + col
            let sy = py + row
            if sx >= 0 and sx < wl_def.view_width and sy >= 0 and sy < wl_def.screen_height:
                let src = (usize)(row * pic.width + col)
                if src < pic.pixels.length:
                    r.vbuf[(usize)(sy * wl_def.view_width + sx)] = pic.pixels[src]
            col += 1
        row += 1

pub func write_ppm(r: Refresh*, path: str) -> !:
    var out: u8[192128]
    let header = b"P6\n320 200\n255\n"
    var n: usize = 0
    for b in header:
        out[n] = b
        n += 1
    for y in 0..<wl_def.screen_height:
        for x in 0..<wl_def.view_width:
            let i = (usize)r.vbuf[(usize)(y * wl_def.view_width + x)] * 3
            out[n] = (u8)((u16)pal.pal[i] * 255 // 63)
            out[n + 1] = (u8)((u16)pal.pal[i + 1] * 255 // 63)
            out[n + 2] = (u8)((u16)pal.pal[i + 2] * 255 // 63)
            n += 3
    try files.write((c.str)path, out[0..<n])

pub func fill_screen(r: Refresh*, color: u8):
    var i: usize = 0
    while i < 64000:
        r.vbuf[i] = color
        i += 1

func ensure_vga_lut(r: Refresh*):
    if r.vga_ready:
        return
    ## gpu.Color is linear-light sRGB. VGA DAC bytes are CRT/sRGB-encoded 0..63.
    var i: i64 = 0
    while i < 64:
        let eight = (i * 4) | (i // 16)
        let s = (f64)eight / 255.0
        var lin = 0.0
        if s <= 0.04045:
            lin = s / 12.92
        else:
            lin = math.pow((s + 0.055) / 1.055, 2.4)
        r.vga_lin[(usize)i] = lin
        i += 1
    r.vga_ready = true

func vga_channel(r: Refresh*, dac: u8, fade: i64) -> f64:
    var i = (i64)dac
    if i < 0:
        i = 0
    if i > 63:
        i = 63
    var lin = r.vga_lin[(usize)i]
    if fade != 10:
        lin = lin * (f64)fade / 10.0
    if lin < 0.0:
        lin = 0.0
    if lin > 1.0:
        lin = 1.0
    return lin

pub func present(r: Refresh*, raster: ui.Raster*, fade: i64) -> !:
    ensure_vga_lut(r)
    var f = fade
    if f < 0:
        f = 0
    if f > 10:
        f = 10
    for y in 0..<wl_def.screen_height:
        for x in 0..<wl_def.view_width:
            let i = (usize)r.vbuf[(usize)(y * wl_def.view_width + x)] * 3
            let red = vga_channel(r, pal.pal[i], f)
            let green = vga_channel(r, pal.pal[i + 1], f)
            let blue = vga_channel(r, pal.pal[i + 2], f)
            try raster.put((usize)(y * wl_def.view_width + x), gpu.Color(red, green, blue))

func blit(r: Refresh*, raster: ui.Raster*) -> !:
    try present(r, raster, 10)