Nagymama

Ha a Furor programnyelvemre gondolsz, folyamatos fejlesztés alatt áll. De annyira, hogy ha hiszed ha nem, de épp írok hozzá egy játékot... Mármint, egy játékprogramot írok Furor nyelven. Gondoltam ezt csinálom meg előbb, mint a text editoromat, mert az utóbbihoz azért jó sok minden kell, és ugye sokféleképp lehet nekivágni annak a feladatnak, várok amíg kikristályosodik mi meg hogy... Meg tudnám írni azonnal is, korábban csináltam már egyet egy régebbi programnyelvemben, de most annál jobbra vágyom.

Ez a játékprogram azonban „ötletileg” világos, csak meg kell írni. Ma készen is lett egy demo verzió. Ez annyit jelent, hogy teljesen kész van, cakpakk, egyetlen dolog hiányzik belőle: a „szörnyek”. De enélkül is játszható, tudniillik ez egy labirintusos játék, és a kisgyerekek élvezik már magát azt is ha az utat keresgélhetik egy labirintusban, meg közben összeszedhetik a kincseket.

E játékban külön szórakoztató elem, hogy nemcsak falak vannak a labirintusban de forgóajtók is. Ezeket a szélüknek nekimenve el lehet forgatni. Ez azért fontos mert ha beleteszem majd a szörnyeket is a játékba, azok buták lesznek, nem tudják majd kinyitni ezeket a forgóajtókat, így ezen ajtók megfelelő irányba állításával a játékos megvédheti magát a közelben bóklászó szörnytől. Ennek ötletét egy régi C-64 -es játékból csórtam aminek ha jól emlékszem „Lady Tut” volt a címe.

Van a játékosnak bizonyos számú bombája is, amivel minden falat felrobbanthat maga körül. De csak falat, önmagát vagy szörnyet stb nem.

A játék kinézetre elég primitív, mert CLI felületen fut... Azaz például a kincseket a $ karakter jelképezi, a hőst a @ jel, stb. A szörnyek majd ha belekerülnek a * jellel jeleztetnek, mert az hasonlít a Covidra, hehehe...

Itt egy pálya, kicopyzva a terminálból:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
X$                                                    X             X
X XXXXXXXXXXXXXX-o-XXXX XXXXXXXXXXXXXXXXXXX XXXXXXXXX XXX X-o-XXXXX X
X X                   X X       X           X   X     X X X         X
X X XXXXXXXXX XXX X XXX X XX-o-XX XXXXXXXXXXX XXX XXXXX X X XXXXXXXXX
X X         X   X X     X                   X             X         X
X X XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXX-o-XXXXXXXXXXXX-o-X
X X                   X X       X               X     X X           X
X XX-o-XXXX XXX X XXX X XXXXXXX XXXXXXXXXXX XXX XXXXX X X X-o-XXXXX X
X X         X   X X     X                   X         X   X         X
X X XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXX-o-XXXXXXXXXX-o-XX XXX XXXXXXXXX
X X                     X                             X   X         X
X XXXXXXXXX-o-XXXXXXXXX XXXXXXXXXXXXXXXX-o- XXXXXXXXX XXX XXXXXXXXX X
X X X                 X X     X X   X       X X |     X X X X       X
X X X X -o-XX XXX X X X X XXX X X X X X XXX X X o X XXX X X X X XXXXX
X X   X     X   X X X X X   X   X X   X   X X   | X   X X X X X     X
X X XXXXXXXXX XXX X XXX X XXXXXXX XXXXXXXXX X XXX X-o-X X X X X XXXXX
X X         X   X X   X X              $  X X   X     X X X   X     X
X XXXXXXXXX XXX X XXX X XXXXXXXXXXXXXXXXXXX XXX XX-o- X X XXXXXXXXX X
X X         X   X X     X                   X             X         X
X XXXXXXX-o-XXXXXXXXXXX XXXXXXXXXXXXXXXX-o-XXXXXXXXXXXXXXXXXXXXXXXX X
X X X   X             X X     X X   X         X |     X X   X       X
X X X X XXX XXX X X X X X X X X X X X XXX X X X o X X X X X X XXX X X
X X   X     X   X X X X X X X   X X   X   X X   | X X X X X   X   X X
X@X XXXXXXXXX XXX X XXX X XXXXXXX XXXXXXXXXXX XXX XXXXX X X XXXXXXXXX
X X         X   X X   X X       X           X   X     X X X         X
X X XXXXXXXXX XXX X XXX X XXXXXXX XXXXXXXXXXX XXX XXXXX X X XXXXXXXXX
X X         X   X X     X                   X   X     X   X         X
X XXXXXXXXXXXXX XXXXXXX X-o-XXXXXXXXXXXXXXX XXX XXXXX XXX XXX-o-XXX X
  X             X       X                   X             X   $     X
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Sajnos annál is primitívebbnek látszik így mint amilyen valóságban. Az ok az, hogy itt fekete-fehér, a valóságban azonban színes. Aztán, a képernyőmön nem X karaktereket látsz a falak helyett hanem inverz szóközöket azaz ténylegesen FALNAK tűnnek!

Az -o- részek meg ezek függőleges megfelelője a forgóajtó; az o karakter az ajtó közepe.

Mielőtt valaki nagyon belemelegedne a játékprogramom lecsepülésébe hogy fúj, ez hogy néz ki meg minden, annak előrebocsátom hogy hát persze ez olyan amilyen, de tényleg csak a kinézete, és a megjelenítést a programomban egy rövidke rész végzi, amit könnyedén ki lehetne cserélni akármi másra, ha majd valamikor lesz a Furor nyelvemnek valamiféle grafikus libraryja... a megjelenítőnek ugyanis marhára semmi köze a program többi részéhez, lényegében egy karakteres tömb az „inputja”, annak elemeit kell kiirogatnia. Na most ezt jelenleg a CLI képernyőre írja ki, de könnyen belátható, ha volna grafikus interfészem, ezt pillanatok alatt ki lehetne cserélni benne s akkor máris itt egy remek (bár kisgyerekeknek való) játékprogram! Mert egyáltalán semmi máson nem kéne a programban változtatni hozzá!

A szörnyek még azért nem kerültek bele mert még nem volt rá időm, meg mert azokat automatikusan kell mozgatni az alatt is amíg a játékos lép, szóval ehhez egy külön program kell. A forkolás képességét már tudja a Furor, de a két program a forkolás után is képes kell legyen bizonyosfokú kommunikációra egymással, ezt a shared memory területen akarom megoldani. Na és a shared memoryval kapcsolatos funkciókat csak ma emeltem be a Furorba... A többi tehát holnapra marad.

Szóval a progi játszható már, de szörnyek nincsenek még benne. Ja, a labirintus mérete állítható, és természetesen minden indításnál más alakú a labirintus, mert a program maga generálja egy algoritmussal...

Na és mert teljes mértékben tisztában vagyok vele hogy csak gúnyból, trollkodásból „érdeklődtél”, (a stílusod is erre utal) ezért „ha már lúd legyen kövér” alapon, hogy igazán tl;dr hosszú legyen e postom íme a progi jelen verziójának teljes forráskódja, hehehe:

###sysinclude terminal.uh
###sysinclude into.uh
###sysinclude math.uh
###define MERETX 69
// A labirintus oszlopainak számozása 0 és MERETX-1 közt történik.
// MERETX muszáj hogy páratlan szám legyen.
###define MERETY 31
// A labirintus sorainak számozása 0 és MERETY-1 közt történik.
// MERETY muszáj hogy páratlan szám legyen.
###define TREASURE '$
###define TREASUREDB 3
// A treasuredb jelenti, hány $ jel lesz elhelyezve
###define WAY 32
###define FAL 'X
// Az alábbi doors az ajtók számát jelzi a labirintus falaiban.
###define doors 20
###define AJTÓKÖZEPE 'o
###define AJTÓSZÁRNYFÜGGŐLEGES '|
###define AJTÓSZÁRNYVÍZSZINTES '-
###define AJTÓszín $e
###define AJTÓháttérszín 0
###define FALszín $1b
###define FALháttérszín FALszín
###define HŐS '@
###define HŐSszín 9
###define HŐSháttérszín 0
###define kincsszín $b
###define kincsháttérszín 0

argc 2 > {
."Labirintusjáték. Készítette: Viola Zoltán alias Harold King alias Fossil Codger.\n"
." (itt a mailcímem szerepelt de kitöröltem a kedves HUP-trollok miatt...)\n"
."A program a Furor programnyelven íródott, azt a programnyelvet is én, Viola Zoltán írtam.\n"
."A játék célja: az összes kincs megszerzése. A kincs jelképe a $ jel.\n"
."Kilépés: az Esc 2-szer lenyomva, vagy a q.\n"
."A b lenyomásával robbanthatsz, de csak amíg maradt bombád.\n"
."Egy bomba minden falat lerombol a játékos körül (a labirintus legszélső, keretező"
." falait kivéve), de a szörnyeket nem öli meg.\n"
."A bomba átlósan se rombol, csak függőlegesen és vízszintesen!\n"
."A bomba nem pusztítja el az ajtókat, és a kincset se.\n"
."A játék akkor ér véget, ha az összes kincset megszerezted.\n"
."A labirintusban nem csak falak, de forgóajtók is vannak.\n"
."A forgóajtó ha vízszintes, így néz ki: -o-\n"
."Ha meg függőleges akkor így:\n"
."|\n"
."o\n"
."|\n"
."A forgóajtó közepét az o karakter, a szárnyait a vonal jelképezi.\n"
."A forgóajtó elfordítható, ha a szárnyának a megfelelő irányból nekimész a karaktereddel,\n"
."és ha semmi se áll az elforgatás útjában.\n"
."A játékost a @ jelképezi a játékban, s kiindulási helye mindig a bal alsó sarokban van.\n"
."Van a játékban kis csalásra is lehetőség: a B (nagy bé betű) minden lenyomása eggyel\n"
."megnöveli a bombáid mennyiségét.\n"

end
}

3 sto bombs // A bombák száma.
randinit // A véletlenszámgenerátor inicializálása
pálya MERETY MERETX createsharedscreen
üres() // Ez elkészíti az üres területet, falakkal körülhatárolva
generatemaze() // Ez legenerálja véletlenszerűen a labirintust
// ********************************************************************
//
// Ki- és bejáratok generálása, ha szükséges:
//
MERETY 2 - dup sto y sto newy 0 dup sto x sto newx
pálya @y @x HŐS [[^]] // A hős karakterének letevése
// ********************************************************************
// Kiírjuk a labirintust a CLI képernyőre:
cursoroff
cls

kirajzol:
@newy sto y @newx sto x
kirajzol2:
topleft
#k MERETY yloop: {| MERETX {|
pálya {}§yloop {} [[]] FAL == { FALszín tint FALháttérszín !tint pálya {}§yloop {} [[]] print {<}  }
pálya {}§yloop {} [[]] AJTÓSZÁRNYFÜGGŐLEGES == { AJTÓszín tint AJTÓháttérszín !tint pálya {}§yloop {} [[]] print {<} }
pálya {}§yloop {} [[]] AJTÓSZÁRNYVÍZSZINTES == { AJTÓszín tint AJTÓháttérszín !tint pálya {}§yloop {} [[]] print {<} }
pálya {}§yloop {} [[]] AJTÓKÖZEPE           == { AJTÓszín tint AJTÓháttérszín !tint pálya {}§yloop {} [[]] print {<} }
pálya {}§yloop {} [[]] HŐS           == { HŐSszín tint HŐSháttérszín !tint pálya {}§yloop {} [[]] print {<} }
pálya {}§yloop {} [[]] 'a >= pálya {}§yloop {} [[]] 'z <= &
{ kincsszín tint kincsháttérszín !tint pálya {}§yloop {} [[]] print {<} }

,,, pálya {}§yloop {} [[]] print
|} NL |} ,,, NL
."Collected treasure = " #g @kincsszámláló print ."    Bombs = " @bombs printnl
@kincsszámláló TREASUREDB #g == {
."YOU WON! Congratulations!\n"
goto §vége
}
// Billentyűzetinput
newinputchar: #g 10 into sto kar
@kar 128 < { @kar 27 == then §vége
@kar 'q == then §vége
@kar 'B == { inc bombs goto §kirajzol2 }
@kar 'b == { @bombs else §newinputchar // Ha elfogyott a bomba, hiába minden...
dec bombs
@x 1          > {      pálya @y @x -- [[]] FAL == { pálya @y @x -- WAY [[^]] } }
@y 1          > { @x { pálya @y -- @x [[]] FAL == { pálya @y -- @x WAY [[^]] } } }
@x MERETX 2 - < {      pálya @y @x ++ [[]] FAL == { pálya @y @x ++ WAY [[^]] } }
@y MERETY 2 - < { @x { pálya @y ++ @x [[]] FAL == { pálya @y ++ @x WAY [[^]] } } }
goto §kirajzol2
}
goto §newinputchar }
@kar $ff & sto k
@x sto newx @y sto newy
@k 1 == { // kurzorfel
dec newy @newy else §newinputchar
@x else §lépés
@y 1 == §newinputchar
//  -o-
//  @
pálya @newy @newx        [[]] AJTÓSZÁRNYVÍZSZINTES ==
pálya @newy @newx ++     [[]] AJTÓKÖZEPE ==
pálya @newy -- @newx     [[]] WAY ==
pálya @newy -- @newx ++  [[]] WAY ==
pálya @newy ++ @newx 2 + [[]] WAY ==
pálya @newy ++ @newx ++  [[]] WAY ==
& & & & & {
pálya @newy @newx     WAY [[^]]
pálya @newy @newx 2 + WAY [[^]]
pálya @newy -- @newx ++ AJTÓSZÁRNYFÜGGŐLEGES [[^]]
pálya @newy ++ @newx ++ AJTÓSZÁRNYFÜGGŐLEGES [[^]]
goto §lépés
}
//  -o-
//    @
pálya @newy    @newx     [[]] AJTÓSZÁRNYVÍZSZINTES ==
pálya @newy    @newx --  [[]] AJTÓKÖZEPE ==
pálya @newy -- @newx     [[]] WAY ==
pálya @newy -- @newx --  [[]] WAY ==
pálya @newy ++ @newx 2 - [[]] WAY ==
pálya @newy ++ @newx --  [[]] WAY ==
& & & & & {
pálya @newy    @newx     WAY [[^]]
pálya @newy    @newx 2 - WAY [[^]]
pálya @newy -- @newx -- AJTÓSZÁRNYFÜGGŐLEGES [[^]]
pálya @newy ++ @newx -- AJTÓSZÁRNYFÜGGŐLEGES [[^]]
goto §lépés
}
goto §lépés
} // kurzorfel vége
@k 2 == { // kurzorle
inc newy @newy MERETY -- >= then §newinputchar
@x else §lépés
//  @
//  -o-
pálya @newy    @newx     [[]] AJTÓSZÁRNYVÍZSZINTES ==
pálya @newy    @newx ++  [[]] AJTÓKÖZEPE ==
pálya @newy ++ @newx     [[]] WAY ==
pálya @newy ++ @newx ++  [[]] WAY ==
pálya @newy -- @newx 2 + [[]] WAY ==
pálya @newy -- @newx ++  [[]] WAY ==
& & & & & {
pálya @newy    @newx     WAY [[^]]
pálya @newy    @newx 2 + WAY [[^]]
pálya @newy -- @newx ++ AJTÓSZÁRNYFÜGGŐLEGES [[^]]
pálya @newy ++ @newx ++ AJTÓSZÁRNYFÜGGŐLEGES [[^]]
goto §lépés
}
//    @
//  -o-
pálya @newy    @newx     [[]] AJTÓSZÁRNYVÍZSZINTES ==
pálya @newy    @newx --  [[]] AJTÓKÖZEPE ==
pálya @newy ++ @newx     [[]] WAY ==
pálya @newy ++ @newx --  [[]] WAY ==
pálya @newy -- @newx 2 - [[]] WAY ==
pálya @newy -- @newx --  [[]] WAY ==
& & & & & {
pálya @newy    @newx     WAY [[^]]
pálya @newy    @newx 2 - WAY [[^]]
pálya @newy -- @newx -- AJTÓSZÁRNYFÜGGŐLEGES [[^]]
pálya @newy ++ @newx -- AJTÓSZÁRNYFÜGGŐLEGES [[^]]
goto §lépés
}
goto §lépés
} // kurzorle vége
@k 3 == { // kurzorjobbra
inc newx @newx MERETX >= then §newinputchar
@x MERETX -- == then §newinputchar
@x else §lépés
//  @|
//   o
//   |
//@newy 2 + MERETY >= then §lépés
pálya @newy     @newx    [[]] AJTÓSZÁRNYFÜGGŐLEGES ==
pálya @newy ++  @newx    [[]] AJTÓKÖZEPE == & else §jobbra2
pálya @newy     @newx ++ [[]] WAY ==
pálya @newy ++  @newx ++ [[]] WAY ==
pálya @newy ++  @newx -- [[]] WAY ==
pálya @newy 2 + @newx -- [[]] WAY ==
& & & {
pálya @newy     @newx WAY [[^]]
pálya @newy 2 + @newx WAY [[^]]
pálya @newy ++  @newx -- AJTÓSZÁRNYVÍZSZINTES [[^]]
pálya @newy ++  @newx ++ AJTÓSZÁRNYVÍZSZINTES [[^]]
goto §lépés
}
//   |
//   o
//  @|
jobbra2:
@newy -- else §lépés
pálya @newy     @newx    [[]] AJTÓSZÁRNYFÜGGŐLEGES ==
pálya @newy --  @newx    [[]] AJTÓKÖZEPE ==
pálya @newy     @newx ++ [[]] WAY ==
pálya @newy --  @newx ++ [[]] WAY ==
pálya @newy --  @newx -- [[]] WAY ==
pálya @newy 2 - @newx -- [[]] WAY ==
& & & & & {
pálya @newy     @newx WAY [[^]]
pálya @newy 2 - @newx WAY [[^]]
pálya @newy --  @newx -- AJTÓSZÁRNYVÍZSZINTES [[^]]
pálya @newy --  @newx ++ AJTÓSZÁRNYVÍZSZINTES [[^]]
goto §lépés
}
goto §lépés
} // kurzorjobbra vége
@k 4 == { // kurzorbalra
@x else §newinputchar
dec newx @newx else §newinputchar
//   |@
//   o
//   |
//@newy 2 + MERETY >= then §lépés
pálya @newy     @newx    [[]] AJTÓSZÁRNYFÜGGŐLEGES ==
pálya @newy ++  @newx    [[]] AJTÓKÖZEPE == & else §balra2
pálya @newy     @newx -- [[]] WAY ==
pálya @newy ++  @newx -- [[]] WAY ==
pálya @newy ++  @newx ++ [[]] WAY ==
pálya @newy 2 + @newx ++ [[]] WAY ==
& & & {
pálya @newy     @newx WAY [[^]]
pálya @newy 2 + @newx WAY [[^]]
pálya @newy ++  @newx -- AJTÓSZÁRNYVÍZSZINTES [[^]]
pálya @newy ++  @newx ++ AJTÓSZÁRNYVÍZSZINTES [[^]]
goto §lépés
}
//   |
//   o
//   |@
balra2:
//@newy -- else §lépés
pálya @newy     @newx    [[]] AJTÓSZÁRNYFÜGGŐLEGES ==
pálya @newy --  @newx    [[]] AJTÓKÖZEPE == & else §lépés
pálya @newy     @newx -- [[]] WAY ==
pálya @newy --  @newx ++ [[]] WAY ==
pálya @newy --  @newx -- [[]] WAY ==
pálya @newy 2 - @newx ++ [[]] WAY ==
& & & {
pálya @newy     @newx WAY [[^]]
pálya @newy 2 - @newx WAY [[^]]
pálya @newy --  @newx -- AJTÓSZÁRNYVÍZSZINTES [[^]]
pálya @newy --  @newx ++ AJTÓSZÁRNYVÍZSZINTES [[^]]
goto §lépés
}
goto §lépés

} // kurzorbalra vége
goto §newinputchar
lépés:
pálya @newy @newx [[]] FAL        == then §newinputchar
pálya @newy @newx [[]] AJTÓKÖZEPE == then §newinputchar
pálya @newy @newx [[]] AJTÓSZÁRNYVÍZSZINTES == then §newinputchar
pálya @newy @newx [[]] AJTÓSZÁRNYFÜGGŐLEGES == then §newinputchar
pálya @newy @newx [[]] TREASURE == { inc kincsszámláló }
pálya @y @x WAY [[^]]
pálya @newy @newx HŐS [[^]]
goto §kirajzol

// ********************************************************************
vége:
,,, cursoron
end
{ „k” }
{ „x” }
{ „y” }
{ „kar” }
{ „newx” }
{ „newy” }
{ „bombs” }
{ „pálya” }
{ „kincsszámláló” }
{ „myerrorhandler” // A hibakezelő rutin. Igazság szerint abszolút nincs szükség rá,
// de itt illik legyen a helye ha egy komolyabb progi része lenne
// ez a labirintusrajzoló.
#g sto hibakód sto hívórutin sto hívóneve
."Hiba történt ebben a névtérben: " @hívóneve sprintnl
."Ezt a hibakódot kaptam: " @hibakód printnl
end
{ „hibakód” }
{ „hívórutin” }
{ „hívóneve” }
}
// ---------------------------------------------
{ „üres” __usebigbossnamespace
// Kitölti úttal az egész pályát, de a széleit falakkal
MERETY yciklus: {| MERETX {|
pálya {}§yciklus {} WAY [[^]]
|} |}
MERETY {| pálya {} 0 FAL [[^]] pálya {} MERETX -- FAL [[^]] |}
MERETX {| pálya 0 {} FAL [[^]] pálya MERETY -- {} FAL [[^]] |}
end
}
// ---------------------------------------------
{ „generatemaze” __usebigbossnamespace
###sysinclude math.uh
// Az alábbi sorban beállítjuk az errorhandler függvényt a megfelelőképpen:
@initflag !{ one initflag myerrorhandler §myerrorhandlerlabel set errorhandler }

#g // Végig egész számokkal dolgozunk
// Az alábbi 2 sorban memóriát foglalunk 2 stringnek, amik
// segédváltozókként funkcionálnak majd, flagek tárolását végzik:
MERETX mem !maximize sto oszlopflag
MERETY mem !maximize sto sorflag
// ***********************************************************
// Az oszlopok és sorok első és utolsó pozícióit bejelöljük,
// mondván hogy ott már van fal.
//
@oszlopflag 0 1 [^]
@oszlopflag @oszlopflag~ -- 1 [^]
@sorflag    0 1 [^]
@sorflag    @sorflag~    -- 1 [^]
// ***********************************************************
// Az alábbi 2 ciklusban az oszlopok és sorok flagjait tároló
// stringek minden páratlanadik pozícióját bejelöljük, ez jelzi
// később, hogy azokkal a sorokkal illetve oszlopokkal nem kell
// törődnie. Fal ugyanis csak páros indexű helyeken építhető.
//
MERETX -- {| {} 2 !/ then{<} @oszlopflag {+} 1 [^] |}
MERETY -- {| {} 2 !/ then{<} @sorflag    {+} 1 [^] |}
// ***********************************************************
nextrandom:
// ...............................................
// E két ciklus csekkolja le, van-e még olyan
// sor illetve oszlop, amit nem vizsgáltunk végig.
@oszlopflag {~ @@ !{ goto §kell } |}
@sorflag    {~ @@ !{ goto §kell } |}
// ...............................................
// Elhelyezzük a forgóajtókat:

doors {|
newrandomneed:
MERETX random sto x
MERETY random sto y pálya @y @x [[]] WAY == then §newrandomneed
// Most már biztos hogy itt fal van.
@x        2   < then §newrandomneed @y        2   < then §newrandomneed
@x MERETX 3 - > then §newrandomneed @y MERETY 3 - > then §newrandomneed
// Megnézzük, függőleges ajtót betehetünk-e.
pálya @y -- @x [[]] FAL == // Ha az aktuális pozíció fölött is fal van
pálya @y ++ @x [[]] FAL == // Ha az aktuális pozíció alatt  is fal van
pálya @y -- @x -- [[]] WAY == // balfelső  sarok szabad
pálya @y -- @x ++ [[]] WAY == // jobbfelső sarok szabad
pálya @y ++ @x -- [[]] WAY == // balalsó   sarok szabad
pálya @y ++ @x ++ [[]] WAY == // jobbalsó  sarok szabad
pálya @y    @x -- [[]] WAY == // bal  szomszéd   szabad
pálya @y    @x ++ [[]] WAY == // jobb szomszéd   szabad
& & & & & & & else §vízszintesteszt
pálya @y @x AJTÓKÖZEPE [[^]]
pálya @y -- @x AJTÓSZÁRNYFÜGGŐLEGES [[^]]
pálya @y ++ @x AJTÓSZÁRNYFÜGGŐLEGES [[^]]
{<}
vízszintesteszt:
// Megnézzük, vízszintes ajtót betehetünk-e.
pálya @y @x -- [[]] FAL == // Ha az aktuális pozíció mellett balra  is fal van
pálya @y @x ++ [[]] FAL == // Ha az aktuális pozíció mellett jobbra is fal van
pálya @y -- @x -- [[]] WAY == // balfelső  sarok szabad
pálya @y -- @x ++ [[]] WAY == // jobbfelső sarok szabad
pálya @y ++ @x -- [[]] WAY == // balalsó   sarok szabad
pálya @y ++ @x ++ [[]] WAY == // jobbalsó  sarok szabad
pálya @y ++ @x    [[]] WAY == // fent szabad
pálya @y -- @x    [[]] WAY == // lent szabad
& & & & & & & else §newrandomneed
pálya @y @x AJTÓKÖZEPE [[^]]
pálya @y @x -- AJTÓSZÁRNYVÍZSZINTES [[^]]
pálya @y @x ++ AJTÓSZÁRNYVÍZSZINTES [[^]]
|}
// Elhelyezzük a kincseket.
TREASUREDB {|
newrandomneed2: MERETX random sto x MERETY random sto y pálya @y @x [[]] WAY != then §newrandomneed2
pálya @y @x TREASURE [[^]]
|}
// ...............................................
@oszlopflag free @sorflag free // Az ideiglenes változók
// memóriaterületének felszabadítása
end
kell:
4 random                // Választunk egy irányt véletlenszerűen
§jumpingtable[] [goto]  // és elugrunk a megfelelő rutinra
bal: // balról jobbra
MERETY random 2 / 2 * sto aktrand // így biztos páros szám
@sorflag @aktrand [] !{
MERETX -- {|
pálya @aktrand {}  [[]] FAL == { {<} }
pálya @aktrand {+} [[]] FAL == { {<} }
pálya @aktrand {} FAL [[^]]
|}
@sorflag @aktrand 1 [^]
}
goto §nextrandom

jobb: // jobbról balra
MERETY random 2 / 2 * sto aktrand
@sorflag @aktrand [] !{
MERETX -- {|
pálya @aktrand {-}  [[]] FAL == { {<} }
pálya @aktrand {--} [[]] FAL == { {<} }
pálya @aktrand {-}  FAL [[^]]
|}
@sorflag @aktrand 1 [^]
}
goto §nextrandom

lent: // Lentről fel
MERETX random 2 / 2 * sto aktrand
@oszlopflag @aktrand [] !{
MERETY -- {|
pálya {-}  @aktrand [[]] FAL == { {<} }
pálya {--} @aktrand [[]] FAL == { {<} }
pálya {-}  @aktrand  FAL [[^]]
|}
@oszlopflag @aktrand 1 [^]
}
goto §nextrandom

fent: // Fentről le
MERETX random 2 / 2 * sto aktrand
@oszlopflag @aktrand [] !{
MERETY -- {|
pálya {}  @aktrand [[]] FAL == { {<} }
pálya {+} @aktrand [[]] FAL == { {<} }
pálya {}  @aktrand  FAL [[^]]
|}
@oszlopflag @aktrand 1 [^]
}
goto §nextrandom
// ..........................................................
myerrorhandlerlabel: fail
{ „x” } { „y” }
{ „initflag” }
{ „oszlopflag” }
{ „sorflag” }
{ „aktrand” }
jumpingtable: §bal §jobb §lent §fent
}
// ---------------------------------------------------------

Na most ha valaki eddig netán végigolvasta, az azért láthatja a kódból hogy ez már eddig is egy elég hosszú programocska, azaz nem nyúlfarknyi! Ebben már SOK MINDEN van. Még ilyen sor is hogy

set errorhandler

ami ugye arra utal, a nyelvem fejlett hibakezelő szolgáltatással rendelkezik... (oké, ezen a részen még van mit csiszolnom, de azért már működik). Látszik hogy képes a nyelvem dinamikusan allokált memóriaterületek kezelésére is, nem csak statikus változókéra, képes ugrani tömbben tárolt pointerek alapján, ésatöbbi.

Meg van benne a világon minden izémizé is még. Ez egy „rather complex” program már, és maga a tény hogy a compilerem a bájtkód előállítása során ezt a sok mindent képes megemészteni, beleértve az include fájlok behúzását is, a rengeteg define direktívát is meg minden, nem gabalyodik bele a rengeteg címkébe, az ugrási címek kiszámításába, a függvények névterének a váltogatásába, a feltételes blokkok és a ciklusok elejének-végének kiszámítgatásába stb, az azért arra utal szerényen szólva is, hogy SZÉP és KOMOLY munkát végeztem, s a nyelvem igenis HASZNÁLHATÓ!

Maga a tény hogy egy ilyen komplexitású programot meg lehet írni benne, az meg nemcsak a használhatóságára bizonyíték, de arra is hogy talán mégse olyan megtanulhatatlanul nehéz, mint azt egyesek a furcsa szintaxisra rápillantva azonnal rávágják... szerintem merő irigységből.

Igen, azt én is elismerem, mikroszkopikus esélye sincs annak hogy a nyelvem valaha is olyan széles körben elterjedt legyen mint mondjuk a C vagy a Java. DE SOSE EZ VOLT A CÉLOM.

Az azonban hogy „használhatatlan”, az teljes mértékben overstatement, és a kinézete miatti meghökkenés okozta overreaction. Azaz bocsánat, túlreagálás! Csak a magyar nyelv már kezd too hard lenni. És különben is, van valami túl kemény, barbár hangzása, talán az urali eredet miatt... :)

Ez egy használható nyelv, bár azt elismerem, bugok lehetnek benne még akár bőven is, minthogy friss nyelv, nem sok idő óta tesztelem. De épp ezért írok benne programokat, hogy a bugok kiderüljenek.

A nyelv ismétlem használható, a nehézsége meg kábé azon a szinten van mint a FORTH -é. Tény, a FORTH manapság nem egy trendi nyelv, na és akkor mi van?! Most mégis, miért KÉNE nekem és ÉPP nekem pontosan a legtrendibb nyelvek stílusát és kinézetét majmolni?! Ha a nyelvem mindenben olyan volna mint azok, akkor felesleges is lett volna megírnom...

Na ennyi tényleg elég, ez még szerintem is hosszú post.

Várom sok szeretettel (nem...) a trollfajzatokat! Itt a fincsi csemege, irigykedjetek nyugodtan!

A mama szerepel benne. És a mama sok helyen (tájnyelvekben) a nagymama jelentéssel bír.

Különben meg te nem érted mit írtam fentebb, vagy inkább nagyonis érted de megpróbálsz megint minden kis részletbe belekötni és félremagyarázni.

És tényleg leszarom, legalábbis amit te írkálsz nekem. Ebben a témában pláne mert a blogbejegyzés nem az enyém, az eredeti verset se én írtam, szóval ez a téma eléggé az ingerküszöböm alatt van, tudod.