restructure toward ecs

two_player_cleaning_game/src/assets.fnl

@@ -0,0 +1,9 @@
+(local assets {})
+
+(love.graphics.setDefaultFilter "nearest" "nearest")
+(set assets.objects-sprite (love.graphics.newImage "assets/objects.png"))
+(set assets.walls-sprite (love.graphics.newImage "assets/walls.png"))
+(set assets.battery-bar-sprite (love.graphics.newImage "assets/battery_bar.png"))
+(set assets.player-sprite (love.graphics.newImage "assets/player.png"))
+
+assets

two_player_cleaning_game/src/colors.fnl

@@ -0,0 +1,30 @@
+;; colors
+(lambda color [full-r full-g full-b]
+  (let [(r g b) (love.math.colorFromBytes full-r full-g full-b)]
+  [r g b]
+))
+
+(local colors {
+ :cream (color 255 238 204)
+ :dark-purple (color 70 66 94)
+ :dark-pink (color 255 105 115)
+ :dark-blue (color 21 120 140)
+ :light-blue (color 0 185 190)
+ :light-pink (color 255 176 163)
+ :black [0 0 0]
+ :black-half-tone [0 0 0 0.25]
+})
+
+(fn reset-color []
+  "reset color to white (no tinting)"
+  (love.graphics.setColor 1 1 1))
+
+(lambda set-color [color]
+  "set color to the given color from the color pallet"
+  (love.graphics.setColor (unpack (. colors color))))
+
+{
+  :reset-color reset-color
+  :set-color set-color
+  : colors
+}

two_player_cleaning_game/src/levels/tutorial.fnl

@@ -0,0 +1,47 @@
+(local color (require "src/colors.fnl"))
+(local tiny (require "libs/tiny"))
+(local utils (require "src/utils.fnl"))
+
+(local level {})
+
+
+; function HudSystem:init(layerFlag)
+; 	self.filter = tiny.requireAll("drawHud", layerFlag)
+; end
+
+; function HudSystem:process(e, dt)
+; 	e:drawHud(dt)
+; end
+(fn bg-render [screen]
+  (let [system (tiny.system {: screen})]
+    (fn system.draw [self]
+        (print "Drawing BG")
+        (color.set-color color.colors.cream)
+        (love.graphics.rectangle "fill" 0 0 self.screen.canvas-w self.screen.canvas-h))
+    (utils.debug-print system)
+    system
+    ))
+
+(local root-render (tiny.system))
+(fn root-render.pre-draw [self]
+    (print "Pre-drawing root")
+    ; use canvas
+    (love.graphics.setCanvas level.canvas)
+    ; clear the screen
+    (love.graphics.clear))
+
+
+(local camera {:x 0 :y 0})
+
+(local debug true)
+
+(fn load [screen]
+  (set level.canvas (love.graphics.newCanvas screen.canvas-w screen.canvas-h))
+  (tiny.world
+    root-render
+    (bg-render screen)))
+
+
+{
+  : load
+}

two_player_cleaning_game/src/network.fnl

@@ -0,0 +1,133 @@
+(local socket (require "socket"))
+
+;; Guide: https://www.love2d.org/wiki/Tutorial:Networking_with_UDP
+
+;; Configuration
+(local config {
+  :host "localhost"
+  :port 9999
+})
+
+;; Network state
+(local state {
+  :socket nil
+  :connected false
+  ; :player-id nil
+  ; :last-error nil
+})
+
+;; Callback functions for network events
+; (local callbacks {
+;   :on-ready (fn [])
+;   :on-wait (fn [])
+;   :on-opponent-update (fn [data])
+;   :on-error (fn [error])
+; })
+
+(fn init []
+  "Initialize UDP connection to server
+   Returns true on success, false on error"
+    (let [udp (socket.udp)]
+      (udp:setpeername config.host config.port)
+      (udp:settimeout 0) ; non-blocking
+
+      (set state.socket udp)
+      (set state.connected true)))
+
+(fn send-msg [dg]
+  (state.socket:send dg))
+
+(fn update [dt]
+  (let [(data msg) (state.socket:receive)]
+    (when data
+      (print (fennel.view {: data : msg})))))
+
+; (fn register []
+;   "Send REGISTER message to server"
+;   (when state.socket
+;     (try
+;       (state.socket:send "REGISTER")
+;       (catch err
+;         (set state.last-error err)
+;         (when callbacks.on-error (callbacks.on-error err))))))
+
+; (fn split-string [str delimiter]
+;   "Split string by delimiter into table"
+;   (local result [])
+;   (local current "")
+;   (each [i 1 (length str) 1]
+;     (let [char (string.sub str i i)]
+;       (if (= char delimiter)
+;         (do
+;           (table.insert result current)
+;           (set current ""))
+;         (set current (.. current char)))))
+;   (table.insert result current)
+;   result)
+
+; (fn parse-message [msg]
+;   "Parse message in format: COMMAND#arg1#arg2#..."
+;   (split-string msg "#"))
+
+; (fn send-update [x y rotation battery]
+;   "Send player state to server in format: UPDATE#x#y#rotation#battery"
+;   (when state.socket
+;     (try
+;       (let [msg (.. "UPDATE#" x "#" y "#" rotation "#" battery)]
+;         (state.socket:send msg))
+;       (catch err
+;         (set state.last-error err)))))
+
+; (fn update [dt]
+;   "Call from love.update to process incoming messages"
+;   (when state.socket
+;     (let [(msg _src-ip _src-port) (state.socket:receivefrom)]
+;       (when msg
+;         (let [parts (parse-message msg)
+;               command (. parts 1)]
+;           (match command
+;             "READY_TO_PLAY" (callbacks.on-ready)
+;             "WAIT" (callbacks.on-wait)
+;             "UPDATE" (callbacks.on-opponent-update {
+;               :x (tonumber (. parts 2))
+;               :y (tonumber (. parts 3))
+;               :rotation (tonumber (. parts 4))
+;               :battery (tonumber (. parts 5))
+;             })
+;             _ (print (.. "← Message: " msg))))))))
+
+; (fn set-callback [event cb]
+;   "Register callback for network events
+;    Available events: :on-ready :on-wait :on-opponent-update :on-error"
+;   (tset callbacks event cb))
+
+(fn close []
+  "Close network connection"
+  (when state.socket
+    (state.socket:close)
+    (set state.socket nil)
+    (set state.connected false)))
+
+; (fn is-connected []
+;   "Check if currently connected to server"
+;   state.connected)
+
+; (fn get-last-error []
+;   "Get the last error that occurred"
+;   state.last-error)
+
+;; Export public API
+{
+  : init
+  : update
+  : state
+  : send-msg
+  : close
+  ; :register register
+  ; :send-update send-update
+  ; :update update
+  ; :set-callback set-callback
+  ; :close close
+  ; :is-connected is-connected
+  ; :get-last-error get-last-error
+}

two_player_cleaning_game/src/utils.fnl

@@ -0,0 +1,6 @@
+(lambda debug-print [obj]
+  (print (fennel.view obj)))
+
+{
+  : debug-print
+}