This shows you the differences between two versions of the page.
| Both sides previous revision Previous revision Next revision | Previous revision Next revision Both sides next revision | ||
|
en:dydaktyka:ggp:gdl [2018/01/16 01:21] msl [4 Knowledge Interchange Format] |
en:dydaktyka:ggp:gdl [2019/01/03 22:51] msl |
||
|---|---|---|---|
| Line 27: | Line 27: | ||
| Let's start with players "nought" and "cross". There is a special fact ''role'' just to do that: | Let's start with players "nought" and "cross". There is a special fact ''role'' just to do that: | ||
| - | <code prolog> | + | <code> |
| role(nought) | role(nought) | ||
| role(cross) | role(cross) | ||
| </code> | </code> | ||
| - | Syntax is the same as in the Prolog (or Datalog) language with the only difference, that there is no dot at the end of the sentece. All constants start with a lower-cased letter and variables are upper-cased. | + | Syntax is the same as in the Prolog (or Datalog) language with the only difference, that there is no dot at the end of the sentence. All constants start with a lower-cased letter and variables are upper-cased. |
| ==== Fluents ==== | ==== Fluents ==== | ||
| Line 44: | Line 44: | ||
| To define the fluents one uses the ''base'' facts: | To define the fluents one uses the ''base'' facts: | ||
| - | <code prolog> | + | <code> |
| base(cell(M,N,x)) :- index(M) & index(N) | base(cell(M,N,x)) :- index(M) & index(N) | ||
| base(cell(M,N,o)) :- index(M) & index(N) | base(cell(M,N,o)) :- index(M) & index(N) | ||
| Line 58: | Line 58: | ||
| Here '':-'' reprenst implication ''<-''. ''&'' is a logical and. In natural language the first line means: "if M and N represent cells' indexes, then there is a fluent for cell with (M, N) coordinates, telling there is a cross in it". If we didn't use rules, we could write all the fluents by hand: | Here '':-'' reprenst implication ''<-''. ''&'' is a logical and. In natural language the first line means: "if M and N represent cells' indexes, then there is a fluent for cell with (M, N) coordinates, telling there is a cross in it". If we didn't use rules, we could write all the fluents by hand: | ||
| - | <code prolog> | + | <code> |
| base(cell(1,1,x)) base(cell(1,1,o)) base(cell(1,1,b)) | base(cell(1,1,x)) base(cell(1,1,o)) base(cell(1,1,b)) | ||
| base(cell(1,2,x)) base(cell(1,2,o)) base(cell(1,2,b)) | base(cell(1,2,x)) base(cell(1,2,o)) base(cell(1,2,b)) | ||
| Line 87: | Line 87: | ||
| In order to define an action we use the ''input'' predicate: | In order to define an action we use the ''input'' predicate: | ||
| - | <code prolog> | + | <code> |
| input(R, mark(M,N)) :- role(R) & index(M) & index(N) | input(R, mark(M,N)) :- role(R) & index(M) & index(N) | ||
| input(R, noop) :- role(R) | input(R, noop) :- role(R) | ||
| Line 115: | Line 115: | ||
| Now we have to define the initial state of the game (draw the empty board). The ''init'' predicate serves this purpose. For the tic-tac-toe every cell should be empty, and the ''nought'' player should play first. | Now we have to define the initial state of the game (draw the empty board). The ''init'' predicate serves this purpose. For the tic-tac-toe every cell should be empty, and the ''nought'' player should play first. | ||
| - | <code prolog> | + | |
| + | <code> | ||
| init(cell(M,N,b)) :- index(M) & index(N) | init(cell(M,N,b)) :- index(M) & index(N) | ||
| init(control(nought)) | init(control(nought)) | ||
| Line 125: | Line 126: | ||
| To define the state evolution we use the ''next'' predicate, defining the fluent state in the next turn. The 'does' predicate check what actions were made by the players during the current turn. | To define the state evolution we use the ''next'' predicate, defining the fluent state in the next turn. The 'does' predicate check what actions were made by the players during the current turn. | ||
| - | <code prolog> | + | <code> |
| next(cell(M,N,x)) :- | next(cell(M,N,x)) :- | ||
| does(cross,mark(M,N)) & | does(cross,mark(M,N)) & | ||
| Line 168: | Line 169: | ||
| Every player knows that there are two ways to finish the game: make a line or fill all the available cells. Now we will check if there was a line made by the player. | Every player knows that there are two ways to finish the game: make a line or fill all the available cells. Now we will check if there was a line made by the player. | ||
| - | <code prolog> | + | <code> |
| line(Z) :- row(M,Z) | line(Z) :- row(M,Z) | ||
| line(Z) :- column(M,Z) | line(Z) :- column(M,Z) | ||
| Line 198: | Line 199: | ||
| Now we can define the ending conditions with the ''terminal'' predicate: | Now we can define the ending conditions with the ''terminal'' predicate: | ||
| - | <code prolog> | + | <code> |
| terminal :- line(x) | terminal :- line(x) | ||
| terminal :- line(o) | terminal :- line(o) | ||
| Line 218: | Line 219: | ||
| Bots don't have feelings but we still should give them prize for the good game. And we do this with the ''goal'' predicate: | Bots don't have feelings but we still should give them prize for the good game. And we do this with the ''goal'' predicate: | ||
| - | <code prolog> | + | <code> |
| goal(cross,100) :- line(x) & ~line(o) | goal(cross,100) :- line(x) & ~line(o) | ||
| goal(cross,50) :- ~line(x) & ~line(o) | goal(cross,50) :- ~line(x) & ~line(o) | ||
| Line 233: | Line 234: | ||
| There is no arithmetics in GLD --- numbers are only used to define indexes, prizes, time, etc. | There is no arithmetics in GLD --- numbers are only used to define indexes, prizes, time, etc. | ||
| </WRAP> | </WRAP> | ||
| - | |||
| ==== End ==== | ==== End ==== | ||
| Line 243: | Line 243: | ||
| Let's take an even simpler game: | Let's take an even simpler game: | ||
| - | <code prolog> | + | <code> |
| role(white) | role(white) | ||
| role(black) | role(black) | ||
| Line 278: | Line 279: | ||
| terminal :- true(p) & true(q) & true(r) | terminal :- true(p) & true(q) & true(r) | ||
| + | |||
| </code> | </code> | ||
| Answer the following questions: | Answer the following questions: | ||
| - | - how many player is there? | + | - how many players are there? <fs xx-small> (correct answer: 2, why?)</fs> |
| - | - how many fluents are defined? | + | - how many fluents are defined? <fs xx-small>(correct answer: 4, why?)</fs> |
| - | - how many actions are there? | + | - how many actions are there? <fs xx-small>(correct answer: 8, why?)</fs> |
| - | - how many legal moves does the 'white' player have in the initial state of the game? | + | - how many legal moves does the 'white' player have in the initial state of the game? <fs xx-small>(correct answer: 3, why?)</fs> |
| - | - how many fluents are true in the initial state of the game? | + | - how many fluents are true in the initial state of the game? <fs xx-small>(correct answer: 1, why?)</fs> |
| - | - assume in the first turn, the white player performed the 'a' action and the 'black' player action 'd'. How many fluents are true in the second turn? | + | - assume in the first turn, the white player performed the 'a' action and the 'black' player action 'd'. How many fluents are true in the second turn? <fs xx-small>(correct answer: 1, why?)</fs> |
| - | - what is the smaller number of turns required to end the game? | + | - what is the smallest number of turns required to end the game? <fs xx-small>(correct answer: 4, why?)</fs> |
| - | - does the game always end? (is it possible to loop the game indifinetely?) | + | - does the game always end? (is it possible to loop the game indefinitely?) |
| === - Assignment 2 === | === - Assignment 2 === | ||
| - | Please model the 'crosses and crosses' game. The rules are similar to the tic-tac-to, again we have nine cells, but both players use the crosses. Players loses when he first creates the line. | + | Please model the 'crosses and crosses' game. The rules are similar to the tic-tac-toe, again we have nine cells, but both players use the crosses. Player loses when he first creates the line. |
| === - Assignment 3 === | === - Assignment 3 === | ||
| Line 303: | Line 305: | ||
| Everything we learned so far is true, but the GDL has an alternative syntax used to store and transfer the games: the Knowledge Interchange Format. It's based on a lisp and uses a prefix notation. Moreover '':-'' operator is replaced with ''<='', ''&'' with ''and'', negation ''~'' with ''not''. The variables start with the ''?''. Below you can see an example of translation between Prolog: | Everything we learned so far is true, but the GDL has an alternative syntax used to store and transfer the games: the Knowledge Interchange Format. It's based on a lisp and uses a prefix notation. Moreover '':-'' operator is replaced with ''<='', ''&'' with ''and'', negation ''~'' with ''not''. The variables start with the ''?''. Below you can see an example of translation between Prolog: | ||
| - | <code prolog> | + | <code> |
| p(a,Y) | p(a,Y) | ||
| ~p(a,Y) | ~p(a,Y) | ||
| Line 313: | Line 315: | ||
| and KIF: | and KIF: | ||
| - | <code lisp> | + | <code scheme> |
| (p a ?y) | (p a ?y) | ||
| (not (p a ?y)) | (not (p a ?y)) | ||
| Line 325: | Line 327: | ||
| For every example below, tell if the KIF version is a faithful translation of the Prolog one. | For every example below, tell if the KIF version is a faithful translation of the Prolog one. | ||
| - | <code lisp> | + | <code scheme> |
| r(a,b) :- p(a) & q(b) | r(a,b) :- p(a) & q(b) | ||
| (<= (r a b) (and (p a) (q b))) | (<= (r a b) (and (p a) (q b))) | ||
| </code> | </code> | ||
| - | <code lisp> | + | <code scheme> |
| r(a,b) :- p(a) & q(b) | r(a,b) :- p(a) & q(b) | ||
| (<= (r a b) (p a) (q b)) | (<= (r a b) (p a) (q b)) | ||
| </code> | </code> | ||
| - | <code lisp> | + | <code scheme> |
| r(x,y) :- p(x) & q(y) | r(x,y) :- p(x) & q(y) | ||
| (<= (r ?x ?y) (p ?x) (q ?y)) | (<= (r ?x ?y) (p ?x) (q ?y)) | ||
| </code> | </code> | ||
| - | <code lisp> | + | <code scheme> |
| r(X,Y) :- p(X) & q(Y) | r(X,Y) :- p(X) & q(Y) | ||
| (<= (r ?x ?y) (p ?x) (q ?y)) | (<= (r ?x ?y) (p ?x) (q ?y)) | ||
| Line 356: | Line 358: | ||
| Translate all the models you've created today to the KIF format. | Translate all the models you've created today to the KIF format. | ||
| - | ===== - Walidacja modeli ===== | + | ===== - Validation ===== |
| <WRAP center round tip 60%> | <WRAP center round tip 60%> | ||
| - | Poniższe instrukcje przygotowane są z myślą o laboratorium C2 316, gdzie każdy komputer ma Eclipse. | + | The instructions below require an Eclipse IDE. |
| </WRAP> | </WRAP> | ||
| - | Proszę uruchomić Eclipse i następnie: | + | Please run the Eclipse IDE and: |
| * ''File -> Import Project'' | * ''File -> Import Project'' | ||
| - | * Wybrać opcję importowania z repozytorium git | + | * Import the git repository |
| - | * Jeżeli tej opcji nie ma (Eclipse jest za stare), to trzeba ręcznie sklonować repo i zaimportować projekt z katalogu. Reszta tutejszej instrukcji nie ma sensu FIXME | + | * If there is no such option (Eclipse is too old), one has to download the repository by hand and ignore the further instructions. |
| - | * Wybrać opcję klonowania z zewnętrznego URI | + | * Clone from the remote URI |
| - | * Wpisać URI: ''https://github.com/ggp-org/ggp-base.git'' | + | * Fill URI: ''https://github.com/ggp-org/ggp-base.git'' |
| - | * Wybrać gałąź ''master'' | + | * Select the ''master'' branch |
| - | * Wybrać jakiś //rozsądny// katalog dla projektu | + | * Select a //reasonable// catalogue for the project |
| - | * Wybrać projekt ''ggp-base'' do zaimportowania | + | * Select a ''ggp-base'' project to be imported |
| - | ==== - Dodanie gier do środowiska ==== | + | ==== - Adding Custom Games ==== |
| - | W katalogu projektu proszę dostać się do ścieżki ''games/games'' i stworzyć tam trzy katalogi ''kolko-krzyzyk'', ''krzyzyk-krzyzyk'' i ''spock''. Każdy katalog powinien zawierać dwa pliki: | + | In the project directory go to the ''games/games'' catalogue and create there three directories ''tic-tac-toe'', ''cross-cross'' and ''spock''. Every directory should contain two files: |
| - | * plik ''.kif'' z modelem gry | + | * ''<name>.kif'' file with the model |
| - | * plik ''METADATA'' z zawartością: | + | * ''METADATA'' file containing: |
| <code javascript> | <code javascript> | ||
| { | { | ||
| - | "gameName": "<nazwa gry>", | + | "gameName": "<game name>", |
| - | "rulesheet": "<nazwa pliku kif>" | + | "rulesheet": "<kif file name>" |
| } | } | ||
| </code> | </code> | ||
| - | ==== - Walidacja gier ==== | + | ==== - Games' Validation ==== |
| + | |||
| + | From the Eclipse run the ''Validator'' app (one of the targets next to the ''play'' button). | ||
| - | Z poziomu Eclipse proszę uruchomić aplikację ''Validator'' (rozwijana lista przy guziki ''play''). | + | ''Validator'' will check if the model is a valid GDL model. |
| - | ''Validator'', jak sama nazwa wskazuje, ma na celu sprawdzenie, czy dany model jest prawidłowym modelem GDL. | + | === Assignment === |
| - | === Ćwiczenia === | + | - In the ''Repository'' field choose ''Local Game Repository'' |
| + | - In the ''Game'' field select ''Tic-Tac-Toe'' | ||
| + | - Press ''Validate'' --- There should be no failure | ||
| + | - Repeat the same for your custom models | ||
| + | - Fix your models to be playable | ||
| - | - W polu ''Repository'' wybrać ''Local Game Repository'' | ||
| - | - W polu ''Game'' wybrać ''Tic-Tac-Toe'' | ||
| - | - Wciśnąć przycisk ''Validate'' --- program powinien pokazać same sukcesy | ||
| - | - Powtórzyć to samo dla własnych modeli | ||
| - | - Poprawić własne modele | ||
| - | - Zdobyć kolejne sukcesy. | ||
