I removed the variable sharing with C for the time being:
Since I want to be making a game in lisp with just some
OS-facing C gears grinding along in the background. I'm now
using ECL's sffi:c-inline to call C functions, which is
pass-by-value.
Now the loop mapcs 'funcall to a list of closures #'game
takes. I'm still going to use c-progn's shared variables,
but in the future I am going to use them to capture
information from SDL2 (events and pixels) into the lisp side
instead of doing some logic in C.
I started making xs and os (or xs and +s), but I just did
the grid for now, with much clearer and more functional
infrastructure. If I run out of time, I will just submit a
gomoku game like emacs' since I have that grid.
One reason I concentrated on using a list of functions is
that instead of tapping away in vi, :sh
running and running back to vi for editing like an
unsophisticated language, I want to be adding and changing
the list of functions being run smoothly while the game is
running. I guess I will add a second thread to keep a repl
available and a lock on that list.
I think the code is already much prettier. I have a function
that returns a closure returning (x1 y1 x2 y2)s or nils
describing one direction of a rectangular grid, which could
be transposed:
And another function that uses ffi:c-inline to make the
color and drawing C closure:
(defun draw-lines-from (fun rgb) "
Calls SDL_SetRenderDrawColor and
SDL_RenderDrawLine
with rgb and on a list from fun.
"
(lambda ()
(loop
for (x1 y1 x2 y2) = (funcall fun)
for (r g b) = rgb
while x1
do (ffi:c-inline (r g b 255) (:int :int :int :int) nil
"SDL_SetRenderDrawColor(renderer, #0, #1, #2, #3)"
:one-liner t)
do (ffi:c-inline (x1 y1 x2 y2)
(:int :int :int :int) nil
"SDL_RenderDrawLine(renderer, #0, #1, #2, #3)"
:one-liner t))))
So the game (= simple grid), with no currently C shared
variables (well, renderer is visible) is:
(defun xs&+s () "
I was thinking of naughts and crosses, but ultimately
I'm just drawing a grid.
"
(let* ((horiz-lines
(draw-lines-from
(coord-liner 1 5 50 1 4 50 :transpose nil)
'(255 0 0)))
(verti-lines
(draw-lines-from
(coord-liner 1 5 50 1 4 50 :transpose t)
'(255 255 0)))
(funs (list horiz-lines verti-lines)))
(game () () funs)))
Because my grid-cells are half-open, the direction of lines
being drawn is one greater than the length of the direction
being drawn in. Anway, try it out yourself ;p
By the way, is no-one using Shinmera's CL game engine? I
thought that had a big version recently.
*The crazy way the previous version of this game worked let
some scoping magic happen: but I have just removed the want
for that scoping for now.