Wolf - Goat - Cabbage problem by D.S.Larionov

(defun make-state (f w g c)
    (list f w g c)
)

(defun farmer-side (state)
    (nth 0 state)
)

(defun wolf-side (state)
    (nth 1 state)
)

(defun goat-side (state)
    (nth 2 state)
)

(defun cabbage-side (state)
    (nth 3 state)
)

(defun farmer-take-self (state)
    (safe (make-state (opposite (farmer-side state))
                      (wolf-side state)
                      (goat-side state)
                      (cabbage-side state)
          )
    )
)

(defun farmer-take-wolf (state)
    (cond ((equal (farmer-side state) (wolf-side state))
               (safe (make-state (opposite (farmer-side state))
                                 (opposite(wolf-side state))
                                 (goat-side state)
                                 (cabbage-side state))
               )
           )
           (t nil)
    )
)

(defun farmer-take-goat (state)
    (cond ((equal (farmer-side state) (goat-side state))
               (safe (make-state (opposite (farmer-side state))
                                 (wolf-side state)
                                 (opposite (goat-side state))
                                 (cabbage-side state)
                     )
               )
          )
          (t nil)
    )
)

(defun farmer-take-cabbage (state)
    (cond ((equal (farmer-side state) (cabbage-side state))
               (safe (make-state (opposite (farmer-side state))
                                 (wolf-side state)
                                 (goat-side state)
                                 (opposite (cabbage-side state))
                     )
               )
          )
          (t nil)
    )
)

(defun opposite (side)
    (cond ((equal side 'e) 'w)
          ((equal side 'w) 'e)
    )
)

(defun safe (state)
    (cond ((and (equal (goat-side state) (wolf-side state))
                (not (equal (farmer-side state) (wolf-side state)))
           ) nil)
          ((and (equal (goat-side state) (cabbage-side state))
                (not (equal (farmer-side state) (goat-side state)))
           ) nil)
          (t state)
     )
)

(defun path (state goal been-list)
    (cond ((null state) nil)
          ((equal state goal) (reverse (cons state been-list)))
          ((not (member-lis state been-list ))
           (or (path (farmer-take-self state) goal (cons state been-list))
               (path (farmer-take-wolf state) goal (cons state been-list))
               (path (farmer-take-goat state) goal (cons state been-list))
               (path (farmer-take-cabbage state) goal (cons state been-list))
           )
          )
    )
)

(defun member-lis (x lis)
    (cond ((null lis) nil)
          ((equal x (car lis)) t)
          (t (member-lis x (cdr lis)))
    )
)

(defun solve-fwgc (state goal)
    (path state goal nil)
)