Towards a Real-time Game Description Language

Jakub Kowalski

and Andrzej Kisielewicz

Institute of Computer Science, University of Wrocław, Wrocław, Poland

Institute of Mathematics, University of Wrocław, Wrocław, Poland

Keywords:

General Game Playing, Knowledge Representation, Game Description Language, Real-time Games.

Abstract:

For the sake of the General Game Playing competition, the Game Description Language (GDL) has been

developed as a high-level knowledge representation formalism, able to describe any ﬁnite, n-player, turn-

based, deterministic, full-information game. The last two restrictions were removed by the later extension

called GDL-II. In this paper, we discuss our extension of GDL, called rtGDL, that makes it possible to describe

a large variety of games involving a real-time factor. We consider its effectiveness and expressiveness, arguing

that this is a promising direction of research in the ﬁeld of General Game Playing.

1 INTRODUCTION

The aim of General Game Playing (GGP) is to de-

velop a system that can play a variety of games with

previously unknown rules. Unlike standard AI game

playing, where designing an agent requires special

knowledge about the game, in GGP the key is to cre-

ate a universal algorithm performing well in different

situations and environments.

The beginning of the GGP ﬁeld dates from 1968

with the work (Pitrat, 1968) concerning the class of

arbitrary chess-like board games. In 2005 General

Game Playing was identiﬁed as a new Grand Chal-

lenge of Artiﬁcial Intelligence and from this year the

annual International General Game Playing Compe-

tition (IGGPC) has taken place to foster and moni-

tor progress in this research area (Genesereth et al.,

2005). For a more detailed survey of General Game

Playing and International GGP Competition, its his-

tory, achievements and actual research challenges, we

refer to (Genesereth and Thielscher, 2014).

For the purpose of IGGPC, a new language called

the Game Description Language (GDL) (Love et al.,

2006) was developed. GDL has enough power to de-

scribe all turn-based, ﬁnite and deterministic n-player

games with full information. Playing a game given

by such a description requires not only developing a

move searching algorithm, but also implementing a

reasoning approach to understand the game rules in

the sense of computing legal moves, the state update

function, and the goal function.

In 2010, GDL-II (for Game Description Language

with Incomplete Information), the extension to GDL

removing deterministic and full information restric-

tions was proposed in (Thielscher, 2010), and the

claim has been made that GDL is now the complete

language, without any need for further extensions.

In our opinion, if GDL is to be a general artiﬁcial

intelligence language it has still too many restrictions.

In particular, one of such restrictions is the require-

ment that the game has to be turn-based. In (Kowal-

ski and Kisielewicz, 2015), we proposed the exten-

sion of GDL called the Real-time Game Description

Language (rtGDL) that can represent games involv-

ing time-based events, where the exact moment of an

action is relevant. This concerns most current video

games such as Real-time Strategies, Shooters, Sport

Games and Role-playing Games. Research towards

playing these games by AI agents did not enter (yet)

a phase of generalization, and it is focused on using a

specially designed algorithms (Ontan

on et al., 2013;

Hingston, 2010).

This paper is to argue that the properties of rtGDL

make it a potentially useful and interesting direction

of research in the GGP domain. No real number arith-

metic is required inside the rule engine, which unlike

some other proposed extensions, e.g. (Thielscher and

Zhang, 2010), preserve the pure declarative charac-

ter of GDL, and allows to re-use the same reasoning

engine as in plain GDL. We show that this extension

ensures ﬁnite derivability and effectiveness required

for practical use. We address the problem of possi-

ble lags during the communication, and discuss the

expressiveness of the language.

494

Kowalski, J. and Kisielewicz, A.

Towards a Real-time Game Description Language.

DOI: 10.5220/0005816904940499

In Proceedings of the 8th International Conference on Agents and Artiﬁcial Intelligence (ICAART 2016) - Volume 2, pages 494-499

ISBN: 978-989-758-172-4

2 REAL-TIME GDL

GDL is a high-level, strictly declarative language us-

ing logic programming-like syntax. Every game de-

scription contains declarations of player roles, the ini-

tial game state, legal moves, state transition func-

tion, terminating conditions and the goal function.

GDL does not provide any predeﬁned functions: nei-

ther arithmetic expressions nor game-domain speciﬁc

structures like board or card deck. Every function and

declaration must be deﬁned explicitly from scratch,

and a few provided keywords serve as a minimal set

of instructions required to grant to the rules a proper

semantic. This ensures that, given the game rules, any

additional, background knowledge is not required for

the player.

A surprisingly simple, but very powerful GDL-

II extension proposed by Thielscher allows non-

deterministic, imperfect information games, by

adding only two additional keywords, and slightly

changing the communication protocol.

The extension of GDL presented in (Kowalski and

Kisielewicz, 2015) is intended to remove another im-

portant restriction of GDL games that they need to be

turn-based. It preserves the purely declarative style,

so that the state computing inference engine can re-

main unchanged. In general, dealing with real-time

games may involve real number arithmetic, which

cannot be encoded in pure GDL in a simple way.

The proposed approach requires real arithmetic on the

level of search engine reasoning only. On the level

of the rule engine, numbers are treated like standard

terms without additional semantics (in a manner sim-

ilar to natural numbers in the goal relation).

Changes between rtGDL and GDL keywords are

summarized in Table 1. Keywords that are not listed:

role, legal, does, terminal and goal remain un-

changed. Parameter T ∈ R

∪{∞} linked with the fact

F encodes the lifetime of this fact, that is, the time for

which this fact will be true. After the time is over, the

state update is performed and the additional relation

expired(F) indicates that F have just expired and al-

lows changes based on this knowledge.

Table 1: The rtGDL keywords: the top three are modiﬁed

GDL keywords, while the last two are the new keywords.

init(T,F) F lasts for time T in the initial state

true(T,F) F lasts for time T in the current state

next(T,F) F lasts for time T in the next state

infinity stands for ∞ time value

expired(F) holds when F becomes obsolete

State updates are performed after a player makes a

move or when some fact becomes obsolete. Before

such an update is computed, all times assigned to the

set of holding facts are properly updated according to

the time since the last update.

Keywords restrictions taking into account their in-

tended meaning remain the same as in standard GDL

(Love et al., 2006), with the addition that the new key-

word expired is restricted in the same way as true.

Also, we adopt the convention that to be considered as

valid, rtGDL game description must be stratiﬁed (Apt

et al., 1988), allowed (Lloyd and Topor, 1986), and

satisfy the general recursion restriction (see (Schiffel

and Thielscher, 2014, Deﬁnition 3.)). These restric-

tions ensure that game rules, despite introducing time-

based values, which can be arbitrary real numbers,

can be effectively and unambiguously interpreted by

a state transition system, and all relevant derivations

remain ﬁnite and decidable (see Theorem 1).

2.1 Semantics

We show that rtGDL may be seen as a straightforward

extension of GDL. As in GDL, any game descrip-

tion deﬁnes a ﬁnite set of domain-dependent function

symbols and constants, which determines a (usually

inﬁnite) set of ground symbolic expressions Σ. These

ground terms can represent players, moves, parts of

the game state, etc. However, unlike in the standard

GDL, the game states are not simply subsets of Σ. Ev-

ery individual feature of the game state has assigned

a lifetime, which is a real number value or the inﬁn-

ity symbol, and describes the period of time for which

the feature holds (after that, unless other events occur,

it ceases to be a part of the state). Moreover, initially

declared real numbers which occur in Σ are not the

only ones that may appear. Any real number, given

by the outside environment as updated lifetime, can

appear as a constant later during the game.

Therefore, we deﬁne an rtGDL game state to be

a ﬁnite subset of R

∞

× Γ, where R

∞

= (0, ∞] (in-

cluding ∞), and Γ ⊆ Σ(R

∞

) where Σ(R

∞

) is a set of

ground terms of the game, with the set of constants

extended by R

∞

. To deﬁne the declarative semantics

as a state transition system we follow (Kowalski and

Kisielewicz, 2015). First, the elements of the game

model are endowed suitably with the component R

∞

• R ⊆ Σ (the roles);

• s

⊆ R

∞

× Σ (the initial position);

• t ⊆ P

ﬁn

∞

× Γ) (the terminal positions);

• l ⊆ R × Γ × P

ﬁn

∞

× Γ) (the legality relation);

• u : R

∞

×(R 9 Γ) × P

ﬁn

∞

× Γ) 7→ P

ﬁn

∞

× Γ)

(the update function);

• g ⊆ R × N × P

ﬁn

∞

× Γ) (the goal relation);

Towards a Real-time Game Description Language

495

(where P

ﬁn

(A) denotes the ﬁnite subsets of A). The

legality relation l(r, m, S), states that in the position S,

a player r can perform move m. Given a time ∆t since

the last state update, and a partial function of the joint

moves performed by the players M : (R 9 Γ), the state

update function u(t, M, S) determines the updated po-

sition. Finally, the relation g(r, n, S) deﬁnes the payoff

of player r in the game state S.

Let G be a valid game description of an n-player

rtGDL game. The players’ roles are deﬁned by

the derivable instances of role(R). Other game el-

ements have a real-time factor. A game state S =

{(t

, f

), . . . , (t

, f

)} is encoded as a set of facts

(ground terms) with assigned lifetimes. At the be-

ginning of the game, the state is composed of the

derivable instances of init(T,F). We use the key-

word true to extend the game description G by the

facts resulting from S, which form the set

true

def

= {true(t

, f

), . . . , true(t

, f

)}.

If terminal is derivable from G ∪ S

true

, then the

state S is a terminal position. Instances of goal(R,N)

derivable from G ∪ S

true

assign to every player R

its reward N. Legal actions are derivable instances of

legal(R,M), for every role R and every move M.

The state of the game remains unchanged until an

event occurs. There are two types of events: action-

based, caused by players’ moves, and expired-based,

resulting from expiration of some facts in S

true

. Let

∆t be the time since the last occurrence of an event.

When a subset of players r

, . . . , r

, where ∀ j i

∈

{1, . . . , n}, perform moves m

, . . . , m

, then

does

def

= {does(r

), . . . , does(r

)}.

Let us notice that M

does

0 if no player sends a move.

Performing state update requires updating lifetime

of every holding fact, and information about facts that

expired. These two sets are deﬁned in a following

way:

µ(S, ∆t) = {true(t

− ∆t, f

) :

true(t

, f

) ∈ S

true

∧ t

> ∆t}

exp

∆t

def

= {expired( f

) :

true(t

, f

) ∈ S

true

∧ t

≤ ∆t}

where µ(S, ∆t) updates the facts lifetimes and S

exp

∆t

contains expired facts. The updated position is com-

posed of instances of next(T,F) derivable from G ∪

does

∪ µ(S, ∆t) ∪ S

exp

∆t

In order to summarize above in a formal deﬁni-

tion, as in (Schiffel and Thielscher, 2014), we make

use of the fact that any stratiﬁed set of clauses G has

a unique stable model (Gelfond and Lifschitz, 1988).

We denote it SM[G ]. Due to the syntax restriction in

rtGDL, it is ﬁnite ((Love et al., 2006)).

Deﬁnition 1. Let G be a valid rtGDL speciﬁcation,

whose signature determines the set of ground terms

Σ, and Γ ⊆ Σ(R

∞

). The semantics of G is the state

transition system (R, s

,t, l, u, g) given by

• R = {r ∈ Σ : role(r) ∈ SM[G]};

• s

= {(t, f ) ∈ R

∞

× Σ : init(t, f ) ∈ SM[G]};

• t = {S ∈ 2

∞

×Γ

: terminal ∈ SM[G ∪ S

true

]};

• l = {(r, m, S) : legal(r,m) ∈ SM[G ∪ S

true

]},

for all r ∈ R, m ∈ Γ and S ∈ P

ﬁn

∞

× Γ);

• u(∆t, M, S) = {(t, f ) : next(t, f ) ∈ SM[G ∪

does

∪µ(S, ∆t)∪S

exp

∆t

]}, for all M : (R 9 Γ), S ∈

ﬁn

∞

× Γ), and minimal ∆t such that M

does

∪

exp

∆t

• g = {(r, n, S) : goal(r,n) ∈ SM[G ∪S

true

]}, for

all r ∈ R, n ∈ N and S ∈ P

ﬁn

∞

× Γ).

The model in the above deﬁnition is uncountably in-

ﬁnite, and cannot be used itself as an effective de-

scription of the game. Yet, it is locally ﬁnite in the

sense that all stable models involved are ﬁnite and ef-

fectively computable. This is in spite of that rtGDL

games involve a real-time factor and incomplete infor-

mation (on time when events occur). In other words,

our extension preserves the crucial property of “ﬁnite

derivability”, which for rtGDL setting can be speci-

ﬁed in the following way. A state of the game is the

set of all facts (ground terms) holding in a given mo-

ment of the game. Each state that can be achieved

from the initial state by a ﬁnite sequence of moves of

the players performed in certain times from the start

of the game is called a reachable state. The last state

occurring before the present state S in this sequence

is called the preceding state for S (and the given se-

quence of moves). Note that the same state can be

reached by various sequences of moves.

Theorem 1. Let G be a valid rtGDL game descrip-

tion. Then, each reachable state is ﬁnite and can be

effectively computed from any preceding state, given

the joint move and the time passed.

Proof. (Sketch). The proof is similar as in case

of GDL and GDL-II, based on results on logic pro-

gramming. First, since G is stratiﬁed, by (Gelfond

and Lifschitz, 1988) it admits a unique stable model

SM[G] as the declarative semantics, which is the same

a the “iterated ﬁxed point” model M

in (Apt et al.,

1988). Moreover, by the allowedness and the gen-

eral recursion restriction this model is ﬁnite (Love

et al., 2006; Schiffel and Thielscher, 2010). It can

be effectively computed using, e.g., the iterative pro-

cedure described in (Apt et al., 1988). This implies,

in particular that the initial state is ﬁnite and can be

effectively computed. Now the proof is by induc-

tion. Assuming that a reached state is ﬁnite, the joint

ICAART 2016 - 8th International Conference on Agents and Artiﬁcial Intelligence

496

move of the players contains a ﬁnitely many new

real time constants, and therefore the stable model

SM[G ∪ M

does

∪ µ(S, ∆t) ∪ S

exp

∆t

] is ﬁnite. It follows

that there are ﬁnitely many instances of next(T,F)

derivable from G ∪ M

does

∪µ(S, ∆t) ∪ S

exp

∆t

, and as be-

fore they can be effectively computed.

The result above means, in particular, that any ﬁ-

nite part of the game tree may be effectively computed

on the basis of the moves and times they occur.

3 EXECUTION MODEL

There are various possibilities to handle real-time

events in an execution model of rtGDL. The simplest

model, we presented in (Kowalski and Kisielewicz,

2015), requires very little deviation from the standard

execution model of GDL (Love et al., 2006).

In every state S reached at time t (starting from the

initial position s

), the game waits until the ﬁrst event

occurs. Let t

be the time of that event. Then the

game state should be updated according to the func-

tion u(t

− t, M, S) and all players should be notiﬁed

about the update and its time. The process repeats un-

til the game reaches a terminal position, with players’

rewards given by the goal relation g.

To decrease the number of messages, and keep

the communication protocol similar to standard GDL

one, the Game Manager can send to the players only

information about actions. Since the players must

maintain their own internal clocks anyway, they can

use them to keep the track of expiration of facts and

update states in connection with expired-based events.

The above simple execution model does not ad-

dress the problem of possible lags during communi-

cation. It may be treated as suitable in the scenario

when rtGDL programs compete on the same server,

and communication delay may be ignored. Yet, in

case of games played through the GGP website, lags

may cause practical problems with having up-to-date

knowledge about the current state of the game.

One direction to deal with the delay problem is

to divide the time axis into small intervals and admit

communication only at the end points of these inter-

vals. The intervals should be large enough to provide

time for indispensable computation. Another possible

approach is to allow for the Game Manager to stop the

time of the game in the situations when updating the

state requires more time. The choice between models

should depend on the possible applications.

Another problem concerns correcting information

about the current state of the game in the situation

when a message about an action-based event just ar-

rived can make some knowledge obsolete. The point

is that an action-based event may change lifetimes of

other events.

Consider a message m notifying about an action-

based event with timestamp t, received at time t

> t.

The player, having access to all previous messages,

and thus to the move history, has full knowledge about

the state s at time t (including lifetimes of all facts).

Thus, the player can backtrack to this state and, given

m, perform the suitable state update.

Assuming stable time difference between a player

and the Game Manager, it is possible for the player,

after performing at least one move, to synchronize

with the Game Manager and be able to send every

later move so that it arrives at the desired time.

Indeed, assume a player sent a move at time t

As an answer, he get a PLAY message at time t

, with

parameter t

describing the time when the Game Man-

ager received his move. Now, the player can put

∆t = t

− t

, and for every move which should be re-

ceived by the Game Manager at time t, the player can

send it at the time t − ∆t on its own clock. The esti-

mation ∆t can be adjusted to be more reliable as the

game continues.

This problem recalls the known practical problem

in the GGP competitions of sending moves a little bit

earlier to make sure they arrive to the Game Manager

at time. Yet, in rtGDL setting, it is more essential to

adjust the time as exact as possible.

We may summarize all the above:

Theorem 2. For each Real-time GDL game taking

place through the website, there exists a time delay

∆t, such that, for any time t

, the players are able

to compute fully the state of the game at time t

with

delay not larger than ∆t.

4 EXPRESSIVENESS OF RTGDL

To illustrate how the game rules are constructed,

we provide an rtGDL code of a complete Game of

Chicken. It is a well known game, where two players

pretend to be tough, and do not want to swerve from

the colliding path waiting for the opponent to do this.

1 role( whi t e ). role( bla c k ).

2 init(infinity, di r ( white , st r ai gh t )).

3 init(infinity, di r ( black , st r ai gh t )).

4 init(1.0 , t ime r ) .

6 next( T , t i mer ) ⇐ true( T , t ime r ).

7 next(infinity, di r (R , sw e rv e ))

8 ⇐ does(R , sw erv e ).

9 next( T , dir ( R , D )) ⇐ true(T , dir ( R , D ))

10 ∧ ¬ does( R , s w er v e ).

11 legal( R , s w er v e )

12 ⇐ true(T , dir ( R , s tr a ig ht ) ) .

Towards a Real-time Game Description Language

497

13 terminal ⇐ expired( ti m er ).

14 goal( R ,0) ⇐ true( T , dir ( R , s tr ai g h t ) )

15 ∧ true(S , dir (P , s tr a ig ht ))

16 ∧ distinct(R , P ).

17 goal( R , 8 0) ⇐ true(T , dir (R , s w er v e ))

18 ∧ true( S , di r (P , st ra i gh t )).

19 goal( R , 9 0) ⇐ true(T , dir (R , s w er v e ))

20 ∧ true( S , di r (P , sw e rv e ))

21 ∧ distinct( R , P ).

22 goal( P , 100 ) ⇐ true(T , dir ( R , s w er v e ))

23 ∧ true( S , di r (P , st ra i gh t )).

The game lasts for the one unit of time. Each player

starts riding straight ahead, and until the timer holds,

he player can decide to swerve. After swerving, no

more legal moves are allowed.

The payoff matrix is deﬁned as follows. In the

case of a crash, both players’ reward is 0. If only one

player decides to swerve his reward is 80, while his

opponent’s reward is 100. When both players decide

to swerve they gain 90 points each.

We now proceed to show that, in principle, all

GDL games can be expressed in rtGDL. To this end

we need the following deﬁnition.

Deﬁnition 2. We say that an rtGDL game G

has an

equivalent semantics to a GDL game G if there is a

procedure converting any program for G to a program

for G

, so that the result of any rtGDL competition C

between converted programs is the same as the result

of GDL competition C of the original GDL programs.

The deﬁnition could be stated more formally, but it is

sufﬁcient for the sketch of the proof provided below.

Theorem 3. For every GDL game G there exist real-

time GDL game G

with equivalent semantic.

Proof. (Sketch). Considering G as a GDL spec-

iﬁcation, we convert it, step by step, in an rtGDL

speciﬁcation. First, all occurrences of true, init,

and next are modiﬁed to ﬁt the rtGDL syntax by en-

dowing each with the lifetime parameter infinity.

We introduce three new function constants made(R,M),

clock, and moved(R) with intention to postpone the

state update until playclock clock expires, and to

mark down that the player R has performed his move.

Accordingly, all occurrences of does(r,m) are re-

placed by true(infinity, made(r,m)), and every

rule of the form next(infinity, f )⇐ φ is replaced by

next(infinity, f )⇐ φ ∧ expired(clock). In addi-

tion we add a set of new rules:

next(infinity,moved(R)) ⇐ does(R,M).

next(infinity,made(R,M))

⇐ does(R,M) ∧ ¬ true(infinity,moved(R)).

next(infinity,F)

⇐ true(T,clock) ∧ true(infinity,F).

The intended meaning of the constant clock is en-

sured by the following:

init(1.0,clock).

next(1.0,clock) ⇐ expired(clock).

next(t,clock) ⇐ true(t,clock).

The presented code allows the players to perform pre-

cisely one move during the unit clock interval. The

optimal strategy of the players (based on the given

strategy for the corresponding GDL game) should be

to make use of all the timelimit to compute their sin-

gle move as in GDL and send it to the Game Manager.

Then, the result of the competition will be the same.

Here we need to make a theoretical assumption

that, as a result of such strategy, the players send their

moves at the same time, at the end of the timelimit,

and in consequence, at the same time are informed

about their joint move. Another theoretical assump-

tion is that players do not send illegal moves, because

the rtGDL Game Manager handles illegal moves in a

different way than the GDL one.

In practice, the games G and G

would not be fully

equivalent, especially when it is essential that players

have no knowledge about the moves done by other

players during the same turn. Also, the error handling

would require a special solution. (The simplest one

would be to treat illegal moves as the loss.)

It is natural to compare rtGDL games with Extensive

Form Continuous-time games (Simon and Stinch-

combe, 1989). Let us recall that in such games the

players act on the interval R = [0, 1]. Let A be the

joint set of all possible actions of all players. The de-

cision node is a pair h0,

0i or ht, hi, where t ∈ (0, 1]

and h is a function from [0, t) to A, representing the

history of the game up to time t. Now, since every

rtGDL game has to be ﬁnite in terms of match dura-

tion, it is always possible to map rtGDL lifetime units

to (0, 1] such that every match do not go beyond R.

The construction is straightforward, and we may see

that every rtGDL game can be represented in the form

of the Extensive Form Continuous-time game.

However, it should be noted, that rtGDL nodes al-

lows only ﬁnite number of legal actions. This restric-

tion adopted to preserve ﬁnite derivability property of

GDL games is, at the same time, a serious limitation.

In particular, it does not allow players to use real num-

bers in their move messages, which is a natural action

in many games.

5 CONCLUSION

With introduction of GDL-II, it was claimed that

the GDL language can be considered complete

(Thielscher, 2010; Schiffel and Thielscher, 2014), and

additional elements can only serve for simplifying

description or will be forcing setting extensions far

ICAART 2016 - 8th International Conference on Agents and Artiﬁcial Intelligence

498

beyond the concept of General Game Playing (e.g.

open-world games or physical games like in General

Video Game Playing (Perez et al., 2015)).

Our position is contrary. We argue that our real-

time extension (Kowalski and Kisielewicz, 2015) pre-

serves the core idea of GDL – a concise purely log-

ical description of the game and a simple execution

model. At the same time it is a larger extension than

GDL-II, allowing a game to have an inﬁnite number

of states and the players to have an inﬁnite number

of actions. By introducing time based events and by

giving relevance to the move ordering it makes it pos-

sible to describe properly many real world situations.

It makes real-time general gaming a very hard, but in-

teresting area of further GGP research. In particular,

it allows to model many elements of the popular com-

puter games, which are currently used as a test-bed

for dedicated AI players, e.g. Super Mario Bros, Un-

real Tournament 2004 (Hingston, 2010), or Starcraft

(Ontan

on et al., 2013).

Beyond the usage in GGP, the correlations be-

tween the GDL and game theory (Thielscher, 2011)

and Multiagent Systems (Schiffel and Thielscher,

2010) are often pointed out. A goal for GDL is to

become a universal description language which can

describe as large class of game-like problems as pos-

sible, at the same time remaining compact, high-level

and machine-processable. We presented the next step

into such a generalization of problems description,

which brings the class of games covered by the GDL

family closer to real-time game theory (e.g. Extensive

Games in Continuous Time, Continuous Time Re-

peated Games (Bergin and MacLeod, 1993)) and Real

Time Multiagent Systems (Julian and Botti, 2004).

Moreover, we think that GDL language family

can be further expanded. In particular, it is pos-

sible to merge presented Real-time extension with

Thielscher’s Incomplete Information extension to ob-

tain the broadest general description language so far.

The sketch of such construction has been presented in

(Kowalski and Kisielewicz, 2015).

ACKNOWLEDGEMENTS

This work was supported by Polish National Sci-

ence Centre grants No 2014/13/N/ST6/01817 and No

2012/07/B/ST1/03318.

REFERENCES

Apt, K. R., Blair, H. A., and Walker, A. (1988). Founda-

tions of deductive databases and logic programming.

chapter Towards a Theory of Declarative Knowledge,

pages 89–148.

Bergin, J. and MacLeod, W. B. (1993). Continuous time re-

peated games. International Economic Review, pages

21–37.

Gelfond, M. and Lifschitz, V. (1988). The stable model

semantics for logic programming. In ICLP/SLP, vol-

ume 88, pages 1070–1080.

Genesereth, M., Love, N., and Pell, B. (2005). General

game playing: Overview of the AAAI competition.

AI Magazine, 26:62–72.

Genesereth, M. and Thielscher, M. (2014). General Game

Playing. Morgan & Claypool.

Hingston, P. (2010). A new design for a turing test for bots.

In CIG, pages 345–350. IEEE.

Julian, V. and Botti, V. (2004). Developing real-time multi-

agent systems. Integrated Computer-Aided Engineer-

ing, 11(2):135–149.

Kowalski, J. and Kisielewicz, A. (2015). Game Description

Language for Real-time Games. In GIGA, pages 23–

30.

Lloyd, J. W. and Topor, R. W. (1986). A basis for deductive

database systems II. The Journal of Logic Program-

ming, 3(1):55–67.

Love, N., Hinrichs, T., Haley, D., Schkufza, E., and Gene-

sereth, M. (2006). General Game Playing: Game De-

scription Language Speciﬁcation. Technical Report

LG-2006-01, Stanford Logic Group.

Ontan

on, S., Synnaeve, G., Uriarte, A., Richoux, F.,

Churchill, D., and Preuss, M. (2013). A survey of

real-time strategy game AI research and competition

in Starcraft. T-CIAIG, 5(4):293–311.

Perez, D., Samothrakis, S., Togelius, J., Schaul, T., Lucas,

S., Cou

etoux, A., Lee, J., Lim, C., and Thompson,

T. (2015). The 2014 General Video Game Playing

Competition. T-CIAIG. To appear.

Pitrat, J. (1968). Realization of a general game-playing pro-

gram. In IFIP Congress, pages 1570–1574.

Schiffel, S. and Thielscher, M. (2010). A Multiagent

Semantics for the Game Description Language. In

Agents and Artiﬁcial Intelligence, volume 67 of CCIS,

pages 44–55.

Schiffel, S. and Thielscher, M. (2014). Representing and

Reasoning About the Rules of General Games With

Imperfect Information. JAIR, 49:171–206.

Simon, L. K. and Stinchcombe, M. B. (1989). Extensive

Form Games in Continuous Time: Pure Strategies.

Econometrica, 57(5):1171–1214.

Thielscher, M. (2010). A General Game Description Lan-

guage for Incomplete Information Games. In AAAI,

pages 994–999.

Thielscher, M. (2011). The General Game Playing Descrip-

tion Language is Universal. In IJCAI, pages 1107–

1112.

Thielscher, M. and Zhang, D. (2010). From general game

descriptions to a market speciﬁcation language for

general trading agents. volume 59 of LNBIP, pages

259–274.

Towards a Real-time Game Description Language

499