Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
en:dydaktyka:ggp:gdl [2018/01/16 01:26]
msl [5.1 Adding Custom Games]
en:dydaktyka:ggp:gdl [2019/06/27 15:49] (current)
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 ===
  
 {{ :​pl:​dydaktyka:​ggp:​rock-paper-spock.jpg?​300|}} {{ :​pl:​dydaktyka:​ggp:​rock-paper-spock.jpg?​300|}}
-Please model the "Rock Paper Scissors Lizard Spock" game. You can learn the rules from this [[https://​www.youtube.com/​watch?​v=iapcKVn7DdY|video]]. The image on the right is also a good reference. You can practice it with a colleague or like a modern man: [[http://www.playmycode.com/​play/​game/​cainy393/​rock-paper-scissors-lizard-spock|online...]].+Please model the "Rock Paper Scissors Lizard Spock" game. You can learn the rules from this [[https://​www.youtube.com/​watch?​v=iapcKVn7DdY|video]]. The image on the right is also a good reference. You can practice it with a colleague or like a modern man: [[https://rpsls.net|online...]].
  
 ===== - Knowledge Interchange Format ===== ===== - Knowledge Interchange Format =====
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 385: Line 387:
 </​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. 
  
  
en/dydaktyka/ggp/gdl.1516062417.txt.gz · Last modified: 2019/06/27 16:00 (external edit)
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0