Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-demo-wolf3d

Source of release 0.4.1

0.4.1 / src / game.lucb

## luce-ui widget hosting the Wolf3D play loop.
from luce_gpu import gpu
from luce_window import input
import interop
import memory
import ownership
from luce_ui import ui
from luce_ui.ui import Widget, Layout, Size, Constraints, Event, Painter, Raster, Font
import wl_def
import wl_play
import wl_draw
import wl_menu
import wl_game
import id_sd
from wl_types import Game, Buttons

pub struct GameView: Widget:
    let box: interop.Reference[Layout]
    var raster: Raster
    var game: Game
    var refresh: wl_draw.Refresh
    var buttons: Buttons
    let font: interop.Reference[Font]

    pub func init(head_path: str, maps_path: str, vswap_path: str) -> !:
        let box = try interop.Reference[Layout].adopt(new Layout() in memory.heap, ui.layout_type, memory.heap)
        errdefer box.release()
        try box.value().set_limits(Size(320.0, 200.0), Size(16384.0, 16384.0))
        try box.value().set_flex()
        box.value().set_focusable(true)
        box.value().request_focus()
        var raster = try Raster(wl_def.view_width, wl_def.screen_height)
        errdefer raster.close()
        let font = try interop.Reference[Font].adopt(new Font(size = 16.0) in memory.heap, ui.font_type, memory.heap)
        errdefer font.release()
        self.box = box
        self.raster = raster
        self.game = try wl_game.load_game(head_path, maps_path, vswap_path)
        self.refresh = wl_draw.Refresh()
        self.buttons = Buttons()
        self.font = font
        wl_menu.tick(&self.game, &self.refresh, self.buttons, 0.0)
        try wl_draw.present(&self.refresh, &self.raster, self.game.fade)

    pub func layout() -> interop.Reference[Layout]:
        return self.box.clone()

    pub func measure(available: Constraints) -> interop.Outcome[Size]:
        _ = available
        return interop.Outcome[Size].success(interop.Owned[Size](Size()))

    pub func draw(target: interop.View[gpu.RenderTarget]) -> interop.Outcome[unit]:
        self.paint(target) catch failure:
            return fail_unit(failure.code, failure.message)
        return ok_unit()

    pub func event(event: Event) -> interop.Outcome[unit]:
        if event.cancelled:
            self.buttons = Buttons()
            return ok_unit()
        if event.kind == input.EventKind.key_down or event.kind == input.EventKind.key_up:
            apply_key(&self.buttons, event.key, event.kind == input.EventKind.key_down, event.repeated)
        elif event.kind == input.EventKind.modifiers_changed:
            apply_modifiers(&self.buttons, event)
        elif event.kind == input.EventKind.text_input and event.codepoint == 32:
            self.buttons.use = true
            self.buttons.use_edge = true
        elif event.kind == input.EventKind.pointer_down and event.button == 0:
            if self.game.mode == wl_def.mode_game:
                if not self.buttons.attack:
                    self.buttons.attack_edge = true
                self.buttons.attack = true
        elif event.kind == input.EventKind.pointer_up and event.button == 0:
            self.buttons.attack = false
        return ok_unit()

    pub func tick(elapsed: f64) -> !:
        if self.game.mode == wl_def.mode_game:
            if self.buttons.escape_edge:
                self.game.mode = wl_def.mode_menu
                self.game.ingame = true
                self.game.menu_cur = 0
                self.game.fade = 0
                id_sd.start_music(&self.game.mixer, &self.game.audio, wl_def.mus_wonderin)
            elif self.buttons.pause:
                self.game.mode = wl_def.mode_pause
                self.game.fade = 10
            else:
                wl_play.simulate(&self.game, self.buttons, elapsed)
        if self.game.mode == wl_def.mode_game:
            try wl_draw.three_d_refresh(&self.game, &self.refresh, &self.raster)
        else:
            wl_menu.tick(&self.game, &self.refresh, self.buttons, elapsed)
            try wl_draw.present(&self.refresh, &self.raster, self.game.fade)
        self.buttons.attack_edge = false
        self.buttons.use_edge = false
        self.buttons.enter_edge = false
        self.buttons.escape_edge = false
        self.buttons.any_key = false
        self.buttons.pause = false
        self.box.value().invalidate()

    func paint(target: interop.View[gpu.RenderTarget]) -> !:
        var painter = try Painter(target)
        defer painter.close()
        let size = try target.get().size()
        try painter.rectangle(gpu.Rect(width = size.width, height = size.height), gpu.Color())
        try self.raster.draw(target, gpu.Rect(width = size.width, height = size.height))

    pub func close():
        self.game.close()
        self.font.release()
        self.raster.close()
        self.box.release()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        self.box.trace(visit, context)
        self.font.trace(visit, context)

    pub func wants_quit() -> bool:
        return self.game.want_quit

pub let game_view_type: interop.Type[GameView] = interop.Type[GameView]("Wolf3D view", GameView.close, GameView.trace, closeable = true, main_thread = true)

func apply_modifiers(buttons: Buttons*, event: Event):
    if event.control and not buttons.attack:
        buttons.attack_edge = true
    buttons.attack = event.control
    buttons.run = event.shift
    buttons.strafe = event.alt

func apply_key(buttons: Buttons*, key: input.Key, down: bool, repeated: bool):
    if down:
        buttons.any_key = true
    if key == input.Key.w or key == input.Key.up:
        buttons.forward = down
    elif key == input.Key.s or key == input.Key.down:
        buttons.back = down
    elif key == input.Key.a or key == input.Key.left:
        buttons.turn_left = down
    elif key == input.Key.d or key == input.Key.right:
        buttons.turn_right = down
    elif key == input.Key.left_shift or key == input.Key.right_shift:
        buttons.run = down
    elif key == input.Key.left_alt or key == input.Key.right_alt:
        buttons.strafe = down
    elif key == input.Key.left_control or key == input.Key.right_control:
        if down and not buttons.attack:
            buttons.attack_edge = true
        buttons.attack = down
    elif key == input.Key.space:
        if down and not buttons.use:
            buttons.use_edge = true
        buttons.use = down
    elif key == input.Key.digit_1:
        buttons.ready_knife = down
    elif key == input.Key.digit_2:
        buttons.ready_pistol = down
    elif key == input.Key.digit_3:
        buttons.ready_machine = down
    elif key == input.Key.digit_4:
        buttons.ready_chain = down
    elif key == input.Key.enter:
        if down and not buttons.enter:
            buttons.enter_edge = true
        buttons.enter = down
    elif key == input.Key.escape:
        if down and not buttons.escape:
            buttons.escape_edge = true
        buttons.escape = down
    elif key == input.Key.p:
        if down:
            buttons.pause = true
    elif key == input.Key.y:
        buttons.yes = down
    elif key == input.Key.n:
        buttons.no = down

func ok_unit() -> interop.Outcome[unit]:
    return interop.Outcome[unit].success(interop.Owned[unit](()))

func fail_unit(code: ErrorCode, message: str) -> interop.Outcome[unit]:
    let text = interop.copy_text(message) catch exhausted:
        return interop.Outcome[unit].failure(memory.exhausted, interop.Owned[str]("out of memory copying a UI error"))
    return interop.Outcome[unit].failure(code, text)