anchor.diff:  		     (+ (* a 1-distance) (* b distance)))
   	     x y))))
   
  -(defun make-move-cylinder-func (node start end speed handler)
  +(defun make-move-cylinder-func (node maze start end speed handler)
     (let* ((pos      start)
   	 (movement (sb-cga:vec* 
   		    (sb-cga:normalize 
   		     (sb-cga:vec- end start))
   		    speed)))
  -    (format t "movement = ~A~%" movement)
       (lambda ()
         (let ((distance (sb-cga:vec-length (sb-cga:vec- pos end))))
  -	(format t "start=~A end=~A movement=~A pos=~A distance=~A~%" start end movement pos distance)
   	(if (<  distance speed)
   	    (progn (funcall handler) nil)
   	    (progn
  
positive.code: 			  (* (- i w/2) 2))))
      *maze*))
  
  (defun reset-maze (w h)
    (destroy-all-statics)
    (let ((maze (make-game-maze w h)))
      (ode:body-set-position *body* 
  			   (- 2 (* 2 (ash w -1))) 
  			   .5
  			   (- 2 (* (ash h -1) 2)))
      (clinch:set-identity-transform cylinder-node)
      (clinch:rotate cylinder-node (clinch:degrees->radians 90) 1 0 0)
      (position-cylinder cylinder-node
  		       (- 2 (* 2 (ash w -1))) 
  		       (- 2 (* (ash h -1) 2)))
      maze))
  
    ;; init game objects...
  (defun init ()
  
    (init-opengl)
  
  
negative.code: 		    (sb-cga:vec+ pos movement))
  	      (position-cylinder node (aref pos 0) (aref pos 2))))))))
     
  (defun find-valid-movement (maze x y)
    (destructuring-bind (w h) (array-dimensions maze)
      (list (and (> x 0) (aref maze (1- x) y))
  	  (and (> y 0) (aref maze x (1- y)))
  	  (and (< x (1- w)) (aref maze (1+ x) y))
  	  (and (< y (1- h)) (aref maze x (1+ y))))))
  
  (defun get-random-valid-direction (maze x y)
    (loop with lst = (find-valid-movement maze x y)
       for r = (random 4)
       until (nth r lst)
       finally (return 
  	       (cond ((= r 0) '(-1 0))
  		     ((= r 1) '(0 -1))
  		     ((= r 2) '(1 0))
  		     ((= r 3) '(0 1))))))
  
  (defun move-random-valid-direction (node maze pos)
    (let* ((dir (get-random-valid-direction maze (first pos) (second pos)))
  	 (dest (map 'list #'+ pos dir)))
      (make-move-cylinder-func node pos dest .1
  			     (lambda ()
  			       ))))
  
  			       
  			       (move-random-valid-direction node maze dest)))))
      
    
  
  
  (defun make-game-maze (width height)
  