Prefabs

1 files changed, 20 insertions, 31 deletions

diff --git a/tests/scene-loader-test.scm b/tests/scene-loader-test.scm
index 6a0b27c..137d7ed 100644
--- a/tests/scene-loader-test.scm
+++ b/tests/scene-loader-test.scm
@@ -75,28 +75,22 @@
   (define (open-font filename size) (list 'font filename size)))
 (import (prefix sdl2-ttf "ttf:"))
 
+;; Mock downstroke-prefabs
+;; The mock registry is just an alist ((type . constructor) ...) for test simplicity.
+;; instantiate-prefab maps to the constructor call.
+(module downstroke-prefabs *
+  (import scheme (chicken base))
+  (define (instantiate-prefab registry type x y w h)
+    (let ((entry (assq type registry)))
+      (and entry ((cdr entry) x y w h)))))
+(import downstroke-prefabs)
+
 ;; Load scene-loader module
 (include "scene-loader.scm")
 (import downstroke-scene-loader)
 
 (test-begin "scene-loader")
 
-(test-group "make-prefab-registry + instantiate-prefab"
-  (let* ((registry (make-prefab-registry
-                     'player (lambda (x y w h) (list #:type 'player #:x x #:y y #:width w #:height h))
-                     'enemy  (lambda (x y w h) (list #:type 'enemy  #:x x #:y y #:width w #:height h))))
-         (result (instantiate-prefab registry 'player 10 20 16 16)))
-    (test-assert "instantiate-prefab returns a plist for known type"
-      (list? result))
-    (test-equal "player has correct x"
-      10
-      (entity-ref result #:x))
-    (test-equal "player has correct type"
-      'player
-      (entity-ref result #:type))
-    (test-assert "unknown type returns #f"
-      (not (instantiate-prefab registry 'unknown 10 20 16 16)))))
-
 (test-group "tilemap-objects->entities"
   (let* ((obj1 (make-object name: "player1" type: "player"     x: 10  y: 20  width: 16 height: 16 properties: '()))
          (obj2 (make-object name: "deco"    type: "decoration" x: 50  y: 60  width: 32 height: 32 properties: '()))
@@ -104,29 +98,24 @@
          (tm   (make-tilemap width: 100 height: 100 tilewidth: 16 tileheight: 16
                              tileset-source: "" tileset: #f layers: '()
                              objects: (list obj1 obj2 obj3)))
-         (fn   (lambda (type x y w h)
-                 (cond
-                   ((eq? type 'player) (list #:type 'player #:x x #:y y #:width w #:height h))
-                   ((eq? type 'enemy)  (list #:type 'enemy  #:x x #:y y #:width w #:height h))
-                   (else #f))))
-         (result (tilemap-objects->entities tm fn)))
+         ;; mock registry: alist of (type . constructor)
+         (registry
+           (list (cons 'player (lambda (x y w h) (list #:type 'player #:x x #:y y #:width w #:height h)))
+                 (cons 'enemy  (lambda (x y w h) (list #:type 'enemy  #:x x #:y y #:width w #:height h)))))
+         (result (tilemap-objects->entities tm registry)))
     (test-equal "filters #f results: 2 entities from 3 objects"
-      2
-      (length result))
+      2 (length result))
     (test-equal "first entity is player"
-      'player
-      (entity-ref (car result) #:type))
+      'player (entity-ref (car result) #:type))
     (test-equal "second entity is enemy"
-      'enemy
-      (entity-ref (cadr result) #:type)))
+      'enemy  (entity-ref (cadr result) #:type)))
 
   (let* ((tm-empty (make-tilemap width: 100 height: 100 tilewidth: 16 tileheight: 16
                                  tileset-source: "" tileset: #f layers: '()
                                  objects: '()))
-         (result (tilemap-objects->entities tm-empty (lambda (t x y w h) #f))))
+         (result (tilemap-objects->entities tm-empty '())))
     (test-equal "empty object list returns empty list"
-      0
-      (length result))))
+      0 (length result))))
 
 (test-group "game-load-tilemap! / game-load-tileset! / game-load-font!"
   ;; game-load-tilemap! calls load-tilemap and stores result