Az ágensek csapatokba sorolása a nevük alapján történik. Az ágensek nevének két részből kell állnia, mely két részt az alulvonás ("_") karakter választja el. A név első fele a csapat neve, a második fele pedig az ágenst azonosítja. A név második fele elhagyható (ahogy például a "simple_" ágens esetében is történik), ilyenkor az ágensek egy automatikus sorszámot kapnak a nevük végére a keretrendszertől.

A minden szükséges anyag letölthető a verseny honlapjáról. Először a Jason keretrendszert kell letölteni majd ezt követően az AgentGame környezetet kell működőképes állapotba hozni (lásd a Telepítési útmutatót). Az AgentGame környezet tartalmaz mindent, ami a megoldás alapjául szolgálhat: található benne két mintapélda, és a minta ágensek a telepítést követően azonnal kipróbálhatóak.

A környezet beüzemelését követően javasolt a mintapéldákból kiindulni, és azok kódjának módosításával, kiegészítésével egyre magasabb intelligenciával rendelkező ágenseket létrehozni. A beadó rendszerben az elkészült ágensek (csak .asl vagy .asl és .java) forráskódját kell beadni. A kiértékelő rendszer a beadott csapatokat a szerveren automatizáltan minden más csapattal összepárosít és a játékok eredménye szintén a beadó rendszerben érhető el.

A szimulátor legfontosabb grafikus felülete a főablak. Ennek az ablaknak a jobb oldalán látható a játéktér, melyen a játék folyamán az összes fontos esemény nyomon követhető:

A jobb oldalon egymás alatt a következő információk láthatóak:

A MAS Console a Jason saját ablaka, de a szimulátor is megjelenít itt üzeneteket. Az ágensek a print belső utasítással tudnak szöveges üzeneteket kiírni, ami a hibakeresésük során igen hasznos lehet.

A MAS Console ablakában lehetőség van szimuláció közben is aktiválni a debug módot, vagy megtekinteni az éppen futó ágensek forráskódját. A MAS Console bezárásakor a Jason automatikusan megszakítja a szimuláció futását.

Amennyiben a szimulátor konfigurációja engedélyezi a játék végén a grafikonok megjelenítését, akkor az utolsó kör után megjelenő, az alábbihoz hasonló ablakban látható az ágensek illetve a csapatok összenergiájának alakulása.

A szimulátort a mas2j fájlban a GameEnvironment-nek paraméterkén átadott konfigurációs fájl segítségével lehet konfigurálni. Ez a fájl alapértelmezés szerint az AgentGame.conf fájl, mely két fő részre bontható.

A fájl első felében a szimulátor gyakorlati működését meghatározó beállítások kaptak helyet, melyeket alább részletezünk. A fájl második felében a játékkal kapcsolatos beállítások szerepelnek (például cselekvések költsége, pálya mérete, stb.), melyeket a verseny keretén belül nincs értelme módosítani, ezért jelentésükre (a fájlban elhelyezett kommenteknél bővebben) nem térünk ki.

A szimulátor fontosabb testreszabható beállításai:

A konfigurációs fájl bőven kommentezett, ezért az egyes beállítások használata a fájl alapján értelemszerű.

A simple ágens koncepciója igen egyszerű, mégis viszonylag sok aspektusát lefedi a szükséges AgentSpeak programozásnak. Az ágens alapvetően a pályán bolyong: arra megy, amerre éppen néz egészen addig, amíg falnak nem megy, ahol aztán visszafordul. Ezen kívül 5% valószínűséggel menetközben is elfordul, aminek hatására mozgása tényleg barangolás jellegű.

Ha az ágens meglát egy ennivalót, akkor azt célként tűzi ki magának és odamegy megenni. Ha az ágens ennivalóra lép, akkor azt ösztönösen megeszi. Ha az ágensnek elfogy az energiája, akkor a továbbiakban a várakozás cselekvést hajtja végre.

Az ágens programja számos ponton továbbfejleszthető illetve szuboptimális, azonban célja nem is versenyképes résztvevőként szerepelni a játékban. Szerepe elsősorban egy egyszerű működőképes ágens példájául szolgálni, illetve a hallgatói fejlesztések kiindulási alapját nyújtani. Így tehát első kísérletezésként javasolt a simple ágenssel kód tekintetében teljesen azonos neptun ágenst szerkeszteni és módosítani, majd az eredményt a módosítás nélküli simple csapattal összevetni!

Az ágens programja számos megjegyzés sorral indul. Megjegyzéseket mind /* és */ karakterek közé, mind a sor elejére elhelyezett // jel mögé írhatunk.

/**************************************************************************

AgentGame v2.0.

Copyright Peter Eredics (BUTE-DMIS) 2010.

simple.asl - Simple agent running for the closest food it sees

**************************************************************************/

///////////////////////////////////////////////////////////////////////////

// INIT

///////////////////////////////////////////////////////////////////////////

// No initial beliefs yet

///////////////////////////////////////////////////////////////////////////

// Being out of energy

///////////////////////////////////////////////////////////////////////////

+time(_) : myenergy(Energy) & Energy<25 <-

wait.

Az ágens kódjának első terve arról gondoskodik, hogy amennyiben az ágensnek 25 egységnél kevesebb az energiája, akkor ne tegyen semmit, pontosabban a várakozás cselekvést hajtsa végre. A terv felépítése a következő:

Mivel az ágens szinte minden cselekvését a +time(_) triggereli és mivel ez a terv szerepel először az ágens forráskódjában, ezért ez tekinthető a legmagasabb prioritású tervnek, hiszen ha a feltételei teljesülnek (az energia kevesebb mint 25), akkor mindenképpen ez hajtódik végre.

A következő blokkban az evéssel kapcsolatos tervek szerepelnek. Az első terv arról gondoskodik, hogy amennyiben az ágens eat_at_my_pos célja meghiúsul (enni szeretne ott, ahol már nincs ennivaló), akkor a Jason ne jelezzen hibát (ha az eredeti terv meghiúsult, akkor az itt visszaadott true érték miatt a Jason végül sikeresnek értékeli a cselekvést - ami az adott helyzetben (amikor tényleg nincs mit megenni az adott pozíción) elfogadható működés.

A második terv +!eat_at_my_pos bevezetője akkor aktiválódik, ha az ágens felveszi a céljai közé az eat_at_my_pos célt - lásd később a kódban, amikor az ágens ennivalót érzékel magától 0 távolságra.

///////////////////////////////////////////////////////////////////////////

// Eating related things

///////////////////////////////////////////////////////////////////////////

-!eat_at_my_pos <-

true.

+!eat_at_my_pos <- eat.

A következő részben a mozgással kapcsolatos tennivalók kaptak helyet. Először is az ágensnek néha véletlen irányba kell fordulnia, amit a .random(R) beépített cselekvéssel hajt végre, aminek következtében az R változó egy 0-1 közötti véletlen értéket kap. Ezután az R*4 értékű paraméterrel végrehajtva a turn cselekvést, pont a kívánt célt értjük el.

///////////////////////////////////////////////////////////////////////////

// Moving

///////////////////////////////////////////////////////////////////////////

// First we define what a random turn is, and how to make it:

+!randomTurn <-

.random(R);

turn(R*4).

A következő terv arról gondoskodik, hogy ha az ágens korábban úgy döntött, hogy a következő lépésben véletlenszerű irányba fordul, akkor ez történjen meg. Ezt a döntését az ágens egy hiedelem, a scheduled_random_turn felvételével jelezte a tudásbázisában. A terv törzsében először eltávolítjuk ezt a hiedelmet (hogy az ágens ne forogjon végtelen ciklusban), majd áttérünk a randomTurn terv végrehajtására.

// If a random turn was scheduled before, execute it!

+time(_) : scheduled_random_turn <-

-scheduled_random_turn;

!randomTurn.

A következő blokk arról gondoskodik, ha egy ágens valamilyen okból nem képes az általa választott irányba haladni (az ilyen külső okot a Jason a step cselekvés sikertelenségével jelzi, ami egyben a !move terv meghiúsulását is jelenti, ami a szintaxis alapján a -!move(_)triggert jelenti). Ilyenkor ha volt kinézett ennivaló cél, akkor azt az ágens elveti és véletlen irányba fordul.

// If we are unable to move (our last position is the same as our position

// now),forget the target and schedule a random turn to avoid geting

// stucked together with an agent moving from the opposite direction

-!move(_) <-

-target(_,_);

+scheduled_random_turn.

Minden egyéb esetben a mozgás nem bonyolult dolog: végre kell hajtani a megfelelő irányba a step cselekvést, és kész is:

// If we are not stucked, we just have to keep moving

+!move(Dir) <-

step(Dir).

A következő két terv az evéssel kapcsolatos. Az első terv feltétel részében az szerepel, hogy az ágens által érzékelt ennivalók (a food érzékelés paramétere, a Food lista tartalma) közül a legközelebbi (a .min beépített utasítás az első elem alapján rendezi a listaelemeket) 0 távolságra van. Ilyenkor el kell felejteni a korábbi célt ahova az ágens tartott (ami az esetek többségében egyébkén a jelenlegi pozíció), és enni kell!

///////////////////////////////////////////////////////////////////////////

// Time triggered "intelligence" of the agent

///////////////////////////////////////////////////////////////////////////

// Is there food at my position?

// - the list of food objects I see is Food

// - each food object is represented in the list in the form of

// [distance_from_me, food_value, position_x, position_y]

// - the .min internal function chooses the minimal value in Food

// - the food objects (=lists) are ordered by their first element (=distance)

// - the "[0,..." means that the distance of the closest food is zero

// If yes, let's eat it and forget about it as a target!

+time(_): food(Food) & .min(Food,[0,V,X,Y]) <-

-target(_,_);

!eat_at_my_pos.

Ezután azt a helyzetet kell kezelnünk, hogy az ágens elérte a célnak választott ennivalót (target), de ott már nincs ennivaló. Ha lenne ugyanis, akkor az eggyel ezelőtti terv lenne aktív: ez a második terv csak akkor aktiválódik, ha az előző nem tudott, vagyis az ágens a target pozíción van, de ott nem érzékel magától 0 távolságra ennivalót. Ilyenkor a célról le kell mondani és az ágens továbbhalad abba az irányba, amerre néz (a mydir érzékelés segítségével határozza meg saját nézési irányát).

// If we get at the target cell, but there is no food there anymore

// (because if there would be a food, the plan above would have been

// executed) let's sadly forget about our target.

+time(_): target(X,Y) & mypos(X,Y) & mydir(Dir) <-

-target(_,_);

!move(Dir).

A következő négy terv arról gondoskodik, hogy az ágens abba az irányba haladjon, amerre a célja van. Érdemes megjegyezni, hogy egy egyszerű saját Java cselekvés segítségével (amely a pozíció és a cél ismeretében visszaadná a szükséges irányt) ezen a ponton a négy terv helyett elég lenne egy is - tehát ez tipikusan olyan pont, ahol az AgentSpeak gyengeségét Javából lehet csökkenteni.

// If we have a target different from our current position, let's move

// towards it. (Note: if our position would be the target position, one of

// the plans above would have been selected earlier.)

+time(_): target(Fx,Fy) & mypos(Mx,My) & Fx>Mx <-

!move(1).

+time(_): target(Fx,Fy) & mypos(Mx,My) & Fx

 !move(3).

+time(_): target(Fx,Fy) & mypos(Mx,My) & Fy>My <-

!move(2).

+time(_): target(Fx,Fy) & mypos(Mx,My) & Fy

 !move(0).

Az alábbi blokk azért felelős, hogy ha az ágensnek nincs már kijelölt célja (hiszen egy korábbi terv se aktivizálódott), akkor amennyiben ennivalók vannak a látóterében, akkor a legközelebbit jelölje ki célnak (vegye fel hiedelmei közé a target(Fx,Fy)-t).

// If we see some food and we had no target before, we select the closest

// food and move towards it. (Note: if we would have a target, one of the

// plans above would fit it, thus here we are sure that we had no plans

// earlier.

+time(_): food(Food) & .min(Food,[_,_,Fx,Fy]) & mydir(D) <-

+target(Fx,Fy);

!move(D).

A forráskód utolsó blokkja felelős azért, hogy az ágens véletlenszerűen bolyongjon. Ezek a tervek ismét csak akkor aktiválódnak, ha korábban egy terv se illeszkedett, vagyis az ágens nem áll ennivalón, nincs kinézett ennivaló célja, és nem is lát potenciális célként kitűzhető ennivalót maga előtt. Ilyenkor 5% valószínűséggel véletlen irányba halad az ágens, illetve addig halad előre, amíg falnak nem ütközik, ahol aztán visszafordul.

///////////////////////////////////////////////////////////////////////////

// Time triggered random roaming of the agent

///////////////////////////////////////////////////////////////////////////

// The rules bellow are executed only, if the agent has no target and it

// can't see any food right now.

// With a 5% probability we turn into a random direction

+time(_): .random(P) & P>0.95 <-

!randomTurn.

// Otherwise we should just move forward...

+time(_): mypos(X,Y) & mydir(0) & Y>0<-

!move(0).

+time(_): mypos(X,Y) & mydir(1) & X<59 <-

!move(1).

+time(_): mypos(X,Y) & mydir(2) & Y<59 <-

!move(2).

+time(_): mypos(X,Y) & mydir(3) & X>0 <-

!move(3).

// ... and turn back when reaching the wall

+time(_): mydir(D) & D < 2 <-

turn(D+2).

+time(_): mydir(D) & D >= 2 <-

turn(D-2).

A simple_debug ágens célja kettős: egyrészt mintául kíván szolgálni saját Java belső cselekvések készítéséhez, másrészt univerzálisan beépíthető hibakereső felületet kíván nyújtani minden hallgatói ágens számára. Az ágens AgentSpeak forráskódja szinte teljesen azonos a simple ágensével. Az egyetlen eltérés, hogy minden olyan helyen, ahol az ágens fizikai cselekvést hajt végre (például lép, fordul, eszik, stb.), szerepel egy további mentális cselekvés is, méghozzá a debug.DebugAction nevet viselő.

A debug.DebugAction a saját fejlesztésű belső utasítások mintapéldája. Forráskódja a debug package-ben, a DebugAction.java fájlban található. A debug package név saját választás, tetszőlegesen más is lehetne. A fájlokat az src/java/[package_név] könyvtárba kell elhelyezni, vagyis jelen esetben a DebugAction.java fájl a src/java/debug könyvtárba került. Kicsit zavaró lehet, hogy a környezet forráskódja is az src/java mappában található, de ettől függetlenül tetszőleges package-t ezáltal almappát lehet ebben a könyvtárban tetszés szerint létrehozni.

A src/java/debug könyvtár két Java forrásfájlt tartalmaz. Az első a DebugAction.java, mely magát a saját belső utasítást implementálja:

// A saját definiálású package

package debug;

// Szükséges importok a Jason-ból

import jason.asSemantics.*;

import jason.asSyntax.*;

// Maga a saját osztály, a Jason DefaultInternalAction osztályából

// származtatva

public class DebugAction extends DefaultInternalAction{

// Serial a sorosíthatósághoz - nincs gyakorlati jelentősége

private static final long serialVersionUID = 4L;

// A grafikus felület (működését lásd lent)

DebugFrame debugFrame;

// A konstruktor nem tesz mást, mint inicializálja a GUI-t: a

// konstruktor csak az első hívás előtt fut le, a továbbiakban az

// objektum a memóriában marad, tehát lehet magának a belső

// cselekvésnek "állapota", az ebben az osztályban rögzített

// változók segítségével.

public DebugAction() {

debugFrame = new DebugFrame();

}

// Ezt a függvényt hívja a Jason, ha egy ágens ezt az utasítást

// hajtja végre.

public Object execute(TransitionSystem ts, final Unifier un, final

Term[] arg) throws Exception {

// Itt frissítjük a GUI-t - a ts feldolgozását lásd később.

debugFrame.add(ts);

// Ez a belső utasítás mindig sikerrel tér vissza, így nincs

// szükség hibakezelésre az ASL kódban.

return true;

}

}

A grafikus felület egy egyszerű JFrame-ből származtatott ablak.

A forráskód legnagyobb része a grafikus komponensek létrehozásával és frissítésével foglalkozik. Ezen kívül mindössze két fontos részlet található a forráskódban. Az első a DebugAction által hívott debugFrame.add():

public void add(TransitionSystem ts) {

// Add current state to the history

history.add(ts.getAg().getBB().toString());

Itt történik a hívó ágens (getAg) tudásbázisának (getBB) szöveggé alakítása. Ezt a szöveget az activateStep függvény a következőképpen értelmezi:

// Load state in text format

String[] array = history.get(stepID).split("\\s");

String Result = "";

// Try to identify data in the text lines

for (int x=0; x<array.length; x++) {

Result = Result + array[x] +"\n";

// Update the GUI with the data found

if (array[x].indexOf("time")==0)

labelTime.setText(

array[x].substring(array[x].indexOf("(")+1,

array[x].indexOf(")")));

else if (array[x].indexOf("mypos")==0)

labelPos.setText(

array[x].substring(array[x].indexOf("(")+1,

array[x].indexOf(")")));

else if (array[x].indexOf("mydir")==0)

labelDir.setText(

array[x].substring(array[x].indexOf("(")+1,

array[x].indexOf(")")));

else if (array[x].indexOf("myenergy")==0)

labelEnergy.setText(

array[x].substring(array[x].indexOf("(")+1,

array[x].indexOf(")")));

}

// Load clear text belief base to the text box

textArea.setText(Result);

Néhány kitüntetett információ kiválogatása után végül a teljes szöveg is megjelenik a szöveg boxban.

Győződjünk meg róla, hogy rendelkezünk legalább 1.6-os Java fejlesztő és futtatókörnyezettel. Amennyiben nem, először telepítsük ezeket innen:  http://www.oracle.com/technetwork/java/javase/downloads/index.html

Fontos: 64 bites Windows használata esetén is x86-os JDK-ra van szükség a JOGL támogatáshoz!

Töltsük le a Jason rendszer legfrissebb változatát innen:  http://sourceforge.net/projects/jason/files/

Töltsük le az AgentGame rendszert és csomagoljuk ki egy szimpatikus könyvtárba.

A szimulátor a hatékony megjelenítéshez hardveres OpenGL támogatást vesz igénybe. Ennek következtében szükség van a JOGL könyvtár telepítésére. A JOGL könyvtárhoz szükséges fájlok az AgentGame install könyvtárának jogl/win32 almappájában vannak.

Keressünk meg minden telepített JDK verziót a számítógépen (tipikusan a c:\Program Files\java\*jdk* könyvtárakat), és ezeken belül helyezzük el a kicsomagolt .dll fájlokat a \bin, a kicsomaolt jogl.jar fájlt pedig a \lib könyvtárakban.

Keressünk meg minden telepített JRE verziót a számítógépen (tipikusan a c:\Program Files\java\*jre* könyvtárakat), és ezeken belül helyezzük el a kicsomagolt .dll fájlokat a \bin, a kicsomaolt jogl.jar fájlt a \lib\ext könyvtárakban. A jdk könyvtárak is tartalmazhatnak jre alkönyvtárat, ezekbe is kerüljenek be a fájlok!

Az AgentGame az 1.10-es verziótól felfelé JFreeChart komponenseket használ a grafikonok megjelenítéséhez. Az ezekhez szükséges .két jar fájl az AgentGame-et tartalmazó tömörített fájl \install könyvtárában található. Helyezzük őket az előbbi két lépésben meghatározott \lib és \lib\ext könyvtárakba!

Ezt követően indítsuk el a szimulátort a Jason-ból. A futtatásról további információ a szimulátort bemutató fejezetben található.

Megjegyzés: Ha probléma van a pálya kirajzolásával (nem jelenik meg rendesen, exception-t dob a program, stb.), akkor érdemes megkísérelni a grafikus kártya driverének frissítését!

A ZIP fájl gyökérkönyvtára csak és kizárólag az alábbi három elemet tartalmazhatja:

Tegyük fel, hogy a Beadó rendszerben az "Adamant" aliast kaptuk, és szeretnék beadni a Simple ágenst egy apró saját Java kiegészítéssel megspékelve. Először elkészítjük a saját csapatunkat:

+time(_) : myenergy(Energy) & Energy<25 & adamant.AlwaysTrue <- wait.

Több internal action-t is definiálhatnánk (ezeket mind a src/java/adamant könyvtáron belül), lehetne több ágensünk is (például adamant_master.asl, adamant_slave.asl stb. neveken), de maradjunk az egyszerű példánál és tegyük fel, hogy elégedettek vagyunk az ágensünk működésével. Szeretnénk beadni a megoldást. Ehhez a következőket kell tennünk:

A beadást követően a beadó rendszer feldolgozza a feltöltött fájlt. A fenti példa esetében erről a következő üzenetet kapjuk a Beadások, eredmények oldalon:

A bekuldott tomoritett fajl tartalma:

asl

config.txt

java

Az /asl mappaban az alabbi agenseket azonositottuk:

adamant_.asl

A forditas a kovetkezo osztalyokat allitotta elo:

AlwaysTrue.class

A config.txt a kovetkezo agenseket definialja:

adamant_ [verbose=0] #5;

Amennyiben a feldolgozás során hiba történik, akkor a fenti kimenetben a megfelelő helyen hibajelzést található: ilyenkor a versenyben továbbra is a legutóbb sikeresen beadott változat vesz részt (ha van már ilyen) mindaddig, amíg az új verzió beadása nem sikerül.

A Beadó rendszerben tekinthető meg a verseny pillanatnyi állása:

A beadott csapatok között lejátszott játékokhoz egyenként tartozik egy részletező oldal, ahol nyomon követhető az egyes ágensek illetve csapatok pontszámának alakulása. Itt kerül feltüntetésre a szimulátor kimenete is benne az esetleges hibaüzenetekkel.

A játékok részletes megtekintésén kívül lehetőség nyílik továbbá a beadó rendszerben az egyes csapatok teljesítményét egyenként megjeleníteni, illetve a csapatok különböző beadott verzióit összehasonlítani is.

Kidolgozta: Eredics Péter, BME