--- Log opened Sun Feb 24 00:00:58 2008
00:06 -!- gerpetya [i=gerpetya@catv-d5de8335.catv.broadband.hu] has quit [Read error: 104 (Connection reset by peer)]
11:39 -!- gerpetya [i=gerpetya@catv-d5de8335.catv.broadband.hu] has joined #spqr
11:39 < gerpetya> hali
11:39 < gerpetya> vagy?
11:43 < vmiklos> joregg
11:44 < gerpetya> lenne egy kerdesem a leptetessel kapcsolatban
11:45 < gerpetya> ugyebar a kigyoelemnek a fieldet vhogy ismernie kene, amin van
11:45 < gerpetya> (a leptetes miatt)
11:46 < gerpetya> es akkor a kigyoelem rendezne a leptetest
11:46 < vmiklos> hm
11:46 < gerpetya> vagy pedig a mezok intezzek el a leptetest es akkor...
11:46 < vmiklos> a leptetest nem a kigyonak kene vegeznie?
11:46 < gerpetya> igen, de a kigyo csak az elemeit ismeri
11:47 < vmiklos> tehat akkor kigyoemem leptet -> kigyo leptet -> minden kigyoelem leptet -> kigyoelemhez tartozo mezo utkoztet
11:47 < vmiklos> ez igy baromsag?
11:48 < gerpetya> csak az a gaz, hogy magat a tenyleges leptetest csak a gamefield vegezheti, hiszen o ismeri a mezok szomszedjait
11:48 < vmiklos> hm
11:48 < gerpetya> tehat meg maga a mezo sem tudja, hogy ki a szomszedja
11:49 < gerpetya> ahhoz hogy megtudja, le kell kerdeznie a gamefield-tol
11:49 < gerpetya> igazabol arra kene sztem torekedni, hogy egy adott esemenyt minel kevesebb objektum vegezzen el
11:49 < vmiklos> igen, ez stimm
11:50 < vmiklos> gamefield == mezo?
11:50 < gerpetya> nem
11:50 < gerpetya> a gamefield maga a játéktér
11:50 < gerpetya> a mezo pedig az eleme
11:50 < vmiklos> ja ertem
11:51 < gerpetya> meg azt se nagyon tudom, hogy hogyan taroljuk magat a mezoket a játéktér osztályban
11:51 < vmiklos> 2d tomb?
11:52 < gerpetya> pill
11:52 < gerpetya> na, csak kavarodok már itt az ékezetekkel:)
11:52 < gerpetya> szval
11:53 < gerpetya> a lényeg, hogy az lenne a legjobb, ha a mező közvetlenül tudná, hogy ki a szomszédja
11:53 < vmiklos> hat akkor esetleg olyasmit lehetne, hogy: a kigyonak van egy leptet metodusa ami meghivja az egyes kigyoelemekre a leptet metodust az meg annyit csinal, hogy meghivja a kigyoelem alatt levo mezo 
11:53 < gerpetya> és a kígyóelem honnan tudja, hogy ki van alatta?
11:54 < vmiklos> bah:)
11:54 < vmiklos> hat akkor esetleg olyasmit lehetne, hogy: a kigyonak van egy leptet metodusa ami meghivja az egyes kigyoelemekre a leptet metodust az meg annyit csinal, hogy meghivja a gamefield lepteto metodusat, megadva h merre akar lepni, meg h o kicsoda. a gamefield metodusa az visszaadja ennek megfeleloen az uj mezot
11:54 < vmiklos> na ezt akartam irni, bar a kerdes tovabbra is fennall
11:54 < gerpetya> mert végülis el tudná tárolni a kígyóelem az alatta lévő mezőt, csak akkor már elég redundáns lenne
11:55 < vmiklos> jaja
11:55 < vmiklos> hm nem. amit most utoljara irtam ahhoz nem kell tudja a kigyoelem h hol all
11:56 < vmiklos> leven a kigyoelem a gamefieldnek csak a kigyoelem objektumot adja at
11:56 < vmiklos> es a gamefield meg pl vegigkerdezi a mezoktol h "bennevagy-e"
11:56 < vmiklos> "bennevan-e"
11:57 < vmiklos> aztan ha ez igy nagyon lassu lesz akkor esetleg tarolhatjuk a kigyoelemben h o hol van, de ezt majd kesobb
11:58 < gerpetya> nem is csak a lassúságán van a gond, hanem hogy rengeteg felesleges művelet van, ezért nem tetszik
11:58 < gerpetya> csak minden elképzelésemmel ez a baj
11:58 < gerpetya> :S
11:58 < vmiklos> sztem most arra kene torekedni h minden adatot csak 1x taroljunk
11:59 < vmiklos> az h ezt lassu-e elerni az nem a ma problemaja
11:59 < gerpetya> ok
12:03 < vmiklos> a gamefielden a fal is u.ugy egy teljes mezot foglal el mint a bogyo, ugye?
12:04 < vmiklos> ezt a legegyszerubb megvalositani :)
12:07 < gerpetya> igen, az is egy mező
12:08 < vmiklos> jatek inditasanal en a kovetkezokre gondoltam: egyreszt a jatekosok letrehozasa, masreszt a gamefield inicializalasa (gondolom ott konstruktorban meg kene adni pl egy 2d tombben h melyik mezon mi legyen; 0 = semmi, 1 = strawberry stb es akkor az alapjan letrehozna a megfelelo objektumokat) harmadreszt pedig a kigyok letrehozasa. van meg valami ami szted kell?
12:08 < vmiklos> ja es nyilvan a kigyok jatekosokhoz valo rendelese
12:09 < gerpetya> igen
12:09 < gerpetya> ennyi, ami kell
12:09 < gerpetya> vagyis nem (mármint nincs más ami kell) :D
12:09 < vmiklos> k
12:10 < vmiklos> asszem 1x leirom magamnak szoban mielott elkezdek szenvedni a netbeans szekvencia-diagram-keszitojevel ;)
12:13 < gerpetya> még vmi az ütközéshez: a kígyóelem honnan tudja, hogy melyik kígyóhoz tartozik?
12:14 < vmiklos> nem jo ha kap ra 1 referenciat konstruktorban?
12:15 < vmiklos> vagy pedig megkerdezheti attol az objektumtol ahol a kigyok listajat taroljuk
12:15 < vmiklos> elvileg utobbi az ami rendundancia nelkul tarol:)
12:17 < vmiklos> utobbit kene, ha kovetkezetesek vagyunk (mezo se tudja h kik a szomszedjaik redundancia-elkerules vegett)
12:20 < gerpetya> nézegettem a régi doksikat (mintapelda.pdf meg hasonlók) és ott is van redundancia rendesen
12:21 < gerpetya> végülis a kígyóelem az nem változik
12:21 < gerpetya> mindig ugyanaz a kígyó lesz a tulajdonosa
12:21 < vmiklos> uhum
12:21 < gerpetya> nemtom
12:22 < vmiklos> van egy otletem
12:22 < vmiklos> a kigyo mar letezik mikor letrejonnek az egysegei?
12:22 < gerpetya> hát gondolom
12:22 < vmiklos> mert akkor az egysegek megkaphatnak konstruktorban a kigyo referenciajat
12:23 < vmiklos> es arra is meglenne a magyarazat h miert nem csinaljuk u.ezt a mezoknel: mivel a mezok letrehozasakor meg a szomszedok nem leteznek altalaban
12:24 < gerpetya> viszont a mezőknél meg azért lenne jó megint tárolni, mert nem kéne minden egyes szomszéd kérésnél végignézni az összes mezőt
12:25 < vmiklos> hm. akkor azt lehet, hogy ketszer megyunk vegig
12:25 < vmiklos> egyszer letrehozzuk az osszeset
12:25 < vmiklos> es masodik korben meg beallitjuk a szomszedokat
12:25 < gerpetya> jaja
12:26 < vmiklos> a snake valtozoihoz sztem kene 1 enum ami megmondja h a 4 iranybol merre fog lepni a kov lepteteskor
12:27 < gerpetya> az van, igen, csak még a honlapra nem írtam
12:27 < vmiklos> ok
12:30 < vmiklos> azt szerinted hol lenne erdemes tarolni h pl a wasd meg a nyilak melyik kigyot vezerlik?
12:31 < gerpetya> a játékosban kéne tárolni
12:31 < gerpetya> mivel minden kígyót ugyanaz vezérel egy játékoson belül, ezért gondolom
12:32 < vmiklos> elvileg lehet olyat h 1 jatekosnak 2 kigyoja van es azokat kulon tudja vezerelni :)
12:32 < vmiklos> ja de akkoris jo amit mondtal
12:33 < vmiklos> jatekosban lehetne tarolni azokat a bill. kodokat amik az adott jatekoshoz tartoznak + egy referenciat az aktiv kigyora
12:34 < vmiklos> + egy listat az osszes jatekoshoz tartozo kigyora de gondolom erre te is gondoltal csak meg nincs fenn a honlapon
12:34 < gerpetya> az már elvileg fenn van
12:35 < vmiklos> ja latom
12:35 < gerpetya> annyira belemélyültem ebbe az egész modellbe, hogy már a legegyszerűbb dolgokon sem tudok gondolkodni:(
12:36 < vmiklos> :)
12:41 < vmiklos> a robotoknal legyen ugy h a jatekosban van egy boolean h robot-e vagy nem?
12:41 < vmiklos> leven az ido leptetesenel a robotoknal random kell majd egy olyan h iranyt valtoztat v epp nem csinal semmit. a normal jatekosoknal meg nyilvan nem szabad belenyulni
13:02 < vmiklos> hm feltetelezem h igy lesz aztan max majd atirom
13:06 < vmiklos> masik kerdes: akkor az utkozes osszefoglalva ugy lenne, hogy: vegigmegyunk minden jatekoson, azon belul kigyon, azon belul kigyoelemen;
13:07 < vmiklos> a kigyoelem lekerdezi a megfelelo iranyhoz tartozo kovetkezo mezot, tehat pl ujmezo = mezo.getLeft() majd annak meghivja a stepOn metodusat
13:07 < vmiklos> jol gondolom?
13:18 < gerpetya> igen
13:18 < gerpetya> vhogy igy lesz
13:19 < vmiklos> amugy igaza volt a sracnak, ha 1 ember elore lekodolja a jatekot utana mar tok 1xu umlt csinalni belole :P
13:19 < gerpetya> :)
13:19 < vmiklos> pl: kigyoelem mozgatasa
13:20 < vmiklos> az uj elemnel meghivom a stepOn metodust es akkor eltarolja h rajta vagyok
13:20 < vmiklos> de a regirol meg ki kell lepni valami stepOuttal
13:20 < vmiklos> es ez most csak teljesen veletlenul jutott eszembe. ha meg lekodolod akkor trivialis
13:20 < vmiklos> na mind1;)
13:22 < gerpetya> ez a modell még mindig nem tetszik, a rengeteg keresés miatt:(
13:23 < vmiklos> azt is lehet csinalni, hogy mindent 2x tarolunk, csak akkor meg a valtoztatas lesz csunya
13:23 < gerpetya> hát igen, az se szép megoldás
13:23 < vmiklos> tehat pl ilyen forciklusnal mikor ilyen van, h
13:23 < vmiklos> for (minden kigyora)
13:23 < vmiklos> eh
13:23 < vmiklos> for (minden jatekosra)
13:24 < vmiklos>     for (minden kigyora)
13:24 < vmiklos>         for (minden kigyoelemre)
13:24 < vmiklos> akkor ugyis egyszerre latsz mindent
13:24 < vmiklos> tehat nem baj h a kigyoelem nem tudja h melyik kigyohoz tartozik
13:24 < vmiklos> az ilyen esetekben meg lehet uszni redundancia nelkul
13:26 < vmiklos> amugy most, hogy a mezoknel meg a kigyoelemben meg a mezoben is van redundancia, hol kell meg sokat keresni?
13:27 < gerpetya> mármint akkor most a kígyóelem meg a mező között van redundancia?
13:27 < vmiklos> nemugy :)
13:27 < vmiklos> szal azt beszeltuk h lesz olyan h a palyan taroljuk a mezoket meg a mezokben is a szomszedokat
13:28 < vmiklos> ill. h a kigyoban taroljuk a kigyoelemek listajat de a kigyoelemekben is taroljuk h melyik kigyohoz tartoznak
13:28 < gerpetya> igen
13:28 < gerpetya> ok
13:28 < gerpetya> és a keresés a kígyóelem-mező között jön elő
13:29 < vmiklos> kiveve ha azt is taroljuk a kigyoelemben :)
13:29 < gerpetya> na igen
13:29 < gerpetya> "mármint akkor most a kígyóelem meg a mező között van redundancia?"
13:29 < gerpetya> ezért írtam
13:29 < gerpetya> :)
13:29 < vmiklos> jaa
13:30 < gerpetya> végülis ez az egyetlen redundancia, ami változik is
13:30 < gerpetya> hiszen a többi állandó
13:30 < gerpetya> szval az nem is annyira gáz
13:30 < vmiklos> es akkor legalabb sehol sincs felesleges kereses
13:31 < vmiklos> mezo.stepOut(); mezo = mezo.getLeft(); mezo.stepOn();
13:31 < vmiklos> kb ennyi a szinkronban tartas
13:31 < vmiklos> nem veszes
13:32 < gerpetya> vagy hogy tuti legyen, mezo = mezo.stepOn();
13:32 < gerpetya> és akkor még csak el sem lehet rontani
13:32 < vmiklos> jaja:)
13:33 < gerpetya> na, akkor ezt leírom, megalkotom és felviszem a honlapra
13:33 < vmiklos> ooo. erre gondoltal: mezo.stepOut(); mezo = mezo.getLeft().stepOn(); ?
13:33 < gerpetya> ja igen
13:33 < gerpetya> :D
13:33 < vmiklos> k :)
13:38 < vmiklos> kozben megkerdeztem egyik evfolyamtarsam es aztmondja h naluk is voltak ilyen redundanciak
13:49 -!- cassus [n=cassus@3e44ab41.adsl.enternet.hu] has joined #spqr
13:49 < cassus> g direkt nincs itt?
13:50 < vmiklos> mi nem raktuk ki :)
13:50 < cassus> ok
13:51 < vmiklos> a szekvenciadiagramokhoz csinaltam ilyen "otlet szoban" dolgot, es petyaval azt beszeltuk idaig, mert ez igy kb felvetett 1 csomo problemat
13:51 < vmiklos> h hogy legyen a leptetes, utkozes, stb
13:51 < cassus> ok
13:51 < vmiklos> de most nekem kb tiszta szal epp indul a netbeans h akkor ebbol legyen szep uml szekvenciadiagram
13:51 < cassus> remélem erről csináltok "meeting"-et
13:51 < cassus> és a döntéseket feljegyzitek oda
13:51 < vmiklos> hat persze :D
13:52 < vmiklos> amugy nem jutott eszembe de majd tenyleg kene csinalni
13:52 < cassus> hajrá :)
13:52 < cassus> ugye tudtok létrehozni ti is meeting-et?
13:53 < vmiklos> jaja
13:53 < cassus> ok
13:53 -!- KisGergelyG [n=Miranda@catv-5984b1c9.catv.broadband.hu] has joined #spqr
13:53 < cassus> hi
13:53 < gerpetya> hali
13:53 < KisGergelyG> hello
13:53 < cassus> röviden tudjátok prezentálni, hogy milyen megoldást találtatok az ütközés kezelésére?
13:53 < vmiklos> igen
13:53 < cassus> hogy ha nem tetszik, már most vissza tudjam dobni...
13:54 < cassus> akkor hallgatlak
13:54 < gerpetya> :)
13:54 < vmiklos> azt talaltuk ki h mivel mindig a snakeunit utkozik valamivel, ezert az adott utkozes ott lesz lekodolva amivel utkozik a snakeunit
13:56 < cassus> nem
13:56 < cassus> :)
13:56 < vmiklos> mondjuk engem ez annyibol erint h mikor leptetunk egy snakeunitot
13:56 < vmiklos> akkor 3 dolgot csinalok
13:57 < vmiklos> egyreszt kilepek a regi mezorol
13:57 < cassus> a bogyónak kell tudnia, hogy milyen hatása lesz a kígyóra?
13:57 < vmiklos> masreszt az iranynak megfelelo szomszedos mezot lekerdezem
13:57 < vmiklos> harmadreszt ralepek arra az uj mezore, ami ekkor kezeli az utkozest is
13:58 < gerpetya> hát végülis a való életben is elég kétértelmű a dolog
13:58 < gerpetya> vagy a kígyó tudja, hogy mit csinál ha megeszi a bogyót
13:58 < gerpetya> vagy a bogyó tudja, hogy mi történik ha megeszi a kígyó
13:58 < cassus> vagy egy 3. fél
13:59 < cassus> a kígyó ütközéskezelője
13:59 < cassus> megnéztétek a visitor-t?
13:59 < KisGergelyG> cassus furán jelennek meg az ékezetes karaktereid
13:59 < vmiklos> forditva is csinalhatod, csinalhatsz a snakeunitnak collideWith(FieldBerry fb), collideWith(StoneBerry sb) metodusokat
13:59 < vmiklos> de akkor meg barmilyen uj elem van akkor modositani kell a snakeunit objektumot
13:59 < cassus> vagy egy 3. fél
13:59 < cassus> megnéztétek a visitor-t?
13:59 < KisGergelyG> csak kérdés, hogy fel akarunk-e készülni arra, hogy lesz még másfajta bogyó
14:00 < cassus> fel hát
14:00 < cassus> G: nem, neked furcsák :)
14:00 < KisGergelyG> csak nekem jól mutatja gerpetyáét is
14:01 < vmiklos> cassus: milyen visitort?
14:02 < vmiklos> :)
14:02 < cassus> http://en.wikipedia.org/wiki/Visitor_pattern
14:02 < cassus> én utf8-at használok alap karakter kódolásként irc-en is
14:03 < KisGergelyG> és azt mirandában hol kell beállítani?
14:03 < cassus> A practical result of this separation is the ability to add new operations to existing object structures without modifying those structures.
14:03 < cassus> g: ahhoz nem értek :)
14:03 < KisGergelyG> na jó, akkor hagyjuk
14:04 < vmiklos> cassus: jaa, vilagos
14:05 < vmiklos> ez az amit mondtam h a kigyonak lehet 8fajta collideWith() metodusa
14:06 < cassus> aha, majdnem
14:06 < vmiklos> effektive u.ugy a konek hivom meg az utkozos metodusat csak az osszesen egy 1soros callback ha jol ertem
14:06 < vmiklos> es a tenyleges funkcionalitas igy a kigyoban lesz
14:06 < cassus> mert honnan tudja a mező, hogy melyik objektum rajta a kígyó?
14:06 < cassus> az igazi, az, hogy van egy collidable interfész
14:06 < cassus> amit minden word objectum megvalósít
14:06 < vmiklos> jaja, igy is van
14:06 < gerpetya> most így van
14:07 < cassus> de akkor nem csak a kígyóban van collideWidth
14:07 < gerpetya> nem
14:07 < gerpetya> minden bogyóban, falban, kígyóelemben
14:07 < cassus> sőt, akkor a valódi handler-ek sem a kígyóban vannak, hanem egy külön objektumban
14:07 < cassus> csak valahogy a szimmetriát kell ügyesen biztosítani
14:07 < KisGergelyG> és akkor ha sokminden ütközik egyszerre egy mezőn, akkor minek a collidewith-je hívódik meg, és milyen paraméterrel?
14:08 < cassus> a kérdés jó
14:08 < vmiklos> egyszerre egy kigyo lep a mezore
14:08 < cassus> ez nem jó :)
14:08 < vmiklos> egyesevel leptetjuk a kigyokat 1 forciklusban, nem? :)
14:08 < KisGergelyG> az nem szimmetrikus
14:08 < vmiklos> es akkor az a kigyo utkozik a mezon talalhato objektumokkal
14:08 < cassus> mert ha 4 kígyó megy egymással szemben, és egyszerrre kellene találkozniuk
14:09 < cassus> akkor nem jó, ha random módon az egyik életben marad
14:09 < KisGergelyG> mert akkor pl. ha két fűrész kígyó lép azonos mezőre, akkor attól függ, hogy melyik hal meg, hogy te melyiket veszed előre a ciklusban
14:09 < vmiklos> hmm
14:09 < gerpetya> nemnem
14:09 < cassus> najó
14:09 < gerpetya> én nem így gondoltam
14:09 < gerpetya> úgy gondoltam, hogy minden lép
14:09 < gerpetya> aztán minden kígyóra megnézzük az ütközéseket
14:10 < cassus> vagy minden mezőre...
14:10 < KisGergelyG> igen, csak hogyan nézed meg? minden, a mezőn lévő világobjektumnak mehívod a collide-ját minden másik obejktummal paraméterül?
14:10 < vmiklos> es ha kigyoval meg bogyoval is utkozol akkor melyik a "hatasosabb"?
14:11 < KisGergelyG> szerintem a legszebb, legtisztább az lenne, ha minden mezőn lévő dolgokból egy heterogén kollekció készülne, és minden obejktum ezt kapná paraméterül
14:11 < KisGergelyG> hogy mikkel is ütközött
14:11 < gerpetya> igen, először is definiálni kéne, hogy mi van az ilyen szélsőséges esetekben
14:11 < cassus> vmiklos: a kérdés jogos, determenisztikus működés kell
14:12 < KisGergelyG> kiköthetjük a nemdeterminisztikus, sorsolás alapú működést is, nem lenne egyedülálló a játékok közt, hogy valamit sorsol az engine
14:12 < KisGergelyG> csak szerintem annyira nem szép
14:12 < cassus> :)
14:13 < cassus> akkor most hallgatások meg az én javaslatomat
14:13 < cassus> <javaslat>
14:13 < cassus> az ütközéseket nem a kígyók, hanem a mezők kezdeményezik
14:14 < cassus> a mező ha 1-nél több világelem van rajta
14:14 < cassus> akkor sorba megy rajtuk
14:15 < cassus> mindegyiknek szól, hogy itt egy tömb a többiekről
14:15 < cassus> csinálj, amit szeretnél
14:15 < cassus> a mező iterációkát okosan kell megcsinálni, hogy a törlődő és új mező elemeket is kezelje
14:15 < cassus> iterációját
14:16 < cassus> </javaslat>
14:16 < cassus> <reakciók>
14:16 < KisGergelyG> igen, én is valami ilyesmire gondoltam azzal a heterogén kollekciós dologgal
14:16 < vmiklos> nekem tetszik ezis
14:16 < gerpetya> végülis nem rossz
14:16 < cassus> ezzel megoldhatjuk, hogy pl. a bogyó semmit nem csinál
14:16 < gerpetya> és hogy jön be a visitor?
14:17 < cassus> ott, amikor a kígyó feje megkapja, hogy kikkel van egy mezőn
14:17 < vmiklos> ugy, hogy mikor a strawberry utkozik 1 objecttel akkor a starwberry meg fogja hivni az object collideWith(StrawBerry) metodusat
14:17 < KisGergelyG> nem
14:18 < KisGergelyG> a mező hívja meg az object collidewithjét, paraméterül meg egy heterogén kollekciót ad, amiben az egyik elem az akármilyen berry
14:18 < gerpetya> és akkor lesz egy ütközés kezelő osztály is?
14:18 < gerpetya> vagy hogy gondoltátok?
14:18 < vmiklos> sztem nem
14:19 < KisGergelyG> hogyhogy ütközés kezelő osztály?
14:19 < KisGergelyG> az miért kellene?
14:19 < vmiklos> ugye mindig kigyo utkozik valamivel
14:19 < cassus> vagy nem :)
14:19 < vmiklos> ket berry hogy utkozik? :)
14:19 < gerpetya> jó de a többi nem fontos
14:19 < cassus> még nem tudjuk
14:19 < gerpetya> éppenséggel ütközhet, de úgy sem történik semmi
14:19 < vmiklos> ja, technikailag nyilvan utkozik
14:20 < cassus> ha nem fontos, hogy így legyen, akkor ne zárjuk be magunkat
14:20 < KisGergelyG> ja, simán lehet, hogy akármilyen pluszelem, mondjuk mozgó fal meg fog jelenni a feladatban hirtelen
14:20 < vmiklos> tehat pl van 1 berry es megkapja h utkozott o1 o2 o3 objektumokkal
14:20 < vmiklos> ez ugye a collideWith(List<Object> o) metodus
14:21 < KisGergelyG> valami ilyesmi
14:21 < vmiklos> es ezutan ebben a metodusban annyi tortenik, h
14:21 < vmiklos> meghivodik az o1.collideWith(Berry b)
14:21 < vmiklos> o2.collideWith(Berry b)
14:21 < vmiklos> o3.collideWith(Berry b)
14:21 < vmiklos> metodusok
14:21 < KisGergelyG> nem
14:21 < vmiklos> elvileg ez a visitor pattern ha jol ertem :)
14:21 < KisGergelyG> a mező hívja meg mindegyik rajta lévőnek a collidewith-jét
14:21 < KisGergelyG> és ők már nem hívnak másokat
14:21 < cassus> a visitor így lenne
14:21 < cassus> de a visitor nem tudom hogy kezeli ezt a többszörös dolgot...
14:22 < KisGergelyG> én bevallom, nem is igazán értem a visitor patternt
14:22 < vmiklos> az instanceOf() fv-t ismered?
14:23 < KisGergelyG> hallomásból
14:23 < vmiklos> annyit csinal h adsz neki 1 instance-t meg 1 classt
14:23 < KisGergelyG> de nem fontos most, hogy elmagyarázd
14:23 < vmiklos> es megmondja h az instance az a class peldanyositasa-e v nem
14:23 < KisGergelyG> mármint, szerintem értem az aktuális ötletet, még ha nem is értem a visitor patternt
14:24 < gerpetya> na akkor most egy pill
14:24 < vmiklos> ez az egesz visitor pattern meg arrol szol h instanceOf() es egyeb halalos bunok nelkul hogy lehet tobbfajta objektumot utkoztetni (jelen esetben)
14:24 < vmiklos> sztem
14:24 < gerpetya> szval akkor megkapja a heterogén kollekciót az objektum
14:24 < gerpetya> és utána mit csinál?
14:24 < vmiklos> meghivja az egyes objektumok collideWith()jet
14:25 < KisGergelyG> eldönti a megadott algoritmus alapján, hogy vele mi történik
14:25 < vmiklos> igazabol nemtudom h kell-e nekunk azzal foglalkozni h mivan harmas utkozes eseten :S
14:25 < KisGergelyG> nem hívja a többi objektum semmijét, mert az a mező dolga
14:25 < cassus> szerintem kell a 3-as ütközéssel foglalkozni
14:25 < KisGergelyG> szerintem veszélyes nem foglalkozni vele
14:25 < vmiklos> lehet h pont kell, mert ez egy erdekes problema de azis lehet h eppen tulbonyolitjuk :)
14:25 < cassus> mert az nem lehet, hogy 3 egymással szembe menő kígyóból így egy túlélné random
14:26 < gerpetya> ja értem
14:26 < vmiklos> nekem tetszik egy ilyen feature ;)
14:26 < gerpetya> szval ütközésnél nem végez senki semmin semmit, csak a megadott objektumok alapján magát intézi el
14:26 < gerpetya> jól értem?
14:26 < cassus> szerintem így lehet megoldani a felelősségeket
14:26 < vmiklos> hm, ez nekem idaig nem jott le de amugy igen
14:26 < cassus> hogy ütközésnél mindenki arra figyel, hogy neki mi dolga van
14:26 < KisGergelyG> szerintem is így a legtisztább
14:27 < KisGergelyG> csak arra kell figyelni, hogy még nem pusztítsa el magát semelyik
14:27 < cassus> ?
14:27 < KisGergelyG> mert akkor az utána jövőknek gondja lesz a saját sorsuk eldöntésével
14:27 < cassus> igen
14:27 < cassus> kell még egy kör
14:27 < vmiklos> lehetne erre 2 allapot
14:27 < cassus> amikor az állapot változások megtörténnek
14:27 < KisGergelyG> hanem először egy iterációban mindegyik meghozza a döntést, és a következőben meg végrehajtja
14:27 < vmiklos> egyszer elobol haldoklo
14:28 < vmiklos> aztan utana haldoklobol halott
14:28 < vmiklos> jaja
14:28 < KisGergelyG> ige, ilyesmi
14:28 < cassus> én nem nevezném ezt még1 állapotnak
14:28 < cassus> inkább legyen aktuális állapot, és következő állapot
14:28 < KisGergelyG> aha
14:28 < vmiklos> azt is lehet
14:29 < gerpetya> szval akkor 3 lépés lesz a körben: 1.léptetés, 2.ütközés/haldoklás, 3.meghalás ?
14:29 < cassus> 1. léptetés 2. ütközés 3. állapot váltás
14:29 < KisGergelyG> valami ilyesmi
14:29 < gerpetya> ja igen, állapot váltás
14:29 < cassus> ki loggolja ezt a meeting-et?
14:29 < KisGergelyG> csak annyira kell még figyelni, hogy az állapotváltás után sajnos lehet, hogy kell még egy kör...
14:30 < KisGergelyG> mert a bogyóevés miatt keletkezhetnek új ütközések
14:30 < vmiklos> technikailag en logolok, de az nem azonos a drupalos naploval
14:30 < gerpetya> de most tisztázni kéne megint vmit
14:30 < KisGergelyG> majd akkor írok én logot
14:30 < cassus> köszi
14:30 < KisGergelyG> de még nem hoztunk effektíve döntést, vagy igen?
14:31 < KisGergelyG> ha ezt már eldöntöttnek tekintjük, akkor beleírom
14:31 < gerpetya> sztem a bogyók hatása csak a következő körben kéne érvényesüljön, nem?
14:31 < KisGergelyG> úgy is lehet
14:31 < KisGergelyG> valójában ez a lehetőség nem jutott eszemnbe, de így tényleg egyszerűbb
14:31 < cassus> g: majd olvasd vissza a chatlog-ot, és kihámozod, mik voltak a döntések
14:32 < KisGergelyG> oké, csak valaki küldje el majd, mert nálam mirandánál csak az utolsó x sor látszik
14:32 < vmiklos> rendben, az nem problema
14:32 < vmiklos> kerdes akkor h mit ertunk allapot alatt. mert ha abban a kigyok meghalasan kivul a hosszat is taroljuk benne akkor ez alapbol megoldott
14:32 < cassus> iii
14:33 < cassus> itt nem kígyók, kigyóelemek ütköznek...
14:33 < cassus> ugye a kígyó nem világelem..
14:33 < KisGergelyG> jaja
14:33 < cassus> vagy igen?
14:33 < gerpetya> de a kígyóelem az
14:33 < gerpetya> a kígyó nem
14:34 < vmiklos> akkor a kigyoelemnek lehetne egy tulajdonsaga h "el-e"
14:34 < cassus> szerintem a fej állapota, hogy növekedni kell majd
14:34 < vmiklos> vagy az
14:35 < cassus> és ha mondjuk egy fej a falnak ütközik
14:35 < vmiklos> akkor tuti nem novekszik :)
14:35 < gerpetya> legyen egyébként külön fej osztály? csak mert most perpill úgy van, hogy attól lesz fej, hogy a 0. sorszámú a kígyó listájában
14:35 < cassus> akkor láncolt listában végig küld visitort, ami elintézi, hogy a végétől előre az összes elemet megöli
14:35 < KisGergelyG> hát, lehet, hogy nem ártana
14:36 < KisGergelyG> egy esetszétválasztást a collideban megspórolnánk vele
14:36 < cassus> a növekedést is egy ilyen visitor-al lehetne megcsinálni
14:37 < cassus> de akár még a kövek mozgását is
14:37 < cassus> meg a kígyó mozgását
14:38 < cassus> és ez így nagyon rugalmas
14:38 < gerpetya> még mindig nem értem, hogy mitől lesz ez visitor?
14:38 < gerpetya> vagyis mi köze van hozzá
14:39 < cassus> meglátogatja az összes kígyó elemet
14:39 < gerpetya> ott nem az a lényeg, hogy egy általános interfész van, melyben egy azonos nevű függvény típusonként külön van
14:39 < vmiklos> de.
14:40 < cassus> de ezt egy típussal is el lehet játszani
14:40 < gerpetya> a lényeg: hol lesz lekódolva pl, hogy ha falnak megy a kígyó, akkor meghal?
14:40 < vmiklos> a kigyoban
14:41 < KisGergelyG> szerintem a fejnek meghívódik a collidewith-je
14:41 < vmiklos> illetve majd a fal is megkapja h utkozott egy kigyoval de o nem hal meg :)
14:41 < gerpetya> tehát magyarul a kígyó tud majd mindent
14:41 < KisGergelyG> az alapján ő tudja, hogy ütközött
14:41 < vmiklos> nem, a kigyo csak azt tudja h neki mit kell csinalni
14:41 < KisGergelyG> és szól az őt tartalmazó kígyónak
14:41 < KisGergelyG> és a kígyó meg szól a saját egységeinek
14:41 < cassus> szerintem nem
14:42 < cassus> erre mondtam a látogatós dolgot
14:42 < cassus> ami szerintem rugalmasabb
14:42 < gerpetya> azaz hogy lenne a megvalósítás?
14:42 < cassus> máris mondom
14:42 < cassus> a lényeg az, hogy nem központi "agy" van
14:42 < cassus> és ez a teljes kígyó
14:43 < cassus> hanem a részek egymással kommunikálnak csak
14:43 < vmiklos> ja ez majd azert lesz jo mert pl ha kettevaghato lesz 1 kigyo akkor azt is le tudjuk kezelni :)
14:43 < cassus> és ilyen utazó ügynök szerűen mennek a parancsok
14:43 < cassus> mondok egy konkrét példát
14:43 < cassus> halál
14:44 < cassus> az első szegmens ütközik fallal
14:45 < cassus> csinál egy KígyóDarabÜzközöttFallal objektumot
14:45 < cassus> és átadja neki magát
14:45 < cassus> az tudja, hogy ekkor bizony a teljes kígyót ki kell nyírni
14:45 < cassus> elkéri a kígyódarabtól a következő kígyódarabot
14:45 < cassus> és arra is meghívja magát
14:46 < cassus> vagy még jobb
14:46 < cassus> ha több féle kígyódarab lehet
14:46 < cassus> hogy visszahívatja magát vele
14:46 < cassus> de ez már részletkérdés
14:46 < KisGergelyG> ez így elég fura szerintem
14:46 < cassus> még nem fejeztem be :)
14:46 < gerpetya> :)
14:46 < KisGergelyG> ja bocs, mondjad
14:46 < cassus> tehát ott tartunk, hogy a kinyíró rutin a második kigyó elemnél tart
14:47 < cassus> és még semmit nem csinál
14:47 < cassus> csak eljut így láncolva a kígyó végéig
14:47 < cassus> annak szól, hogy halj meg
14:47 < cassus> majd return-ol
14:47 < cassus> és az utolsó előttinek is szól, hogy halj meg
14:47 < cassus> és így mindenkinek
14:48 < cassus> amiért jó ez
14:48 < vmiklos> sorry, 6ig nem leszek, de utana igerem visszaolvasok meg minden :/
14:48 < cassus> mert a mozgást is meg lehet így csinálni pl.
14:48 < KisGergelyG> oké csak hagyd logolni a kliensed :D
14:48 < vmiklos> okok:)
14:48 < cassus> szóval szerintem ez annyira rugalmas, hogy érdemes megjátszani
14:49 < cassus> ja, és így nem is kell teljeskígyó objektum
14:49 < KisGergelyG> és akkor minden lehetséges ütközési forgatókönyvhöz tartozik egy objektum?
14:49 < cassus> elég ha a fej különleges, és azt lehet vezérelni
14:49 < cassus> g: csak azokhoz, ahol kell valamit csinálni
14:50 < gerpetya> de még mindig nem világos, hogy az az objektum hogy fog kinézni
14:50 < KisGergelyG> de most pont arról volt szó, hogy sokféle ütközés lehet, kígyó kígyóval, három kígyó egymással, három kígyó egymással és fallal, stb.
14:51 < cassus> szerintem állapotokkal ez is kezelhető
14:51 < KisGergelyG> szerintem egyszerűbb, ha az ütközésben résztvevő egység eldönti, hogy mi történik az egész kígyóval, és a döntést közvetíti mindegyik egység felé
14:51 < cassus> nem, az nagyon csúnya lenne
14:52 < cassus> szerintem ebből a szempontból 8, hogy közvetlenül, vagy ilyen láncon keresztül közvetíti
14:52 < cassus> itt a lényeg, hogy hogyan döntsük el, mi történjen
14:53 < gerpetya> de akkor ezekszerint lesz vagy 80ezer objektum az ütközésekre?
14:53 < cassus> az nem lenne jó :)
14:53 < KisGergelyG> hát nem tudom. nekem valahogy jobb megoldásnak tűnik, hogy legyen egyvalaki, aki felelős az egész kígyóért
14:53 < KisGergelyG> ami lehet egy kígyó objektum, vagy lehet a fej is
14:54 < KisGergelyG> és ha egy egységgel történik valami, akor szól az egész kígyóért felelős objektumnak
14:54 < KisGergelyG> ő meghozza a döntést
14:54 < KisGergelyG> és közvetíti a beosztottak felé
14:54 < vmiklos> van olyan h nem a fejnek utkozik valami, megis hatassal van a kigyora?
14:54 < cassus> igen
14:54 < KisGergelyG> persze
14:54 < cassus> sawberry
14:55 < cassus> ezzel simán lehet levágást is csinálni
14:55 < KisGergelyG> egy fűrész levág belőle darabot
14:55 < vmiklos> hm
14:55 < cassus> az a hely, ami fűrész-es fejjel ütközött
14:55 < cassus> csinál egy ilyen gyilkoló dolgot, és meghívja magára
14:55 < cassus> az végigfut
14:55 < vmiklos> ja igen
14:55 < cassus> és mindenkit kinyír attól a ponttól vissza
14:55 < gerpetya> ez mondjuk így jó
14:55 < cassus> ezt kicsit bonyolultabb, ha egységes kezelés van...
14:56 < cassus> szerintem ez a bonyolultabb struktúra megéri a rugalmasságot amit ad
14:56 < vmiklos> ha siman listaval csinalnank a kigyoelemeket
14:56 < gerpetya> de akkor nem lenne jó, ha lenne pl egy KígyóÜtközik osztály amiben nyolcvanezer fv. minden típusra (sawberry, fej, stb)?
14:56 < vmiklos> akkor a meghalas mindig fegigmehetne a kigyo vegeig
14:56 < vmiklos> es nem kene kulonleges kigyo meg kigyofej csak siman kigyoelem
14:56 < gerpetya> ja és a fv.nevek ugyanazok
14:57 < vmiklos> ezt magaban a kigyoban is megcsinalhatod
14:57 < gerpetya> jogos
14:57 < gerpetya> ezért nem értem amit cassus írt
14:58 < gerpetya> mert minek az összes ütközésfajtára külön osztály? akkor hol van a visitor?
14:58 < vmiklos> csak annyi h sztem nem annyira bonyas
14:58 < vmiklos> nem lenne eleg az utkozesnel atadni azt a parametert amit a fej kapott?
14:59 < vmiklos> tehat a 2. elem utkozo fve pont u.ugy hivodna meg mint a feje
14:59 < cassus> ezzel a gond az, hogy a kontextus nem adódik át
14:59 < vmiklos> csak a fejt kivulrol hivtak meg, a 2. elemet meg a fej, 3.at a 2., stb
14:59 < cassus> tehát, hogy hol ütközött
14:59 < KisGergelyG> valahogy nekem fura, hogy az egyes egységek hozzanak döntéseket
14:59 < KisGergelyG> az egész kígyóra vonatkozóan
15:00 < cassus> nem a kígyóelem hozza a döntést
15:00 < cassus> hanem a kezelő
15:00 < cassus> ami az aktuális folyamatot vezérli
15:00 < KisGergelyG> de ő hozza létre a mindnekinek pusztító üzenetet átadó objektumot, nem?
15:01 < cassus> ő maga az az objektum, ahogy én fogalmazni akartam
15:01 < cassus> szerintem lépjünk egyet vissza
15:01 < cassus> keressük meg azokat a pontokat, ahol még közös talajon állunk
15:01 < cassus> és onnan építsük fel
15:02 < KisGergelyG> hát nálam ott kezdődik a dolog, hogy jön a léptetés
15:02 < KisGergelyG> minden világobjektum vlamailyen módon megtudja, hogy lépett az idő
15:02 < KisGergelyG> és esetleg csinál valamit
15:03 < cassus> ok eddig szerintem tisza
15:03 < cassus> ez az első kör
15:03 < cassus> második kör: a mező egyenként minden elemnek átadja az összes többit és a felelőssége mindenkinek az, hogy a saját állapotát változtassa ekkor
15:03 < KisGergelyG> igen
15:03 < cassus> második kör
15:03 < cassus> harmadik kör
15:03 < cassus> a változtatásokat érvényre jutnak
15:03 < cassus> ez ilyen magas szinten eddig jó?
15:03 < gerpetya> igen
15:04 < gerpetya> ez jó
15:04 < cassus> ok, akkor ez egy döntés
15:05 < cassus> g?
15:05 < cassus> elfogadod?
15:05 < KisGergelyG> részemről rendben
15:05 < cassus> nagyon jó
15:05 < cassus> akkor ez megvan
15:05 < cassus> akkor még1 dolgot beszéljünk meg
15:05 < cassus> ami aránylag egyszerű
15:05 < cassus> aztán jön a nehéz része
15:06 < cassus> tehát most átugorjuk, hogy hogyan találja ki az obj, hogy mit kellene csinálnia
15:06 < cassus> thf kitalálta
15:06 < KisGergelyG> és akkor ami nyitott kérdés maradt az az, hogy ha az egyik elem változása más elemeket is változtatna, pl. az egyik kígyóelem pusztulása mások pusztulását is maga után vonja, akkor hogyan történik meg ezen változtatások érvényre juttatása
15:06 < cassus> hogyan juttatja el az üzenetet amit kell az összes kígyó elemnek?
15:07 < cassus> erre javasoltam én, hogy legyen egy obj, ami végig fut a listán, és mindent elrendez
15:07 < gerpetya> mármint itt a halálra gondoltok?
15:07 < gerpetya> de miért nem tud a kígyó végigfutni?
15:07 < KisGergelyG> én azt gondoltam, hogy ez a közvetítő objektum lehetne maga a kígyó
15:08 < cassus> én meg azt, hogy ezt a felelőségget még darabolni lehet kisebb esetekre
15:08 < cassus> és így egy isten obj helyett sok kicsi lenne
15:09 < KisGergelyG> nem tudom, valahogy nem érzem szükségét, hogy tovább daraboljuk a kígyó felelősségeit
15:09 < gerpetya> én sem
15:09 < cassus> megmondom miért érdemes
15:09 < KisGergelyG> valahogy az számomra logikailag egy, jól körülhatárolható egység
15:09 < cassus> szerintem
15:09 < cassus> szóval az érvem az
15:10 < cassus> hogyha ezek a parancs végrehajtó obj-ok
15:10 < cassus> külön vannak a kígyótól
15:10 < cassus> és mondjuk azon kívül, hogy foreach elem in lista: elem.halál();
15:10 < cassus> valami okosabbat is kell csinálniuk
15:11 < cassus> mondjuk állapotot kell fenntartaniuk a lista bejárás során
15:11 < KisGergelyG> hmm, milyen állapotfenntartásra gondolsz?
15:11 < cassus> állapotos bejárás
15:12 < cassus> mondjuk olyan, hogy minden második kígyóelemet kővé változtatja
15:12 < cassus> szóval van állapota a bejárónak
15:13 < cassus> vagy tfh lesz olyan elem, hogyha a kígyó meghalna, akkor ő inkább leszakad, és önálló kígyóként folytatja útját
15:13 < cassus> akkor hogyha ez az egyszerű bejárás így bonyolodik...
15:13 < cassus> akkor bizony a kígyó obj csúnyán el fog hízni
15:14 < cassus> és egy csomó olyan változó lesz benne, ami csak bizonyos műveletek esetén érdekes
15:14 < KisGergelyG> szerintem az, hogy létrehozunk lokális változókat az egyes dolgok kezelésére szolgáló függvényekben, az nem olyan nagy baj
15:14 < cassus> az ötlet jó
15:15 < cassus> csak akkor nem tudsz double dispatch-t csinálni
15:15 < KisGergelyG> miért kellene itt double dispatch?
15:15 < cassus> azaz ez megöli annak a lehetőségét, hogy többfajta kígyóelem legyen
15:15 < cassus> erre mondtam, a potenciális fej példát
15:15 < cassus> hogy egy olyan kígyóelem
15:16 < cassus> aki felülbírálja a meghalást
15:16 < cassus> és önállósodik helyette
15:16 < KisGergelyG> tehát arra gondolsz, hogy az az elem csak bizonyos fajta halál esetén csinálja ezt? és ezért ahhoz, hogy eldöntse, önállósodik-e, tudnia kell, hogy milyen esemény váltotta ki a haljál meg üzenetet?
15:17 < cassus> nem
15:17 < cassus> tudnia kell, beleszólni az események folyásába
15:18 < cassus> és a halál üzenetet spec. módon kezelnie
15:18 < cassus> és megszakítanija a hívási láncot
15:18 < KisGergelyG> jaértem, hogy ha ő nem hal meg, akkor az utána lévők se
15:19 < cassus> szerintem én most eleget érveltem
15:19 < cassus> szeretném ha megmutatnátok ti
15:19 < cassus> hogy miért jó az ha egybe van minden vezérlés a kígyó obj-ban
15:19 < cassus> és miért nem jó az, ha a parancsok külön objektumként futnak végig a láncon
15:20 < KisGergelyG> egyszerűbb megvalósítani. és még nem értettem meg 100%ban, hogy miért rosszabb
15:20 < gerpetya> igen, ez még nekem sem nagyon világos, hogy miért rosszabb
15:20 < KisGergelyG> szegény cassus, ketten fárasztjuk ugyanazzal :)
15:22 < cassus> röviden azért, mert rugalmatlanabb
15:22 < KisGergelyG> na jó, de valahol meg kell húzni egy határt abban, hogy mennyire akarunk rugalmas kódot írni
15:22 < KisGergelyG> nem készülhetünk fel mindenre
15:23 < cassus> szerintem azt a +10 2 soros konstruktor függvényt és osztályt megéri
15:23 < KisGergelyG> meg valahogy nekem még az se jött át, hogy miért jobb az adott esetben a sok külön objektum az eseményekre. ott hogyan tud beleszólni egy elem a következők sorsába?
15:23 < cassus> és egy ilyet vissza lehet adni egy függvényből
15:24 < cassus> másik függvényt nem
15:25 < gerpetya> de nem lesz sok minden egyes eseményhez egy új osztályt létrehozni?
15:25 < cassus> nem eseményenként, parancsonként kell
15:26 < KisGergelyG> tehát lesz egy KillUnit class, egy MakeStoneUnit class, stb.?
15:26 < cassus> aha
15:26 < KisGergelyG> azt le tudnád írni, hogy mondjuk egy ilyen leszakad én önálló életet kezd eseménysor hogyan nézne ki pontosan?
15:27 < cassus> aha
15:27 < KisGergelyG> kezdve onnan, hogy az egyik blokk ráébred, hogy őt bizony megette egy fűrész?
15:27 < cassus> ott még nem tartunk :)
15:28 < cassus> onnantól, hogy eldöntötte valaki, hogy meg kell ölni a mögötte levőket
15:28 < cassus> onnantól tudom
15:28 < KisGergelyG> arra gondoltam, hogy meghívódik az ütközéskor a mező által hívott collidewith
15:29 < cassus> én meg azt mondom, hogy a "minek kell történnie" döntést meghozásnál még nem tartunk, most arról vitatkozunk, hogy tfh megvan a döntés, hogyan juttatjuk el az elemekhez
15:29 < KisGergelyG> végülis engem is csak ez a része érdekel
15:29 < gerpetya> :)
15:30 < cassus> :)
15:30 < cassus> ok, akkor elmondom amit tudok
15:30 < cassus> innentől kezdve
15:30 < KisGergelyG> tehát az elem meghozta a döntést, hogy őt megették, a mögötte lévők meg elvileg meghalnak
15:30 < cassus> aztán rátok bízom
15:30 < cassus> tehát megvan a döntés, hogy innentől meg kell hallnia a többienek
15:30 < cassus> és megvan ez a parancs obj
15:31 < cassus> átadja magát a darab a parancs obj-nak
15:31 < cassus> aki lekéri tőle a következő elemet
15:31 < cassus> és megkéri a következő elemet, hogy hívja vissza
15:31 < KisGergelyG> tehát az elem létrehoz egy parancs objektumot, aminek az a feladata, hogy a kapott elemet és a mögötte lévőket kinyírja?
15:31 < cassus> a "létrehoz" erős
15:31 < cassus> ez tfh a döntés részeként megvan
15:32 < cassus> úgy értem ez az eredménye a dönésnek
15:32 < cassus> egy parancs obj
15:32 < KisGergelyG> oké
15:32 < cassus> amire meg kell magát hívnia
15:32 < cassus> szóval
15:32 < cassus> ott tartottam
15:32 < cassus> hogy a második elemtől kér a killParancs egy visszahívást
15:32 < cassus> a második elem bárgyú, és visszahítvja
15:32 < cassus> ekkor elkéri tőle a harmadik elemet
15:32 < cassus> akitől szintén kér egy visszahívást
15:32 < cassus> ámde ez a szuper elem
15:33 < cassus> aki nem hívja vissza
15:33 < cassus> és így túléli
15:33 < cassus> valahogy jelzi, hogy innentől ő kígyófej
15:33 < cassus> a játékos obj felé
15:33 < cassus> hogy lehessen vezérelni
15:33 < cassus> és egyszerűen visszatér
15:34 < cassus> és kész
15:34 < cassus> most pedig megyek
15:34 < cassus> dolgom van
15:34 < cassus> a döntés a tietek
15:34 < cassus> majd pár óra mulva jövök
15:34 < KisGergelyG> oké
15:34 < KisGergelyG> gerpetya?
15:34 < gerpetya> pill
15:35 < KisGergelyG> mi a véleményed?
15:36 < gerpetya> nem értem, hogy ez a killParancs miért megy pl a kígyófej felé?
15:36 < KisGergelyG> miért a kígyófej felé menne?
15:37 < gerpetya> vagy cassus most nem azt írta?
15:37 < KisGergelyG> én az eredeti leírásban a fejnek adtam az egyes sorszámot, és a faroknak a "testhossz" sorszámot
15:37 < KisGergelyG> tehát ha egy adott elemtől a nála eggyel nagyobb sorszámút kéred le, akkor a farok felé haladsz
15:38 < gerpetya> nem értem még mindig, hogy miért jobb annál, ha a kígyó, aki úgyis ismeri az elemit, kinyír mindent ami a farok felé van
15:38 < KisGergelyG> igazából rájöttem, hogy két dologról van itt szó, nem egyről
15:38 < KisGergelyG> egyrészt, ő azt javasolta, hogy ne csak sorban meghívódjon a gyilkolás minden elemre
15:38 < KisGergelyG> hanem miután az egyikre meghívtad, tőle kérd el a következőt
15:39 < KisGergelyG> és ha ő nem akarja, hogy a következők meghaljanak, akkor nem adja oda
15:39 < gerpetya> de ez miért is jó?
15:39 < KisGergelyG> mert így meg lehet csinálni egy leszakadó kígyódarabot
15:39 < gerpetya> hmmm
15:40 < KisGergelyG> nem gondolom én sem, hogy ez egy annyira lényeges fícsör
15:40 < KisGergelyG> de cassus szerint így rugalmasabb
15:41 < gerpetya> hát nem tudom
15:41 < KisGergelyG> a másik dolog meg, amit akarna, hogy a kígyóelemekre vonatkozó döntések ne egy központi helyről kerüljenek végrehajtásra, hanem mindegyikhez legyen egy külön végr4ehajtó objektum
15:41 < gerpetya> de ezt még mindig nem értem, hogy miért jó ha külön van?
15:42 < gerpetya> hiszen a való életben is a kígyó "tudja", hogy meghal
15:42 < gerpetya> nem pedig egy külső vezérlő
15:42 < KisGergelyG> mert így kevésbé lesz "bloated" a kígyó objektum, illetve itt nem is lesz egybe kígyó objektum, hanem az egyes végrehajtó funkcióinak lesznek különobjektumai
15:43 < KisGergelyG> ugyanakkor van valami az egészben, ami engem zavar
15:43 < KisGergelyG> a kígyó számomra logikailag egy egység. és az hogy nincs ehhez tartozó objektum, ami saját magával kapcsolatban döntéseket hoz és végrehajtja azokat, az kontraintuitív
15:45 < KisGergelyG> szóval szerintem lehetne valami áthidaló megoldást csinálni
15:46 < KisGergelyG> lenne kígyó objektum, ami meghozza az egész kígyóra vonatkozó döntéseket
15:46 < KisGergelyG> és a végrehajtást is ő intézi
15:46 < gerpetya> ezt én is így gondoltam
15:46 < KisGergelyG> de a végrehajtást nem muszáj közvetlenül
15:46 < KisGergelyG> ezeket a parancs obejktumokat ő is létrehozhatja
15:47 < KisGergelyG> és átadhatja paraméterül hogy melyik egység eseménye váltotta ki a dolgot, és innentől kezdve ugyanolyan, mint ahogy ő írta
15:49 < gerpetya> de miért lényeges, hogy melyik egység váltotta ki?
15:49 < KisGergelyG> pl. a lefűrészelésnél nem mindegy, hogy honnatól kezdve halnak meg az egységek
15:49 < gerpetya> vagy itt a kígyó egységre gondolsz?
15:49 < gerpetya> jaaa
15:49 < gerpetya> ok
15:50 < KisGergelyG> egység az az egy mezőt elfoglaló világobjektum, ami a kígyót alkotja
15:50 < gerpetya> ok, már értem
15:50 < gerpetya> végülis ez így ok
15:51 < gerpetya> akkor legyen így?
15:51 < gerpetya> vagy mi legyen?
15:52 < KisGergelyG> hát nézd, te csinálod az objektumos feladatot, így szerintem döntsd el te. de mindenesetre cassus szerintem elég tapasztalt ilyen téren, szóval valószínűleg nem hülyeség, amit mond, még ha nem is egészen értem, hogy miért jobb így
15:53 < KisGergelyG> nekem talán legjobban egy ilyen kompromisszumos, "van kígyó, de a parancsok végrehajtása ilyen dinamikusan történik" dolog tetszene
15:53 < KisGergelyG> de nem állítom, hogy átlátom az egyes módok előnyeit és hátrányait
15:54 < gerpetya> lényegében ez az áthidaló megoldás is tükrözi cassus "szemléletét"
15:54 < gerpetya> mert így is rugalmas lesz a modell
15:54 < KisGergelyG> a kígyó mellett szól például, hogy szerintem logikátlan lenne az egész kígyóra jellemző globális dolgokat az egységekben tárolni
15:55 < KisGergelyG> bár az eredeti feladatban nem nagyon van ilyen, de el tudom képzelni, hogy pl. lesznek még újabb bogyók
15:55 < gerpetya> igen, erre én is gondoltam
15:55 < gerpetya> (mint lehetséges követelmény változás)
15:55 < KisGergelyG> pl. ami eszembe jutott, az a "páncél bogyó": az egész kígyó sebezhetetlenné válik egy időre
15:56 < KisGergelyG> ez egész kígyóra jellemző számlálót igényelne
15:56 < gerpetya> jó, akkor legyen ez az "áthidaló" megoldás
15:57 < KisGergelyG> részemről rendben, bár a dolgohoz hozzátartozik, hogy akkor még le kell tisztázni, hogy milyen függvényhívások sorozata történik egy-egy ütközésnél
15:57 < KisGergelyG> hogy most akkor a kígyó részt vesz benne, vagy micsoda
15:57 < KisGergelyG> és hogy a döntések hol születnek meg
15:57 < gerpetya> igen, még ez nem tiszta
15:58 < gerpetya> ugyebár a kígyóelem megkapja a mezőtől a heterogén kollekciót
15:58 < KisGergelyG> igen
15:59 < KisGergelyG> és akkor ő a kollekcióra alkalmaz valami algoritmust
15:59 < gerpetya> és itt jöhetne be, hogy lenne a kígyónak vmely függvénye, több fajta paraméterrel és az alapján hívódnának meg a különböző fajták
15:59 < KisGergelyG> milyen függvényre gondolsz?
15:59 < gerpetya> lenne collide(SawBerry); collide(FieldBerry); stb.
16:00 < KisGergelyG> ez így kicsit fura lenne, mert akkor miért adtunk át eleve kollekciót az egységnek?
16:00 < gerpetya> mondjuk ja
16:00 < gerpetya> de akkor mit csinál a kígyó a kollekcióval?
16:00 < KisGergelyG> a legrosszabb az egészben ez a sokminden egy mezőn típusú lehetőség
16:01 < KisGergelyG> pl. ha ketten lépnek egy mezőre, akkor melyik eszi meg a bogyót?
16:01 < KisGergelyG> pl. ha két fűrész lép egy kőbogyóra
16:01 < gerpetya> lehet hogy először ezeket kéne definiálni
16:01 < KisGergelyG> akkor nem mindegy
16:01 < KisGergelyG> ez már az algoritmikus része
16:01 < KisGergelyG> most nem ez a lényeg
16:02 < KisGergelyG> hanem, hogy egy sok-sokkal ütközés az több, mint néhány darab egy-eggyel ütközés összessége vagy egymásutánja
16:02 < KisGergelyG> sajnos
16:02 < gerpetya> ja
16:03 < KisGergelyG> akkor próbáljuk meg először két részre bontani a dolgot
16:03 < KisGergelyG> első lehetőség: nevezett algoritmus az egységben fut le, és a döntést közvetíti a kígyó felé
16:03 < KisGergelyG> második lehetőség, hogy az ütközés paramétereit közvetíti, és a döntés is a kígyóban születik meg
16:04 < gerpetya> ütközés paraméterei alatt azt érted, hogy mivel ütközött?
16:04 < KisGergelyG> most beszélj egy kicsit te, arról hogy melyiknek milyen előnyeit, hátrányait látod
16:05 < KisGergelyG> igen, meg azt is, hogy melyik egység
16:05 < KisGergelyG> mert ha a kígyó azt nem kapja meg, akkor az kicsit gáz lehet
16:06 < gerpetya> van olyan esemény, amely csak egy adott egységre van kihatással?
16:07 < gerpetya> eddig még nincs, úgyhogy sztem a kígyó lenne a logikus, mert ott a döntés szempontjából minden információ megvan
16:07 < KisGergelyG> hát, olyan, ami pillanatnyilag csak a fejre van hatással, olyan van, a kőegységgé változás
16:07 < KisGergelyG> meg ha a farkát harapja le egy fűrész
16:08 < KisGergelyG> de ezek inkább kivételek
16:08 < gerpetya> na, még ezt is tisztázni kéne, pl mitől lesz kőegység egy egység?
16:08 < KisGergelyG> azt szerintem elég jól leírtam
16:08 < KisGergelyG> a leírásban
16:08 < gerpetya> mármint nem maga az esemény
16:08 < KisGergelyG> vagy mire gondolsz?
16:08 < gerpetya> hanem az objektum modellben honnan látszik, hogy kőegység
16:08 < gerpetya> ?
16:09 < gerpetya> egy változóban tárolom, hogy ő kő?
16:09 < KisGergelyG> na ez egy jó kérdés
16:09 < gerpetya> kiesni, elveszni nem tud belőle, tehát sztem nem nagyon érdemes objektumként kezelni
16:10 < KisGergelyG> tisztán oop szépségi szempontból valószínűleg az lenne szép, ha a kő meg a normál egységek is egy közös őstől származnának
16:10 < KisGergelyG> viszont ez meg azért gáz, mert akkor hogyan alakítod oda-vissza az egységeket?
16:10 < gerpetya> na igen
16:11 < gerpetya> szval akkor marad egy változó, ami megkülönbözteti őt a többitől
16:11 < gerpetya> ugye?
16:11 < KisGergelyG> hát egyelőre próbáljuk meg így, de gyanítom, hogy lz nem fogja annyira szeretni
16:12 < KisGergelyG> de majd megkérdezzük tőle, hogy van-e valami ötlete az oda-vissza változás kezelésére
16:12 < gerpetya> lehetséges, hogy holnapra be kéne tervezni egy személyes találkozót, akár csak mi hárman cassus nélkül, hogy átbeszéljük személyesen, mert szvsz könnyebb mint irc-n
16:13 < gerpetya> mármint az egész modellt átbeszélni
16:13 < KisGergelyG> az kicsit gond lehet, mert 8-18 órám van, sőt igazából még 18 után is, tai chi, ráadásul az cassusnak is
16:13 < gerpetya> ahham
16:13 < KisGergelyG> bár jelekről én szerintem simán eljöhetnénk
16:14 < KisGergelyG> nem hiszem, hogy akármelyikünknek nagyon gondot okozna
16:14 < gerpetya> végülis akár én is
16:14 < KisGergelyG> amúgy szerintem is kéne ez a találkozó
16:16 < gerpetya> na mind1, akkor majd ha miklos is lesz beszélünk még róla
16:16 < KisGergelyG> oké
16:16 < KisGergelyG> és akkor ezt most függőben hagyod? mármint az objektummodellt? vagy megcsinálod az egyik verzió szerint, és legfeljebb átírod?
16:16 < KisGergelyG> amúgy most jöttem rá, hogy én is dependelek a dolgon
16:17 < gerpetya> igen, ez a gond, csak lehet hogy már előbb kellett volna erről beszélni
16:17 < KisGergelyG> mert nekem kell ugye a state machine-eket megcsinálni a kígyóra meg a kígyóelemre
16:17 < KisGergelyG> de tegnap nekem egész nap challenge day volt
16:17 < KisGergelyG> és csak pénteken osztottuk kia  feladatokat
16:17 < KisGergelyG> szóval ez tényleg szívás, dehát így alalkult
16:18 < gerpetya> jaja, mondjuk így nem lehetett volna máskor
16:18 < KisGergelyG> jó lenne legközelebb még a szerdai leadás utánra szervezni valamit közvetlenül, megbeszélni a jövő hetit
16:18 < gerpetya> akkor megpróbálom megírni az egyik verzió szerint, hogy legalább lássunk vmit és legfeljebb átírom
16:18 < gerpetya> jaja, az jó lenne
16:18 < KisGergelyG> oké, szerintem az lesz a legjobb
16:32 < gerpetya> akkor most a jelenlegi verzió szerint minden egyes parancsra lenne külön osztály?
16:32 < gerpetya> vagy csak a több egységet erintőre?
16:33 < gerpetya> *érintőre
16:33 < gerpetya> úgyértem egy fűrészszámláló beállítást a kígyó is el tud végezni minden nélkül
16:33 < KisGergelyG> hát, szerintem arra talán nem kell
16:34 < gerpetya> de pl. a hossz növelésre kéne külön obj?
16:34 < KisGergelyG> hát arra szerintem kéne
16:34 < KisGergelyG> bár az se tiszta még nekem, hogy azt hogyan csináljuk meg
16:34 < KisGergelyG> most akkor a következő lépésben nő meg a hossza?
16:35 < gerpetya> sztem igen
16:35 < gerpetya> szval a legutolsó helyen létrejön egy új egység
16:35 < gerpetya> de sztem ezt is meg lehetne oldani egy belső változóval
16:36 < gerpetya> vmi bool növelésKell
16:36 < gerpetya> és a léptetésnél ha növelésKell true, akkor csinál egy új egységet a végére
16:36 < gerpetya> és false-ra állítja
16:37 < gerpetya> de akkor meg előjön, hogy a halálra miért kell külön vmi, ha semmi másra nincs?!
16:38 < KisGergelyG> hát nem tudom pontosan
16:38 < gerpetya> mert az, hogy nem tud vmi leválni (esetleges páncél vagy vmi más miatt), azt a legelején tudod
16:38 < KisGergelyG> kár hogy cassus elment
16:38 < gerpetya> ha meg leszakad, akkor meg csak a halál fv.-t kell átírni
16:39 < gerpetya> olyan úgy sem lesz, hogy vmi meghal, de a következő nem tud
16:39 < KisGergelyG> szerintem egyelőre csináld meg úgy, ahogy jónak látod, aztán majd lzvel meg cassussal is konzultálunk holnap
16:39 < gerpetya> ok
16:39 < KisGergelyG> vagy remélhetőleg cassussal még ma is tudunk
16:40 < gerpetya> most már csak az nem tiszta, hogy mi legyen a kollekcióval amit megkap
16:40 < KisGergelyG> hát az alapján egy előre megadott algoritmussal eldönti, hogy mi lesz a saját sorsa
16:41 < gerpetya> de gondolok itt arra, hogy pl Kígyóra: collideWith(Kollekció, KígyóElem) hívás után
16:42 < gerpetya> a Kollekció minden elemére hív egy collide(KollekcióElem) fv.-t?
16:42 < gerpetya> és az meg úgy lenne pl.: collide(SawBerry) { Kígyó.setSawCounter(); }
16:42 < gerpetya> stb.
16:42 < KisGergelyG> nem, azt a mező csinálja meg, az hívja minden elemre
16:42 < KisGergelyG> illetve
16:42 < KisGergelyG> ja értem mire gondolsz
16:43 < gerpetya> de honnan tudja a kígyó, hogy mit kap? kell vmi fv., ami típusonként szétszedi
16:43 < KisGergelyG> hát ez is igaz
16:43 < gerpetya> számomra ez logikusnak tűnik
16:43 < gerpetya> és könnyen bővíthető
16:44 < KisGergelyG> én valami olyasmire gondoltam, hogy megnézi, van-e kőegység azon a mezőn. ha van, biztosan mindenki meghal
16:44 < KisGergelyG> ha nincs, akkor megnézi, van-e fűrész fej
16:44 < KisGergelyG> stb.
16:44 < gerpetya> de hogy nézi meg? hogy dönti el, hogy az az-e?
16:45 < KisGergelyG> hát nem tudom. kell a worldobejctnek valami olyan interfész, ami alapján eldönthető róla, hogy ő beletartozik-e egy adott kategóriába, vagy nem
16:46 < gerpetya> ezért gondoltam a külön típusú fv.-ekre, mert a visitor-nak is ez a lényege
16:46 < gerpetya> hogy az hívódik meg, amilyen típusú
16:46 < gerpetya> (legalábbis nekem ez jött le)
16:46 < KisGergelyG> nem értem egészen
16:47 < gerpetya> mármint mit?
16:47 < KisGergelyG> hogy te hogyan akarnád megcsinálni
16:47 < KisGergelyG> hogy a kollekció minden elemére meghívja azt a másik függvényt
16:48 < KisGergelyG> és aztán?
16:48 < gerpetya> és magába a másik fv.-be lenne lekódolva, hogy mit csinál
16:50 < KisGergelyG> na jó, én belezavarodtam
16:50 < gerpetya> most már kezdek én is:)
16:51 < KisGergelyG> három órája csak ezen tökölünk
16:51 < gerpetya> na mind1, átgondolom az egészet
16:51 < KisGergelyG> szerintem mostmár holnapig hagyjuk ezt a fenébe
16:51 < gerpetya> most viszont lépek, mert meek pestre
16:51 < gerpetya> ok
16:51 < KisGergelyG> csináld ahogy jónak látod, és holnap lesz még alkalmunk átbeszélni
16:51 < gerpetya> oké
16:51 < gerpetya> na meek, bye
16:51 < KisGergelyG> csáó
16:51 -!- gerpetya [i=gerpetya@catv-d5de8335.catv.broadband.hu] has left #spqr []
16:54 < KisGergelyG> ha valaki akar valami mondani, előtte pingeljen meg msnen, mert ezt az ablkaot én most bezárom, meg egyébként se szokta jelezni miranda, ha ircn írnak
16:54 -!- KisGergelyG [n=Miranda@catv-5984b1c9.catv.broadband.hu] has quit ["Miranda IM! Smaller, Faster, Easier. http://miranda-im.org"]
18:11 -!- cassus [n=cassus@3e44ab41.adsl.enternet.hu] has left #spqr []
18:16 < vmiklos> re
18:16 -!- Irssi: [@ChanServ] [ CIA-31] [ vmiklos] 
19:23 -!- gerpetya [n=gerpetya@pc1089.ktk.bme.hu] has joined #spqr
19:23 < gerpetya> hali
19:32 < vmiklos> hello
22:36 -!- cassus [n=cassus@3e44ab41.adsl.enternet.hu] has joined #spqr
22:36 < cassus> hi
22:36 < cassus> http://spqr-lab.sch.bme.hu/node/75
22:36 < cassus> összeszedtem minden ütközés kezeléssel kapcsolatos gondolatom
22:37  * vmiklos elkezdi olvasni
22:39 < vmiklos> azt, hogy a kigyo elore lep ki tarolja? vagy ezzel most ne foglalkozzunk?
22:40 < vmiklos> en eredetileg olyasmire gondoltam, hogy meghivna a regi mezo stepOut() metodusat, lekerdezne pl a getLeft() metodussal a baloldali szomszedot (ha epp olyan az iranya), majd a kapott uj mezo stepOn() metodusat hivna meg
22:49 < cassus> akár ez is jó
22:49 < cassus> csak ez geometria függő
22:49 < cassus> egy régebben javasolt megoldásom geom független
22:49 < cassus> tehát pl. hatszöges is lehet
22:49 < vmiklos> akkor csak annyi h egy enumban taroljuk a lehetseges iranyokat
22:50 < vmiklos> es egy getNext(irany) fv adja meg a kovetkezo cellat
22:50 < vmiklos> es igy akkor akar lehet kesobb 6szogletu, 3ds v ami jolesik
22:52 < cassus> ujuj
22:52 < cassus> enum
22:52 < vmiklos> javaban nincs enum? :]
22:52 < cassus> van
22:52 < cassus> de ez nagyon c-s megoldás
22:52 < cassus> én jobb szeretném ha lenne egy irány obj
22:52 < cassus> amin lenne egy getLeft és getRight fv
22:53 < cassus> és át tudnád adni a mezőnek, hogy melyik mező van ebben az irányban
22:53 < vmiklos> hm
22:53 < cassus> field.getFieldInDirection(direction)
22:53 < vmiklos> igen, es a direction azis egy class?
22:53 < cassus> aha
22:53 < cassus> de most inkább objektum
22:53 < vmiklos> ugy ertettem :)
22:54 < vmiklos> es azon belul hogy tarolod a lehetseges iranyokat?
22:54 < vmiklos> enumot ugyse tudsz objektumon kuvul tarolni, tehat adott h a direction is objektum legyen
22:54 < cassus> ha 4szög, akkor mondjuk enum, ha folytonos, akkor mondjuk double
22:55 < vmiklos> ja ez igaz
22:55 < cassus> de a felhasználás szemponjából mindegy, hogy mi van bene
22:55 < cassus> benne
22:55 < cassus> tudod, komponens alapú sw fejlesztés :)
22:55 < vmiklos> ez igaz :)
22:57 < cassus> a leírásom hogy tetszik?
22:58 < vmiklos> kisse overkill de sztem eleg allat otlet :)
22:59 < cassus> ezzel bebetonozzuk, hogy szinte mindent meg tudjunk csinálni kódba írás nélkül :)
22:59 < vmiklos> tehat valszeg kicsit tobbet teljesitunk vele mint amennyit kene viszont az tetszik h 0 ganyolassal le tudja akkor kezelni pl a harmas utkozest
23:03 < cassus> és ez az a dolog, amit pontosan fel lehet ismerni, ha valaki rólunk másolt :)
23:03 < cassus> amúgy elég sokat törtem rajta a fejem, és G is sokat segített
23:04 < cassus> én elégedett vagyok vele :)
23:04 < vmiklos> :]
23:06 < vmiklos> http://spqr-lab.sch.bme.hu/node/48
23:06 < vmiklos> errol mi a velmenyetek?
23:07 < vmiklos> semmi vilagrengeto nincs benne, nincs is elbonyolotitva de nem jutott eszembe ok h ennel komplekszebb kene
23:07 < vmiklos> komplexebb*
23:08 < cassus> ennél tudok egyszerűbbet
23:08 < cassus> relatív vezérlés
23:08 < vmiklos> tehat?
23:08 < cassus> amúgy pedig erősen javaslom, hogy nézd meg a use case-eket, amikhez szekvenciát gyártasz
23:09 < cassus> nem neked kell mindent kitalálni, az alapok már megvannak!
23:09 < cassus> http://spqr-lab.sch.bme.hu/node/33
23:09 < cassus> még szerencse, hogy ilyen ismerős volt a probléma :)
23:09 < vmiklos> ah
23:09 < vmiklos> :]
23:09 < vmiklos> hm hulye vagyok
23:10 < vmiklos> teljesen az volt bennem h csak 1 use case-t csinaltunk idaig pedig 3 csak 1hez volt abra
23:10 < cassus> és ez vasárnap este derül ki... :(
23:10 < vmiklos> hat, kiderulhetne kedd este is, ha mindenkepp optimista akarsz lenni ;)
23:11 < cassus> ezért jó, hogy hülyéskedünk vasárnap esti próba-határidővel
23:11 < vmiklos> :)
23:11 < gerpetya> kicsit úgyérzem a leírás alapján, hogy ezzel a modellel még biliárd is lehetne a kígyóból:D
23:12 < gerpetya> de amúgy tetszik
23:12 < gerpetya> jó rugalmas:D
23:12 < cassus> zoli azt szereti :)
23:12 < cassus> és amúgy is biliárd lesz a végén :)
23:12 < vmiklos> de amugy az az otlet rendben, hogy a kigyokat iranyito billentyuk kodjait a kigyoban taroljuk?
23:12 < cassus> csak ezt nekünk még nem szabad tudni
23:12 < cassus> hogy maga a kígyó tudja, hogy milyen billentyűre kell neki figyelnie?
23:13 < vmiklos> masik eset h csinalunk kulon classt amiben hashmapben vannak a a billkodok es kigyo-referenciak
23:13 < cassus> én még fokoznám
23:13 < vmiklos> es az input handler onnan szedi ki h melyik kigyot kell buzizni
23:13 < cassus> hashmap
23:13 < cassus> de nem a kígyókra
23:13 < cassus> hanem input parser-ekre
23:14 < cassus> aki eldönti, hogy milyen eseményt jelent ez és van egy referenciája a kígyóra
23:14 < cassus> és akkor szól a kígyónak, hogy snake.turnLeft()
23:14 < cassus> és ekkor szépen le van választva a vezérlés
23:14 < cassus> és akár egérrel/hálón keresztül is lehet
23:14 < vmiklos> hm a vegeredmeny tetszik de a hogyan nem vilagos
23:14 < cassus> új osztály
23:15 < cassus> SnakeKeyboardController
23:15 < vmiklos> van benne 1 hasmap ahol az itemek kigyoreferenciak
23:15 < vmiklos> de mik a keyek?
23:15 < cassus> SnakeKeyboardController
23:15 < cassus> ez 1 kígyóhoz tartozik
23:15 < cassus> KeyboardController
23:15 < cassus> tartalmazza ezket
23:15 < cassus> SnakeKeyboardController
23:15 < cassus> tudja, hogy melyik az a 3 gomb, ami az ő kígyójának érdekes
23:16 < cassus> és hogy melyik esetén mit kell hívni rajta
23:16 < cassus> KeyboardController
23:16 < cassus> tudja, hogy milyen gombok vannak kiosztva, és melyikket kinek kell továbbadni parse-olásra
23:16 < cassus> SnakeKeyboardController -t nevezzük inkább SnakeKeyboardParser -nek
23:17 < vmiklos> tehat van 1 KeyboardInputHandler
23:18 < vmiklos> kap 1 'a'betut. kikeresni 1 hasmapbol a megfelelo SnakeKeyboardControllert
23:18 < vmiklos> es meghivja a SnakeKeyboardController.press('a')-t
23:18 < vmiklos> majd a SnakeKeyboardController meghivja a Snake.turnLeft()et
23:18 < vmiklos> erre gondoltal?
23:18 < cassus> pontosan
23:18 < cassus> indeed :)
23:18 < gerpetya> na, vmi hasonlóra jutottam ekapcsán én is
23:19 < gerpetya> elolvastam egyébként amit írtál cassus
23:19 < gerpetya> tetszik
23:19 < cassus> köszi :)
23:19 < cassus> igyekeztem érthetően leírni
23:19 < gerpetya> mennyit dolgoztál rajta? :)
23:20 < cassus> irc-en kevésbé sikerült
23:20 < cassus> kitalálni 3-4 óra, megírni 1 óra
23:20 < cassus> úgy tűnik, nem megy, hogy én csak nézem, és ti megcsináljátok :)
23:20 < cassus> nem bírom ki, hogy ne szóljak bele mindenbe :)
23:20 < gerpetya> majd a kódolás része...
23:20 < gerpetya> :D
23:21 < gerpetya> aztán jó legyen ám a gáme, mert nyáron mobilra is akarom implementálni:D
23:21 < cassus> mobilra is?
23:21 < cassus> eleve menni fog, write once, run everywhere
23:21 < vmiklos> debug*
23:21 < vmiklos> ;)
23:21 < cassus> sőt, pár kattintással netes játékká is lehet tenni
23:21 < cassus> najó, nem
23:22 < cassus> de fel van készítve arra is
23:22 < vmiklos> http://spqr-lab.sch.bme.hu/node/33 ebbe be tudom valahogy allitani h kapcsolodo feladat a http://spqr-lab.sch.bme.hu/node/48?
23:22 < vmiklos> irasnal tudom h hogy kell beallitani de use case-nel nem latok ilyen mezot
23:22 < vmiklos> illetve rosszul mondom
23:23 < vmiklos> egyet be lehet allitani, kerdes h lehet-e megegyet
23:23 < vmiklos> v sokat akarok :)
23:23 < cassus> eddig lehetett, aztán direkt levettem egy-re
23:23 < cassus> mert ha sok volt, akkor az auto-linkelése ennek a mezőnek nem ment :(
23:24 < vmiklos> ja ok
23:24 < cassus> szóval szerintem tegyél be egy linket erre a feladat leírásába
23:24 < vmiklos> jaja
23:24 < cassus> van egy easylink-es gomb
23:24 < cassus> a tinymce-ben
23:24 < cassus> azzal egyszerűnek kell lennie :)
23:24 < cassus> csak rá kéne vennem, hogy megjelenítse a scroll bar-t
23:25 < vmiklos> hat, ha mukodne akkor tenyleg egyszeru lenne ;)
23:25 < vmiklos> click egy cikkre, eltunik a popup es annyi
23:25 < cassus> valamit ki kell jelölni
23:25 < cassus> azt fogja linkesíteni
23:25 < cassus> beír, kijelöl, linkesít
23:26 < vmiklos> jaa
23:26 < vmiklos> i c
23:27 < vmiklos> es mukodik is
23:27 < vmiklos> thx
23:30 < gerpetya> akkor csináljam meg majd ehhez a leíráshoz az objektum katalógust és leírást
23:30 < gerpetya> ?
23:30 < cassus> feltéve ha ezt a modellt elfogadjátok
23:30 < gerpetya> nekem tetszik, mint már említettem
23:30 < gerpetya> az enyém ehhez képest egyszerűbb
23:30 < cassus> csak mert ami pl. a végén van, eddig arra azt mondtátok, hogy nem értitek miért jó
23:30 < gerpetya> de kevésbé rugalmas
23:31 < gerpetya> szval maradhat ez
23:31 < cassus> ok
23:31 < cassus> akkor szerintem ezt most eldöntöttük
23:31 < gerpetya> hát még most sem igazán világos, de már dereng hogy miért gondoltad
23:31 < gerpetya> :)
23:31 < vmiklos> http://spqr-lab.sch.bme.hu/node/33 ezt frissitettem
23:31 < gerpetya> vagyis nem nem igazán világos, hanem csak lehet hogy felesleges, de legalább felkészülünk egy lehetséges módosításra
23:31 < gerpetya> ami nem hátrány
23:32 < gerpetya> és tényleg nem sok lekódolni
23:32 < cassus> vmiklos: azt nem
23:32 < vmiklos> ja igen a http://spqr-lab.sch.bme.hu/node/48 -at :)
23:32 < gerpetya> akkor most a naplóba bekerüljön az eddigi felesleges tanácskozás a modellekről?
23:32 < gerpetya> vagy az része az egésznek? mármint a cél eléréséhez kellett végülis
23:33 < gerpetya> :)
23:33 < cassus> szerintem kerüljön bele minden
23:33 < gerpetya> ok
23:33 < vmiklos> azert csak nem vonnak le pontot ;)
23:33 < cassus> aztán zolival ezt én elintézem
23:33 < gerpetya> :)
23:33 < cassus> neki kicsit más a véleménye, mi egy napló
23:33 < cassus> szerintem a munkánkat dokumentálja
23:38 < cassus> ja, érdekességképp elmondom
23:38 < cassus> hogy ez a működés hogy alakult ki
23:38 < cassus> először egy végtelen állapotgépre gondoltam
23:38 < cassus> mint gráfra
23:39 < cassus> ami ügyesen van megcsinálva, hogy a bejövő események sorendjétől független legyen a kimenet
23:39 < cassus> aztán redukáltam ezt egy véges gráfra
23:39 < cassus> aztán ilyen PERT szerűen lettek szintek a gráfban
23:39 < gerpetya> lol:)
23:39 < cassus> majd az egész átcsapott turing-gépbe
23:40 < vmiklos> :]
23:40 < cassus> aztán kialakult ez...
23:40 < gerpetya> cassus és a gráfja! lehetne akár egy újabb sikerkönyv is:D
23:40 < cassus> csak hogy lássátok mit tököltem ezzel órákat :)
23:40 < gerpetya> te mindenben a gráfot látod?! :DDD
23:40 < vmiklos> http://spqr-lab.sch.bme.hu/node/47 na ez az utolso otlet mara: az az otlet tetszik nektek, hogy a jatek maga 1 Game objektum peldanyositasa, es ott van az oldalon emlitett 6 lepes?
23:41 < gerpetya> jaja, jóez
23:41 < gerpetya> és most bogyók létrejöhetnek a játék során?
23:41 < gerpetya> :)
23:42 < vmiklos> nincs megtiltva de en csak a jatek inicializalasakor irtam a letrejottukrol :)
23:42 < gerpetya> végülis azt már nem nagy dolog implementálni, ha mégis kéne
23:42 < vmiklos> jaja
23:43 < vmiklos> amugy a nokias snake-ben is van ilyen
23:43 < vmiklos> mmint van furesz-bogyo
23:43 < vmiklos> es azert h megnohess ujra teremnek bogyok menet kozben
23:43 < vmiklos> "mikor epp nem nezel oda"
23:43 < vmiklos> szal szigoruan olyan jatekteruleten amit nem latsz a kameraval
23:45 < cassus> nekem tetszik ez a szekvencia
23:45 < cassus> csak gondolj arra, hogy milyen műveletek lesznek új játék indításakor
23:45 < cassus> és a program 0-ról indításakor
23:45 < cassus> lehet, hogy más, lehet, hogy nem
23:46 < vmiklos> ha a Game objectbol indul minden
23:46 < cassus> ideális esetben, ha Game obj-ról van szó, akkor nem kellene
23:46 < vmiklos> akkor ha megszunik a Game object akkor minden belole letrehozott objektum is megszunik
23:46 < vmiklos> jaja, tehat ha nem csesszuk el akkor max annyi kell ekore h 1 yesno dialog h szeretnel-e ujabb jateok jatszani v kilepsz
23:46 < vmiklos> ami meg mar a grafikus felulet
23:47 < vmiklos> jatekot*
23:47 < cassus> aha
23:47 < cassus> de ezzel majd akkor foglalkozunk..
23:47 < vmiklos> +
23:48 < vmiklos> na megnezem mennyi ido kinyomtatni 130 oldalt ketoldalasan
23:48 < cassus> :)
23:48 < cassus> mit nyomtatsz?
23:50 < vmiklos> gitar kottak
23:51 < cassus> printer benchmark :)
--- Log closed Mon Feb 25 00:00:19 2008