393 lines
15 KiB
Fennel
393 lines
15 KiB
Fennel
(local pxl8 (require :pxl8))
|
|
(local effects (require :pxl8.effects))
|
|
(local net (require :pxl8.net))
|
|
(local sky (require :mod.sky))
|
|
|
|
(local bob-amount 4.0)
|
|
(local bob-speed 8.0)
|
|
(local cam-smoothing 0.25)
|
|
(local cell-size 64)
|
|
(local cursor-sensitivity 0.008)
|
|
(local gravity -800)
|
|
(local grid-size 64)
|
|
(local ground-y 64)
|
|
(local jump-force 175)
|
|
(local land-recovery-speed 20)
|
|
(local land-squash-amount -4)
|
|
(local max-pitch 1.5)
|
|
(local move-speed 200)
|
|
(local turn-speed 2.0)
|
|
|
|
(local sim-tick-rate 60)
|
|
(local sim-dt (/ 1.0 sim-tick-rate))
|
|
(local history-size 128)
|
|
(local correction-threshold 1.0)
|
|
|
|
(var auto-run? false)
|
|
(var auto-run-cancel-key nil)
|
|
(var bob-time 0)
|
|
(var cam-pitch 0)
|
|
(var cam-x 1000)
|
|
(var cam-y 64)
|
|
(var cam-yaw 0)
|
|
(var cam-z 1000)
|
|
(var camera nil)
|
|
(var cursor-look? true)
|
|
(var grounded? true)
|
|
(var land-squash 0)
|
|
(var light-time 0)
|
|
(var network nil)
|
|
(var smooth-cam-x 1000)
|
|
(var smooth-cam-z 1000)
|
|
(var velocity-y 0)
|
|
(var world nil)
|
|
(var fps-avg 0)
|
|
(var fps-sample-count 0)
|
|
|
|
(local FIREBALL_COLOR 184)
|
|
|
|
(fn init-fireball-palette []
|
|
(for [i 0 7]
|
|
(let [t (/ i 7)
|
|
r (math.floor (+ 0xFF (* t 0)))
|
|
g (math.floor (+ 0x60 (* t (- 0xE0 0x60))))
|
|
b (math.floor (+ 0x10 (* t (- 0x80 0x10))))]
|
|
(pxl8.set_palette_rgb (+ FIREBALL_COLOR i) r g b))))
|
|
|
|
(var client-tick 0)
|
|
(var last-processed-tick 0)
|
|
(var time-accumulator 0)
|
|
(var position-history {})
|
|
(var pending-inputs {})
|
|
|
|
(fn history-idx [tick]
|
|
(+ 1 (% tick history-size)))
|
|
|
|
(fn store-position [tick x z yaw]
|
|
(tset position-history (history-idx tick) {:tick tick :x x :z z :yaw yaw}))
|
|
|
|
(fn get-position [tick]
|
|
(let [entry (. position-history (history-idx tick))]
|
|
(when (and entry (= entry.tick tick))
|
|
entry)))
|
|
|
|
(fn store-pending-input [tick input]
|
|
(tset pending-inputs (history-idx tick) {:tick tick :input input}))
|
|
|
|
(fn get-pending-input [tick]
|
|
(let [entry (. pending-inputs (history-idx tick))]
|
|
(when (and entry (= entry.tick tick))
|
|
entry.input)))
|
|
|
|
(fn apply-movement [x z yaw input]
|
|
(var new-x x)
|
|
(var new-z z)
|
|
|
|
(let [move-forward (or input.move_y 0)
|
|
move-right (or input.move_x 0)]
|
|
(when (or (not= move-forward 0) (not= move-right 0))
|
|
(let [forward-x (- (math.sin yaw))
|
|
forward-z (- (math.cos yaw))
|
|
right-x (math.cos yaw)
|
|
right-z (- (math.sin yaw))
|
|
len (math.sqrt (+ (* move-forward move-forward) (* move-right move-right)))
|
|
norm-forward (/ move-forward len)
|
|
norm-right (/ move-right len)
|
|
move-delta (* move-speed sim-dt)]
|
|
(set new-x (+ new-x (* move-delta (+ (* forward-x norm-forward) (* right-x norm-right)))))
|
|
(set new-z (+ new-z (* move-delta (+ (* forward-z norm-forward) (* right-z norm-right))))))))
|
|
|
|
(values new-x new-z))
|
|
(fn init []
|
|
(set camera (pxl8.create_camera_3d))
|
|
(set world (pxl8.create_world))
|
|
(sky.generate-stars 12345)
|
|
(init-fireball-palette)
|
|
|
|
(set network (net.Net.new {:port 7777}))
|
|
(when network
|
|
(network:connect)
|
|
(network:spawn cam-x cam-y cam-z cam-yaw cam-pitch))
|
|
|
|
(let [result (world:generate {
|
|
:type pxl8.PROCGEN_ROOMS
|
|
:width 64
|
|
:height 64
|
|
:seed 42
|
|
:min_room_size 5
|
|
:max_room_size 10
|
|
:num_rooms 20})]
|
|
(if (< result 0)
|
|
(pxl8.error (.. "Failed to generate rooms - result: " result))
|
|
(let [floor-tex (pxl8.procgen_tex {:name "floor"
|
|
:seed 11111
|
|
:width 64
|
|
:height 64
|
|
:base_color 19})
|
|
wall-tex (pxl8.procgen_tex {:name "wall"
|
|
:seed 12345
|
|
:width 64
|
|
:height 64
|
|
:base_color 4})
|
|
sky-tex (pxl8.create_texture [0] 1 1)]
|
|
|
|
(let [result (world:apply_textures [
|
|
{:name "floor"
|
|
:texture_id floor-tex
|
|
:rule (fn [normal] (> normal.y 0.7))}
|
|
{:name "ceiling"
|
|
:texture_id sky-tex
|
|
:rule (fn [normal] (< normal.y -0.7))}
|
|
{:name "wall"
|
|
:texture_id wall-tex
|
|
:rule (fn [normal] (and (<= normal.y 0.7) (>= normal.y -0.7)))}])]
|
|
(when (< result 0)
|
|
(pxl8.error (.. "Failed to apply textures - result: " result))))))))
|
|
|
|
(fn sample-input []
|
|
(var move-forward 0)
|
|
(var move-right 0)
|
|
|
|
(when (pxl8.key_pressed "`")
|
|
(set auto-run? (not auto-run?))
|
|
(when (and auto-run? (pxl8.key_down "w"))
|
|
(set auto-run-cancel-key "w")))
|
|
(when (and auto-run? (not auto-run-cancel-key) (or (pxl8.key_down "w") (pxl8.key_down "s")))
|
|
(set auto-run? false)
|
|
(when (pxl8.key_down "s")
|
|
(set auto-run-cancel-key "s")))
|
|
(when (and auto-run-cancel-key (not (pxl8.key_down auto-run-cancel-key)))
|
|
(set auto-run-cancel-key nil))
|
|
|
|
(when (or (pxl8.key_down "w") auto-run?)
|
|
(set move-forward (+ move-forward 1)))
|
|
(when (and (pxl8.key_down "s") (not= auto-run-cancel-key "s"))
|
|
(set move-forward (- move-forward 1)))
|
|
(when (pxl8.key_down "a")
|
|
(set move-right (- move-right 1)))
|
|
(when (pxl8.key_down "d")
|
|
(set move-right (+ move-right 1)))
|
|
|
|
{:move_x move-right
|
|
:move_y move-forward
|
|
:look_dx (pxl8.mouse_dx)
|
|
:look_dy (pxl8.mouse_dy)})
|
|
|
|
(fn reconcile [server-tick server-x server-z]
|
|
(let [predicted (get-position server-tick)]
|
|
(when predicted
|
|
(let [dx (- predicted.x server-x)
|
|
dz (- predicted.z server-z)
|
|
error (math.sqrt (+ (* dx dx) (* dz dz)))]
|
|
(when (> error correction-threshold)
|
|
(set cam-x server-x)
|
|
(set cam-z server-z)
|
|
|
|
(for [t (+ server-tick 1) client-tick]
|
|
(let [input (get-pending-input t)
|
|
hist (get-position t)]
|
|
(when (and input hist)
|
|
(let [(new-x new-z) (apply-movement cam-x cam-z hist.yaw input)]
|
|
(set cam-x new-x)
|
|
(set cam-z new-z)
|
|
(store-position t cam-x cam-z hist.yaw))))))))))
|
|
|
|
(fn update [dt]
|
|
(let [fps (pxl8.get_fps)]
|
|
(set fps-sample-count (+ fps-sample-count 1))
|
|
(set fps-avg (+ (* fps-avg (/ (- fps-sample-count 1) fps-sample-count))
|
|
(/ fps fps-sample-count)))
|
|
(when (>= fps-sample-count 120)
|
|
(set fps-sample-count 0)
|
|
(set fps-avg 0)))
|
|
|
|
(when (world:is_loaded)
|
|
(let [input (sample-input)
|
|
grid-max (* grid-size cell-size)
|
|
movement-yaw cam-yaw]
|
|
|
|
(set time-accumulator (+ time-accumulator dt))
|
|
|
|
(while (>= time-accumulator sim-dt)
|
|
(set time-accumulator (- time-accumulator sim-dt))
|
|
(set client-tick (+ client-tick 1))
|
|
|
|
(store-pending-input client-tick input)
|
|
|
|
(let [(new-x new-z) (apply-movement cam-x cam-z movement-yaw input)]
|
|
(when (and (>= new-x 0) (<= new-x grid-max)
|
|
(>= new-z 0) (<= new-z grid-max))
|
|
(let [(resolved-x _ resolved-z) (world:resolve_collision cam-x cam-y cam-z new-x cam-y new-z 5)]
|
|
(set cam-x resolved-x)
|
|
(set cam-z resolved-z)))
|
|
|
|
(store-position client-tick cam-x cam-z movement-yaw)))
|
|
|
|
(when cursor-look?
|
|
(set cam-yaw (- cam-yaw (* input.look_dx cursor-sensitivity)))
|
|
(set cam-pitch (math.max (- max-pitch)
|
|
(math.min max-pitch
|
|
(- cam-pitch (* input.look_dy cursor-sensitivity))))))
|
|
|
|
(when (and (not cursor-look?) (pxl8.key_down "up"))
|
|
(set cam-pitch (math.min max-pitch (+ cam-pitch (* turn-speed dt)))))
|
|
(when (and (not cursor-look?) (pxl8.key_down "down"))
|
|
(set cam-pitch (math.max (- max-pitch) (- cam-pitch (* turn-speed dt)))))
|
|
(when (and (not cursor-look?) (pxl8.key_down "left"))
|
|
(set cam-yaw (+ cam-yaw (* turn-speed dt))))
|
|
(when (and (not cursor-look?) (pxl8.key_down "right"))
|
|
(set cam-yaw (- cam-yaw (* turn-speed dt))))
|
|
|
|
(when network
|
|
(let [(ok err) (pcall (fn []
|
|
(network:send_input {:move_x input.move_x
|
|
:move_y input.move_y
|
|
:look_dx input.look_dx
|
|
:look_dy input.look_dy
|
|
:yaw movement-yaw
|
|
:tick client-tick})
|
|
(network:update dt)
|
|
(when (network:poll)
|
|
(let [snapshot (network:snapshot)]
|
|
(when (and snapshot (> snapshot.tick last-processed-tick))
|
|
(set last-processed-tick snapshot.tick)
|
|
(let [player-id (network:player_id)]
|
|
(when (> player-id 0)
|
|
(let [curr (network:entity_userdata player-id)]
|
|
(when curr
|
|
(let [srv-x (pxl8.unpack_f32_be curr 0)
|
|
srv-z (pxl8.unpack_f32_be curr 8)]
|
|
(reconcile snapshot.tick srv-x srv-z)))))))))))]
|
|
(when (not ok)
|
|
(pxl8.error (.. "Network error: " err)))))
|
|
|
|
(set smooth-cam-x (+ (* smooth-cam-x (- 1 cam-smoothing)) (* cam-x cam-smoothing)))
|
|
(set smooth-cam-z (+ (* smooth-cam-z (- 1 cam-smoothing)) (* cam-z cam-smoothing)))
|
|
|
|
(when (and (pxl8.key_pressed "space") grounded?)
|
|
(set velocity-y jump-force)
|
|
(set grounded? false))
|
|
|
|
(set velocity-y (+ velocity-y (* gravity dt)))
|
|
(set cam-y (+ cam-y (* velocity-y dt)))
|
|
|
|
(when (<= cam-y ground-y)
|
|
(when (not grounded?)
|
|
(set land-squash land-squash-amount))
|
|
(set cam-y ground-y)
|
|
(set velocity-y 0)
|
|
(set grounded? true))
|
|
|
|
(when (< land-squash 0)
|
|
(set land-squash (math.min 0 (+ land-squash (* land-recovery-speed dt)))))
|
|
|
|
(let [moving (or (not= input.move_x 0) (not= input.move_y 0))]
|
|
(if (and moving grounded?)
|
|
(set bob-time (+ bob-time (* dt bob-speed)))
|
|
(let [target-phase (* (math.floor (/ bob-time math.pi)) math.pi)]
|
|
(set bob-time (+ (* bob-time 0.8) (* target-phase 0.2))))))
|
|
|
|
(set light-time (+ light-time (* dt 0.15))))))
|
|
|
|
(fn frame []
|
|
(pxl8.clear 1)
|
|
|
|
(when (not camera)
|
|
(pxl8.error "camera is nil!"))
|
|
|
|
(when (not world)
|
|
(pxl8.error "world is nil!"))
|
|
|
|
(when (and world (not (world:is_loaded)))
|
|
(pxl8.text "World not loaded yet..." 5 30 12))
|
|
|
|
(when (and camera world (world:is_loaded))
|
|
(let [bob-offset (* (math.sin bob-time) bob-amount)
|
|
eye-y (+ cam-y bob-offset land-squash)
|
|
forward-x (- (math.sin cam-yaw))
|
|
forward-z (- (math.cos cam-yaw))
|
|
target-x (+ smooth-cam-x forward-x)
|
|
target-y (+ eye-y (math.sin cam-pitch))
|
|
target-z (+ smooth-cam-z forward-z)
|
|
aspect (/ (pxl8.get_width) (pxl8.get_height))]
|
|
|
|
(camera:lookat [smooth-cam-x eye-y smooth-cam-z]
|
|
[target-x target-y target-z]
|
|
[0 1 0])
|
|
(camera:set_perspective 1.047 aspect 1.0 4096.0)
|
|
|
|
(let [light-pulse (+ 0.7 (* 0.3 (math.sin (* light-time 2))))
|
|
forward-x (- (math.sin cam-yaw))
|
|
forward-z (- (math.cos cam-yaw))
|
|
light-x (+ smooth-cam-x (* 150 forward-x) (* 50 (math.cos light-time)))
|
|
light-z (+ smooth-cam-z (* 150 forward-z) (* 50 (math.sin light-time)))
|
|
light-y (+ eye-y 30)]
|
|
(pxl8.begin_frame_3d camera {
|
|
:ambient 80
|
|
:celestial_dir [0.5 -0.8 0.3]
|
|
:celestial_intensity 0.5
|
|
:lights [{:x light-x :y light-y :z light-z
|
|
:r 255 :g 200 :b 150
|
|
:intensity (* 255 light-pulse)
|
|
:radius 400}]})
|
|
(pxl8.clear_depth)
|
|
|
|
(sky.update-gradient 1 2 6 6 10 18)
|
|
(sky.render smooth-cam-x eye-y smooth-cam-z)
|
|
(pxl8.clear_depth)
|
|
|
|
(world:render [smooth-cam-x eye-y smooth-cam-z])
|
|
|
|
(pxl8.end_frame_3d)
|
|
|
|
(let [dx (- light-x smooth-cam-x)
|
|
dy (- light-y eye-y)
|
|
dz (- light-z smooth-cam-z)
|
|
dist (math.sqrt (+ (* dx dx) (* dy dy) (* dz dz)))]
|
|
(when (> dist 1)
|
|
(let [inv-dist (/ 1 dist)
|
|
dir-x (* dx inv-dist)
|
|
dir-y (* dy inv-dist)
|
|
dir-z (* dz inv-dist)
|
|
cos-yaw (math.cos cam-yaw)
|
|
sin-yaw (math.sin cam-yaw)
|
|
cos-pitch (math.cos cam-pitch)
|
|
sin-pitch (math.sin cam-pitch)
|
|
rx (+ (* dir-x cos-yaw) (* dir-z sin-yaw))
|
|
rz (+ (* (- dir-x) sin-yaw) (* dir-z cos-yaw))
|
|
ry (- (* dir-y cos-pitch) (* rz sin-pitch))
|
|
fz (+ (* dir-y sin-pitch) (* rz cos-pitch))]
|
|
(when (> fz 0.01)
|
|
(let [width (pxl8.get_width)
|
|
height (pxl8.get_height)
|
|
fov 1.047
|
|
half-fov-tan (math.tan (* fov 0.5))
|
|
ndc-x (/ rx (* fz half-fov-tan aspect))
|
|
ndc-y (/ ry (* fz half-fov-tan))
|
|
sx (math.floor (* (+ 1 ndc-x) 0.5 width))
|
|
sy (math.floor (* (- 1 ndc-y) 0.5 height))
|
|
screen-size (/ 400 dist)
|
|
base-radius (math.max 2 (math.min 12 (math.floor screen-size)))
|
|
pulse-int (math.floor (* 180 light-pulse))]
|
|
(when (and (>= sx 0) (< sx width) (>= sy 0) (< sy height))
|
|
(effects.glows [
|
|
{:x sx :y sy :radius (+ base-radius 2) :intensity (/ pulse-int 5) :color (+ FIREBALL_COLOR 1) :shape effects.GLOW_CIRCLE}
|
|
{:x sx :y sy :radius base-radius :intensity pulse-int :color (+ FIREBALL_COLOR 5) :shape effects.GLOW_DIAMOND}]))))))))
|
|
|
|
(sky.render-stars cam-yaw cam-pitch 1.0)
|
|
|
|
(let [cx (/ (pxl8.get_width) 2)
|
|
cy (/ (pxl8.get_height) 2)
|
|
crosshair-size 4
|
|
red-color 18]
|
|
(pxl8.line (- cx crosshair-size) cy (+ cx crosshair-size) cy red-color)
|
|
(pxl8.line cx (- cy crosshair-size) cx (+ cy crosshair-size) red-color))
|
|
|
|
(pxl8.text (.. "fps: " (string.format "%.0f" fps-avg)) 5 5 12)
|
|
(pxl8.text (.. "pos: " (string.format "%.0f" cam-x) ","
|
|
(string.format "%.0f" cam-y) ","
|
|
(string.format "%.0f" cam-z)) 5 15 12))))
|
|
|
|
{:init init
|
|
:update update
|
|
:frame frame}
|