aboutsummaryrefslogtreecommitdiff
path: root/scene-loader.scm
blob: 519622eb13852cc20be5a0eecf0a2d5f2b4d201e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
(module downstroke/scene-loader *
  (import scheme
          (chicken base)
          (only srfi-1 filter-map)
          (srfi 69)
          (prefix sdl2 "sdl2:")
          (prefix sdl2-ttf "ttf:")
          defstruct
          downstroke/tilemap
          downstroke/world
          downstroke/engine)

  ;; Create a prefab registry from alternating symbol/constructor pairs.
  ;; Returns a srfi-69 hash-table mapping symbols to constructor functions.
  (define (make-prefab-registry . pairs)
    (let ((ht (make-hash-table)))
      (let loop ((p pairs))
        (if (null? p) ht
            (begin
              (hash-table-set! ht (car p) (cadr p))
              (loop (cddr p)))))))

  ;; Instantiate a prefab by type from the registry.
  ;; Returns the entity plist if type exists, #f otherwise.
  (define (instantiate-prefab registry type x y w h)
    (let ((ctor (hash-table-ref/default registry type #f)))
      (and ctor (ctor x y w h))))

  ;; Convert TMX object list to entities.
  ;; Object types are strings from XML; convert to symbols before instantiating.
  ;; Filters out #f results (objects without registered prefabs).
  (define (tilemap-objects->entities tilemap instantiate-fn)
    (filter-map
      (lambda (obj)
        (instantiate-fn (string->symbol (object-type obj))
                        (object-x obj) (object-y obj)
                        (object-width obj) (object-height obj)))
      (tilemap-objects tilemap)))

  ;; Create an SDL2 texture from the tileset image embedded in a tilemap.
  (define (create-tileset-texture renderer tilemap)
    (sdl2:create-texture-from-surface
      renderer
      (tileset-image (tilemap-tileset tilemap))))

  ;; Load a TMX tilemap file and store it in the game asset registry.
  ;; Returns the loaded tilemap struct.
  (define (game-load-tilemap! game key filename)
    (let ((tm (load-tilemap filename)))
      (game-asset-set! game key tm)
      tm))

  ;; Load a TSX tileset file and store it in the game asset registry.
  ;; Returns the loaded tileset struct.
  (define (game-load-tileset! game key filename)
    (let ((ts (load-tileset filename)))
      (game-asset-set! game key ts)
      ts))

  ;; Load a TTF font file and store it in the game asset registry.
  ;; size is the point size. Returns the loaded font.
  (define (game-load-font! game key filename size)
    (let ((font (ttf:open-font filename size)))
      (game-asset-set! game key font)
      font))

  ;; Load a scene from a TMX tilemap file.
  ;; 1. Loads the tilemap from the file (and stores in assets)
  ;; 2. Creates a texture from the tilemap's tileset image
  ;; 3. Creates a scene with empty entities list
  ;; 4. Sets the scene on the game
  ;; Returns the scene.
  (define (game-load-scene! game filename)
    (let* ((tm    (game-load-tilemap! game 'tilemap filename))
           (tex   (create-tileset-texture (game-renderer game) tm))
           (scene (make-scene
                    entities:        '()
                    tilemap:         tm
                    camera:          (make-camera x: 0 y: 0)
                    tileset-texture: tex
                    camera-target:   #f)))
      (game-scene-set! game scene)
      scene))

) ;; end module