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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
* guile-2d
Guile-2d is a 2D game programming library for GNU Guile. It is a
layer above SDL and OpenGL that provides abstractions for common 2D
game programming requirements such as:
- Sprites
- Animation
- Tilesets
- Tile maps
- Scene graph
- Input handling
- Scripting
** Inspiration
Every programming language should have a fun, easy to use 2D game
library. Guile-2d draws it's inspiration from great
libraries/frameworks such as [[http://love2d.org][LÖVE]], [[http://pygame.org][Pygame]], and [[http://pyglet.org][Pyglet]].
** Example
Here is the simplest Guile-2d application (so far).
#+BEGIN_SRC scheme
(use-modules (figl gl)
(2d sprite)
(2d game-loop)
(2d window))
(define window-width 800)
(define window-height 600)
(define sprite #f)
(define (key-down key)
(display key) (newline)
(case key
;; Quit program when ESCAPE or Q is pressed.
((any-equal? key 'escape 'q)
(close-window)
(quit))))
;; Draw our sprite
(define (render)
(draw-sprite sprite))
;; Register callbacks.
(set-render-callback (lambda () (render)))
(set-key-down-callback (lambda (key) (key-down key)))
;; Open the window.
(open-window window-width window-height)
;; Load a sprite and center it on the screen.
;; Must be done AFTER opening the window.
(set! sprite (load-sprite "sprite.png" #:position (vector (/ window-width 2)
(/ window-height 2))))
;; Start the game loop.
;; The render callback will be called through this procedure.
(run-game-loop)
#+END_SRC
** Features
*** Sprites
Sprites encapsulate the presentation of an image or a region of an
image.
The simplest way to get started with sprites is to use the
=load-sprite= procedure. All arguments except the filename are
optional keyword arguments.
#+BEGIN_SRC scheme
(define sprite (load-sprite "cirno.png" #:position #(0 0) #:scale (1 1)
#:rotation (0) #:color #xffffff #:anchor 'center))
#+END_SRC
Alternatively, you can make a sprite from an existing texture. The
same keyword arguments in =load-sprite= are also available here.
#+BEGIN_SRC scheme
(define sprite (make-sprite (load-texture "cirno.png")))
#+END_SRC
Position, scale, rotation, color, and anchor are mutable.
#+BEGIN_SRC scheme
(set-sprite-position! sprite #(100 100))
#+END_SRC
Drawing a sprite is simple.
#+BEGIN_SRC scheme
(draw-sprite sprite)
#+END_SRC
*** Sprite Batches
When drawing many sprites, it is inefficient to send them to the
GPU individually. Sprite batches resolve this issue by sending
sprites to the GPU in large chunks.
To take advantage of this, create a sprite batch and use
=with-sprite-batch=. All calls to =draw-sprite= will use the
sprite batch within this form.
#+BEGIN_SRC scheme
(define sprites (make-a-ton-of-sprites))
(define batch (make-sprite-batch))
(with-sprite-batch batch
(for-each
(lambda (sprite) (draw-sprite sprite))
sprites))
#+END_SRC
*** Coroutines and Agendas
The ability to write scripts is very important for most games. A
script for an RPG NPC could look like this:
#+BEGIN_SRC scheme
;; Walk up one tile and then down one tile, forever.
(while #t
(walk 'up)
(walk 'down))
#+END_SRC
Unfortunately, running this script as it is means completely
locking up the program in an unbounded loop. However, coroutines
(and a scheduler known as the "agenda") are here to save the day!
Coroutines are procedures that can be exited at any point and
resumed later.
It would be nice if after every call to =walk=, the NPC would wait
for one second before taking its next step. This is where the
agenda comes in. The agenda is used to schedule procedures to be
run after an arbitrary number of game updates (1 by
default). Since coroutines and the agenda go hand in hand, there
exists a =wait= procedure to pause a coroutine and schedule it to
be resumed later.
Using a coroutine and the agenda, the NPC script can be rewritten
such that it does not halt further program execution.
#+BEGIN_SRC scheme
(agenda-schedule
(colambda ()
(while #t
(walk 'up)
(wait 60)
(walk 'down)
(wait 60))))
#+END_SRC
=colambda= is a useful macro that is syntactic sugar for a lambda
expression executed as a coroutine. =agenda-schedule= accepts a
thunk (a procedure that takes 0 arguments) and schedules it to be
executed later. In this example we do not provide a second
argument to =agenda-schedule=, which means that the thunk will be
executed upon the next game update.
Since guile-2d enforces a fixed timestep and updates 60 times per
second, waiting for 60 updates means that the NPC will wait one
second in between each step.
** REPL Driven Development
The read-eval-print-loop present in Guile allows you to develop
your game while it is running! This allows you to see in real time
what your changes do to the game without having to restart the
program every time.
** This section needs to be completed. **
** Dependencies
- [[https://gitorious.org/guile-figl/guile-figl][guile-figl]]
No official release. guile-2d runs off of the latest master
version.
As of this writing, =make= will fail due to errors with building
texinfo files. Currently there is an error on line 19188 of
=doc/low-level-gl.texi=. To fix, join lines 19188 and 19189
together.
- [[https://www.gnu.org/software/guile-sdl/index.html][guile-sdl]] >= 0.5.0
- SDL 1.2
** License
GNU LGPL v3
|
