gambit-game-lib/scmlib.scm at 46c8723ebf7663fe0ba04fc0853d1337515787e7 · netguy204/gambit-game-lib · GitHub

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
(##include "math.scm")
(##include "common.scm")
(##include "spriter.scm")

(define *test-image* (make-parameter #f))

(define-structure particle r dr)

(define (particle-x p)
  (vect-x (particle-r p)))

(define (particle-y p)
  (vect-y (particle-r p)))

(define (particle-integrate p dt)
  (vect-add-into! (particle-r p)
                  (particle-r p)
                  (vect-scale (particle-dr p) dt)))

(define (rand-in-range min max)
  (+ min (random-integer (- max min))))

(define (random-particle)
  (let ((img-w (image-width (*test-image*)))
        (img-h (image-height (*test-image*))))
    (make-particle (make-vect (random-integer (- 640 img-w))
                              (random-integer (- 480 img-h)))
                   (make-vect (rand-in-range -100 100)
                              (rand-in-range -100 100)))))

(define (call-with-resources fn)
  (parameterize ((*test-image* (image-load "test.png")))
    (fn)))

(define *ps* #f)
(define *anim* #f)
(define *scml* #f)

(define (ensure-resources)
  (call-with-resources
   (lambda ()
     (set! *ps* (repeatedly random-particle 100))
     (set! *scml* (scml-load "monster/Example.SCML"))
     (set! *anim* (animation (entity *scml* "0") "Idle")))))

(define (update-particle sprite-list p dt w h)
  (let* ((x (particle-x p))
         (y (particle-y p))
         (dr (particle-dr p))
         (sprite (frame/make-sprite)))

    (if (or (>= x w) (<= x 0))
        (vect-scale-both-into! dr dr -1 1))
    (if (or (>= y h) (<= y 0))
        (vect-scale-both-into! dr dr 1 -1))

    (particle-integrate p dt)
    (sprite-resource-set! sprite (*test-image*))
    (sprite-x-set! sprite (particle-x p))
    (sprite-y-set! sprite (particle-y p))
    (frame/spritelist-append sprite-list sprite)))

(define (update-view-old dt)
  (call-with-resources
   (lambda ()
     (let ((w (- 640 (image-width (*test-image*))))
           (h (- 480 (image-height (*test-image*)))))
       (let loop ((ps *ps*)
                  (sprite-list #f))
         (if (null? ps)
             (if sprite-list (spritelist-enqueue-for-screen! sprite-list))
             (loop (cdr ps)
                   (update-particle sprite-list
                                    (car ps) dt w h))))))))

(define (tkey->sprite tkey ox oy)
  (let* ((image (image-load (tkey-name tkey)))
         (sprite (frame/make-sprite))
         (h (image-height image))
         (w (image-width image))
         (px-img-offset (* (tkey-cx tkey) w))
         (py-img-offset (* (tkey-cy tkey) h))
         (piv-x (+ ox (tkey-x tkey)))
         (piv-y (+ oy (tkey-y tkey))))

    (sprite-resource-set! sprite image)
    (sprite-x-set! sprite piv-x)
    (sprite-y-set! sprite piv-y)
    (sprite-origin-x-set! sprite px-img-offset)
    (sprite-origin-y-set! sprite py-img-offset)

    (sprite-angle-set! sprite (tkey-angle tkey))
    sprite))

(define (add-animation sprite-list anim time ox oy)
  (reduce (lambda (sprite-list tkey)
            (frame/spritelist-append sprite-list
                                     (tkey->sprite tkey ox oy)))
          #f
          (reverse (interp-anim anim time))))

(define (update-view dt)
  (let* ((cycles-for-anim (seconds->cycles (animation-length *anim*)))
         (anim-cycle (modulo (clock-time *game-clock*) cycles-for-anim))
         (anim-time (cycles->seconds anim-cycle))
         (sprite-list (add-animation #f *anim* anim-time 320 100)))

    (update-view-old dt)
    (spritelist-enqueue-for-screen! sprite-list)))


(define (update-view-test dt)
  (spritelist-enqueue-for-screen!
   (frame/spritelist-append
    #f
    (let* ((sprite (frame/make-sprite))
           (cycles-per-rot (seconds->cycles 2.0))
           (rot-cycle (modulo (clock-time *game-clock*) cycles-per-rot))
           (angle (* 360.0 (/ rot-cycle cycles-per-rot)))
           (img (image-load "test.png"))
           (w (image-width img))
           (h (image-height img)))

      (sprite-resource-set! sprite img)
      (sprite-x-set! sprite 320)
      (sprite-y-set! sprite 240)
      (sprite-origin-x-set! sprite w)
      (sprite-origin-y-set! sprite h)
      (sprite-angle-set! sprite angle)
      sprite))))