# HG changeset patch # User Steve Losh # Date 1489509343 0 # Node ID 3f23f6b95cac6ae02f95b14114836bfb6abe9957 # Parent 49fd0e0e0c80f6c7b1c1c0d19d2803956339a4d0 Fix parsing to not be recursive diff -r 49fd0e0e0c80 -r 3f23f6b95cac gdl/kriegTTT_5x5.gdl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gdl/kriegTTT_5x5.gdl Tue Mar 14 16:35:43 2017 +0000 @@ -0,0 +1,171 @@ +(role xplayer) +(role oplayer) + +(init (cell 1 1 b)) +(init (cell 1 2 b)) +(init (cell 1 3 b)) +(init (cell 1 4 b)) +(init (cell 1 5 b)) +(init (cell 2 1 b)) +(init (cell 2 2 b)) +(init (cell 2 3 b)) +(init (cell 2 4 b)) +(init (cell 2 5 b)) +(init (cell 3 1 b)) +(init (cell 3 2 b)) +(init (cell 3 3 b)) +(init (cell 3 4 b)) +(init (cell 3 5 b)) +(init (cell 4 1 b)) +(init (cell 4 2 b)) +(init (cell 4 3 b)) +(init (cell 4 4 b)) +(init (cell 4 5 b)) +(init (cell 5 1 b)) +(init (cell 5 2 b)) +(init (cell 5 3 b)) +(init (cell 5 4 b)) +(init (cell 5 5 b)) +(init (step 1)) + +(<= (legal ?p (mark ?m ?n)) + (role ?p) + (true (cell ?m ?n ?c)) + (distinct ?c ?p) + (not (true (tried ?p ?m ?n)))) + +(<= doublehit + (does xplayer (mark ?m ?n)) + (does oplayer (mark ?m ?n))) + +(<= (validmove ?p ?m ?n) + (does ?p (mark ?m ?n)) + (true (cell ?m ?n b)) + (not doublehit)) + +(<= (marked ?m ?n) + (does ?p (mark ?m ?n)) + (not doublehit)) + +(<= (next (cell ?m ?n ?p)) + (validmove ?p ?m ?n)) + +(<= (next (cell ?m ?n ?c)) + (true (cell ?m ?n ?c)) + (distinct ?c b)) + +(<= (next (cell ?m ?n b)) + (true (cell ?m ?n b)) + (not (marked ?m ?n))) + +(<= (next (tried ?p ?m ?n)) + (does ?p (mark ?m ?n)) + (not (validmove ?p ?m ?n))) + +(<= (next (tried ?p ?m1 ?n1)) + (true (tried ?p ?m1 ?n1)) + (does ?p (mark ?m2 ?n2)) + (not (validmove ?p ?m2 ?n2))) + +(<= (next (step ?n)) + (true (step ?m)) + (succ ?m ?n)) + +(<= (sees ?p (yougotit ?m ?n)) + (validmove ?p ?m ?n)) + +(<= (sees ?p (mark ?m ?n)) + (does ?p (mark ?m ?n)) + (not (validmove ?p ?m ?n))) + +(<= terminal + (line xplayer)) + +(<= terminal + (line oplayer)) + +(<= terminal + (not open)) + +(<= terminal + (true (step 30))) + +(<= (line ?c) + (true (cell ?m 1 ?c)) + (true (cell ?m 2 ?c)) + (true (cell ?m 3 ?c)) + (true (cell ?m 4 ?c))) + +(<= (line ?c) + (true (cell ?m 2 ?c)) + (true (cell ?m 3 ?c)) + (true (cell ?m 4 ?c)) + (true (cell ?m 5 ?c))) + +(<= (line ?c) + (true (cell 1 ?n ?c)) + (true (cell 2 ?n ?c)) + (true (cell 3 ?n ?c)) + (true (cell 4 ?n ?c))) + +(<= (line ?c) + (true (cell 2 ?n ?c)) + (true (cell 3 ?n ?c)) + (true (cell 4 ?n ?c)) + (true (cell 5 ?n ?c))) + +(<= open + (true (cell ?m1 ?n1 b)) + (not (true (tried xplayer ?m1 ?n1))) + (true (cell ?m2 ?n2 b)) + (not (true (tried oplayer ?m2 ?n2)))) + +(<= (goal xplayer 100) + (line xplayer)) + +(<= (goal xplayer 50) + (not (line xplayer)) + (not (line oplayer))) + +(<= (goal xplayer 0) + (line oplayer)) + +(<= (goal oplayer 100) + (line oplayer)) + +(<= (goal oplayer 50) + (not (line xplayer)) + (not (line oplayer))) + +(<= (goal oplayer 0) + (line xplayer)) + +(succ 1 2) +(succ 2 3) +(succ 3 4) +(succ 4 5) +(succ 5 6) +(succ 6 7) +(succ 7 8) +(succ 8 9) +(succ 9 10) +(succ 10 11) +(succ 11 12) +(succ 12 13) +(succ 13 14) +(succ 14 15) +(succ 15 16) +(succ 16 17) +(succ 17 18) +(succ 18 19) +(succ 19 20) +(succ 20 21) +(succ 21 22) +(succ 22 23) +(succ 23 24) +(succ 24 25) +(succ 25 26) +(succ 26 27) +(succ 27 28) +(succ 28 29) +(succ 29 30) \ No newline at end of file diff -r 49fd0e0e0c80 -r 3f23f6b95cac gdl/latenttictactoe.gdl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gdl/latenttictactoe.gdl Tue Mar 14 16:35:43 2017 +0000 @@ -0,0 +1,262 @@ +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Latent Tictactoe +;;; Based on Tictactoe game available at GGP-Server +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Created by: Tomas Motal (tmotal@labe.felk.cvut.cz) +;;; Czech Technical University in Prague +;;; Faculty of Elektrotechnics, department of Cybernetics. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Rules: The same rules as for standard tic tac toe apply only players do not +;; see opponent's moves unless they try to put their mark on a location where +;; there already is opponent's mark from the previous turns. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Roles +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + (role xplayer) + (role oplayer) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Initial State +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + (init (cell 1 1 b)) + (init (cell 1 2 b)) + (init (cell 1 3 b)) + (init (cell 2 1 b)) + (init (cell 2 2 b)) + (init (cell 2 3 b)) + (init (cell 3 1 b)) + (init (cell 3 2 b)) + (init (cell 3 3 b)) + (init (deniedx 1 1 b)) + (init (deniedx 1 2 b)) + (init (deniedx 1 3 b)) + (init (deniedx 2 1 b)) + (init (deniedx 2 2 b)) + (init (deniedx 2 3 b)) + (init (deniedx 3 1 b)) + (init (deniedx 3 2 b)) + (init (deniedx 3 3 b)) + (init (deniedo 1 1 b)) + (init (deniedo 1 2 b)) + (init (deniedo 1 3 b)) + (init (deniedo 2 1 b)) + (init (deniedo 2 2 b)) + (init (deniedo 2 3 b)) + (init (deniedo 3 1 b)) + (init (deniedo 3 2 b)) + (init (deniedo 3 3 b)) + (init (control xplayer)) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Dynamic Components +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + (<= (next (cell ?m ?n x)) + (does xplayer (mark ?m ?n)) + (true (cell ?m ?n b))) + + (<= (next (deniedx ?m ?n x)) + (does xplayer (mark ?m ?n)) + (true (deniedx ?m ?n b))) + + (<= (next (cell ?m ?n o)) + (does oplayer (mark ?m ?n)) + (true (cell ?m ?n b))) + + (<= (next (deniedo ?m ?n x)) + (does oplayer (mark ?m ?n)) + (true (deniedo ?m ?n b))) + + (<= (next (cell ?m ?n ?w)) + (true (cell ?m ?n ?w)) + (distinct ?w b)) + + (<= (next (cell ?m ?n b)) + (does ?w (mark ?j ?k)) + (true (cell ?m ?n b)) + (or (distinct ?m ?j) (distinct ?n ?k))) + + (<= (next (deniedx ?m ?n x)) + (true (deniedx ?m ?n x))) + + (<= (next (deniedo ?m ?n x)) + (true (deniedo ?m ?n x))) + + (<= (next (deniedx ?m ?n b)) + (does xplayer (mark ?j ?k)) + (true (deniedx ?m ?n b)) + (or (distinct ?m ?j) (distinct ?n ?k))) + + (<= (next (deniedo ?m ?n b)) + (does oplayer (mark ?j ?k)) + (true (deniedo ?m ?n b)) + (or (distinct ?m ?j) (distinct ?n ?k))) + + (<= (next (deniedo ?m ?n b)) + (does xplayer (mark ?m ?n)) + (true (deniedo ?m ?n b))) + + (<= (next (deniedx ?m ?n b)) + (does oplayer (mark ?m ?n)) + (true (deniedx ?m ?n b))) + + (<= (next (deniedo ?m ?n b)) + (does xplayer (mark ?j ?k)) + (true (deniedo ?m ?n b)) + (or (distinct ?m ?j) (distinct ?n ?k))) + + (<= (next (deniedx ?m ?n b)) + (does oplayer (mark ?j ?k)) + (true (deniedx ?m ?n b)) + (or (distinct ?m ?j) (distinct ?n ?k))) + + (<= (row ?m ?x) + (true (cell ?m 1 ?x)) + (true (cell ?m 2 ?x)) + (true (cell ?m 3 ?x))) + + (<= (column ?n ?x) + (true (cell 1 ?n ?x)) + (true (cell 2 ?n ?x)) + (true (cell 3 ?n ?x))) + + (<= (diagonal ?x) + (true (cell 1 1 ?x)) + (true (cell 2 2 ?x)) + (true (cell 3 3 ?x))) + + (<= (diagonal ?x) + (true (cell 1 3 ?x)) + (true (cell 2 2 ?x)) + (true (cell 3 1 ?x))) + + (<= (line ?x) (row ?m ?x)) + (<= (line ?x) (column ?m ?x)) + (<= (line ?x) (diagonal ?x)) + + (<= open + (true (cell ?m ?n b))) + + (<= (next (control oplayer)) + (does xplayer (mark ?x ?y)) + (legal xplayer (mark ?x ?y)) + (true (cell ?x ?y b)) + (true (control xplayer))) + + (<= (next (control xplayer)) + (does xplayer (mark ?x ?y)) + (legal xplayer (mark ?x ?y)) + (true (cell ?x ?y o)) + (true (control xplayer))) + + (<= (next (control xplayer)) + (does oplayer (mark ?x ?y)) + (legal oplayer (mark ?x ?y)) + (true (cell ?x ?y b)) + (true (control oplayer))) + + (<= (next (control oplayer)) + (does oplayer (mark ?x ?y)) + (legal oplayer (mark ?x ?y)) + (true (cell ?x ?y x)) + (true (control oplayer))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Sees terms +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + (<= (sees oplayer controlo) + (does oplayer (mark ?x ?y)) + (legal oplayer (mark ?x ?y)) + (true (cell ?x ?y x)) + (true (control oplayer))) + + (<= (sees xplayer controlx) + (does xplayer (mark ?x ?y)) + (legal xplayer (mark ?x ?y)) + (true (cell ?x ?y o)) + (true (control xplayer))) + + (<= (sees xplayer controlx) + (does oplayer (mark ?x ?y)) + (legal oplayer (mark ?x ?y)) + (true (cell ?x ?y b)) + (true (control oplayer))) + + (<= (sees oplayer controlo) + (does xplayer (mark ?x ?y)) + (legal xplayer (mark ?x ?y)) + (true (cell ?x ?y b)) + (true (control xplayer))) + + (<= (sees ?w (mark ?x ?y)) + (does ?w (mark ?x ?y)) + (legal ?w (mark ?x ?y))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Legality of moves +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + (<= (legal xplayer (mark ?x ?y)) + (true (deniedx ?x ?y b)) + (true (control xplayer))) + + (<= (legal oplayer (mark ?x ?y)) + (true (deniedo ?x ?y b)) + (true (control oplayer))) + + (<= (legal xplayer noop) + (true (control oplayer))) + + (<= (legal oplayer noop) + (true (control xplayer))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Goals +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + (<= (goal xplayer 100) + (line x)) + + (<= (goal xplayer 50) + (not (line x)) + (not (line o)) + (not open)) + + (<= (goal xplayer 0) + (line o)) + + (<= (goal oplayer 100) + (line o)) + + (<= (goal oplayer 50) + (not (line x)) + (not (line o)) + (not open)) + + (<= (goal oplayer 0) + (line x)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Terminal states +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + (<= terminal + (line x)) + + (<= terminal + (line o)) + + (<= terminal + (not open)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; \ No newline at end of file diff -r 49fd0e0e0c80 -r 3f23f6b95cac gdl/mastermind.gdl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gdl/mastermind.gdl Tue Mar 14 16:35:43 2017 +0000 @@ -0,0 +1,471 @@ +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Mastermind +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Version with four colors, four places and 8 chances to make the +;;; right guess. After each move, the player is informed exactly +;;; which colors were guessed correctly. +;;; +;;; GDL description by Tim Federholzner and Peter Kissmann +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; roles +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(role random) +(role player) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; initial state +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; The step counter is initialized to the setup phase. +(init (guess setup)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; legal rules +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; The random player sets up the colors in the first step. +(<= (legal random (set ?c1 ?c2 ?c3 ?c4)) + (true (guess setup)) + (color ?c1) + (color ?c2) + (color ?c3) + (color ?c4) +) + +;;; After the first step the random player can only watch the actual +;;; player. +(<= (legal random watch) + (true (guess ?g)) + (distinct ?g setup) +) + +;;; In the first step the actual player has to wait. +(<= (legal player wait) + (true (guess setup)) +) + +;;; After the first step the actual player can guess the four colors. +(<= (legal player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?g)) + (distinct ?g setup) + (color ?c1) + (color ?c2) + (color ?c3) + (color ?c4) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; next rules +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; The four places are colored the way chosen by the random player. +(<= (next (set 1 ?c1)) + (does random (set ?c1 ?c2 ?c3 ?c4)) +) +(<= (next (set 2 ?c2)) + (does random (set ?c1 ?c2 ?c3 ?c4)) +) +(<= (next (set 3 ?c3)) + (does random (set ?c1 ?c2 ?c3 ?c4)) +) +(<= (next (set 4 ?c4)) + (does random (set ?c1 ?c2 ?c3 ?c4)) +) + +;;; Once colored the places do not change their color. +(<= (next (set ?n ?c)) + (true (set ?n ?c)) +) + +;;; The last move is stored (in order to use it in the terminal and +;;; goal descriptions). +(<= (next (playerset ?c1 ?c2 ?c3 ?c4)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) +) + +;;; Increasing the step counter. +(<= (next (guess ?g2)) + (true (guess ?g1)) + (succ ?g1 ?g2) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; visualization fluents +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(slot 1) +(slot 2) +(slot 3) +(slot 4) + +(<= (next (cell 1 ?n ?c1)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) +) +(<= (next (cell 2 ?n ?c2)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) +) +(<= (next (cell 3 ?n ?c3)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) +) +(<= (next (cell 4 ?n ?c4)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) +) + +(<= (next (cell ?slot ?number ?color)) + (true (cell ?slot ?number ?color)) +) + +(<= (next (cell 5 ?n white)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) + (not (true (set 1 ?c1))) +) +(<= (next (cell 6 ?n white)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) + (not (true (set 2 ?c2))) +) +(<= (next (cell 7 ?n white)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) + (not (true (set 3 ?c3))) +) +(<= (next (cell 8 ?n white)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) + (not (true (set 4 ?c4))) +) + +(<= (next (cell 5 ?n black)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) + (true (set 1 ?c1)) +) +(<= (next (cell 6 ?n black)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) + (true (set 2 ?c2)) +) +(<= (next (cell 7 ?n black)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) + (true (set 3 ?c3)) +) +(<= (next (cell 8 ?n black)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (guess ?n0)) + (succ ?n0 ?n) + (true (set 4 ?c4)) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; sees rules +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; The random player knows all moves. +(<= (sees random (does ?r ?m)) + (does ?r ?m) +) + +;;; The actual player sees only its own moves - to ensure that it +;;; knows which move has been performed in case of a timeout or +;;; similar. +(<= (sees player (does player ?m)) + (does player ?m) +) + +;;; The player is informed of all colors correctly guessed. +(<= (sees player (set 1 ?c1)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?c1)) +) +(<= (sees player (set 2 ?c2)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (set 2 ?c2)) +) +(<= (sees player (set 3 ?c3)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (set 3 ?c3)) +) +(<= (sees player (set 4 ?c4)) + (does player (guessColors ?c1 ?c2 ?c3 ?c4)) + (true (set 4 ?c4)) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; terminal states +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; The game ends after eight guesses. +(<= terminal + (true (guess 8)) +) + +;;; The game also ends once the player has guessed the colors of all +;;; four places correctly. +(<= terminal + fourMatches +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; goal definitions +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; The random player always gets 100 points. +(goal random 100) + +;;; A good player should be able to find the correct solution in at +;;; most four guesses, which results in 100 points. +(<= (goal player 100) + (true (guess 1)) + fourMatches +) +(<= (goal player 100) + (true (guess 2)) + fourMatches +) +(<= (goal player 100) + (true (guess 3)) + fourMatches +) +(<= (goal player 100) + (true (guess 4)) + fourMatches +) + +;;; If guessing all colors correctly took longer than four guesses +;;; the reward is successively decreased. +(<= (goal player 95) + (true (guess 5)) + fourMatches +) + +(<= (goal player 90) + (true (guess 6)) + fourMatches +) + +(<= (goal player 85) + (true (guess 7)) + fourMatches +) + +(<= (goal player 80) + (true (guess 8)) + fourMatches +) + +;;; Guessing less than four colors correctly in the final try results +;;; in successively decreasing rewards. +(<= (goal player 50) + (true (guess 8)) + threeMatches +) + +(<= (goal player 35) + (true (guess 8)) + twoMatches +) + +(<= (goal player 15) + (true (guess 8)) + oneMatch +) + +(<= (goal player 0) + (true (guess 8)) + noMatch +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; utility rules +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; The possible colors. +(color red) +(color blue) +(color green) +(color pink) + +;;; The successor relation (needed for the step counter "guess"). +(succ setup start) +(succ start 1) +(succ 1 2) +(succ 2 3) +(succ 3 4) +(succ 4 5) +(succ 5 6) +(succ 6 7) +(succ 7 8) + +;;; All colors guessed correctly in the last guess. +(<= fourMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?c1)) + (true (set 2 ?c2)) + (true (set 3 ?c3)) + (true (set 4 ?c4)) +) + +;;; In the last guess exactly three colors matched. +(<= threeMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?s1)) + (true (set 2 ?c2)) + (true (set 3 ?c3)) + (true (set 4 ?c4)) + (distinct ?s1 ?c1) +) +(<= threeMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?c1)) + (true (set 2 ?s2)) + (true (set 3 ?c3)) + (true (set 4 ?c4)) + (distinct ?s2 ?c2) +) +(<= threeMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?c1)) + (true (set 2 ?c2)) + (true (set 3 ?s3)) + (true (set 4 ?c4)) + (distinct ?s3 ?c3) +) +(<= threeMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?c1)) + (true (set 2 ?c2)) + (true (set 3 ?c3)) + (true (set 4 ?s4)) + (distinct ?s4 ?c4) +) + +;;; In the last guess exactly two colors matched. +(<= twoMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?c1)) + (true (set 2 ?c2)) + (true (set 3 ?s3)) + (true (set 4 ?s4)) + (distinct ?s3 ?c3) + (distinct ?s4 ?c4) +) +(<= twoMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?c1)) + (true (set 2 ?s2)) + (true (set 3 ?c3)) + (true (set 4 ?s4)) + (distinct ?s2 ?c2) + (distinct ?s4 ?c4) +) +(<= twoMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?c1)) + (true (set 2 ?s2)) + (true (set 3 ?s3)) + (true (set 4 ?c4)) + (distinct ?s2 ?c2) + (distinct ?s3 ?c3) +) +(<= twoMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?s1)) + (true (set 2 ?c2)) + (true (set 3 ?c3)) + (true (set 4 ?s4)) + (distinct ?s1 ?c1) + (distinct ?s4 ?c4) +) +(<= twoMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?s1)) + (true (set 2 ?c2)) + (true (set 3 ?s3)) + (true (set 4 ?c4)) + (distinct ?s1 ?c1) + (distinct ?s3 ?c3) +) +(<= twoMatches + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?s1)) + (true (set 2 ?s2)) + (true (set 3 ?c3)) + (true (set 4 ?c4)) + (distinct ?s1 ?c1) + (distinct ?s2 ?c2) +) + +;;; In the last guess exactly one color matched. +(<= oneMatch + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?c1)) + (true (set 2 ?s2)) + (true (set 3 ?s3)) + (true (set 4 ?s4)) + (distinct ?s2 ?c2) + (distinct ?s3 ?c3) + (distinct ?s4 ?c4) +) +(<= oneMatch + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?s1)) + (true (set 2 ?c2)) + (true (set 3 ?s3)) + (true (set 4 ?s4)) + (distinct ?s1 ?c1) + (distinct ?s3 ?c3) + (distinct ?s4 ?c4) +) +(<= oneMatch + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?s1)) + (true (set 2 ?s2)) + (true (set 3 ?c3)) + (true (set 4 ?s4)) + (distinct ?s1 ?c1) + (distinct ?s2 ?c2) + (distinct ?s4 ?c4) +) +(<= oneMatch + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?s1)) + (true (set 2 ?s2)) + (true (set 3 ?s3)) + (true (set 4 ?c4)) + (distinct ?s1 ?c1) + (distinct ?s2 ?c2) + (distinct ?s3 ?c3) +) + +;;; The last guess was completely incorrect. +(<= noMatch + (true (playerset ?c1 ?c2 ?c3 ?c4)) + (true (set 1 ?s1)) + (true (set 2 ?s2)) + (true (set 3 ?s3)) + (true (set 4 ?s4)) + (distinct ?s1 ?c1) + (distinct ?s2 ?c2) + (distinct ?s3 ?c3) + (distinct ?s4 ?c4) +) \ No newline at end of file diff -r 49fd0e0e0c80 -r 3f23f6b95cac gdl/small_dominion.gdl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gdl/small_dominion.gdl Tue Mar 14 16:35:43 2017 +0000 @@ -0,0 +1,92 @@ +(role duke) (role earl) (role random) +(init (control random)) +(init (deck duke 0 copper)) (init (deck duke 1 copper)) (init (deck duke 2 copper)) (init (deck duke 3 copper)) (init (deck duke 4 estate)) (init (deck duke 5 estate)) (init (decksize duke 5)) (init (victory duke 2)) (init (deck earl 0 copper)) (init (deck earl 1 copper)) (init (deck earl 2 copper)) (init (deck earl 3 copper)) (init (deck earl 4 estate)) (init (deck earl 5 estate)) (init (decksize earl 5)) (init (victory earl 2)) +(init (table 10 estate)) (init (table 5 duchy)) (init (table 30 copper)) (init (table 5 silver)) +(value copper 1) (value silver 2) (value estate 0) (value duchy 0) +(points estate 1) (points duchy 4) (points copper 0) (points silver 0) +(cost copper 0) (cost silver 2) (cost estate 1) (cost duchy 3) + +; a hand is 3 random cards (discarded + bought cards are shuffled in immediately) +(<= (legal random (deal ?player ?a ?b ?c)) (role ?player) (distinct ?player random) (not (true (control ?player))) (not (true (control random))) (true (decksize ?player ?x)) (greater_than_equals ?x ?a) (greater_than_equals ?x ?b) (distinct ?a ?b) (greater_than_equals ?x ?c) (distinct ?a ?c) (distinct ?b ?c)) +(<= (legal random (deal duke ?a ?b ?c)) (true (control random)) (true (decksize duke ?x)) (greater_than_equals ?x ?a) (greater_than_equals ?x ?b) (distinct ?a ?b) (greater_than_equals ?x ?c) (distinct ?a ?c) (distinct ?b ?c)) + +(<= (legal ?player noop) (true dealing) (role ?player) (distinct ?player random)) +(<= (legal ?player (buy copper)) (true (control ?player)) (distinct ?player random)) +(<= (legal ?player (buy ?card)) + (true (control ?player)) (distinct ?player random) (cost ?card ?price) (true (money ?player ?x)) (greater_than_equals ?x ?price) (true (table ?y ?card)) + ;(greater_than_equals ?y 1) + (distinct ?y 0) + ) + +; unsafe rule +; (<= (legal ?player noop) (not (true (control ?player))) (distinct ?player random)) +; fixed version +(<= (legal ?player noop) (role ?player) (not (true (control ?player))) (distinct ?player random)) + +(<= (sees ?player (hand ?a ?b ?c)) (does random (deal ?player ?a ?b ?c))) +; unsafe rule +; (<= (sees ?player (table ?x ?card)) (true (table ?y ?card)) (does ?anyplayer (buy ?card)) (++ ?x ?y)) +; fixed version +(<= (sees ?player (table ?x ?card)) (role ?player) (true (table ?y ?card)) (does ?anyplayer (buy ?card)) (++ ?x ?y)) + +(<= (next (money ?player ?x)) + (role ?player) + (does random (deal ?player ?a ?b ?c)) + (true (deck ?player ?a ?carda)) + (true (deck ?player ?b ?cardb)) + (true (deck ?player ?c ?cardc)) + (value ?carda ?i) + (value ?cardb ?j) + (value ?cardc ?k) + (add ?i ?j ?l) + (add ?k ?l ?x)) + +(<= (next (deck ?player ?x ?card)) (true (deck ?player ?x ?card))) +(<= (next (deck ?player ?index ?card)) (true (decksize ?player ?size)) (++ ?size ?index) (does ?player (buy ?card))) +(<= (next (decksize ?player ?x)) (true (decksize ?player ?x)) (not (true (control ?player)))) +(<= (next (decksize ?player ?y)) (true (decksize ?player ?x)) (++ ?x ?y) (true (control ?player))) +(<= (next (victory ?player ?x)) (true (victory ?player ?x)) (not (true (control ?player)))) +(<= (next (victory ?player ?new)) (true (victory ?player ?old)) (does ?player (buy ?card)) (points ?card ?pts) (add ?pts ?old ?new)) +(<= (next (table ?x ?card)) (true (table ?x ?card)) (true (control random))) +(<= (next (table ?x ?card)) (true (table ?x ?card)) (does ?player (buy ?othercard)) (distinct ?card ?othercard)) +(<= (next (table ?x ?card)) (true (table ?y ?card)) (does ?player (buy ?card)) (++ ?x ?y)) +(<= (next (control duke)) (true (control random))) +(<= (next (control earl)) (true (control duke))) +(<= (next (control duke)) (true (control earl))) +(<= terminal (true (table 0 duchy))) +(<= terminal (true (table 0 estate)) (true (table 0 silver))) +(<= terminal (true (table 0 copper))) + +(<= (goal ?player 100) + (true (victory ?player ?x)) (true (victory ?opponent ?y)) (distinct ?player ?opponent) + (greater_than_equals ?x ?y) + ; made this faster + ; (not (greater_than_equals ?y ?x)) + (distinct ?x ?y) +) +(<= (goal ?player 50) (true (victory ?player ?x)) (true (victory ?opponent ?x)) (distinct ?player ?opponent)) + +(<= (goal ?player 0) + (true (victory ?player ?x)) + (true (victory ?opponent ?y)) + (distinct ?player ?opponent) + (greater_than_equals ?y ?x) + ; fixed this: + ; (not (greater_than_equals ?y ?x)) + ; made this faster + ;(not (greater_than_equals ?x ?y)) + (distinct ?x ?y) +) + +; added this: +(goal random 0) + +(<= (greater_than_equals ?x ?x) (++ ?x ?y)) +(<= (greater_than_equals ?x ?y) (++ ?y ?x)) +(<= (greater_than_equals ?x ?y) (++ ?z ?x) (greater_than_equals ?z ?y)) + +(<= (add 0 ?prev ?prev) (++ ?prev ?x)) +(<= (add 1 ?y ?z) (++ ?y ?z)) +(<= (add ?x ?y ?z) (++ ?littlex ?x) (add ?littlex ?y ?littlez) (++ ?littlez ?z)) + +(++ 0 1) (++ 1 2) (++ 2 3) (++ 3 4) (++ 4 5) (++ 5 6) (++ 6 7) (++ 7 8) (++ 8 9) (++ 9 10) (++ 10 11) (++ 11 12) (++ 12 13) (++ 13 14) (++ 14 15) (++ 15 16) (++ 16 17) (++ 17 18) (++ 18 19) (++ 19 20) (++ 20 21) (++ 21 22) (++ 22 23) (++ 23 24) (++ 24 25) (++ 25 26) (++ 26 27) (++ 27 28) (++ 28 29) (++ 29 30) (++ 30 31) (++ 31 32) (++ 32 33) (++ 33 34) (++ 34 35) (++ 35 36) (++ 36 37) (++ 37 38) (++ 38 39) (++ 39 40) (++ 40 41) (++ 41 42) (++ 42 43) (++ 43 44) (++ 44 45) (++ 45 46) (++ 46 47) (++ 47 48) (++ 48 49) (++ 49 50) (++ 50 51) (++ 51 52) (++ 52 53) (++ 53 54) (++ 54 55) (++ 55 56) (++ 56 57) (++ 57 58) (++ 58 59) (++ 59 60) (++ 60 61) (++ 61 62) (++ 62 63) (++ 63 64) (++ 64 65) (++ 65 66) (++ 66 67) (++ 67 68) (++ 68 69) (++ 69 70) (++ 70 71) (++ 71 72) (++ 72 73) (++ 73 74) (++ 74 75) (++ 75 76) (++ 76 77) (++ 77 78) (++ 78 79) (++ 79 80) (++ 80 81) (++ 81 82) (++ 82 83) (++ 83 84) (++ 84 85) (++ 85 86) (++ 86 87) (++ 87 88) (++ 88 89) (++ 89 90) \ No newline at end of file diff -r 49fd0e0e0c80 -r 3f23f6b95cac gdl/stratego.gdl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gdl/stratego.gdl Tue Mar 14 16:35:43 2017 +0000 @@ -0,0 +1,423 @@ +(role red) +(role blue) + +(x 1) +(x 2) +(x 3) + +(y 1) +(y 2) +(y 3) +(y 4) +(y 5) +(y 6) + +(piece flag) +(piece bomb) +(piece spy) +(piece marshal) +(piece miner) +(piece scout) + +(immobile flag) +(immobile bomb) + +(<= (init (cell ?x 3 b)) + (x ?x) +) + +(<= (init (cell ?x 4 b)) + (x ?x) +) + +(<= (init (inPool ?r ?p)) + (role ?r) + (piece ?p) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(order red 1 1 1) +(order red 2 2 1) +(order red 3 3 1) +(order red 4 1 2) +(order red 5 2 2) +(order red 6 3 2) + +(order blue 1 1 5) +(order blue 2 2 5) +(order blue 3 3 5) +(order blue 4 1 6) +(order blue 5 2 6) +(order blue 6 3 6) + +(<= (legal ?r (place ?x ?y ?p)) + (role ?r) + (true (step ?s)) + (order ?r ?s ?x ?y) + (true (inPool ?r ?p)) +) + +(<= (placed ?r ?p) + (does ?r (place ?x ?y ?p)) +) + +(<= (next (inPool ?r ?p)) + (true (inPool ?r ?p)) + (not (placed ?r ?p)) +) + +(<= (next (cell ?x ?y ?p)) + (does ?r (place ?x ?y ?p)) +) + +(<= (next (occupied ?x ?y ?r)) + (does ?r (place ?x ?y ?p)) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; move for spy, miner and marshal +(<= (legal ?r (move ?x ?y ?x2 ?y2)) + (role ?r) + playingPhase + (true (turn ?r)) + (true (occupied ?x ?y ?r)) + (true (cell ?x ?y ?p)) + (adjacent ?x ?y ?x2 ?y2) + (not (immobile ?p)) + (not (true (occupied ?x2 ?y2 ?r))) +) + +;;; special move for scout +(<= (legal ?r (move ?x ?y ?x3 ?y3)) + (role ?r) + playingPhase + (true (turn ?r)) + (true (occupied ?x ?y ?r)) + (true (cell ?x ?y scout)) + (adjacent ?x ?y ?x2 ?y2) + (adjacent ?x2 ?y2 ?x3 ?y3) + (true (cell ?x2 ?y2 b)) + (not (true (occupied ?x3 ?y3 ?r))) +) + +(<= (legal ?r noop) + (role ?r) + playingPhase + (not (true (turn ?r))) +) + +(<= (anyMobile ?r) + (role ?r) + playingPhase + (true (occupied ?x ?y ?r)) + (true (cell ?x ?y ?p)) + (adjacent ?x ?y ?x2 ?y2) + (not (immobile ?p)) + (not (true (occupied ?x2 ?y2 ?r))) +) + +(<= (legal ?r noop) + (role ?r) + playingPhase + (true (turn ?r)) + (not (anyMobile ?r)) +) + +(<= (anyMoveFrom ?x ?y) + (does ?r (move ?x ?y ?x2 ?y2)) +) + +(<= (anyMoveTo ?x2 ?y2) + (does ?r (move ?x ?y ?x2 ?y2)) +) + +(<= (next (cell ?x ?y ?p)) + (true (cell ?x ?y ?p)) + (not (anyMoveFrom ?x ?y)) + (not (anyMoveTo ?x ?y)) +) + +(<= (next (cell ?x ?y b)) + (does ?r (move ?x ?y ?x2 ?y2)) +) + +(<= (next (occupied ?x ?y ?r)) + (true (occupied ?x ?y ?r)) + (not (anyMoveFrom ?x ?y)) + (not (anyMoveTo ?x ?y)) +) + +(<= (next (cell ?x ?y ?p)) + (true (cell ?x0 ?y0 ?p)) + (does ?r (move ?x0 ?y0 ?x ?y)) + (role ?r2) + (not (true (occupied ?x ?y ?r2))) + (distinct ?r ?r2) +) + +(<= (next (occupied ?x ?y ?r)) + (true (occupied ?x0 ?y0 ?r)) + (does ?r (move ?x0 ?y0 ?x ?y)) + (role ?r2) + (not (true (occupied ?x ?y ?r2))) + (distinct ?r ?r2) +) + +(<= (sees ?r (did ?r ?m)) + (does ?r ?m) +) + +(<= (sees ?r (did ?r2 (move ?x ?y ?x2 ?y2))) + (role ?r) + (does ?r2 (move ?x ?y ?x2 ?y2)) + (distinct ?r ?r2) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(<= (sees ?r (cell ?x ?y ?p)) + (true (cell ?x ?y ?p)) + (true (occupied ?x ?y ?r2)) + (does ?r (move ?x0 ?y0 ?x ?y)) + (distinct ?r ?r2) +) + +(<= (sees ?r (cell ?x ?y ?p)) + (role ?r) + (does ?r2 (move ?x ?y ?x2 ?y2)) + (true (occupied ?x2 ?y2 ?r)) + (true (cell ?x ?y ?p)) +) + +(<= (next (cell ?x ?y ?p)) + (true (cell ?x ?y ?p)) + (true (occupied ?x ?y ?r)) + (does ?r2 (move ?x0 ?y0 ?x ?y)) + (distinct ?r ?r2) + (true (cell ?x0 ?y0 ?p0)) + (beats ?p0 ?p ?p) +) + +(<= (next (cell ?x ?y ?p0)) + (true (cell ?x ?y ?p)) + (true (occupied ?x ?y ?r)) + (does ?r2 (move ?x0 ?y0 ?x ?y)) + (distinct ?r ?r2) + (true (cell ?x0 ?y0 ?p0)) + (beats ?p0 ?p ?p0) +) + +(<= (next (cell ?x ?y b)) + (true (cell ?x ?y ?p)) + (true (occupied ?x ?y ?r)) + (does ?r2 (move ?x0 ?y0 ?x ?y)) + (distinct ?r ?r2) + (true (cell ?x0 ?y0 ?p)) +) + +(<= (next (occupied ?x ?y ?r)) + (true (cell ?x ?y ?p)) + (true (occupied ?x ?y ?r)) + (does ?r2 (move ?x0 ?y0 ?x ?y)) + (distinct ?r ?r2) + (true (cell ?x0 ?y0 ?p0)) + (beats ?p0 ?p ?p) +) + +(<= (next (occupied ?x ?y ?r2)) + (true (cell ?x ?y ?p)) + (true (occupied ?x ?y ?r)) + (does ?r2 (move ?x0 ?y0 ?x ?y)) + (distinct ?r ?r2) + (true (cell ?x0 ?y0 ?p0)) + (beats ?p0 ?p ?p0) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(<= (anyFlag ?r) + (true (cell ?x ?y flag)) + (true (occupied ?x ?y ?r)) +) + +(<= playingPhase + (not (true (step 1))) + (not (true (step 2))) + (not (true (step 3))) + (not (true (step 4))) + (not (true (step 5))) + (not (true (step 6))) +) + +(<= terminal + (role ?r) + (not (anyFlag ?r)) + playingPhase +) + +(<= terminal + playingPhase + (not (anyMobile red)) + (not (anyMobile blue)) +) + +(<= terminal + (true (step 51)) +) + +(<= (goal red 100) + (not (anyFlag blue)) +) + +(<= (goal blue 100) + (not (anyFlag red)) +) + +(<= (goal ?r 50) + (role ?r) + (anyFlag red) + (anyFlag blue) + (true (step 51)) +) + +(<= (goal ?r 50) + (role ?r) + (anyFlag red) + (anyFlag blue) + (not (anyMobile red)) + (not (anyMobile blue)) +) + +(<= (goal red 0) + (not (anyFlag red)) +) + +(<= (goal blue 0) + (not (anyFlag blue)) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; attacker, defender, winner +;;; if attacker and defender are equal, both lose + +(beats spy flag spy) +(beats spy bomb bomb) +(beats spy marshal spy) +(beats spy miner miner) +(beats spy scout scout) + +(beats marshal flag marshal) +(beats marshal bomb bomb) +(beats marshal spy marshal) +(beats marshal miner marshal) +(beats marshal scout marshal) + +(beats miner flag miner) +(beats miner bomb miner) +(beats miner spy miner) +(beats miner marshal marshal) +(beats miner scout miner) + +(beats scout flag scout) +(beats scout bomb bomb) +(beats scout spy scout) +(beats scout marshal marshal) +(beats scout miner miner) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(cellsucc 1 2) +(cellsucc 2 3) +(cellsucc 3 4) +(cellsucc 4 5) +(cellsucc 5 6) + +(<= (adjacent ?x ?y ?x ?y2) + (x ?x) + (cellsucc ?y ?y2) +) +(<= (adjacent ?x ?y ?x ?y2) + (x ?x) + (cellsucc ?y2 ?y) +) +(<= (adjacent ?x ?y ?x2 ?y) + (x ?x) + (x ?x2) + (y ?y) + (cellsucc ?x ?x2) +) +(<= (adjacent ?x ?y ?x2 ?y) + (x ?x) + (x ?x2) + (y ?y) + (cellsucc ?x2 ?x) +) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(init (turn red)) +(<= (next (turn blue)) + (true (turn red)) +) +(<= (next (turn red)) + (true (turn blue)) +) + +(init (step 1)) +(<= (next (step ?n1)) + (true (step ?n0)) + (succ ?n0 ?n1) +) +(succ 1 2) +(succ 2 3) +(succ 3 4) +(succ 4 5) +(succ 5 6) +(succ 6 7) +(succ 7 8) +(succ 8 9) +(succ 9 10) +(succ 10 11) +(succ 11 12) +(succ 12 13) +(succ 13 14) +(succ 14 15) +(succ 15 16) +(succ 16 17) +(succ 17 18) +(succ 18 19) +(succ 19 20) +(succ 20 21) +(succ 21 22) +(succ 22 23) +(succ 23 24) +(succ 24 25) +(succ 25 26) +(succ 26 27) +(succ 27 28) +(succ 28 29) +(succ 29 30) +(succ 30 31) +(succ 31 32) +(succ 32 33) +(succ 33 34) +(succ 34 35) +(succ 35 36) +(succ 36 37) +(succ 37 38) +(succ 38 39) +(succ 39 40) +(succ 40 41) +(succ 41 42) +(succ 42 43) +(succ 43 44) +(succ 44 45) +(succ 45 46) +(succ 46 47) +(succ 47 48) +(succ 48 49) +(succ 49 50) +(succ 50 51) diff -r 49fd0e0e0c80 -r 3f23f6b95cac gdl/transit.gdl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gdl/transit.gdl Tue Mar 14 16:35:43 2017 +0000 @@ -0,0 +1,186 @@ +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; transit +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(role transit) +(role patrol) + +(blocked 1 5) +(blocked 1 4) +(blocked 5 1) +(blocked 5 2) +(blocked 5 3) +(blocked 5 4) +(blocked 5 5) +(blocked 5 6) +(blocked 5 7) +(blocked 5 8) + +(init (control patrol)) +(init (location patrol 3 8)) +(init (location transit 2 1)) +(init (step 1)) + +(<= (legal patrol (move ?dir)) + (true (control patrol)) + (true (location patrol ?x ?y)) + (plegalstep ?dir ?x ?y)) +(<= (legal patrol (move nowhere)) + (not (true (control patrol)))) +(<= (legal transit (move ?dir)) + (true (control transit)) + (true (location transit ?x ?y)) + (tlegalstep ?dir ?x ?y)) +(<= (legal transit (move nowhere)) + (not (true (control transit)))) + +(<= (next (control patrol)) + (true (control transit))) +(<= (next (control transit)) + (true (control patrol))) +(<= (next (location ?char ?x2 ?y2)) + (true (location ?char ?x1 ?y1)) + (does ?char (move ?dir)) + (nextcell ?dir ?x1 ?y1 ?x2 ?y2)) +(<= (next (step ?n++)) + (true (step ?n)) + (succ ?n ?n++)) + +(<= terminal crossed) +(<= terminal timeout) +(<= terminal captured) + +(<= (goal patrol 100) timeout) +(<= (goal transit 0) timeout) +(<= (goal patrol 100) captured) +(<= (goal transit 0) captured) +(<= (goal transit 100) crossed) +(<= (goal patrol 0) crossed) + +(<= crossed + (true (location transit ?x 8)) + (not captured)) +(<= timeout + (true (step 30)) + (not crossed) + (not captured)) +(<= captured + (true (location transit ?x ?y)) + (true (location patrol ?x ?y))) + +(<= (plegalstep north ?x ?y) + (++ ?y ?ynew) + (index ?x) + (not (blocked ?x ?ynew))) +(<= (plegalstep south ?x ?y) + (++ ?ynew ?y) + (index ?x) + (not (blocked ?x ?ynew))) +(<= (plegalstep east ?x ?y) + (++ ?x ?xnew) + (index ?y) + (not (blocked ?xnew ?y))) +(<= (plegalstep west ?x ?y) + (++ ?xnew ?x) + (index ?y) + (not (blocked ?xnew ?y))) + +(<= (tlegalstep north ?x ?y) + (++ ?y ?ynew) + (index ?x) + (not (blocked ?x ?ynew))) +(<= (tlegalstep deast ?x ?y) + (++ ?x ?xnew) + (++ ?y ?ynew) + (not (blocked ?xnew ?ynew))) +(<= (tlegalstep dwest ?x ?y) + (++ ?xnew ?x) + (++ ?y ?ynew) + (not (blocked ?xnew ?ynew))) + +(<= (tlegalstep nowhere ?x ?y) + (index ?x) + (index ?y)) +(<= (plegalstep nowhere ?x ?y) + (index ?x) + (index ?y)) + +(<= (nextcell north ?x ?y ?x ?ynew) + (++ ?y ?ynew) + (index ?x)) +(<= (nextcell south ?x ?y ?x ?ynew) + (index ?x) + (++ ?ynew ?y)) +(<= (nextcell east ?x ?y ?xnew ?y) + (++ ?x ?xnew) + (index ?y)) +(<= (nextcell west ?x ?y ?xnew ?y) + (++ ?xnew ?x) + (index ?y)) +(<= (nextcell deast ?x ?y ?xnew ?ynew) + (++ ?y ?ynew) + (++ ?x ?xnew)) +(<= (nextcell dwest ?x ?y ?xnew ?ynew) + (++ ?y ?ynew) + (++ ?xnew ?x)) +(<= (nextcell nowhere ?x ?y ?x ?y) + (index ?x) + (index ?y)) + +(index 1) +(index 2) +(index 3) +(index 4) +(index 5) +(index 6) +(index 7) +(index 8) + +(++ 1 2) +(++ 2 3) +(++ 3 4) +(++ 4 5) +(++ 5 6) +(++ 6 7) +(++ 7 8) + +(succ 0 1) +(succ 1 2) +(succ 2 3) +(succ 3 4) +(succ 4 5) +(succ 5 6) +(succ 6 7) +(succ 7 8) +(succ 8 9) +(succ 9 10) +(succ 10 11) +(succ 11 12) +(succ 12 13) +(succ 13 14) +(succ 14 15) +(succ 15 16) +(succ 16 17) +(succ 17 18) +(succ 18 19) +(succ 19 20) +(succ 20 21) +(succ 21 22) +(succ 22 23) +(succ 23 24) +(succ 24 25) +(succ 25 26) +(succ 26 27) +(succ 27 28) +(succ 28 29) +(succ 29 30) + +(<= (sees ?r1 (location ?r2 ?x ?y)) + (role ?r2) + (next (location ?r2 ?x ?y)) + (next (location ?r1 ?x ?y)) + (distinct ?r1 ?r2)) +(<= (sees patrol (location transit ?x 8)) + (next (location transit ?x 8))) +(<= (sees ?r (move ?dir)) + (legal ?r (move ?dir))) \ No newline at end of file diff -r 49fd0e0e0c80 -r 3f23f6b95cac gdl/vis_pacman3p.gdl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gdl/vis_pacman3p.gdl Tue Mar 14 16:35:43 2017 +0000 @@ -0,0 +1,484 @@ +(role pacman) +(role blinky) +(role inky) +(init (control pacman)) +(init (location pacman 5 3)) +(init (location blinky 4 6)) +(init (location inky 5 6)) +(init (location pellet 3 1)) +(init (location pellet 4 1)) +(init (location pellet 5 1)) +(init (location pellet 6 1)) +(init (location pellet 3 2)) +(init (location pellet 6 2)) +(init (location pellet 1 3)) +(init (location pellet 2 3)) +(init (location pellet 3 3)) +(init (location pellet 4 3)) +(init (location pellet 6 3)) +(init (location pellet 7 3)) +(init (location pellet 8 3)) +(init (location pellet 1 4)) +(init (location pellet 3 4)) +(init (location pellet 6 4)) +(init (location pellet 8 4)) +(init (location pellet 1 5)) +(init (location pellet 3 5)) +(init (location pellet 6 5)) +(init (location pellet 8 5)) +(init (location pellet 1 6)) +(init (location pellet 2 6)) +(init (location pellet 3 6)) +(init (location pellet 6 6)) +(init (location pellet 7 6)) +(init (location pellet 8 6)) +(init (location pellet 3 7)) +(init (location pellet 6 7)) +(init (location pellet 3 8)) +(init (location pellet 4 8)) +(init (location pellet 5 8)) +(init (location pellet 6 8)) +(init (collected 0)) +(init (step 1)) +(<= (legal pacman (move ?dir)) + (true (control pacman)) + (true (location pacman ?x ?y)) + (legalstep ?dir ?x ?y) + (distinct ?dir nowhere)) +(<= (legal pacman (move nowhere)) + (not (true (control pacman)))) +(<= (legal ?ghost (move ?dir)) + (ghost ?ghost) + (true (control ghosts)) + (true (location ?ghost ?x ?y)) + (legalstep ?dir ?x ?y) + (distinct ?dir nowhere)) +(<= (legal ?ghost (move nowhere)) + (ghost ?ghost) + (not (true (control ghosts)))) +(<= (next (control pacman)) + (true (control ghosts))) +(<= (next (control ghosts)) + (true (control pacman))) +(<= (next (location pellet ?xp ?yp)) + (true (location pellet ?xp ?yp)) + (true (location pacman ?xpm1 ?ypm1)) + (does pacman (move ?dir)) + (nextcell ?dir ?xpm1 ?ypm1 ?xpm2 ?ypm2) + (distinctcell ?xp ?yp ?xpm2 ?ypm2)) +(<= (next (collected ?n++)) + (true (location pacman ?x1 ?y1)) + (does pacman (move ?dir)) + (nextcell ?dir ?x1 ?y1 ?x2 ?y2) + (true (location pellet ?x2 ?y2)) + (true (collected ?n)) + (succ ?n ?n++)) +(<= (next (collected ?n)) + (true (location pacman ?x1 ?y1)) + (does pacman (move ?dir)) + (nextcell ?dir ?x1 ?y1 ?x2 ?y2) + (not (true (location pellet ?x2 ?y2))) + (true (collected ?n))) +(<= (next (location ?char ?x2 ?y2)) + (movable ?char) + (true (location ?char ?x1 ?y1)) + (does ?char (move ?dir)) + (nextcell ?dir ?x1 ?y1 ?x2 ?y2)) +(<= (next (step ?n++)) + (true (step ?n)) + (succ ?n ?n++)) +(<= terminal + captured) +(<= terminal + nopellets) +(<= terminal + timeout) +(<= (goal pacman ?g) + (true (collected ?n)) + (scoremap ?n ?g)) +(<= (goal blinky 0) + (true (location pacman ?xp ?yp)) + (true (location blinky ?xb ?yb)) + (distinctcell ?xp ?yp ?xb ?yb)) +(<= (goal blinky 100) + (true (location pacman ?x ?y)) + (true (location blinky ?x ?y))) +(<= (goal inky 0) + (true (location pacman ?xp ?yp)) + (true (location inky ?xi ?yi)) + (distinctcell ?xp ?yp ?xi ?yi)) +(<= (goal inky 100) + (true (location pacman ?x ?y)) + (true (location inky ?x ?y))) +(<= (legalstep north ?x ?y) + (++ ?y ?ynew) + (cell ?x ?ynew) + (not (blocked ?x ?y ?x ?ynew))) +(<= (legalstep south ?x ?y) + (-- ?y ?ynew) + (cell ?x ?ynew) + (not (blocked ?x ?y ?x ?ynew))) +(<= (legalstep east ?x ?y) + (++ ?x ?xnew) + (cell ?xnew ?y) + (not (blocked ?x ?y ?xnew ?y))) +(<= (legalstep west ?x ?y) + (-- ?x ?xnew) + (cell ?xnew ?y) + (not (blocked ?x ?y ?xnew ?y))) +(<= (legalstep nowhere ?x ?y) + (cell ?x ?y)) +(<= (nextcell north ?x ?y ?x ?ynew) + (index ?x) + (++ ?y ?ynew)) +(<= (nextcell south ?x ?y ?x ?ynew) + (index ?x) + (-- ?y ?ynew)) +(<= (nextcell east ?x ?y ?xnew ?y) + (index ?y) + (++ ?x ?xnew)) +(<= (nextcell west ?x ?y ?xnew ?y) + (index ?y) + (-- ?x ?xnew)) +(<= (nextcell nowhere ?x ?y ?x ?y) + (cell ?x ?y)) +(<= (blocked ?x ?y1 ?x ?y2) + (blockednorth ?x ?y1) + (++ ?y1 ?y2)) +(<= (blocked ?x ?y2 ?x ?y1) + (blockednorth ?x ?y1) + (++ ?y1 ?y2)) +(<= (blocked ?x1 ?y ?x2 ?y) + (blockedeast ?x1 ?y) + (++ ?x1 ?x2)) +(<= (blocked ?x2 ?y ?x1 ?y) + (blockedeast ?x1 ?y) + (++ ?x1 ?x2)) +(<= (distinctcell ?x1 ?y1 ?x2 ?y2) + (cell ?x1 ?y1) + (cell ?x2 ?y2) + (distinct ?x1 ?x2)) +(<= (distinctcell ?x1 ?y1 ?x2 ?y2) + (cell ?x1 ?y1) + (cell ?x2 ?y2) + (distinct ?y1 ?y2)) +(<= captured + (true (location pacman ?x ?y)) + (true (location blinky ?x ?y))) +(<= captured + (true (location pacman ?x ?y)) + (true (location inky ?x ?y))) +(<= nopellets + (true (collected 35))) +(<= timeout + (true (step 100))) + +(blockednorth 4 1) +(blockednorth 5 1) +(blockednorth 1 2) +(blockednorth 2 2) +(blockednorth 4 2) +(blockednorth 5 2) +(blockednorth 7 2) +(blockednorth 8 2) +(blockednorth 2 3) +(blockednorth 4 3) +(blockednorth 5 3) +(blockednorth 7 3) +(blockednorth 2 5) +(blockednorth 4 5) +(blockednorth 5 5) +(blockednorth 7 5) +(blockednorth 1 6) +(blockednorth 2 6) +(blockednorth 4 6) +(blockednorth 5 6) +(blockednorth 7 6) +(blockednorth 8 6) +(blockednorth 4 7) +(blockednorth 5 7) +(blockedeast 1 4) +(blockedeast 1 5) +(blockedeast 2 1) +(blockedeast 2 2) +(blockedeast 2 4) +(blockedeast 2 5) +(blockedeast 2 7) +(blockedeast 2 8) +(blockedeast 3 2) +(blockedeast 3 4) +(blockedeast 3 5) +(blockedeast 3 7) +(blockedeast 5 2) +(blockedeast 5 4) +(blockedeast 5 5) +(blockedeast 5 7) +(blockedeast 6 1) +(blockedeast 6 2) +(blockedeast 6 4) +(blockedeast 6 5) +(blockedeast 6 7) +(blockedeast 6 8) +(blockedeast 7 4) +(blockedeast 7 5) + +(movable pacman) +(movable blinky) +(movable inky) +(ghost blinky) +(ghost inky) +(index 1) +(index 2) +(index 3) +(index 4) +(index 5) +(index 6) +(index 7) +(index 8) +(cell 1 8) +(cell 2 8) +(cell 3 8) +(cell 4 8) +(cell 5 8) +(cell 6 8) +(cell 7 8) +(cell 8 8) +(cell 1 7) +(cell 2 7) +(cell 3 7) +(cell 4 7) +(cell 5 7) +(cell 6 7) +(cell 7 7) +(cell 8 7) +(cell 1 6) +(cell 2 6) +(cell 3 6) +(cell 4 6) +(cell 5 6) +(cell 6 6) +(cell 7 6) +(cell 8 6) +(cell 1 5) +(cell 2 5) +(cell 3 5) +(cell 4 5) +(cell 5 5) +(cell 6 5) +(cell 7 5) +(cell 8 5) +(cell 1 4) +(cell 2 4) +(cell 3 4) +(cell 4 4) +(cell 5 4) +(cell 6 4) +(cell 7 4) +(cell 8 4) +(cell 1 3) +(cell 2 3) +(cell 3 3) +(cell 4 3) +(cell 5 3) +(cell 6 3) +(cell 7 3) +(cell 8 3) +(cell 1 2) +(cell 2 2) +(cell 3 2) +(cell 4 2) +(cell 5 2) +(cell 6 2) +(cell 7 2) +(cell 8 2) +(cell 1 1) +(cell 2 1) +(cell 3 1) +(cell 4 1) +(cell 5 1) +(cell 6 1) +(cell 7 1) +(cell 8 1) +(++ 1 2) +(++ 2 3) +(++ 3 4) +(++ 4 5) +(++ 5 6) +(++ 6 7) +(++ 7 8) +(-- 8 7) +(-- 7 6) +(-- 6 5) +(-- 5 4) +(-- 4 3) +(-- 3 2) +(-- 2 1) +(succ 0 1) +(succ 1 2) +(succ 2 3) +(succ 3 4) +(succ 4 5) +(succ 5 6) +(succ 6 7) +(succ 7 8) +(succ 8 9) +(succ 9 10) +(succ 10 11) +(succ 11 12) +(succ 12 13) +(succ 13 14) +(succ 14 15) +(succ 15 16) +(succ 16 17) +(succ 17 18) +(succ 18 19) +(succ 19 20) +(succ 20 21) +(succ 21 22) +(succ 22 23) +(succ 23 24) +(succ 24 25) +(succ 25 26) +(succ 26 27) +(succ 27 28) +(succ 28 29) +(succ 29 30) +(succ 30 31) +(succ 31 32) +(succ 32 33) +(succ 33 34) +(succ 34 35) +(succ 35 36) +(succ 36 37) +(succ 37 38) +(succ 38 39) +(succ 39 40) +(succ 40 41) +(succ 41 42) +(succ 42 43) +(succ 43 44) +(succ 44 45) +(succ 45 46) +(succ 46 47) +(succ 47 48) +(succ 48 49) +(succ 49 50) +(succ 50 51) +(succ 51 52) +(succ 52 53) +(succ 53 54) +(succ 54 55) +(succ 55 56) +(succ 56 57) +(succ 57 58) +(succ 58 59) +(succ 59 60) +(succ 60 61) +(succ 61 62) +(succ 62 63) +(succ 63 64) +(succ 64 65) +(succ 65 66) +(succ 66 67) +(succ 67 68) +(succ 68 69) +(succ 69 70) +(succ 70 71) +(succ 71 72) +(succ 72 73) +(succ 73 74) +(succ 74 75) +(succ 75 76) +(succ 76 77) +(succ 77 78) +(succ 78 79) +(succ 79 80) +(succ 80 81) +(succ 81 82) +(succ 82 83) +(succ 83 84) +(succ 84 85) +(succ 85 86) +(succ 86 87) +(succ 87 88) +(succ 88 89) +(succ 89 90) +(succ 90 91) +(succ 91 92) +(succ 92 93) +(succ 93 94) +(succ 94 95) +(succ 95 96) +(succ 96 97) +(succ 97 98) +(succ 98 99) +(succ 99 100) +(scoremap 0 0) +(scoremap 1 2) +(scoremap 2 4) +(scoremap 3 6) +(scoremap 4 8) +(scoremap 5 10) +(scoremap 6 12) +(scoremap 7 14) +(scoremap 8 16) +(scoremap 9 18) +(scoremap 10 20) +(scoremap 11 23) +(scoremap 12 26) +(scoremap 13 29) +(scoremap 14 32) +(scoremap 15 35) +(scoremap 16 38) +(scoremap 17 41) +(scoremap 18 44) +(scoremap 19 47) +(scoremap 20 50) +(scoremap 21 53) +(scoremap 22 56) +(scoremap 23 59) +(scoremap 24 62) +(scoremap 25 65) +(scoremap 26 68) +(scoremap 27 71) +(scoremap 28 74) +(scoremap 29 77) +(scoremap 30 80) +(scoremap 31 83) +(scoremap 32 86) +(scoremap 33 89) +(scoremap 34 95) +(scoremap 35 100) + +(<= (visible 1 ?y1 1 ?y2) + (index ?y1) + (index ?y2)) +(<= (visible 3 ?y1 3 ?y2) + (index ?y1) + (index ?y2)) +(<= (visible 6 ?y1 6 ?y2) + (index ?y1) + (index ?y2)) +(<= (visible 8 ?y1 8 ?y2) + (index ?y1) + (index ?y2)) +(<= (visible ?x1 1 ?x2 1) + (index ?x1) + (index ?x2)) +(<= (visible ?x1 3 ?x2 3) + (index ?x1) + (index ?x2)) +(<= (visible ?x1 6 ?x2 6) + (index ?x1) + (index ?x2)) +(<= (visible ?x1 8 ?x2 8) + (index ?x1) + (index ?x2)) + +(<= (sees ?r1 (location ?r2 ?x2 ?y2)) + (next (location ?r2 ?x2 ?y2)) + (next (location ?r1 ?x1 ?y1)) + (visible ?x1 ?y1 ?x2 ?y2)) +(<= (sees ?r1 (collected ?n)) + (role ?r1) + (next (collected ?n))) \ No newline at end of file diff -r 49fd0e0e0c80 -r 3f23f6b95cac src/grounders/fluxplayer.lisp --- a/src/grounders/fluxplayer.lisp Tue Mar 14 13:36:54 2017 +0000 +++ b/src/grounders/fluxplayer.lisp Tue Mar 14 16:35:43 2017 +0000 @@ -73,28 +73,22 @@ (negative-terms (.repeat negative-term-count (.whitespace-and (.positive-integer)))) (positive-terms (.repeat (- term-count negative-term-count) - (.whitespace-and (.positive-integer)))) - (_ (.char= #\newline))) + (.whitespace-and (.positive-integer))))) (.identity (make-rule :id id :positive positive-terms :negative negative-terms)))) -(defun .delimiter-line () - (.progn (.char= #\0) - (.or (.char= #\newline) - (.eof)) - (.identity nil))) - -(defun .grounded-gdl () - (.let* ((rules (.first (.map 'list (.rule-line)))) - (_ (.delimiter-line)) - (index (.first (.map 'list (.index-line)))) - (_ (.delimiter-line))) - (.identity (list rules index)))) - (defun parse-raw-grounded (raw) - (values (parse (.grounded-gdl) raw))) + (with-input-from-string (s raw) + (iterate + (with in-index = nil) + (for line :in-stream s :using #'read-line) + (cond + ((string= "0" line) (setf in-index t)) + (in-index (collect (parse (.index-line) line) :into index)) + (t (collect (parse (.rule-line) line) :into rules))) + (finally (return (list rules index)))))) ;;;; Rebuilding --------------------------------------------------------------- @@ -155,6 +149,7 @@ ; (dump-grounded "8puzzle") ; (dump-grounded "tictactoe") -(dump-grounded "montyhall") +;; (dump-grounded "small_dominion") -;; (dump-grounded "meier") + +;; (time (dump-grounded "meier")) diff -r 49fd0e0e0c80 -r 3f23f6b95cac src/players/random-zdd.lisp --- a/src/players/random-zdd.lisp Tue Mar 14 13:36:54 2017 +0000 +++ b/src/players/random-zdd.lisp Tue Mar 14 16:35:43 2017 +0000 @@ -18,9 +18,6 @@ (dump-gdl <> s)) (ground-gdl-string <>))) (reasoner (make-zdd-reasoner grounded-rules))) - (pr "GROUNDED:") - (pr grounded-rules) - (pr '------------------------------------) (setf (rp-role player) role (rp-reasoner player) reasoner) t))) diff -r 49fd0e0e0c80 -r 3f23f6b95cac src/reasoners/zdd.lisp --- a/src/reasoners/zdd.lisp Tue Mar 14 13:36:54 2017 +0000 +++ b/src/reasoners/zdd.lisp Tue Mar 14 16:35:43 2017 +0000 @@ -12,7 +12,6 @@ atom)) (defun make-iset (reasoner contents) - ; (print-hash-table (zr-term->number reasoner)) (zdd-set (mapcar (curry #'term-to-number reasoner) (map-tree #'find-ggp-symbol contents)))) @@ -154,6 +153,7 @@ (roles (find-roles rules))) (destructuring-bind (term->number number->term possible happens) (scully.terms::integerize-rules rules) + ;; (print-hash-table number->term) (with-zdd (make-instance 'zdd-reasoner :rules rules @@ -167,10 +167,10 @@ (role (make-predicate-zdd `(ggp-rules::legal ,role) term->number)))) :goal-zdds (iterate - (for role :in roles) - (collect-hash - (role (make-predicate-zdd `(ggp-rules::goal ,role) - term->number)))) + (for role :in roles) + (collect-hash + (role (make-predicate-zdd `(ggp-rules::goal ,role) + term->number)))) :terminal-zdd (make-predicate-zdd '(ggp-rules::terminal) term->number) :next-zdd (make-predicate-zdd '(ggp-rules::next) term->number) :percept-universes @@ -568,10 +568,11 @@ (defparameter *rules* (scully.gdl::read-gdl "gdl/meier-grounded.gdl")) (defparameter *rules* (scully.gdl::read-gdl "gdl/pennies-grounded.gdl")) (defparameter *rules* (scully.gdl::read-gdl "gdl/montyhall-grounded.gdl")) +(defparameter *rules* (scully.gdl::read-gdl "gdl/meier-grounded.gdl")) +(defparameter *rules* (scully.gdl::read-gdl "gdl/kriegTTT_5x5-grounded.gdl")) (defparameter *r* nil) -(defparameter *r* (make-zdd-reasoner *rules*)) -(defparameter *i* (initial-iset *r*)) +;; (defparameter *r* (make-zdd-reasoner *rules*)) (defun test () (with-zdd diff -r 49fd0e0e0c80 -r 3f23f6b95cac src/rule-trees.lisp --- a/src/rule-trees.lisp Tue Mar 14 13:36:54 2017 +0000 +++ b/src/rule-trees.lisp Tue Mar 14 16:35:43 2017 +0000 @@ -76,6 +76,7 @@ (let* ((head (rule-head (first rules))) (top (top head)) (cache (make-hash-table :test #'equal))) + ;; (pr head) (recursively ((bodies (mapcar (compose #'sort-body #'rule-body) rules))) (cond ((null bodies) bottom)