Cleaned up a lot!

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 

$    ^rrlwr^M    #   =   rlwrap   previous     rlwrap    ecl
>    ^r(req^M^rre^M    #   =   rlwrap   previous    (require
"jam-no-theme") then (ja::xs&+s) 

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: 

(defun coord-liner (start-x below-x x-space
                     y-start y-stop y-space &key (transpose nil)
                     &aux (cur-x start-x)) "
(coord-liner (start-x below-x x-space
              y-start y-stop y-space
              &key (transpose nil)))
Return a closure that returns
(x1 y1 x2 y2) or nil when it loops,
or if transpose (y1 x1 y2 x2)
"
 (lambda ()
  (reduce 'append
   (mapcar (if transpose 'reverse 'identity)
    (if (< cur-x below-x)
     (prog1 (list (list (* cur-x x-space) (* y-start y-space))
                  (list (* cur-x x-space) (* y-stop y-space)))
      (incf cur-x))
     (prog1 nil (setf cur-x start-x)))))))

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.