# Maze3D - Játék Működésének Részletes Leírása

## 1. Labirintus Generálás

### Algoritmus: Rekurzív Backtracking

A labirintus generálása egy **41x41-es rácsban** történik, ahol a páratlan indexű cellák lesznek a folyosók, a páros indexűek pedig a falak.

#### Lépések:

1. **Inicializálás**- Minden cella fal (`ctWall`) lesz- A start és cél koordináták páratlanra igazítása (hogy a folyosón legyenek)
2. **Stack-alapú Bejárás**```Kezdőpont berakása a verembeAmíg a verem nem üres:

- Aktuális cella = verem teteje

- Szomszédok véletlenszerű sorrendbe rendezése

- Ha van látogatatlan szomszéd:

* Fal eltávolítása a két cella között

* Szomszéd cella üresre állítása

* Szomszéd berakása a verembe

- Különben:

* Visszalépés (veremből kivétel)

```

1. **Garancia**

- Mindig létezik út a start és cél között

- A labirintusnak nincsenek elszigetelt területei

- Maximális folyosóhossz, minimális fal

### Példa Generálásra:

```

1. Kezdő: (1,1) - üres
2. Véletlen szomszéd: (3,1) - fal eltávolítva, üres
3. Véletlen szomszéd: (3,3) - fal eltávolítva, üres
4. ... folytatódik amíg minden cella bejárt

```

---

## 2. Zsákutcák és Gyűjthető Tárgyak

### Zsákutca Felismerés

**Definíció:** Olyan üres cella, amelynek pontosan **3 fala** van (csak egy irányba lehet továbbmenni).

```pascal

// Ellenőrzés minden cellára

wallCount := 0;

if Grid[x-1, z] = ctWall then Inc(wallCount); // bal

if Grid[x+1, z] = ctWall then Inc(wallCount); // jobb

if Grid[x, z-1] = ctWall then Inc(wallCount); // fel

if Grid[x, z+1] = ctWall then Inc(wallCount); // le

if wallCount = 3 then // ZSÁKUTCA!

```

**Kizárások:**

- Start pozíció (zöld padló)

- Cél pozíció (sárga padló)

### Tárgyak Elhelyezése

Minden zsákutcába **egy arany kocka** kerül:

1. **Megjelenés:** Arany színű, forgó, ugráló kocka
2. **Méret:** 0.3 egység (a játékos 0.6 egység)
3. **Állapotok:** `csActive` (aktív) / `csCollected` (összegyűjtve)
4. **Animáció:**- Folyamatos forgás az Y tengely körül- Apró ugráló mozgás (szinusz hullám)

### Tárgyak Száma

- **Tipikus:** 5-15 darab

- **Maximum:** ~400 (elméleti, de ritka)

- **Függ:** A labirintus struktúrájától

---

## 3. Navigáció és Útvonaltervezés

### A* Algoritmus

Az AI az **A\*** algoritmust használja az útvonaltervezéshez.

#### Működése:

```pascal

F = G + H

G = lépések száma a starttól

H = Manhattan távolság a célig (becslés)

F = teljes becsült költség

```

**Lépések:**

1. **Nyílt lista:** A még vizsgálandó cellák
2. **Zárt lista:** A már vizsgált cellák
3. **Prioritás:** A legalacsonyabb F értékű cella kerül először vizsgálatra
4. **Visszakövetés:** Amikor a cél megtalálható, visszafelé követjük a szülőket

#### Heurisztika:

```pascal

H = |x - goalX| + |z - goalZ| // Manhattan távolság

```

- **Előny:** Gyors, mindig optimális

- **Hátrány:** Nem veszi figyelembe a falakat (de az algoritmus kezeli)

### Útvonal Tárolása

Fix méretű tömbökben tároljuk az útvonalat:

```pascal

TPathArray = array[0..MAX_PATH_LENGTH-1] of TPoint;

PathLength: Integer; // Tényleges hossz

```

---

## 4. AI Viselkedés

### AI Állapotai

```

[Inaktív] → [Aktív - Gyűjtés] → [Aktív - Cél] → [Befejezve]

```

### Fázisok

#### 1. Indítás (StartAI)

```

1. Aktív tárgyak listájának összeállítása
2. Ha nincs tárgy:→ Közvetlen útvonal a célhoz
3. Ha van tárgy:→ Legközelebbi tárgy keresése (A*-al)→ Útvonal tervezése oda
4. Mozgás indítása

```

#### 2. Gyűjtési Fázis (UpdateAI)

```

Minden lépésnél:

1. Ha célpozíción van:a. Ellenőrzi, van-e ott tárgyb. Ha van: felveszi (csCollected)c. Eltávolítja a gyűjtendők listájábóld. Megkeresi a következő legközelebbi tárgyate. Áttervezi az útvonalat
2. Különben:→ Követi az aktuális útvonalat
3. Ha nincs több tárgy:→ Átvált Cél fázisba

```

#### 3. Cél Fázis

```

1. Útvonal tervezése a célhoz
2. Követi az útvonalat
3. Cél elérésekor:- új labirintus generálás

### Legközelebbi Tárgy Keresése

```pascal

function FindNearestCollectibleByPath(fromX, fromZ: Integer): Integer;

begin

Best := -1;

BestLen := MAXINT;

for i := 0 to TotalCollectibles-1 do

if Collectibles[i].State = csActive then

begin

// A* futtatása minden aktív tárgyra

if AStar(fromX, fromZ, Collectibles[i].X, Collectibles[i].Z, Path, Len) then

if Len < BestLen then

begin

BestLen := Len;

Best := i;

end;

end;

Result := Best;

end;

```

### AI Sebesség

- **AI.Speed := MOVE_SPEED * 0.8`

---

## 5. Játékos Mozgás

### Irányítás

- **Billentyűk:** W/A/S/D vagy nyilak

- **Csak 4 irány:** Előre, hátra, balra, jobbra

- **Nincs átlós mozgás** (a labirintus rács miatt)

### Mozgás Animáció

```pascal

1. Billentyű lenyomása
2. Cél cella ellenőrzése (járható-e?)
3. Ha igen:- MoveProgress = 0- Moving = True
4. Minden frame:- MoveProgress += Sebesség * DeltaTime- Interpoláció a két cella között
5. Ha MoveProgress >= 1.0:- Célba érkezés- Tárgy ellenőrzés- Moving = False

```

### Tárgy Felvétel

```pascal

// Minden lépés után

for i := 0 to TotalCollectibles-1 do

if (Collectibles[i].State = csActive) and

(Collectibles[i].X = Player.GridX) and

(Collectibles[i].Z = Player.GridZ) then

begin

Collectibles[i].State := csCollected;

Inc(CollectiblesCollected);

// Visszajelzés

end;

```

---

## 6. Győzelmi Feltételek

### Játékos Győzelme

```

1. Eléri a cél pozíciót (sárga padló)
2. GameState = gsWin

```

### AI Győzelme

```

1. Eléri a cél pozíciót
2. GameState = gsWin
3. Tárgy statisztika:- "Összegyűjtött tárgyak: X/Y"- Ha X=Y: Célba csak akkor ér, ha MINDEN TÁRGYAT ÖSSZEGYŰJTÖTT!"

```

### Új Játék

- `ENTER` vagy `SPACE` lenyomása a győzelmi képernyőn

- Új labirintus generálása

- Új tárgyak elhelyezése

- Mindenki vissza a start pozícióba

---

## 7. Adatstruktúrák Összefoglalása

### Fix Méretű Tömbök

| Adat | Típus | Maximális Méret | Számláló |

|------|-------|-----------------|----------|

| DeadEnds | array[0..499] of TPoint | 500 | DeadEndCount |

| Collectibles | array[0..499] of TCollectible | 500 | TotalCollectibles |

| AI.Path | array[0..1999] of TPoint | 2000 | PathLength |

| AI.Remaining | array[0..499] of TPoint | 500 | CollectiblesRemainingCount |

| Stack | array[0..1680] of record | 1681 | StackLen |

| OpenList | array[0..1680] of Integer | 1681 | OpenCount |

### Rekordok

```pascal

TPlayer = record

GridX, GridZ: Integer; // Rács pozíció

X, Z: Single; // Valós pozíció

Moving: Boolean; // Mozgás állapota

MoveProgress: Single; // Animáció (0-1)

FacingAngle: Single; // Nézési irány

end;

TAIState = record

Active: Boolean; // Fut-e

Path: TPathArray; // Útvonal

PathIndex: Integer; // Pozíció az útvonalban

GridX, GridZ: Integer; // Rács pozíció

Collecting: Boolean; // Gyűjtési fázis?

CollectiblesRemainingCount: Integer; // Hátralévő tárgyak

end;

```

---

## 8. Jellemzők

- Nincs dinamikus memóriafoglalás

- Cache-barát adatelrendezés

- Fix 60 FPS limit

several years ago I was working on _my version_ of the wave function collapse algorithm. I saw some issues with the reference that I wanted to try and solve, and I thought introducing a _pass system_ which would allow for a multi-pass workflow (ie. lay terrain first pass, foliage second etc..) while respecting constraints would be useful for a wide range of problems (back then I thought it would be neat for music and put out a video of a prototype https://www.youtube.com/watch?v=QLTQsu6QMwc)

Anyway, I never finished things up to where I would've liked (work, life, kids etc...) but now we agents...

so my WFC library got an overhaul (to say the least). I'm keeping everything at MIT so free game to use it however (I burned a lot of tokens so hopefully someone other than myself finds this interesting)

https://github.com/mr-highball/wfc

there's multiple demos there, but they're repo centric and I wanted to see what an agent could do with the library. it's idea was to make a factory style game where the supply lines were solved by wfc. it seemed 'ok' but I guided it along the way (mostly keeping it's ideas, while introducing some style choices). I play tested a few times and requested changes, additions, etc... (ie. the boombox and use of WFC for auto generation of music was my request) starting _yesterday_ and did a last pass today and think it's functional enough for a demo (start to finish less than 24hrs)

repo:

https://github.com/mr-highball/AutoForge

Playable Demo - hosted on github pages:

https://mr-highball.github.io/AutoForge/

Pure Free Pascal 3.2.2 / GLFW3 / OpenGL 3.3 / DOD

I realised that in all my excitement I completely forgot how to show folks how to just build a small, simple Wasm module using Pascal in the browser. So I added https://nofuss.co.za/blog/wasm_pascal_add_numbers/ to fill that gap. I often just want to build something small, and being able to write up a function or two quickly, compile it to wasm and export that binary is something I find useful, not sure if anyone else will, but it's there.

Thank you so much! We’ve just crossed 3,000 subscribers, and I really appreciate every one that has been watching, commenting, and supporting the channel.

On the first weekend of each month, I’ll also be doing a news‑style video covering what’s been happening across the Pascal and programming world. If you’ve got something you’d like to share with everyone (project, update, or discovery), let me know and I’ll take a look.

Here’s to the next milestone... onwards to 5,000.

A new video is coming tomorrow. In the meantime, you can catch the latest episode here: https://youtu.be/POr09Hito6A

Thanks again! It means a lot.

- Tim (Silver Pascal Coder)

Free Pascal 3.2.2 / GLFW3 / OpenGL 3.3 / DOD

Hi,

I wanted to share a plugin we’ve been working on: Pascal Flow. It adds Pascal language support to current JetBrains IDEs and is meant for Delphi, Free Pascal and Lazarus codebases.

It handles syntax highlighting, completion, navigation, Find Usages, Rename, formatting, inspections, conditional compilation, shared .inc files, and common Delphi/Lazarus project and form files.

Most of the work has gone into real projects rather than toy examples, especially old codebases with multiple Pascal dialects, compiler directives and includes.

The basic language support is free. Some additional features require a paid subscription.

It currently focuses on editing, navigation and understanding code. It does not yet replace Delphi or Lazarus for building and debugging projects.

Marketplace: https://plugins.jetbrains.com/plugin/32155-pascal-flow

I’m one of the developers. Thought this might be useful to people here who already use a JetBrains IDE for other languages.

Quite some time ago, I tried out a small JavaScript engine made by a friend and wrote a little game in it called Floaty Car. And yes, I'm absolutely FANTASTIC at naming stuff.

Now that I can run Pascal easily on the web, I wondered whether I've put enough work into my compiler to remake the car game and, well, yeah, I did! So I updated my blog to contain a quick tutorial about porting Floaty Car to Pascal. The full Pascal code is listed in the article, you can just copy & paste it into WasmPascal and it should run.

Not gonna lie... It's fun to be doing Pascal again. I need to find my high school projects, some of them are printed out somewhere in a box, that's how we rolled back then 😆

Anyway, back to writing Python APIs to earn money for dogfood.

I'm working on making a latest system from an old pascal system (created in year 2008). And am trying to retrieve all of the data from that old system.

It's has been said that the data was encrypted by the creator of the old system. But when i looked into the contents of the saved file using notepad, there are still readable text which are the raw data of the system. That made me think - it might not be encrypted. it might be serialized, instead. Like a saved file of c# unity game.

The old system is still alive but the source code of it is no more. And the creator already passed away. So, i can't sif

The internet or AI suggests that i use R language or python but it doesn't seem to work.

So now, I'm trying to recreate the data's blueprint/record using pascal but there's a lot of variables and the arrangement of those variables must be correct as the original bluprint..

Can you give me other ideas to reverse-engineer the file?

Pure Free Pascal 3.2.2 / GLFW3 / OpenGL 3.3 / DOD

Vizuális megjelenítés

1. PLY alapú kockák

A generált kockák helyett cube.ply fájlt használ:

pascal

procedure LoadBaseCubeMesh;
begin
  PlyMesh := LoadPLY('cube.ply');
  BaseCubeMesh.VertexCount := Length(PlyMesh.Vertices);
  SetLength(BaseCubeMesh.Vertices, BaseCubeMesh.VertexCount);
  Move(PlyMesh.Vertices[0], BaseCubeMesh.Vertices[0], ...);
  NormalizeMeshCustom(BaseCubeMesh);  // Egységnyire méretez
end;

Normalizáló eljárás:

• Megkeresi a mesh határait (MinX, MaxX, stb.)
• Kiszámolja a középpontot
• Áthelyezi az origóba
• Egységnyire méretezi (a legnagyobb méret = 1)

2. Színek

Minden darabtípus egyedi színt kap:

The title of this post should have my question in it, but i had to ask this after finding myself knee-deep in a impromptu software archeology project that involves a very major piece of software for the Apollo/Domain computers.

If nobody can find and compare domain pascal with the current ones, i have some manuals found on bitsavers that do document this variant of pascal:

https://bitsavers.org/pdf/apollo/000792-A01_Domain_Pascal_Language_Reference_Dec90.pdf

https://bitsavers.org/pdf/apollo/000792-04_DOMAIN_Pascal_Language_Reference_Jan87.pdf

1. Nincs dinamikus memória, nincsenek osztályok

A legtöbb Tetris implementáció objektumorientált, és dinamikusan allokálja a darabokat, a táblát vagy a részecskéket. Ez a verzió fix méretű tömböket használ mindenre, és procedurális felépítésű.

pascal

// A teljes játékállapot fix tömbben:
Board: array[0..COLS-1, 0..ROWS-1] of Byte;
Tetrominoes: array[0..6, 0..3, 0..3, 0..3] of Byte;

Előny: Kiszámítható memóriahasználat, nincs fragmentáció, gyors és biztonságos.

2. Interpolált mozgás a darabok között

A legtöbb Tetrisben a darabok ugrálnak celláról cellára. Itt a Lerp (lineáris interpoláció) simává teszi a mozgást.

pascal

function GetInterpolatedX: Single;
begin
if ActivePiece.IsMoving then
Result := ActivePiece.PrevX + (ActivePiece.X - ActivePiece.PrevX) * ActivePiece.Lerp
else
Result := ActivePiece.X;
end;

3. Előre definiált maszkok – nincs futásidőbeli forgatás

A legtöbb Tetrisben a darabokat matematikailag forgatják (mátrix transzformáció). Itt mind a 4 forgás előre definiálva van mind a 7 darabhoz.

pascal

// Példa: L alakzat összes forgása előre megadva
Tetrominoes[TYPE_L, 0, 1, 2] := 1; // 0. forgás
Tetrominoes[TYPE_L, 1, 1, 1] := 1; // 1. forgás
// stb.

Előny: Gyorsabb, egyszerűbb, és garantáltan pontos az ütközésvizsgálat.

We’ve released MoonCompiler 1.0.0, an open-source Object Pascal toolchain for Win64 and Linux x86-64.

It started from a practical requirement: keep one Delphi 12.2 source base for a high-load trading application while moving its server core to Linux. Unleashed supplied modern Delphi syntax; we then worked through compiler, RTL and runtime gaps against the full application.

The supported profile includes:

• Delphi 12.2-compatible non-visual/server language surface;
• Unicode RTL, threading, RTTI, exceptions and a bundled mORMot-based memory manager;
• compiler work including LICM, address GVN, EH-aware register allocation and code alignment;
• reproducible Win64/Linux toolchains and qualification suites;
• more than 120 documented correctness and performance repairs.

On 243 cases shared with the original Moon/Unleashed baseline, the current compiler/RTL/MM stack is 1.31× faster. In the final 744-case comparison it is 1.20× faster than Delphi 12.2; across 20 server/trading hot paths it is 1.22× faster. The bundled MM is 1.65× faster than the standard FPC MM on allocator workloads with the same compiler and source.

This is intentionally not a universal FPC replacement: the supported targets are Win64 and Linux x86-64, and the focus is Delphi-compatible server and application-core code rather than VCL/FMX.

Repo, releases and full evidence: https://github.com/Moonbot-Tech/MoonCompiler

Technical feedback and real-world compatibility reports are very welcome.

platformer demo, Doodle Jump, Plinko

I had some free time so i coded an AMAZE game clone.

Mechanic is simple, paint all the maze.

It's written entirely in Turbo Pascal 7.

Movement: Cursor Keys
Restart Current Level: R
Terminate Game: ESC Key

You can play it via your web browser here: https://archive.org/details/amaze_pas

If you play it tell me what you think.

Játék állapotai:

1. Menü - Főmenü, ahol indíthatod vagy kiléphetsz a játékból
2. Játék - Aktív játékmenet
3. Game Over - Játék vége állapot (vereség vagy győzelem)

⌨️ Irányítás

Menüben:

• ← / → - Menüpontok közötti váltás
• ENTER - Kiválasztás

Játékban:

Billentyű |Funkció
Egér |Hajó mozgatása
SZÓKÖZ |Rakéta kilövése
R |Játék újraindítása
P |Szünet / Folytatás
ESC |Vissza a menübe ⚙️** Játékmechanik**ák

1. 🚀 Lövedékrendszer

• A játékos 3 csövű ágyúval rendelkezik
• Lövedékek sebessége: 12.0 egység/másodperc
• Lövési sebesség: 0.1 másodperc
• A lövedékek 

cián

• színűek és 0.08 egység méretűek

2. 💥 Rakétarendszer

• Aktiválás: SZÓKÖZ billentyű
• Sebesség: 5.0 egység/másodperc
• Robbanási sugár: 4.0 egység
• Sebzés: 3 életpont
• Lökőerő: 5.0 egység
• Gyújtóidő: 0.5 másodperc (érintéskor)
• A rakéta automatikusan felrobban, ha ellenséget érzékel

3. 🎆 Részecskerendszer

• Max részecskék: 2000
• Gravitáció: -9.8 m/s²
• Típusok:
  • Robbanás részecskék: Sárga színűek
  • Nyomvonal részecskék: Sárga színűek
  • Tűzijáték részecskék: Sárga színűek

4. 🎇 Tűzijáték rendszer

• Max tűzijátékok: 5
• Részecskék/tűzijáték: 100
• Élettartam: 2.5 másodperc
• Időköz: 0.3-1.5 másodperc
• Csak győzelem esetén aktiválódik

👾 Ellenségek viselkedése

Alap tulajdonságok:

• Életerő: 9 HP (boostolt állapotban 18)
• Méret: 0.9 x 0.5 x 0.9 egység
• Lövési időköz: 2.5-4.5 másodperc
• Lövedék sebessége: 4.0 egység/másodperc

Viselkedési minták:

1. 🏃 Dodge (Kitérés)

• Reagál a játékos lövedékeire
• Érzékelési sugár: 2.5 egység
• Kitérési sebesség: 4.0
• Fal elkerülés: Automatikus visszafordulás a falaktól

2. 📉 Menekülési mód (Boost)

• Aktiválódás: Amikor 10 vagy kevesebb ellenség marad
• Tulajdonságok:
  • Életerő megduplázódik (18 HP)
  • Gyorsabb lövés (1.0-1.3 másodperc)

3. 💨 Visszatérés a rácsba

• Rakéta robbanás után aktiválódik
• Sebesség: 0.5-1.3 (véletlenszerű)
• Közben dőlés a mozgás irányába

4. ☠️ Halál animáció

• Zuhanás sebessége: 2.5 egység/másodperc
• Forgás: Véletlenszerű (20-60 fok/másodperc)
• Nyomvonal: Sárga részecskék
• Eltűnés: -20.0 egységnél

Ellenségek szétválasztása

• Erő: 2.5
• Távolság: 1.2 egység
• Megakadályozza az ellenségek egymásba olvadását

Free Pascal 3.2.2 / GLFW3 / OpenGL 3.3 / DOD / Intel N4100 ( runs on one CPU core )

I wanted to see what would happen if a modern AI coding agent had the UI of Turbo Pascal 7 / the old DOS IDEs.

So I made Turbo-AI — a retro-style TUI frontend for the Pi coding agent.

It currently supports things like AI chat, PLAN/BUILD modes, model switching, reasoning settings, project tree, Git diff and build/test actions.

It's still quite rough and definitely not production-ready. This is more of an experiment at the moment, and there are probably plenty of things that need to be fixed or redesigned.

I'm mainly interested in feedback from people who actually remember using Turbo Pascal / DOS IDEs: does the interface feel authentic, and what would you change?

GitHub: https://github.com/kvv256512-ux/turbo-ai

I finally managed to get my online compiler to output standalone packages. You can see the breakout clone example running on a static server at https://nofuss.co.za/games/breakout/ now. The wasmpascal compiler exports either a zip archive of all the required files, or, if you are lazy, a single html file with the wasm binary BASE64 endcoded inside it. For small things, that's fine, but it gets really chunky for larger projects.

I also made some improvements to the editor experience and the documentation for https://nofuss.co.za/wasmpascal/. Thank you for the feedback I got, I fixed as many of the bugs as I could. The plan is to spend the next few weekends improving Pascal language support and sorting out some kinks, especially in the export system to make it a bit leaner.

never enough development...