more specialized gamestate inspectors, fix upvalues

game/meta/mapinspector.fnl

@@ -1,7 +1,7 @@
 (local inspector (require :inspector.registry))
 (local vats (require :game.meta.vats))
 (local dim (require :game.dim))
-(local {: with-style} (require :editor.imgui))
+(local lume (require :lib.lume))
 
 (fn is-tilemap? [o]
   (and (= (type o) :table) (= (getmetatable o) nil)
@@ -9,10 +9,62 @@
        (. o 0) (. o (- o.h 1)) (not (. o o.h))
        (. o 0 0) (. o 0 (- o.w 1)) (not (. o 0 o.w))))
 
+(fn mapsize [map ?scale]
+  {:w (* dim.tilesize map.w (or ?scale 1))
+   :h (* dim.tilesize map.h (or ?scale 1))})
+
 (inspector.register :tilemap 25
   is-tilemap?
   (fn [form state tbl]
     (vats.drawfunc :game.draw.tilemap :draw-tilemaps form.x form.y [tbl])
-    (with-style form :w (* dim.tilesize tbl.w) :h (* dim.tilesize tbl.h))))
+    (lume.extend form (mapsize tbl))))
+
+(fn draw-game-window [form state ?opts]
+  (let [opts (or ?opts {})
+        x (or opts.x 0) y (or opts.y 0) scale (or opts.scale 1)
+        {: w : h} (mapsize state.map)
+        w (* (or opts.w w) scale) h (* (or opts.h h) scale)
+        oldscissor [(love.graphics.getScissor)]]
+    (love.graphics.push :transform)
+    (love.graphics.translate form.x form.y)
+    (love.graphics.scale scale)
+    (love.graphics.translate (- x) (- y))
+    (love.graphics.setScissor form.x form.y w h) ; scissor does not use transformation matrix
+    (vats.drawfunc :game.draw :draw-game state)
+    (love.graphics.setScissor (unpack oldscissor))
+    (love.graphics.pop)
+    (lume.extend form {: w : h})))
+
+(fn is-gamestate? [val]
+  (and (= (type val) :table)
+          (= (getmetatable val) nil)
+          (not= val.bombs nil)
+          (not= val.map nil)
+          (not= val.entities nil)))
+
+(fn find-entity [state type]
+  (var entity nil)
+  (each [_ e (ipairs state.entities) &until (not= entity nil)]
+    (when (= e.entity type) (set entity e)))
+  entity)
+
+(inspector.register :gamestate 50 is-gamestate?
+  (fn [form state value]
+    (when (= state.scale nil) (set state.scale 0.25))
+    (draw-game-window form value {:scale state.scale})))
+
+(fn draw-game-near-entity [form state entity]
+  (draw-game-window form state {:x (- (. entity.pos 1) (* dim.halftile 4))
+                                :y (- (. entity.pos 2) (* dim.halftile 4))
+                                :w (* dim.tilesize 4) :h (* dim.tilesize 4)
+                                :scale 2}))
+
+(inspector.register :bomberman 20
+  #(and (is-gamestate? $1) (find-entity $1 :bomberman))
+  (fn [form state value] (draw-game-near-entity form value (find-entity value :bomberman))))
+
+(inspector.register :pacman 20
+  #(and (is-gamestate? $1) (find-entity $1 :pacman))
+  (fn [form state value] (draw-game-near-entity form value (find-entity value :pacman))))
 
 {}

inspector/init.fnl

@@ -51,7 +51,7 @@
   (fn [form state value]
     (let [info (debug.getinfo value)
           upcells (Upcell.saveall value)
-          upvalues (when upcells (icollect [_ upcell (ipairs upcells)] (Upcell.get upcell)))
+          upvalues (when upcells (collect [_ upcell (ipairs upcells)] (values (Upcell.name upcell) (Upcell.get upcell))))
           env (getfenv value)]
       (draw-table form state {: info : upvalues : env}))))
 (require :inspector.test)