(defstruct env
  (width 2)
  (height 1)
  (x-pos 0)
  (y-pos 0)
  (dirt-vector (make-array 2))
  (moves-so-far 0))
 
(defstruct agent
  (name "A")
  (program nil)   ;; a function of percept -> action
)
 
(defvar *env*)
 
(defun env-dirt (x y env)
  (aref (env-dirt-vector env)
	(+ x (* y (env-width env)))))
 
(defun set-env-dirt (x y env dirty)
  (setf (aref (env-dirt-vector env)
	      (+ x (* y (env-width env))))
	dirty))
 
;; Draws a picture of an environment
(defun print-env (env)
  (let ((w (env-width env))
	(h (env-height env))
	(x (env-x-pos env))
	(y (env-y-pos env)))
    (format t "      ")
    (dotimes (j w) (format t "~a~0,4:@t" j))
    (format t "~%")
    (dotimes (i h)
      (format t "    ")
      (dotimes (j w) (format t "+---"))
      (format t "+~%")
      (format t "~a~4t" i)
      (dotimes (j w)
	(format t "| ")
	(if (and (= j x) (= i y))
	    (format t "A")
	    (format t " "))
	(if (env-dirt j i env)
	    (format t ";")
	    (format t " ")))
      (format t "|~%")
    )
    (format t "    ")
    (dotimes (j w) (format t "+---"))
    (format t "+~%")
  )
)
 
;; Constructs the perception for an environment
(defun get-percept (env)
  (list :x (env-x-pos env)
	:y (env-y-pos env)
	:dirty (env-dirt (env-x-pos env)
			 (env-y-pos env)
			 env)))
 
;; Applies an action to an enviornment, updating all relevant fields
(defun update-env (action env)
  (cond ((eq action 'suck) (set-env-dirt (env-x-pos env)
					  (env-y-pos env)
					  env
					  NIL
			   )
	)
	((eq action 'left)  (setf (env-x-pos env)
			   	  (max (1- (env-x-pos env)) 0))
	                    (setf (env-moves-so-far env) (1+ (env-moves-so-far env))))
	((eq action 'right) (setf (env-x-pos env)
				  (min (1+ (env-x-pos env))
				       (1- (env-width env))))
	                    (setf (env-moves-so-far env) (1+ (env-moves-so-far env))))
	((eq action 'up)    (setf (env-y-pos env)
				  (max (1- (env-y-pos env)) 0))
	                    (setf (env-moves-so-far env) (1+ (env-moves-so-far env))))
	((eq action 'down) (setf (env-y-pos env)
				  (min (1+ (env-y-pos env))
				       (1- (env-height env))))
	                   (setf (env-moves-so-far env) (1+ (env-moves-so-far env))))
  ))
 
;; Initializes global environment
(defun init-env (width height dirt-probability)
  (setf *env* (make-env :width width
			:height height
			:dirt-vector (make-array (* width height))))
  (dotimes (i (* width height))
    (setf (aref (env-dirt-vector *env*) i)
	  (< (random 1.0) dirt-probability))))
 
;; Simulates a step of an agent on the global environment
(defun simulate-step (agent performance-measure)
  (let ((action (funcall (agent-program agent) (get-percept *env*))))
    (update-env action *env*)
    (format t "Agent ~a just performed action: ~a~%" (agent-name agent) action)
    (print-env *env*)
    (format t "Performance evaluation: ~a~%" (funcall performance-measure *env* agent))
  ))
 
;; Simulates while user asks to keep going, prints every step
(defun simulate (agent performance-measure)
  (loop (simulate-step agent performance-measure)
     (if (not (y-or-n-p "Perform another step? [y/n]: ")) (return))))
 
;; Simulates a given number of steps and prints the resulting performance value
(defun simulate-quiet (agent performance-measure steps)
  (dotimes (i steps)
    (update-env (funcall (agent-program agent) (get-percept *env*)) *env*))
  (format t "Performed ~a steps of simulation, performance value: ~a~%" 
	  steps (funcall performance-measure *env* agent)))
 
;; Simply count the number of clean squares
(defun example-measure (env agent)
  (count-if #'not (env-dirt-vector env)))
 
;; This agent assumes a 2x1 environment
(defun example-agent-program (percept)
  (if (getf percept :dirty)
      'suck
      (if (= 0 (getf percept :x))
	  'right
	  'left
      )
   )
)
 
;; To test an agent interactively, call
;; (simulate (make-agent :name "Simple" :program #'example-agent-program) #'example-measure)
 
;; To test an agent for a number of steps, call
;; (simulate-quiet (make-agent :name "Simple" :program #'example-agent-program) #'example-measure 100)
;;  where 100 is the number of steps to perform