; Rosu-Cojocaru Andrei
; 352 C3
; Tema 2 Sisteme Expert - 5 in linie

(clear)

(assert (citeste lamutare))
(assert (lamutare))

;(assert (mutare 1 2 2))
;(assert (mutare 1 2 3))
;(assert (mutare 1 2 4))

(defrule citestelamutare
    (citeste ?ce&:(eq ?ce lamutare))
    ?f <- (lamutare)
    =>
    (retract ?f)
    (printout t "introduceti cine realizeaza prima mutare" crlf)
    (printout t "1 - utilizator" crlf)
    (printout t "2 - calculator" crlf)
    (assert (lamutare (read)))
)

(defrule valideazalamutare
    ?f <- (citeste ?ce&:(eq ?ce lamutare))
    (lamutare ?x&:(or (= ?x 1) (= ?x 2)))
    =>
    (printout t "raspuns valid" crlf)
    (retract ?f)  
    (assert (citeste mutari))
)

(defrule invalideazalamutare
    (citeste ?ce&:(eq ?ce lamutare))
    ?f <- (lamutare ?x&:(and (<> ?x 1) (<> ?x 2)))
    =>
    (printout t "raspuns invalid" crlf)
    (retract ?f)
    (assert (lamutare))
)

(defrule citestemutareutilizator
    ?f <- (citeste ?ce1&:(eq ?ce1 mutari))
    (lamutare ?x&:(= ?x 1))
    (not (verificare ?ce2&:(eq ?ce2 stare)))
    =>
    (printout t "coordonata x la care se muta : ")
    (bind ?coord_x (read))
    (printout t "coordonata y la care se muta : ")
    (bind ?coord_y (read))
    (assert (ultimamutare ?coord_x ?coord_y))
    (retract ?f)
)

(defrule valideazamutareutilizator
    ?f <- (lamutare ?n&:(= ?n 1))
    ?g <- (ultimamutare ?x ?y&:(and (>= ?x 0) (>= ?y 0)))
    (not (mutare ?cine ?x1&:(= ?x ?x1) ?y1&:(= ?y ?y1)))
    =>
    (printout t "mutare valida" crlf)
    (retract ?f)
    (retract ?g)
    (assert (lamutare 2))
    (assert (mutare 1 ?x ?y))
    (assert (verificare stare))
)

(defrule invalideazamutareutilizator1
    (lamutare ?n&:(= ?n 1))
    ?f <- (ultimamutare ?x ?y&:(or (< ?x 0) (< ?y 0)))
    =>
    (printout t "mutare invalida (mutare in afara tablei de joc)" crlf)
    (retract ?f)
    (assert (citeste mutari))    
)

(defrule invalideazamutareutilizator2
    (lamutare ?n&:(= ?n 1))
    ?f <- (ultimamutare ?x ?y)
    (mutare ?cine ?x1&:(= ?x ?x1) ?y1&:(= ?y ?y1))
    =>
    (printout t "mutare invalida (mutare existenta)" crlf)
    (retract ?f)
    (assert (citeste mutari))
)

; mutari castigatoare pentru calculator (4 in linie)

(defrule mutarecalculator4clinie1
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y&:(> (- ?y 1) 0))
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (- ?y 1))))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 3)))
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (- ?y 1) ")" crlf)
    (assert (mutare 2 ?x (- ?y 1)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)


(defrule mutarecalculator4clinie2
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 4))))
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 4) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 4)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4clinie3
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 1))))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 4)))    
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4clinie4
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 2))))    
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 4)))    
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 2)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4clinie5
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 3))))        
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 4)))    
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 3) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 3)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ccoloana1
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(> (- ?x 1) 0) ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 ?y))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (- ?x 1)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (- ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ccoloana2
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 ?y))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 ?y)))            
    
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 4) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 4) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ccoloana3
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 ?y)))            
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 ?y))        
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ccoloana4
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 ?y))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 2) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ccoloana5
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 ?y))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 3) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala11
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(> (- ?x 1) 0) ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (+ ?y 3)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (- ?x 1)) ?y4&:(= ?y4 (- ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala12
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (+ ?y 3)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 4) "," (+ ?y 4) ")" crlf)
    (assert (mutare 2 (+ ?x 4) (+ ?y 4)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala13
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (+ ?y 4)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 (+ ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala14
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (+ ?y 4)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala15
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (+ ?y 4)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," (+ ?y 3) ")" crlf)
    (assert (mutare 2 (+ ?x 3) (+ ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala21
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(> (- ?x 1) 0) ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0)))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (- ?y 3)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (- ?x 1)) ?y4&:(= ?y4 (+ ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala22
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0) (> (- ?y 4) 0)))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (- ?y 3)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (- ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 4) "," (- ?y 4) ")" crlf)
    (assert (mutare 2 (+ ?x 4) (- ?y 4)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala23
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0) (> (- ?y 4) 0)))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (- ?y 2)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (- ?y 4)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 (- ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala24
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0) (> (- ?y 4) 0)))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (- ?y 4)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (- ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (- ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4cdiagonala25
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0) (> (- ?y 4) 0)))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (mutare ?n&:(= ?n 2) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (- ?y 4)))    
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (- ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," (- ?y 3) ")" crlf)
    (assert (mutare 2 (+ ?x 3) (- ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

; mutari castigatoare pentru utilizator (4 in linie)

(defrule mutarecalculator4ulinie1
    (declare (salience 15))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(> (- ?y 1) 0))
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (- ?y 1))))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 3)))
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (- ?y 1) ")" crlf)
    (assert (mutare 2 ?x (- ?y 1)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ulinie2
    (declare (salience 15))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 4))))
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 4) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 4)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ulinie3
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 1))))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 4)))    
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ulinie4
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 2))))    
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 4)))    
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 2)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ulinie5
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))    
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 3))))        
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 4)))    
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 3) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 3)))
    (assert (verifica stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ucoloana1
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 ?y))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (- ?x 1)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (- ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ucoloana2
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 ?y))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 ?y)))            
    
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 4) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 4) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ucoloana3
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 ?y)))            
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 ?y))        
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ucoloana4
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 ?y))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 2) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4ucoloana5
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 ?y))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 3) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala11
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (+ ?y 3)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (- ?x 1)) ?y4&:(= ?y4 (- ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala12
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (+ ?y 3)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 4) "," (+ ?y 4) ")" crlf)
    (assert (mutare 2 (+ ?x 4) (+ ?y 4)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala13
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (+ ?y 4)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 (+ ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala14
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (+ ?y 4)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala15
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (+ ?y 4)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," (+ ?y 3) ")" crlf)
    (assert (mutare 2 (+ ?x 3) (+ ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala21
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (- ?y 3)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (- ?x 1)) ?y4&:(= ?y4 (+ ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala22
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0) (> (- ?y 4) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (- ?y 3)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (- ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 4) "," (- ?y 4) ")" crlf)
    (assert (mutare 2 (+ ?x 4) (- ?y 4)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala23
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0) (> (- ?y 4) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (- ?y 4)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 (- ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala24
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0) (> (- ?y 4) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (- ?y 4)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (- ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (- ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator4udiagonala25
    (declare (salience 20))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0) (> (- ?y 3) 0) (> (- ?y 4) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x3&:(= ?x3 (+ ?x 4)) ?y3&:(= ?y3 (- ?y 4)))    
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (- ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," (- ?y 3) ")" crlf)
    (assert (mutare 2 (+ ?x 3) (- ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

; mutari castigatoare pentru utilizator (3 in linie)

(defrule mutarecalculator3ulinie1
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (- ?y 1) ")" crlf)
    (assert (mutare 2 ?x (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie2
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie3
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie4
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (- ?y 1) ")" crlf)
    (assert (mutare 2 ?x (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie5
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 3)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie6
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie7
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie8
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 2))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie9
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 2))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie10
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 3))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 3) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana1
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(and (> (- ?x 2) 0) (> (- ?x 1) 0)) ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 2)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (- ?x 1)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (- ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana2
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana3
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 2) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana4
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 3) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana5
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 3)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana6
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana7
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana8
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 2) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana9
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 4) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 4) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ucoloana10
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 3) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala11
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(and (> (- ?x 2) 0) (> (- ?x 1) 0)) ?y&:(and (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (- ?x 2)) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala12
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 (+ ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala13
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala14
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala15
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 3)) ?y1&:(= ?y1 (+ ?y 3)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala16
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala17
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala18
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 (+ ?y 2))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala19
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 (+ ?y 2))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala110
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (+ ?y 3))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," (+ ?y 3) ")" crlf)
    (assert (mutare 2 (+ ?x 3) (+ ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala21
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(and (> (- ?x 2) 0) (> (- ?x 1) 0)) ?y&:(and (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (- ?x 2)) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala22
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(and (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 (- ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala23
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(and (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (- ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (- ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala24
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(and (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (- ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala25
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 3)) ?y1&:(= ?y1 (- ?y 3)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (- ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala26
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (- ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (- ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala27
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (- ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala28
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (- ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 (- ?y 2))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (- ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (- ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (- ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala29
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 (- ?y 2))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (- ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (- ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (- ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala210
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (- ?y 3))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (- ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," (- ?y 3) ")" crlf)
    (assert (mutare 2 (+ ?x 3) (- ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

; mutari castigatoare pentru calculator (3 in linie)

(defrule mutarecalculator3clinie1
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y&:(and (> (- ?y 1) 0) (> (- ?y 2) 0)))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (- ?y 1) ")" crlf)
    (assert (mutare 2 ?x (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3clinie2
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3clinie3
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ulinie4
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (- ?y 1) ")" crlf)
    (assert (mutare 2 ?x (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3clinie5
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 3)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3clinie6
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3clinie7
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3clinie8
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 2))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3clinie9
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 2))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3clinie10
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 3))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" ?x "," (+ ?y 3) ")" crlf)
    (assert (mutare 2 ?x (+ ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana1
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(and (> (- ?x 2) 0) (> (- ?x 1) 0)) ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (- ?x 2)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (- ?x 1)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (- ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana2
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(> (- ?x 1) 0) ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana3
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(> (- ?x 1) 0) ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 2) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana4
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(> (- ?x 1) 0) ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 3) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana5
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 3)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana6
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana7
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 1) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana8
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 2) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana9
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 4) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 4) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3ccoloana5
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 ?y)))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 ?y)))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," ?y ")" crlf)
    (assert (mutare 2 (+ ?x 3) ?y))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala11
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(and (> (- ?x 2) 0) (> (- ?x 1) 0)) ?y&:(and (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (- ?x 2)) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala12
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(> (- ?x 1) 0) ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 (+ ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala13
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(> (- ?x 1) 0) ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala14
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x&:(> (- ?x 1) 0) ?y&:(> (- ?y 1) 0))
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala15
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 3)) ?y1&:(= ?y1 (+ ?y 3)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala16
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala17
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (+ ?y 2)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala18
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (+ ?y 4)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 (+ ?y 2))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (+ ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala19
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (mutare ?n&:(= ?n 2) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 2) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (+ ?y 3)))
    (not (mutare ?n2&:(= ?n2 1) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 (+ ?y 2))))            
    (not (mutare ?n2&:(= ?n2 1) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (+ ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (+ ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3cdiagonala110
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (+ ?y 3))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (+ ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," (+ ?y 3) ")" crlf)
    (assert (mutare 2 (+ ?x 3) (+ ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala21
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(and (> (- ?x 2) 0) (> (- ?x 1) 0)) ?y&:(and (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (- ?x 2)) ?y4&:(= ?y4 (+ ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala22
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(and (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 1)) ?y4&:(= ?y4 (- ?y 1))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala23
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(and (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (- ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (- ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala24
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x&:(> (- ?x 1) 0) ?y&:(and (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (- ?x 1)) ?y3&:(= ?y3 (+ ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (- ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (- ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (- ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala25
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 3)) ?y1&:(= ?y1 (- ?y 3)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (- ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 2)) ?y4&:(= ?y4 (- ?y 2))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala26
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (- ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (- ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala27
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 2)) ?y1&:(= ?y1 (- ?y 2)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 1)) ?y3&:(= ?y3 (- ?y 1))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (- ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (- ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (- ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala28
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 4)) ?y2&:(= ?y2 (- ?y 4)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 (- ?y 2))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 3)) ?y4&:(= ?y4 (- ?y 3))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (- ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (- ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala29
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 3)) ?y2&:(= ?y2 (- ?y 3)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 2)) ?y3&:(= ?y3 (- ?y 2))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (- ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 2) "," (- ?y 2) ")" crlf)
    (assert (mutare 2 (+ ?x 2) (- ?y 2)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator3udiagonala210
    (declare (salience 10))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y&:(and (> (- ?y 4) 0) (> (- ?y 3) 0) (> (- ?y 2) 0) (> (- ?y 1) 0)))
    (mutare ?n&:(= ?n 1) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n&:(= ?n 1) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (not (mutare ?n2&:(= ?n2 2) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (- ?y 3))))            
    (not (mutare ?n2&:(= ?n2 2) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (- ?y 4))))            
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 3) "," (- ?y 3) ")" crlf)
    (assert (mutare 2 (+ ?x 3) (- ?y 3)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)





(defrule mutarecalculator1
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 2) ?x ?y)
    (not (mutare ?n2 ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1))))
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule mutarecalculator2
    (declare (salience 5))
    (citeste ?ce&:(eq ?ce mutari))
    ?f <- (lamutare ?cine&:(= ?cine 2))
    (mutare ?n&:(= ?n 1) ?x ?y)
    (not (mutare ?n2 ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1))))
    =>
    (printout t "calculator muta pe pozitia (" (+ ?x 1) "," (+ ?y 1) ")" crlf)
    (assert (mutare 2 (+ ?x 1) (+ ?y 1)))
    (assert (verificare stare))
    (retract ?f)
    (assert (lamutare 1))
)

(defrule stabilestecastigatorlinie
    (declare (salience 10))
    (verificare ?ce&:(eq ?ce stare))
    (mutare ?n ?x ?y)
    (mutare ?n1&:(= ?n1 ?n) ?x1&:(= ?x1 ?x) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n2&:(= ?n2 ?n) ?x2&:(= ?x2 ?x) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n3&:(= ?n3 ?n) ?x3&:(= ?x3 ?x) ?y3&:(= ?y3 (+ ?y 3)))
    (mutare ?n4&:(= ?n4 ?n) ?x4&:(= ?x4 ?x) ?y4&:(= ?y4 (+ ?y 4)))
    =>
    (printout t "a castigat jucatorul " ?n " deoarece a realizat 5 in linie pe linia " ?x " de la coloana " ?y " la coloana " ?y4 crlf)
    (halt)    
)

(defrule stabilestecastigatorcoloana
    (declare (salience 10))
    (verificare ?ce&:(eq ?ce stare))
    (mutare ?n ?x ?y)
    (mutare ?n1&:(= ?n1 ?n) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 ?y))
    (mutare ?n2&:(= ?n2 ?n) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 ?y))
    (mutare ?n3&:(= ?n3 ?n) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 ?y))
    (mutare ?n4&:(= ?n4 ?n) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 ?y))
    =>
    (printout t "a castigat jucatorul " ?n " deoarece a realizat 5 in linie pe coloana " ?y " de la linia " ?x " la coloana " ?x4 crlf)
    (halt)    
)

(defrule stabilestecastigatordiagonala1
    (declare (salience 10))
    (verificare ?ce&:(eq ?ce stare))
    (mutare ?n ?x ?y)
    (mutare ?n1&:(= ?n1 ?n) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (+ ?y 1)))
    (mutare ?n2&:(= ?n2 ?n) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (+ ?y 2)))
    (mutare ?n3&:(= ?n3 ?n) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (+ ?y 3)))
    (mutare ?n4&:(= ?n4 ?n) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (+ ?y 4)))
    =>
    (printout t "a castigat jucatorul " ?n " deoarece a realizat 5 in linie pe diagonala de tip 1 de la celula (" ?x "," ?y ") la celula " ?x4 "," ?y4 ")" crlf)
    (halt)    
)

(defrule stabilestecastigatordiagonala2
    (declare (salience 10))
    (verificare ?ce&:(eq ?ce stare))
    (mutare ?n ?x ?y)
    (mutare ?n1&:(= ?n1 ?n) ?x1&:(= ?x1 (+ ?x 1)) ?y1&:(= ?y1 (- ?y 1)))
    (mutare ?n2&:(= ?n2 ?n) ?x2&:(= ?x2 (+ ?x 2)) ?y2&:(= ?y2 (- ?y 2)))
    (mutare ?n3&:(= ?n3 ?n) ?x3&:(= ?x3 (+ ?x 3)) ?y3&:(= ?y3 (- ?y 3)))
    (mutare ?n4&:(= ?n4 ?n) ?x4&:(= ?x4 (+ ?x 4)) ?y4&:(= ?y4 (- ?y 4)))
    =>
    (printout t "a castigat jucatorul " ?n " deoarece a realizat 5 in linie pe diagonala de tip 2 de la celula (" ?x "," ?y ") la celula " ?x4 "," ?y4 ")" crlf)
    (halt)    
)

(defrule nustabilestecastigator
    ?f <- (verificare ?ce&:(eq ?ce stare))
    =>
    (printout t "nu exista inca castigator" crlf)
    (retract ?f)
    (assert (citeste mutari))
)

(run)