anchor.diff:  		    (sb-cga:vec+ pos movement))
   	      (position-cylinder node (aref pos 0) (aref pos 2))))))))
      
  - (let ((start (sb-cga:vec 0.0 2.0 10.0))
  -	       (end   (sb-cga:vec 0.0 2.0 20.0))
  -	       (pos   (sb-cga:vec 0.0 2.0 10.0))
  -	       (speed .5))
  -	   (if (< (sb-cga:vec-length (sb-cga:vec- pos end)) speed)
  -	       t
  -	       (setf pos 
  -		     (sb-cga:vec+ pos 
  -				  (sb-cga:vec* 
  -				   (sb-cga:normalize 
  -				    (sb-cga:vec- end start))
  -				   speed)))))
  - (let ((start (sb-cga:vec 0.0 2.0 10.0))
  -	       (end   (sb-cga:vec 0.0 2.0 20.0))
  -	       (pos   (sb-cga:vec 0.0 2.0 10.0))
  -	       (speed .5))
  -	   (if (< (sb-cga:vec-length (sb-cga:vec- pos end)) speed)
  -	       t
  -	       (setf pos 
  -		     (sb-cga:vec+ pos 
  -				  (sb-cga:vec* 
  -				   (sb-cga:normalize 
  -				    (sb-cga:vec- end start))
  -				   speed)))))
  +(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)
  
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:      (make-local-path file)))))
  
  
  (defun position-cylinder (node maze x y &optional (height 2))
  
    (let* ((maze-size (array-dimensions maze)))
      (multiple-value-bind (w h)
  	(maze->position x y (first maze-size) (second maze-size))
        (clinch:set-identity-transform node)
        (clinch:rotate node (clinch:degrees->radians 90) 1 0 0)
        (clinch:scale node 1 height 1)
        (clinch:translate node w height h))))
  
  (defun lerp (x y distance)
    (let ((1-distance (- 1 distance)))
  