;
; Problema celor n regine
;

(deffacts stare-initiala
; starea este reprezentata de un vector in care poz i inseamna coloana reginei de pe linia i:
  (regine) ; starea initiala: nici o regina pe tabla
; dimensiunea tablei:
  (dimensiune 8)  
; vor fi 3 faze: 
; explorare: intotdeauna dupa ce s-a reusit pozitionarea unei regine pe randul anterior
; explorare-detaliu: in cursul pozitionarii unei regine pe un rand
; backtracking: cand explorarea de detaliu esueaza si trebuie facuta o miscare inapoi
; In starea initiala programul se afla in faza:
  (faza explorare)
)

(defrule terminare-cu-succes
  (declare (salience -10))
  ?f <- (faza explorare)
  (dimensiune ?n)
  (regine $?regs)
;  (regine $?regs&:(= ?n (length $?regs)))
  =>
  (retract ?f)
  (printout t "O solutie gasita este: " $?regs crlf)
)

(defrule terminare-cu-esec
  (faza backtracking)
  (regine)
  =>
  (printout t "Esec!" crlf)
)

(defrule init-explDet
  ?f <- (faza explorare)
  (dimensiune ?n)
  ?s <- (regine $?regs&:(< (length $?regs) ?n))
  =>
  (retract ?f ?s)
  (assert (faza explorare-detaliu)
          (regine $?regs 1))
)

(defrule tranz-explDet-backtracking
  (declare (salience -10))
  ?f <- (faza explorare-detaliu)
  (dimensiune ?n)
  ?r <- (regine $?regs ?n)
  =>
  (retract ?f ?r)
  (assert (faza backtracking)
          (regine $?regs)
  )
)

(defrule backtracking
  ?f <- (faza backtracking)
  (dimensiune ?n)
  ?r <- (regine $?regs ?k&:(< ?k ?n))
  =>
  (retract ?f ?r)
  (assert (faza explorare-detaliu)
          (regine $?regs (+ ?k 1))
  )
)

(defrule backtracking-cap-linie
  (faza backtracking)
  (dimensiune ?n)
  ?r <- (regine $?regs ?k&:(= ?k ?n))
  =>
  (retract ?r)
  (assert (regine $?regs))
)

(defrule explDet-cu-succes
  ?f <- (faza explorare-detaliu)
  (regine $?regs ?k&:(not (member ?k $?regs)))
  (not (regine $?beg ?i $?end ?k&:(= (+ (length $?end) 1) (abs (- ?k ?i)))))
  =>
  (retract ?f)
  (assert (faza explorare))
)

(defrule explDet-nereusita
  (faza explorare-detaliu)
  (dimensiune ?n)
  ?r <- (regine $?regs ?k&:(< ?k ?n))
  (or (regine $?regs ?k&:(member ?k $?regs))
      (regine $?beg ?i $?end ?k&:(= (+ (length $?end) 1) (abs (- ?k ?i)))))
  =>
  (retract ?r)
  (assert (regine $?regs (+ ?k 1)))
)