Maximum PC

;; Function to create a target state, that takes in the location of each of the 4 entities of the problem
(defun make-state (farmer fox goose grain)
   (let ((state nil))
      (push grain state)
      (push goose state)
      (push fox state)
      (push farmer state)
   );; pushes the entities onto the list in reverse order so that the farmer is first and the grain is last.
)

;; Finds the side that the farmer is currently standing on
(defun farmer-side (state)
   (setq side (car state))
)

;; Finds the side that the fox is currently standing on
(defun fox-side (state)
   (setq side (second state))
)

;; Finds the side that the goose is currently standing on
(defun goose-side (state)
   (setq side (third state))
)

;; Finds the side that the grain is currently piled on
(defun grain-side (state)
   (setq side (last state))
)

;; Function that performs the blind search through the statespace to find a path / solution
;; to the problem
(defun path-search (state goal pathlist)

)

path (state, goal, pathlist){
   if state == goal{
      append state to pathlist
      return pathlist
   }
   else{
      while (child states exist){
         prev_state = state
         new_child_state = generated child state
         if child == valid
            append prev_state to pathlist
            path (new_child_state, goal, pathlist)
      }
   }
}

;;;For this project all you need to do is (load "textfilename") and run
;;;commands  (solve-ffgg start goal) where start and goal are in form of
;;;'(T T T T) or '(O O O O) or some combo of O and T only

;;returns side of farmer the first element in state
(defun farmer-side (state)
  (first state)
)
;;returns side of fox the second element in state
(defun fox-side (state)
  (second state)
)
;;returns side of goose the third element in state
(defun goose-side (state)
  (third state)
)
;;returns side of grain the fourth element in state
(defun grain-side (state)
  (fourth state)
)
; ;change give state from this side to other side or other side to this side
(defun opposite (currentSide)
   (cond
      ((equal currentSide 'O) 'T); If it was other side its now this side
      ((equal currentSide 'T) 'O);If it was this side it is other side
   )
)
;;Makes a list with the correct format of farmer fox goose grain
(defun make-state (farmer fox goose grain)
   (list farmer fox goose grain)
   )
;;farmer changes side others same
(defun oppositeFsameFGG (state)
  (valid (make-state (opposite (farmer-side state))     ; farmer changes side and checks to see if valid state
            (fox-side state)         ;fox stays on same side
            (goose-side state)         ; goose stays on same side
            (grain-side state)      ; grain stays on same side
   )
  )
)
;;farmer and fox changes side others stay
(defun oppositeFFsameGG (state) (cond
  ((equal (farmer-side state) (fox-side state))   
    (valid (make-state (opposite (farmer-side state))   ; farmer change sides and checks to see if it a valid state
                      (opposite (fox-side state))   ; change sides
                      (goose-side state)         ; goose stays on same side
                      (grain-side state)      ; grain stays on same side
          )
    )
  )
  (t nil) ; not possible to take this path
))                       
;;farmer and goose change side and others stay
(defun oppositeFGosameFG (state) (cond
  ((equal (farmer-side state) (goose-side state))
    (valid (make-state (opposite (farmer-side state))   ; farmer changes sides and checks to see if valid state
                      (fox-side state)         ; fox stays on same side
                      (opposite (goose-side state))   ; goose changes side
                      (grain-side state)      ; grain stays on same side
          )
    )
  )
  (t nil) ; not possible to take this path
))
; ; checks for valid states and returns true if it is or nil if not
(defun valid (state)
   (cond;check to see if invalid state was passed
      ((and (equal (goose-side state) (fox-side state))  ; fox eats goose
      (not (equal (farmer-side state) (fox-side state))) ;no farmer supervision
      ) nil); true so return false, not valid since fox eats goose
   ((and (equal (goose-side state) (grain-side state))  ; goose eats grain
        (not (equal (farmer-side state) (goose-side state))); no farmer supervision
   ) nil); true so return false, not valid since goose eats grain
   (t state)
))
;;farmer and grain change sides and others stay
(defun oppositeFGrsameFG (state) (cond
  ((equal (farmer-side state) (grain-side state))
    (valid (make-state (opposite (farmer-side state))   ; farmer changes side and checks if valid state
                      (fox-side state)         ; fox stays on same side
                      (goose-side state)         ; goose stays on same side
                      (opposite (grain-side state))   ; grain changes side
          )
    )
  )
  (t nil) ; not possible to take this path
))
; ;recurcive calls to search path from given start to goal state
(defun path (start goal previousState)
   (cond
      ((null start) nil)   ; base case we are done since we ran out of nodes
      ((equal start goal) (reverse (cons start previousState)))  ; found state
      ((not (member start previousState :test #'equal))  ; checks based off previous states array for already visited state
      ;Needed to override original to compare strings
      ; if we havent visited it lefts try there children
      (or (path (oppositeFsameFGG start) goal (cons start previousState)) ; only farmer crosses
         (path (oppositeFFsameGG start) goal (cons start previousState))     ; farmer takes fox accross with him
         (path (oppositeFGosameFG start) goal (cons start previousState))     ; farme takes goose accrossed with him
         (path (oppositeFGrsameFG start) goal (cons start previousState))  ; takes grain
   ))))
; ;searches path from start to goal
(defun solve-ffgg (start goal)
      ;Checks for valid strings in the list
      (if(not (valid start)) "Invalid start"
      (if(not (valid goal)) "Invalid Goal Node"
      ;Following checks of invalid char in the list
      (if(not (or (equal (first start) 'T) (equal (first start) 'O))) "Invalid first char in start Node"
      (if(not (or (equal (second start) 'T) (equal (second start) 'O))) "Invalid first char in start Node"
      (if(not (or (equal (third start) 'T) (equal (third start) 'O))) "Invalid first char in start Node"
      (if(not (or (equal (fourth start) 'T) (equal (fourth start) 'O))) "Invalid first char in start Node"
      (if(not (or (equal (first goal) 'T) (equal (first goal) 'O))) "Invalid first char in start Node"
      (if(not (or (equal (second goal) 'T) (equal (second goal) 'O))) "Invalid first char in start Node"
      (if(not (or (equal (third goal) 'T) (equal (third goal) 'O))) "Invalid first char in start Node"
      (if(not (or (equal (fourth goal) 'T) (equal (fourth goal) 'O))) "Invalid first char in start Node"
    (path start goal nil)) ; then info corrent
))))))))))