added points 7-15 to rendszerterv.md

Rendszerterv első része az órán közösen megbeszéltek alapján
2025-11-15 20:19:35 +01:00 · 2025-11-12 11:20:54 +01:00
21 changed files with 253 additions and 1406 deletions
--- a/.github/workflows/dispatcher.yml
+++ b/.github/workflows/dispatcher.yml
@@ -16,9 +16,6 @@ jobs:
      server: ${{ steps.check.outputs.server }}
      ui: ${{ steps.check.outputs.ui }}
    steps:
-      - name: checkout repository 
-        uses: actions/checkout@v4
-
      - name: Determine which tests to run
        id: check
        run: |
@@ -29,13 +26,13 @@ jobs:
          SERVER=false
          UI=false

-          if [[ "$BRANCH" == *"Engine"* ]] ; then
+          if [[ "$BRANCH" == *"Engine"* ]]; then
            ENGINE=true
          fi
-          if [[ "$BRANCH" == *"Server"* ]] ; then
+          if [[ "$BRANCH" == *"Server"* ]]; then
            SERVER=true
          fi
-          if [[ "$BRANCH" == *"UI"* ]] ; then
+          if [[ "$BRANCH" == *"UI"* ]]; then
            UI=true
          fi

--- a/.github/workflows/engine_test.yml
+++ b/.github/workflows/engine_test.yml
@@ -1,6 +1,7 @@
 name: Engine Tests

 on:
+  pull_request:
  workflow_dispatch:
  workflow_call:

@@ -9,6 +10,8 @@ jobs:
    runs-on: self-hosted

    steps:
+      - uses: actions/checkout@v4
+
      - name: Run Engine tests
        run: |
          bash .github/workflows/test.sh engine/
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,6 +1,7 @@
 name: Release build

 on:
+  pull_request:
  workflow_dispatch:
  workflow_call:

--- a/.github/workflows/server_test.yml
+++ b/.github/workflows/server_test.yml
@@ -1,6 +1,7 @@
 name: Server Tests

 on:
+  pull_request:
  workflow_dispatch:
  workflow_call:

@@ -9,6 +10,8 @@ jobs:
    runs-on: self-hosted

    steps:
+      - uses: actions/checkout@v4
+
      - name: Run Server tests
        run: |
          bash .github/workflows/test.sh server/
--- a/.github/workflows/test.sh
+++ b/.github/workflows/test.sh
@@ -30,13 +30,8 @@ echo "$PROJECT_NAME" > "$LOG_FILE"
 awk '/^running [0-9]+ test[s]?$/,/^$/' full_test_output.log >> "$LOG_FILE"

 # --- APPEND TO GLOBAL LOG (in repo root) ---
-if [[ $(git rev-parse --abbrev-ref HEAD) == "master" ]]; then 
-  echo "master" >> $FINAL_LOG
-fi
 cat "$LOG_FILE" >> "$FINAL_LOG"

 # --- SUMMARY ---
 echo ">>> Test output extracted to $PROJECT_PATH/$LOG_FILE"
 echo ">>> Appended to $FINAL_LOG"
-
-cat $(git rev-parse --show-toplevel)/test_data.log
--- a/.github/workflows/ui_test.yml
+++ b/.github/workflows/ui_test.yml
@@ -1,6 +1,7 @@
 name: UI Tests

 on:
+  pull_request:
  workflow_dispatch:
  workflow_call:

@@ -9,6 +10,8 @@ jobs:
    runs-on: self-hosted

    steps:
+      - uses: actions/checkout@v4
+
      - name: Run UI tests
        run: |
          bash .github/workflows/test.sh ui/
--- a/.github/workflows/upload_data.yml
+++ b/.github/workflows/upload_data.yml
@@ -20,77 +20,33 @@ jobs:
          echo "$GOOGLE_SERVICE_ACCOUNT_JSON" > service_account.json
          
          python <<'PYCODE'
-          import gspread, json, subprocess
+          import gspread, json, time, subprocess

+          # credentials
          creds = json.load(open("service_account.json"))
          gc = gspread.service_account_from_dict(creds)
          sh = gc.open_by_key("${{ secrets.SPREADSHEET_ID }}")
          v = subprocess.run(['git','rev-parse','--show-toplevel'], capture_output=True).stdout.decode().strip()
          print(f"{v}/test_data.log")

-
-          def writeRowsToSpreadsheet(data_list, worksheet):
-              existing_rows = len(worksheet.get_all_values())
-              start_row = existing_rows + 3
-              rows_to_append = [row.split() for row in data_list]
-              print("rows to append")
-              print(f"{rows_to_append}")
-
-              for i, row in enumerate(rows_to_append):
-                  worksheet.insert_row(row, start_row + i)
-
-
          with open(f"{v}/test_data.log", "r") as f:
              lines = [line.strip() for line in f if line.strip()]

-          isMaster = False
          project = lines[0].lower()
-          if project == "master":
-              isMaster = True
-          
-          engine_data = []
-          server_data = []
-          ui_data = []
-          master_data = []
+          worksheet = sh.worksheet(project)

-          for entry in lines:
-              if not isMaster and entry == "engine":
-                  project = "engine"
-              elif not isMaster and entry == "server":
-                  project = "server"
-              elif not isMaster and entry == "ui":
-                  project = "ui"
+          # project name
+          data = lines[1:]

-              if project == "engine" and entry != "engine":
-                  engine_data.append(entry)
-              elif project == "server" and entry != "server":
-                  server_data.append(entry)
-              elif project == "ui" and entry != "ui":
-                  ui_data.append(entry)
-              elif project == "master" and entry != "master":
-                  master_data.append(entry)
+          #blank rows
+          existing_rows = len(worksheet.get_all_values())
+          start_row = existing_rows + 3

-          print("PRINTING FILTERED DATA\n\n")
-          print(f"engine\n{engine_data}")
-          print(f"server\n{server_data}")
-          print(f"ui\n{ui_data}")
-          print(f"master\n{master_data}")
-          print("\n\n\n")
+          # Split data into columns (by spaces)
+          rows_to_append = [row.split() for row in data]

-          if isMaster and len(master_data) != 0:
-              print("uploading to master tab")
-              worksheet = sh.worksheet("master")
-              writeRowsToSpreadsheet(master_data, worksheet)
-              exit(0)
-
-          if len(engine_data) != 0:
-              print("uploading to engine tab")
-              writeRowsToSpreadsheet(engine_data, sh.worksheet("engine"))
-          if len(server_data) != 0:
-              print("uploading to server tab")
-              writeRowsToSpreadsheet(server_data, sh.worksheet("server"))
-          if len(ui_data) != 0:
-              print("uploading to ui tab")
-              writeRowsToSpreadsheet(ui_data, sh.worksheet("ui"))
+          for i, row in enumerate(rows_to_append):
+              worksheet.insert_row(row, start_row + i)

+          print(f"Uploaded {len(rows_to_append)} rows to '{project}' tab.")
          PYCODE
--- a/Docs/kovspec.md
+++ b/Docs/kovspec.md
@@ -1,125 +0,0 @@
-# Követelmény-specifikáció
-
-## 1. Áttekintés
-
-A jelen dokumentum célja, hogy bemutassa a CastlingCreations megrendelésére készülő Knightly nevű alkalmazás alapvető céljait, funkcionális és nem funkcionális követelményeinek áttekintését, valamint a fejlesztés kontextusát.
-
-A Knightly egy modern, digitális sakkalkalmazás, amely kezdetben helyi hálózaton (LAN) keresztül teszi lehetővé két játékos számára, hogy valós időben mérkőzzenek meg egymással. A rendszer egy grafikus felhasználói felületen keresztül biztosítja a játék indítását, a szerver futtatását és a másik félhez történő csatlakozást.
-
-A projekt hosszú távú célja, hogy a Knightly egy online platformmá fejlődjön, amely hasonló módon működik, mint a népszerű sakkportálok (pl. chess.com): a felhasználók fiókot hozhatnak létre, bejelentkezhetnek, és egy központi szerveren keresztül kereshetnek, illetve indíthatnak mérkőzéseket.
-
-A fejlesztés első szakasza azonban a LAN-alapú verzió megvalósítására koncentrál, amely a sakkjátszma logikai alapjainak, a játékállapot kezelésének és a hálózati kommunikáció modelljének megvalósítását célozza. A későbbi online verzió ezekre az alapokra építkezve bővíthető tovább.
-
-## 2. Vágyálom rendszer
-A vágyálom rendszer célja egy teljes körű, modern online sakkplatform létrehozása, amely nemcsak a klasszikus sakkjáték digitális megvalósítását kínálja, hanem egy közösségi, versenyképes és kényelmes felhasználói élményt is biztosít. A hosszú távú cél, hogy a rendszer működése és felépítése a nagyobb nemzetközi sakkoldalakhoz (például a chess.com-hoz vagy a lichess.org-hoz) hasonló legyen, de saját, könnyen kezelhető és letisztult felülettel.
-
-A felhasználók a rendszerben saját profilt hozhatnak létre, amellyel be tudnak jelentkezni, és részt vehetnek online mérkőzéseken más játékosok ellen. A rendszer automatikusan párosítaná őket ellenfelekkel, de lehetőséget adna arra is, hogy barátokat hívjanak meg privát meccsekre. A lejátszott mérkőzések mentésre kerülnének, így a játékosok bármikor visszanézhetnék vagy elemezhetnék azokat.
-
-A játék mellett a felhasználók statisztikákat is láthatnának magukról, például nyerési arányt, aktuális értékszámot (rating), leggyakoribb megnyitásokat, illetve fejlődési tendenciát az idő során. A rendszer ezen felül egy egyszerű chat funkciót is tartalmazna, hogy a játékosok kommunikálhassanak egymással a játszmák közben vagy akár azokon kívül is.
-
-A vágyálom rendszer alapját egy központi szerver képezné, amely kezeli a felhasználói fiókokat, a bejelentkezéseket, a matchmaking folyamatot, valamint a játékok futását és szinkronizálását. A szerver a kliensalkalmazásokkal valós idejű adatkapcsolatot tartana fenn, így a játék során minden lépés azonnal megjelenne a másik játékosnál is.
-
-A platform célja a megbízható és folyamatos működés, akár nagyobb terhelés mellett is. A rendszer fejlesztése során kiemelt szempont lenne a biztonság (adatvédelem, csalás elleni védelem), a stabil hálózati kommunikáció, valamint a bővíthetőség – például ranglisták, versenyek vagy mobilalkalmazás későbbi integrálásának lehetősége.
-
-Összességében a vágyálom rendszer egy minden szempontból teljes értékű, közösségorientált sakkalkalmazás lenne, amely a mostani, helyi hálózaton működő változatból fejlődne tovább egy interneten keresztül bárhonnan elérhető platformmá.
-## 4. Rendszer követelmények
-
-A rendszer célja egy kétjátékos sakkalkalmazás megvalósítása, amely alapvetően hálózati kapcsolat (LAN vagy internet) segítségével biztosítja a valós idejű játékot. A rendszer kliens–szerver architektúrán alapul, ahol az egyes komponensek jól elkülönülten, meghatározott feladatokat látnak el.
-
-### 4.1 Kötelező funkcionális követelmények
-
-A rendszernek az alábbi alapvető funkciókat mindenképpen biztosítania kell:
- Két játékos közötti sakkjátszma lebonyolítása, a hivatalos sakk szabályai alapján.
- A játékosok felváltva tehetnek lépéseket, a lépések érvényességét a kliens oldali logika ellenőrzi.
- A rendszer valós időben szinkronizálja a két kliens állapotát (mindkét fél ugyanazt a táblát látja).
- A játék vége (sakkmatt, patt, idő lejárta) automatikusan felismerésre kerül.
- A szerver egyidejűleg több játékot is képes kezelni (külön szobákban vagy sessionökben).
- A játékosok elindíthatnak új meccset, illetve befejezett játék után visszatérhetnek a főmenübe.
- A rendszer minden játékban egyedi azonosítót (Game ID) használ a játékállapot nyomon követéséhez.
- A kliens értesítéseket kap az ellenfél lépéseiről és a játék állapotváltozásairól.
-
-### 4.2 Kliens oldali követelmények
-
-A kliens felelős a játékos felhasználói élményéért, a grafikus megjelenítésért és a játéklogika helyi működéséért.
-
-A kliensnek tudnia kell:
- A sakk tábla és a figurák megjelenítése, lépések kezelése (egérkattintás vagy billentyűparancsok).
- Lépések érvényesítése és elküldése a szervernek.
- A szervertől érkező események (ellenfél lépése, állapotváltozás) feldolgozása és megjelenítése.
- Hibák és megszakadt kapcsolat kezelése (újracsatlakozási lehetőség).
- Saját IP vagy szerver cím megadása LAN esetén.
- Alapvető menürendszer (csatlakozás, szerverindítás, új játék, kilépés).
- A hálózati kommunikáció egységes formátumban történjen (pl. JSON alapú üzenetek).
-
-### 4.3 Szerver oldali követelmények
-
-A szerver feladata a kliensek közti kommunikáció kezelése, az állapotok szinkronizálása és a játék logikai integritásának megőrzése.
-
-A szervernek tudnia kell:
- Kapcsolatok fogadása és kezelése több kliens esetén is.
- Új játék (session) létrehozása és azonosító kiosztása.
- Üzenetek továbbítása a kliensek között (pl. lépés, visszajelzés, játék vége).
- A játékállapot naprakészen tartása és küldése mindkét félnek.
- Kapcsolat megszakadása esetén az érintett játék szüneteltetése vagy lezárása.
- Üzenetformátumok ellenőrzése és hibás adatok elutasítása.
- Kliensazonosítás és egyszerű hitelesítés (pl. játékosnév alapján).
- A kommunikáció biztonságos kezelése (üzenetduplikáció, szinkronizációs hibák elkerülése).
-
-### 4.4 A komponensek közti kommunikáció (szerződések)
-
-A rendszer komponensei egy meghatározott üzenetprotokollon keresztül kommunikálnak egymással.
-A kommunikáció kétirányú, valós idejű, és az alábbi szerződések szerint zajlik:
-
-A kliens minden lépést csak akkor hajt végre a felhasználói felületen, ha a szervertől visszaigazolást kapott az érvényességéről.
-A szerver az üzeneteket sorosítva, FIFO-elv szerint dolgozza fel, és broadcastolja a változásokat az adott játékhoz tartozó összes kliensnek.
-
-### 4.5 Nem funkcionális követelmények
-
- Megbízhatóság: a rendszernek stabilan kell működnie hálózati késleltetés és csomagvesztés esetén is.
- Teljesítmény: a szerver legalább 10 párhuzamos játékot képes kezelni érezhető lassulás nélkül.
- Biztonság: a kliens csak a szerver által engedélyezett parancsokat hajthatja végre.
- Bővíthetőség: a rendszer felépítése moduláris legyen, hogy később könnyen kiterjeszthető legyen (pl. online matchmaking).
- Platformfüggetlenség: a kliens és a szerver futtatható legyen Windows, Linux és esetleg webes környezetben.
- Karbantarthatóság: kódmodulok (logika, hálózat, UI) elkülönítése, jól dokumentált interfészekkel.
-
-### 4.6 Minimális technikai elvárások
-
- Programozási nyelv: Rust, C#, Python vagy más, hálózati alkalmazásokra alkalmas nyelv.
- Kommunikációs protokoll: TCP vagy WebSocket alapú kapcsolat.
- Adatcsere formátum: JSON.
- Grafikus felület: desktop GUI (pl. egérvezérlés, drag & drop lépés).
- Követelmény kliensoldalon: legalább 4 GB RAM, modern operációs rendszer.
- Követelmény szerveroldalon: 1 CPU mag, 512 MB RAM, állandó hálózati kapcsolat.
-
-## 5. Követelménylista
-
-### Szerver
-| Név | Verzió | Leírás |
-| --- | ------ | ------ |
-| **WebSocket**                  | 1.0    | A szerver és a kliens között folyamatos kétirányú kommunikációt biztosít. A kapcsolat létrejötte után a szerver valós időben képes fogadni és továbbítani az eseményeket (pl. lépés végrehajtása, állapotfrissítés). Hiba esetén a kapcsolat automatikusan újraépül.              |
-| **Kapcsolatok csoportosítása** | 1.0    | A szerver figyeli az elérhető, szabad klienseket, majd két szabad kapcsolatot automatikusan összerendel egy meccsbe. A csoportosítás után a játékosok azonos „room”-ba kerülnek, és a szerver biztosítja az egymás közötti adatkommunikációt.                                     |
-| **Kommunikáció az engine-nel** | 1.0    | A szerver a játékosoktól érkező lépéseket és játékinformációkat továbbítja az engine-nek feldolgozásra. Az engine válasza után a szerver visszaküldi az eredményt a klienseknek (pl. érvényes lépés, matt, patt). A kommunikáció aszinkron módon zajlik, válaszidő-ellenőrzéssel. |
-| **Kommunikáció a UI-al**       | 1.0    | A szerver WebSocket-en keresztül adatokat továbbít a felhasználói felület és az engine között. A UI által kért műveletek (pl. új meccs létrehozása, állapotlekérés) feldolgozását a szerver közvetíti.|
-### Engine
-| Név | Verzió | Leírás |
-| --- | ------ | ------ |
-| **Bitboard** | 1.0 | A játék táblaállapotát bitműveletekkel reprezentálja a hatékonyság érdekében. Minden bábu típus és szín külön bitmask-on kerül tárolásra, lehetővé téve a gyors lekérdezéseket és lépésellenőrzéseket. |
-| **Lépésgenerálás LUT** | 1.0 | Előre kiszámított lookup táblák segítségével gyorsítja a lépésgenerálást és szabályellenőrzést. Ez csökkenti a számítási időt, és optimalizálja az engine teljesítményét. |
-| **Lépésgenerálás** | 1.0 | A különböző bábutípusok (gyalog, bástya, futó, stb.) lépési logikáját valósítja meg. A függvények ellenőrzik a lépés érvényességét, figyelembe véve az aktuális állást, sakkhelyzetet és speciális szabályokat (pl. sáncolás, en passant). |
-| **Util függvények** | 1.0 | Segédfüggvények az engine belső működéséhez, például raycast műveletek, bitműveleti maszkok kezelése, valamint logikai ellenőrzések a lépések és ütések számításához. |
-
-### UI
-| Név | Verzió | Leírás |
-| --- | ------ | ------ |
-| **Belépés** | 1.0 | A felhasználó a kezdőképernyőn keresztül adhatja meg a nevét lokális játékhoz, vagy hitelesítheti magát online játékmód esetén. Hibás adatok esetén a rendszer figyelmeztetést küld. |
-| **Főmenü** | 1.0 | Az alkalmazás központi navigációs felülete, ahol a felhasználó meccset kereshet, új játékot indíthat lokálisan, vagy beállításokat módosíthat. A menü megjeleníti az aktuális státuszt (online/offline). |
-| **Játék** | 1.0 | A játékfelület megjeleníti a táblát, bábukat, lépéseket, és az aktuális játékállást. Támogatja mind az online, mind a lokális módot. A felület kezeli az interakciókat (lépéskattintás, visszavonás, végeredmény kijelzés). |
-| **Kommunikáció a szerverrel** | 1.0 | A kliens a szerveren keresztül kommunikál az engine-nel. A UI felel az üzenetek küldéséért (lépés, új játék, visszajelzés), valamint a szervertől kapott események vizuális megjelenítéséért. |
-
-
-### GitHub Actions (CI/CD)
-| Név | Leírás |
-| --- | ------ |
-| Folyamatos tesztelés | A projekt minden commit után automatikusan tesztelődik. A pipeline lefuttatja a teszteket, és értesítést küld hibás build esetén. |
-| Folyamatos integráció | Az új funkciók beolvadásakor a rendszer automatikusan integrálja a változtatásokat, új buildet hoz létre, és frissíti a fejlesztői környezetet. |
-| Tesztadatok | A tesztadatok legyenek elérhetőek egy táblázatban, dátummal ellátva. (Google Sheets) |
--- a/Docs/rendszerterv.md
+++ b/Docs/rendszerterv.md
@@ -0,0 +1,225 @@
+# Knightly — Rendszerterv (végleges architektúra)
+
+Ez a dokumentum a *Knightly* sakkprojekt végleges rendszertervét írja le. A terv a korábban megosztott draw.io diagramon alapul, és fejlesztésre kész, technikai + működési leírást egyaránt tartalmaz.
+
+---
+
+## Tartalom
+1. Összefoglaló célok
+2. Fő komponensek és szerepek
+3. Kommunikációs modell (WebSocket)
+4. Üzenetsémák (JSON) — szabványosított formátumok
+5. Matchmaking és meccskezelés
+6. Játékfolyamat (lifecycle)
+7. Engine integráció és validáció
+8. UI–Server–Engine adatáramlás
+9. Hálózat, üzemeltetés és deployment
+10. Biztonság és jogosultságok
+11. Naplózás, hibakezelés és monitoring
+12. Tesztelés és CI/CD integráció
+13. Üzemeltetési kézikönyv (runbook)
+14. Fejlesztési roadmap és ajánlott következő lépések
+15. Mellékletek — fontos konfigurációk, environment változók
+
+---
+
+## 1. Összefoglaló célok
+- Kisméretű, LAN-on vagy interneten keresztül futtatható sakk-szerver tervezése.
+- Stabil WebSocket alapú kommunikáció a UI (Rust) és a Server (Rust) között.
+- Egyszerű, megbízható matchmaking (sorbaállás) és 1v1 meccskezelés.
+- A szerver felel a meccsek létrehozásáért, a játék állapotáért és az engine-nek továbbított validálásért.
+- A rendszer skálázható alapokra épül, később központi (cloud) hosztolásra bővíthető.
+
+---
+
+## 2. Fő komponensek és szerepek
+
+### 2.1 UI (Client)
+- Nyelv: Rust (egységes platform). Desktop UI (pl. egui/Tauri/SDL stb.).
+- Feladatai: felhasználói interakció, önálló render, locale input, kliens-oldali lépésellenőrzés előzetes vizsgálata, WebSocket kapcsolat kezelése.
+- Kommunikáció: WebSocket (ws:// vagy wss://) a szerverrel.
+
+### 2.2 Server
+- Nyelv: Rust, aszinkron (`tokio`), WebSocket támogatás (`tokio-tungstenite` vagy `axum`+`tokio-tungstenite`).
+- Feladatai: kapcsolatok kezelése, matchmaking, meccsek életciklusa, üzenetek továbbítása, engine-hez való kommunikáció a lépések ellenőrzésére és szerepeltetésére.
+- Állapot: memória alapú strukturák (`players`, `waiting_queue`, `matches`), opcionális perzisztencia (logok, ranglista) később.
+
+### 2.3 Engine
+- Feladat: sakk-szabályok végrehajtása, lépések validálása, legális lépések listázása, opció: AI játékos.
+- Integrációs lehetőségek:
+  - könyvtárként (Rust crate) közvetlenül a szerveren belül, vagy
+  - külön folyamatként (stdin/stdout) vagy helyi RPC (Unix socket), illetve
+  - távoli szolgáltatás (gRPC/HTTP) később.
+
+---
+
+## 3. Kommunikációs modell (WebSocket)
+- Egy porton fut a WS szerver (pl. `0.0.0.0:8080`). Nem szükséges több port.
+- Minden kliens egyedi WebSocket kapcsolatot nyit. A szerver minden kapcsolatot azonosít (UUID vagy generált client id).
+- A szerver tartja a `tx` (küldő) csatornát minden csatlakozott játékoshoz, így onnan tud üzenetet küldeni.
+- Az üzenetek JSON formátumban érkeznek és mennek (text frames). Binary nem szükséges a kezdetekkor.
+
+**Kapcsolódási lépések:**
+1. UI csatlakozik → `Join` üzenet (felhasználónév).
+2. Szerver visszaad `Welcome` (player id) vagy `Error`.
+3. Keresés vagy hosting esetén a UI küld `FindMatch` vagy `HostLocal` parancsot.
+4. Szerver párosít és `MatchFound` üzenetet küld mindkét félnek, tartalmazza az ellenfél metaadatait és ki kezd.
+
+---
+
+## 4. Üzenetsémák (JSON)
+Az alábbiak a tervezett, szabványosított JSON üzenettípusok. Nem pszeudokód — egyszerű, pontos séma.
+
+### 4.1 **Client -> Server**
+- `Join`
+```json
+{ "type": "join", "username": "Alice" }
+```
+- `FindMatch` (sorbaállás)
+```json
+{ "type": "find_match", "mode": "1v1" }
+```
+- `HostLocal` (ha a kliens hostolni akarja a lokális meccset)
+```json
+{ "type": "host_local", "port": 9001 }
+```
+- `Move` (lépés beküldése)
+```json
+{ "type": "move", "from": "e2", "to": "e4", "promotion": null }
+```
+- `RequestLegalMoves`
+```json
+{ "type": "legal_moves", "fen": "..." }
+```
+- `Resign` / `OfferDraw` / `Chat` — hasonló egyszerű objektumok.
+
+### 4.2 **Server -> Client**
+- `Welcome`
+```json
+{ "type": "welcome", "player_id": "<uuid>" }
+```
+- `MatchFound`
+```json
+{ "type": "match_found", "match_id": "<uuid>", "opponent": {"id":"...","name":"Bob"}, "color": "white" }
+```
+- `OpponentMove`
+```json
+{ "type": "opponent_move", "from": "e2", "to": "e4", "promotion": null }
+```
+- `MoveResult` (valid/invalid, updated FEN, clocks)
+```json
+{ "type": "move_result", "valid": true, "fen": "...", "turn": "black" }
+```
+- `LegalMovesResponse`
+```json
+{ "type": "legal_moves", "moves": ["e2e4","d2d4"] }
+```
+- `Error` / `Info` / `GameEnd`
+
+---
+
+## 5. Matchmaking és meccskezelés
+- **Várólista (FIFO):** a `waiting_queue` (`VecDeque<Uuid>`) tartja a *FindMatch*-előket.
+- **Automatikus párosítás:** ha legalább két játékos van a várólistában, a szerver párba állítja őket és létrehoz egy `Match` struct-ot.
+- **Match struct tartalma:** `match_id`, `white_id`, `black_id`, `fen` (kezdőállás), `move_history`, `clocks`.
+- **Szereposztás:** véletlenszerű (érme dobás szerű) döntés vagy rang alapján.
+- **Állapotkezelés:** a szerver az egyetlen egységes állapotgazda; minden új lépés a szerveren kerül ellenőrzésre és csak ha valid, akkor broadcastolásra.
+
+**Különleges esetek:**
+- Ha egyik fél kilép a meccs közben → szerver értesíti az ellenfelet, meccs státusza `aborted` vagy `win_by_disconnect`.
+- Reconnect: ha a kliens újracsatlakozik, a szerver match-id alapján visszaállíthatja a játékot (ha ezt implementáljuk).
+
+---
+
+## 6. Játékfolyamat (lifecycle)
+1. **Csatlakozás:** client küld `join`, szerver visszaad `welcome`.
+2. **Keresés vagy hostolás:** client küld `find_match` vagy `host_local`.
+3. **Párosítás:** szerver párosít, küld `match_found` mindkét félnek.
+4. **Kezdés:** szerver küld kezdő FEN-t és azt, ki a fehér.
+5. **Lépés küldése:** player A küld `move` üzenetet.
+6. **Validálás:** szerver lekéri a félellenőrzést az engine-től (vagy saját szabályellenőrzés), ha valid → update `fen`, append `move_history`, küld `move_result` és `opponent_move` a másik félnek.
+7. **Végállapot:** ha matt/döntetlen/timeout → szerver `game_end` és törli match-t, kerül a statisztikákba.
+8. **Utak a menübe:** a játékosokat visszairányítjuk a főmenübe, match eltávolítva.
+
+---
+
+## 7. Engine integráció és validáció
+- **Ajánlott integráció:** a chess engine legyen Rust crate, amelyet a szerver hív pontos függvényekkel — így egyszerű és gyors. Ha nem lehetséges, használjunk helyi folyamatot (`stdin/stdout`), vagy IPC (Unix domain socket).
+- **Funkciók az engine-ben:** validálás (`is_move_legal`), lépések generálása (`generate_moves`), FEN kezelése, játék vége ellenőrzése.
+- **SLA/Timeout:** minden engine kéréshez legyen timeout (pl. 2s). Ha az engine nem válaszol → szerver fallback: elutasítja a lépést vagy elfogadja lokálisan, attól függően.
+
+---
+
+## 8. UI–Server–Engine adatáramlás
+- **Kliens → Szerver:** JSON üzenetek (lásd 4. rész).
+- **Szerver → Engine:** függvényhívás vagy IPC hívás a board állás kapcsán.
+- **Engine → Szerver:** válasz: legális/illegális, lehetséges lépések, új FEN.
+- **Szerver → Kliens(ek):** a véglegesített, validált lépést, valamint állapot- és hibainformációkat.
+
+---
+
+## 9. Hálózat, üzemeltetés és deployment
+- **Port:** alap WebSocket port (például `9001` vagy `8080`).
+- **Bind cím:** `0.0.0.0` (LAN- és DDNS-elérést is lehetővé téve), dev környezetben `127.0.0.1` is használható.
+- **Domain/DDNS:** a szerver elérhetővá tehető DDNS-en keresztül (pl. `mychess.ddns.net:9001`).
+- **TLS:** ha publikus elérés szükséges, használj `wss://` TLS-t — pl. reverse proxy (nginx) terminálja a TLS-t és belsőleg csatlakozik `ws://`-on.
+- **Self-hosted runner & CI:** a fejlesztői runner lehet persistens; minden workflow végén takarítás javasolt. Artefaktok feltöltése (logok) az Action-ökben.
+
+---
+
+## 10. Biztonság és jogosultságok
+- **Input validáció:** a szerver soha ne bízzon a kliensben — minden lépést validálni kell az engine-nel.
+- **Rate limiting:** egyszerű védelem (per IP/játékos) botok ellen.
+- **TLS:** javasolt publikus hosztingnál.
+- **Auth:** kezdetben opcionális, később token/username+password vagy OAuth implementálása.
+
+---
+
+## 11. Naplózás, hibakezelés és monitoring
+- **Naplózási szint:** `info` alap, `debug` fejlesztéshez.
+- **Naplófájlok:** per-meccs és per-játékos események — eseményeket timeframe-ekkel rögzíteni.
+- **Error handling:** minden külső hívás (engine, disk, network) timeout-tal és visszapattanó logikával kezelve legyen.
+- **Monitoring:** egyszerű health endpoint (HTTP) és process monitoring (systemd, Prometheus exporter később).
+
+---
+
+## 12. Tesztelés és CI/CD integráció
+- **Unit tesztek:** rule engine, move validation, matchmaker logic.
+- **Integration tesztek:** szerver–kliens kommunikáció; mock engine használata.
+- **CI:** GitHub Actions — teszt workflow-ok per-projekt (Engine/Server/UI). Rendszertervben előírt log exportálás a Google Sheets-be lehetőség.
+
+---
+
+## 13. Üzemeltetési kézikönyv (runbook)
+- **Indítás:** `cargo run --release` vagy systemd service. Ajánlott: service fájl, ami a runner felhasználó alatt fut.
+- **Stop:** graceful shutdown jelzés a futó meccsek befejezésére (vagy mentés után stop).
+- **Frissítés:** stop → pull → `cargo build --release` → restart.
+- **Hiba esetén:** ellenőrizd a naplókat, engine elérhetőségét, hálózati port forwardokat.
+
+---
+
+## 14. Fejlesztési roadmap és ajánlott következő lépések
+1. Alap WebSocket server implementáció és egyszerű client teszt (lokálisan).  
+2. Shared message schema (JSON) és basic `Join/FindMatch/Move` támogatás.  
+3. Matchmaker + in-memory match tárolás.  
+4. Engine integráció (egy egyszerű lib vagy local process).  
+5. Reconnect és állapot-szinkronizáció (sync_state).  
+6. TLS és reverse proxy beállítása (ha publikus).  
+7. Perzisztencia (match history, eredmények).  
+8. Skálázás (ha szükséges: több match host, load balancing, stateless match managers).
+
+---
+
+## 15. Mellékletek — fontos konfigurációk
+- **Environment változók**
+  - `SERVER_BIND=0.0.0.0:9001`
+  - `LOG_LEVEL=info`
+  - `ENGINE_PATH=/opt/knightly/engine` (ha külön process)
+- **Ajánlott crate-ek**: `tokio`, `tokio-tungstenite`, `serde`, `serde_json`, `uuid`, `tracing`.
+
+---
+
+## Záró megjegyzés
+Ez a dokumentum a diagram és a megbeszélések alapján készült. A terv elég részletes ahhoz, hogy a szerver fejlesztését megkezdjétek: tartalmazza az üzenetsémákat, a matchmaking logikát, az engine integrációs lehetőségeket és az üzemeltetési követelményeket.
+
+Ha szeretnéd, legközelebb tudok készíteni belőle egy rövidebb fejlesztői checklistát (sprint backlog), vagy generálhatok egy külön implementációs tervet (fájlok/funkciók szerinti bontás).
--- a/engine/Cargo.toml
+++ b/engine/Cargo.toml
@@ -4,4 +4,3 @@ version = "0.1.0"
 edition = "2024"

 [dependencies]
-once_cell = "1.19"
--- a/engine/src/bitboard.rs
+++ b/engine/src/bitboard.rs
@@ -1,2 +0,0 @@
-mod attackmaps;
-mod utils;
--- a/engine/src/bitboard/attackmaps.rs
+++ b/engine/src/bitboard/attackmaps.rs
@@ -1,252 +0,0 @@
-use once_cell::sync::Lazy;
-
-const A_FILE: u64 = 0x0101_0101_0101_0101;
-const H_FILE: u64 = 0x8080_8080_8080_8080;
-const AB_FILE: u64 = 0x0303_0303_0303_0303;
-const GH_FILE: u64 = 0xC0C0_C0C0_C0C0_C0C0;
-
-/*
- EXPLANATIONS:
- > square_index: 8 * rank number + file number (a-h = 0-7)
- > side: white = 0, black = 1
- > direction_index: 0..8 = [E, NE, N, NW, W, SW, S, SE]
-*/
-
-// KING_ATTACK_MAP[<square_index>]
-pub static KING_ATTACK_MAP: Lazy<[u64; 64]> = Lazy::new(|| {
-  let mut table: [u64; 64] = [0u64; 64];
-
-  for sq in 0..64 {
-    let king: u64 = 1 << sq;
-
-    let left_attacks: u64 = king << 7 | king >> 1 | king >> 9;
-    let right_attacks: u64 = king << 1 | king << 9 | king >> 7;
-
-    table[sq] = (left_attacks & !H_FILE) | (right_attacks & !A_FILE) | king << 8 | king >> 8;
-  }
-  return table;
-});
-
-// PAWN_ATTACK_MAP[<square_index>][<side>]
-pub static PAWN_ATTACK_MAP: Lazy<[[u64; 2]; 64]> = Lazy::new(|| {
-  let mut table: [[u64; 2]; 64] = [[0u64; 2]; 64];
-
-  for sq in 0..64 {
-    let pawn: u64 = 1 << sq;
-    table[sq][0] |= (pawn << 9) & !A_FILE;
-    table[sq][0] |= (pawn << 7) & !H_FILE;
-  }
-  for sq in 0..64 {
-    let pawn: u64 = 1 << sq;
-    table[sq][1] |= (pawn >> 9) & !H_FILE;
-    table[sq][1] |= (pawn >> 7) & !A_FILE;
-  }
-  return table;
-});
-
-// KNIGHT_ATTACK_MAP[<square_index>]
-pub static KNIGHT_ATTACK_MAP: Lazy<[u64; 64]> = Lazy::new(|| {
-  let mut table: [u64; 64] = [0u64; 64];
-
-  for sq in 0..64 {
-    let knight: u64 = 1 << sq;
-
-    let far_left_attacks: u64 = knight << 6 | knight >> 10;
-    let near_left_attacks: u64 = knight << 15 | knight >> 17;
-    let far_right_attacks: u64 = knight << 10 | knight >> 6;
-    let near_right_attacks: u64 = knight << 17 | knight >> 15;
-
-    table[sq] = (far_left_attacks & !GH_FILE) | (far_right_attacks & !AB_FILE) | (near_left_attacks & !H_FILE) | (near_right_attacks & !A_FILE);
-  }
-  return table;
-});
-
-// RAY_TABLE[<square_index>][<direction_index>]
-pub static RAY_TABLE: Lazy<[[u64; 8]; 64]> = Lazy::new(|| {
-  let mut table: [[u64; 8]; 64] = [[0u64; 8]; 64];
-  let dirs: [i8; 8] = [1, 9, 8, 7, -1, -9, -8, -7];
-  for sq in 0..64 {
-    for d in 0..8 {
-      let mut ray: u64 = 0u64;
-      let origin: u64 = 1 << sq;
-      let mut new_target: u64 =  if dirs[d] > 0 {origin << dirs[d]} else {origin >> -dirs[d]};
-      if [0, 1, 7].contains(&d) {
-        new_target &= !A_FILE;
-      }
-      else if [3, 4, 5].contains(&d) {
-        new_target &= !H_FILE;
-      }
-      while new_target != 0 {
-        ray |= new_target;
-
-        new_target =  if dirs[d] > 0 {new_target << dirs[d]} else {new_target >> -dirs[d]};
-        if [0, 1, 7].contains(&d) {
-          new_target &= !A_FILE;
-        }
-        else if [3, 4, 5].contains(&d) {
-          new_target &= !H_FILE;
-        }
-      }
-      table[sq][d] = ray;
-    }
-  }
-
-  return table;
-});
-
-
-
-// <----- TESTS ----->
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-  #[test]
-  fn test_king_attack_map() {
-
-    // test setup for corners [SW, SE, NW, NE]
-    let corner_indexes: [usize; 4] = [0, 7, 56, 63];
-    let corner_attack_maps: [u64; 4] = [
-      (1u64 << 1) | (1u64 << 8) | (1u64 << 9),
-      (1u64 << 6) | (1u64 << 14) | (1u64 << 15),
-      (1u64 << 48) | (1u64 << 49) | (1u64 << 57),
-      (1u64 << 54) | (1u64 << 55) | (1u64 << 62)
-    ];
-
-    // tests for corners
-    for index in 0..4 {
-      assert_eq!(KING_ATTACK_MAP[corner_indexes[index]], corner_attack_maps[index]);
-    }
-
-    // test setup for sides [S, E, W, N]
-    let side_indexes: [usize; 4] = [3, 31, 32, 60];
-    let side_attack_maps: [u64; 4] = [
-      (1 << 2) | (1 << 4) | (1 << 10) | (1 << 11) | (1 << 12),
-      (1 << 22) | (1 << 23) | (1 << 30) | (1 << 38) | (1 << 39),
-      (1 << 24) | (1 << 25) | (1 << 33) | (1 << 40) | (1 << 41),
-      (1 << 51) | (1 << 52) | (1 << 53) | (1 << 59) | (1 << 61)
-    ];
-
-    // tests for sides
-    for index in 0..4 {
-      assert_eq!(KING_ATTACK_MAP[side_indexes[index]], side_attack_maps[index]);
-    }
-
-    // test setup for center
-    let center_index: usize = 27;
-    let center_attack_map: u64 = (1 << 18) | (1 << 19) | (1 << 20) | (1 << 26) | (1 << 28) | (1 << 34) | (1 << 35) | (1 << 36);
-
-    // test for center
-    assert_eq!(KING_ATTACK_MAP[center_index], center_attack_map);
-
-  }
-
-  #[test]
-  fn test_pawn_attack_map() {
-
-    // test setup for white sides
-    let white_side_indexes: [usize; 2] = [24, 31];
-    let white_side_attack_maps: [u64; 2] = [
-      (1 << 33),
-      (1 << 38)
-    ];
-    // tests for white sides
-    for index in 0..2 {
-      assert_eq!(PAWN_ATTACK_MAP[white_side_indexes[index]][0], white_side_attack_maps[index])
-    }
-
-    // test setup for black sides
-    let black_side_indexes: [usize; 2] = [32, 39];
-    let black_side_attack_maps: [u64; 2] = [
-      (1 << 25),
-      (1 << 30)
-    ];
-    // tests for black sides
-    for index in 0..2 {
-      assert_eq!(PAWN_ATTACK_MAP[black_side_indexes[index]][1], black_side_attack_maps[index])
-    }
-
-    // test setup for white center
-    let white_center_indexes: [usize; 2] = [11, 12];
-    let white_center_attack_maps: [u64; 2] = [
-      (1 << 18) | (1 << 20),
-      (1 << 19) | (1 << 21)
-    ];
-    // tests for white center
-    for index in 0..2 {
-      assert_eq!(PAWN_ATTACK_MAP[white_center_indexes[index]][0], white_center_attack_maps[index])
-    }
-
-    // test setup for black center
-    let black_center_indexes: [usize; 2] = [51, 52];
-    let black_center_attack_maps: [u64; 2] = [
-      (1 << 42) | (1 << 44),
-      (1 << 43) | (1 << 45)
-    ];
-    // tests for black center
-    for index in 0..2 {
-      assert_eq!(PAWN_ATTACK_MAP[black_center_indexes[index]][1], black_center_attack_maps[index])
-    }
-  }
-
-  #[test]
-  fn test_knight_attack_map() {
-    // test setup for corners [SW, SE, NW, NE]
-    let corner_indexes: [usize; 4] = [0, 7, 56, 63];
-    let corner_attack_maps: [u64; 4] = [
-      (1 << 17) | (1 << 10),
-      (1 << 13) | (1 << 22),
-      (1 << 41) | (1 << 50),
-      (1 << 46) | (1 << 53)
-    ];
-
-    // tests for corners
-    for index in 0..4 {
-      assert_eq!(KNIGHT_ATTACK_MAP[corner_indexes[index]], corner_attack_maps[index]);
-    }
-
-    // test setup for sides [S, E, W, N]
-    let side_indexes: [usize; 4] = [3, 31, 32, 60];
-    let side_attack_maps: [u64; 4] = [
-      (1 << 9) | (1 << 13) | (1 << 18) | (1 << 20),
-      (1 << 14) | (1 << 21) | (1 << 37) | (1 << 46),
-      (1 << 17) | (1 << 26) | (1 << 42) | (1 << 49),
-      (1 << 43) | (1 << 45) | (1 << 50) | (1 << 54)
-    ];
-
-    // tests for sides
-    for index in 0..4 {
-      assert_eq!(KNIGHT_ATTACK_MAP[side_indexes[index]], side_attack_maps[index]);
-    }
-
-    // test setup for center
-    let center_index: usize = 27;
-    let center_attack_map: u64 = (1 << 10) | (1 << 12) | (1 << 17) | (1 << 21) | (1 << 33) | (1 << 37) | (1 << 42) | (1 << 44);
-
-    // test for center
-    assert_eq!(KNIGHT_ATTACK_MAP[center_index], center_attack_map);
-  }
-
-  #[test]
-  fn test_ray_table() {
-
-    // test setup for all directions from center
-    let starting_square_index: usize = 27;
-    let ray_masks: [u64; 8] = [
-      (1 << 28) | (1 << 29) | (1 << 30) | (1 << 31),
-      (1 << 36) | (1 << 45) | (1 << 54) | (1 << 63),
-      (1 << 35) | (1 << 43) | (1 << 51) | (1 << 59),
-      (1 << 34) | (1 << 41) | (1 << 48),
-      (1 << 26) | (1 << 25) | (1 << 24),
-      (1 << 18) | (1 << 9) | (1 << 0),
-      (1 << 19) | (1 << 11) | (1 << 3),
-      (1 << 20) | (1 << 13) | (1 << 6)
-    ];
-
-    // tests for all directions from starting_square
-    for direction in 0..8 {
-      assert_eq!(RAY_TABLE[starting_square_index][direction], ray_masks[direction]);
-    }
-  }
-}
--- a/engine/src/bitboard/utils.rs
+++ b/engine/src/bitboard/utils.rs
@@ -1,99 +0,0 @@
-#[inline(always)]
-pub fn pop_lsb(value: &mut u64) -> usize {
-  let idx = value.trailing_zeros() as usize;
-  *value &= !(1 << idx);
-  return idx;
-}
-
-#[inline(always)]
-pub fn pop_msb(value: &mut u64) -> usize {
-  let idx = 63 - value.leading_zeros() as usize;
-  *value &= !(1 << idx);
-  return idx;
-}
-
-const RANK_NUMBERS: [char; 8] = ['1', '2', '3', '4', '5', '6', '7', '8'];
-const FILE_LETTERS: [char; 8] = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
-pub fn notation_from_square_number(sq: u8) -> String {
-  let row = sq / 8;
-  let col = sq % 8;
-  let mut notation = String::new();
-
-  let row_not = RANK_NUMBERS[row as usize];
-  let col_not = FILE_LETTERS[col as usize];
-
-  notation.push(col_not);
-  notation.push(row_not);
-  return notation;
-}
-
-
-// <----- TESTS ----->
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-
-  #[test]
-  fn pop_lsb_test() {
-
-    // test setup
-    let test_values: [u64; 6] = [
-      0x8000_0000_0000_0000,
-      0x4E91_CF05_713E_451B,
-      0xD588_2D58_6962_34B0,
-      0x9581_3335_DCAB_1DD4,
-      0xBEAC_DBE0_903A_AC00,
-      0x01E8_C895_A6F0_0000
-    ];
-    let expected_values: [usize; 6] = [63, 0, 4, 2, 10, 20];
-
-    // tests
-    for index in 0..6 {
-      let mut test_value = test_values[index];
-      assert_eq!(pop_lsb(&mut test_value), expected_values[index])
-    }
-  }
-
-  #[test]
-  fn pop_msb_test() {
-    // test setup
-    let test_values: [u64; 6] = [
-      0x86D6_8EB0_96A8_8D1C,
-      0x0000_0000_0000_0001,
-      0x3809_24AF_A7AE_8129,
-      0x0277_DA36_3B31_86D9,
-      0x0000_C1C3_201C_0DB1,
-      0x0000_0203_0DE4_E944
-    ];
-    let expected_values: [usize; 6] = [63, 0, 61, 57, 47, 41];
-
-    // tests
-    for index in 0..6 {
-      let mut test_value = test_values[index];
-      assert_eq!(pop_msb(&mut test_value), expected_values[index])
-    }
-  }
-
-  #[test]
-  fn notation_from_square_number_test() {
-    // test setup
-    let square_indices: [u8; 8] = [1, 12, 22, 27, 32, 47, 53, 58];
-    let notations: [String; 8] = [
-      String::from("b1"),
-      String::from("e2"),
-      String::from("g3"),
-      String::from("d4"),
-      String::from("a5"),
-      String::from("h6"),
-      String::from("f7"),
-      String::from("c8")
-    ];
-
-    // tests
-    for index in 0..8 {
-      let notation = notation_from_square_number(square_indices[index].clone());
-      assert_eq!(notation, notations[index]);
-    }
-  }
-}
--- a/engine/src/main.rs
+++ b/engine/src/main.rs
@@ -1,5 +1,3 @@
-mod bitboard;
-
 fn main() {
    println!("Hello, world!");
 }
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -4,17 +4,3 @@ version = "0.1.0"
 edition = "2024"

 [dependencies]
-tokio = { version = "1", features = ["full"] }
-tokio-tungstenite = "0.21"
-tungstenite = "0.21"
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-futures-util = "0.3.31"
-url = "2.5.7"
-uuid = {version = "1.18.1", features = ["v4", "serde"] }
-anyhow = "1.0.100"
-rand = "0.9.2"
-
-[[bin]]
-name = "client"
-path = "src/bin/client.rs"
--- a/server/src/bin/client.rs
+++ b/server/src/bin/client.rs
@@ -1,208 +0,0 @@
-use futures_util::{SinkExt, StreamExt};
-use serde::{Deserialize, Serialize};
-use std::io::{self, Write};
-use tokio_tungstenite::{connect_async, tungstenite::Message};
-use url::Url;
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(tag = "type")]
-enum ClientMessage {
-    Join { username: String },
-    FindMatch,
-    Move { from: String, to: String },
-    Resign,
-    Chat { text: String },
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-struct ServerMessage {
-    #[serde(rename = "type")]
-    message_type: String,
-    player_id: Option<String>,
-    match_id: Option<String>,
-    opponent: Option<String>,
-    color: Option<String>,
-    reason: Option<String>,
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("Knightly Chess Client");
-    println!("========================");
-
-    // Get server address from user
-    print!("Enter server address [ws://127.0.0.1:9001]: ");
-    io::stdout().flush()?;
-    let mut server_addr = String::new();
-    io::stdin().read_line(&mut server_addr)?;
-    let server_addr = server_addr.trim();
-    let server_addr = if server_addr.is_empty() {
-        "ws://127.0.0.1:9001".to_string()
-    } else {
-        server_addr.to_string()
-    };
-
-    // Connect to server
-    println!("Connecting to {}...", server_addr);
-    let url = Url::parse(&server_addr)?;
-    let (ws_stream, _) = connect_async(url).await?;
-    println!("Connected to server!");
-
-    let (mut write, mut read) = ws_stream.split();
-
-    // Spawn a task to handle incoming messages
-    let read_handle = tokio::spawn(async move {
-        while let Some(message) = read.next().await {
-            match message {
-                Ok(msg) => {
-                    if msg.is_text() {
-                        let text = msg.to_text().unwrap();
-                        println!("\nServer: {}", text);
-
-                        // Try to parse as structured message
-                        if let Ok(parsed) = serde_json::from_str::<ServerMessage>(text) {
-                            match parsed.message_type.as_str() {
-                                "welcome" => {
-                                    if let Some(player_id) = parsed.player_id {
-                                        println!("Welcome! Your player ID: {}", player_id);
-                                    }
-                                }
-                                "match_found" => {
-                                    if let (Some(opponent), Some(color), Some(match_id)) =
-                                        (parsed.opponent, parsed.color, parsed.match_id)
-                                    {
-                                        println!(
-                                            "Match found! Opponent: {}, Color: {}, Match ID: {}",
-                                            opponent, color, match_id
-                                        );
-                                    }
-                                }
-                                "error" => {
-                                    if let Some(reason) = parsed.reason {
-                                        println!("Error: {}", reason);
-                                    }
-                                }
-                                _ => {}
-                            }
-                        }
-                    }
-                }
-                Err(e) => {
-                    eprintln!("Error receiving message: {}", e);
-                    break;
-                }
-            }
-        }
-    });
-
-    // Main loop for sending messages
-    println!("\nAvailable commands:");
-    println!("  join <username>    - Join the server");
-    println!("  findmatch          - Find a match");
-    println!("  move <from> <to>   - Make a move (e.g., move e2 e4)");
-    println!("  chat <message>     - Send chat message");
-    println!("  resign             - Resign from current game");
-    println!("  quit               - Exit client");
-    println!();
-
-    loop {
-        print!("➡️  Enter command: ");
-        io::stdout().flush()?;
-
-        let mut input = String::new();
-        io::stdin().read_line(&mut input)?;
-        let input = input.trim();
-
-        if input.is_empty() {
-            continue;
-        }
-
-        let parts: Vec<&str> = input.split_whitespace().collect();
-        let command = parts[0].to_lowercase();
-
-        match command.as_str() {
-            "quit" | "exit" => {
-                println!("👋 Goodbye!");
-                break;
-            }
-            "join" => {
-                if parts.len() >= 2 {
-                    let username = parts[1..].join(" ");
-                    let message = ClientMessage::Join { username };
-                    send_message(&mut write, &message).await?;
-                } else {
-                    println!("Usage: join <username>");
-                }
-            }
-            "findmatch" | "find" => {
-                let message = ClientMessage::FindMatch;
-                send_message(&mut write, &message).await?;
-                println!("🔍 Searching for a match...");
-            }
-            "move" => {
-                if parts.len() >= 3 {
-                    let from = parts[1].to_string();
-                    let to = parts[2].to_string();
-                    let message = ClientMessage::Move { from, to };
-                    send_message(&mut write, &message).await?;
-                    println!("♟️  Sent move: {} -> {}", parts[1], parts[2]);
-                } else {
-                    println!("Usage: move <from> <to> (e.g., move e2 e4)");
-                }
-            }
-            "chat" => {
-                if parts.len() >= 2 {
-                    let text = parts[1..].join(" ");
-                    let message = ClientMessage::Chat { text };
-                    send_message(&mut write, &message).await?;
-                } else {
-                    println!("Usage: chat <message>");
-                }
-            }
-            "resign" => {
-                let message = ClientMessage::Resign;
-                send_message(&mut write, &message).await?;
-                println!("Resigned from current game");
-            }
-            "help" => {
-                print_help();
-            }
-            _ => {
-                println!(
-                    "Unknown command: {}. Type 'help' for available commands.",
-                    command
-                );
-            }
-        }
-    }
-
-    // Cleanup
-    read_handle.abort();
-    Ok(())
-}
-
-async fn send_message(
-    write: &mut futures_util::stream::SplitSink<
-        tokio_tungstenite::WebSocketStream<
-            tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
-        >,
-        Message,
-    >,
-    message: &ClientMessage,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let json = serde_json::to_string(message)?;
-    write.send(Message::Text(json)).await?;
-    Ok(())
-}
-
-fn print_help() {
-    println!("\n📖 Available Commands:");
-    println!("  join <username>    - Register with a username");
-    println!("  findmatch          - Enter matchmaking queue");
-    println!("  move <from> <to>   - Make a chess move");
-    println!("  chat <message>     - Send chat to opponent");
-    println!("  resign             - Resign from current game");
-    println!("  help               - Show this help");
-    println!("  quit               - Exit the client");
-    println!();
-}
--- a/server/src/connection.rs
+++ b/server/src/connection.rs
@@ -1,218 +0,0 @@
-use futures_util::{SinkExt, StreamExt};
-use serde::{Deserialize, Serialize};
-use std::collections::{HashMap, VecDeque};
-use std::sync::Arc;
-use tokio::net::TcpStream;
-use tokio::sync::Mutex;
-use tokio_tungstenite::{WebSocketStream, tungstenite::Message};
-use uuid::Uuid;
-
-// Type definitions
-pub type Tx = futures_util::stream::SplitSink<WebSocketStream<TcpStream>, Message>;
-pub type ConnectionMap = Arc<Mutex<HashMap<Uuid, PlayerConnection>>>;
-pub type MatchMap = Arc<Mutex<HashMap<Uuid, GameMatch>>>;
-pub type WaitingQueue = Arc<Mutex<VecDeque<Uuid>>>;
-
-// Helper functions to create new instances
-pub fn new_connection_map() -> ConnectionMap {
-    Arc::new(Mutex::new(HashMap::new()))
-}
-
-pub fn new_match_map() -> MatchMap {
-    Arc::new(Mutex::new(HashMap::new()))
-}
-
-pub fn new_waiting_queue() -> WaitingQueue {
-    Arc::new(Mutex::new(VecDeque::new()))
-}
-
-#[derive(Debug)]
-pub struct PlayerConnection {
-    pub id: Uuid,
-    pub username: Option<String>,
-    pub tx: Tx,
-    pub current_match: Option<Uuid>,
-}
-
-#[derive(Debug, Clone)]
-pub struct GameMatch {
-    pub id: Uuid,
-    pub player_white: Uuid,
-    pub player_black: Uuid,
-    pub board_state: String,
-    pub move_history: Vec<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Step {
-    pub from: String,
-    pub to: String,
-}
-
-// Message sending utilities
-pub async fn send_message_to_player(
-    connections: &ConnectionMap,
-    player_id: Uuid,
-    message: &str,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let mut connections_lock = connections.lock().await;
-    if let Some(connection) = connections_lock.get_mut(&player_id) {
-        connection
-            .tx
-            .send(Message::Text(message.to_string()))
-            .await?;
-    }
-    Ok(())
-}
-
-pub async fn broadcast_to_all(connections: &ConnectionMap, message: &str) {
-    let mut connections_lock = connections.lock().await;
-    let mut dead_connections = Vec::new();
-
-    for (id, connection) in connections_lock.iter_mut() {
-        if let Err(e) = connection.tx.send(Message::Text(message.to_string())).await {
-            eprintln!("Failed to send to {}: {}", id, e);
-            dead_connections.push(*id);
-        }
-    }
-
-    // Clean up dead connections
-    for dead_id in dead_connections {
-        connections_lock.remove(&dead_id);
-    }
-}
-
-pub async fn broadcast_to_match(
-    connections: &ConnectionMap,
-    matches: &MatchMap,
-    match_id: Uuid,
-    message: &str,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let matches_lock = matches.lock().await;
-    if let Some(game_match) = matches_lock.get(&match_id) {
-        send_message_to_player(connections, game_match.player_white, message).await?;
-        send_message_to_player(connections, game_match.player_black, message).await?;
-    }
-    Ok(())
-}
-
-// Connection handler
-pub async fn handle_connection(
-    stream: TcpStream,
-    connections: ConnectionMap,
-    matches: MatchMap,
-    waiting_queue: WaitingQueue,
-    event_system: crate::events::EventSystem,
-) -> anyhow::Result<()> {
-    use tokio_tungstenite::accept_async;
-
-    let ws_stream = accept_async(stream).await?;
-    let (write, mut read) = ws_stream.split();
-
-    let player_id = Uuid::new_v4();
-
-    // Store the connection
-    {
-        let mut conn_map = connections.lock().await;
-        conn_map.insert(
-            player_id,
-            PlayerConnection {
-                id: player_id,
-                username: None,
-                tx: write,
-                current_match: None,
-            },
-        );
-    }
-
-    println!("New connection: {}", player_id);
-
-    // Send welcome message
-    let _ = send_message_to_player(
-        &connections,
-        player_id,
-        &format!(r#"{{"type": "welcome", "player_id": "{}"}}"#, player_id),
-    )
-    .await;
-
-    // Message processing loop
-    while let Some(Ok(message)) = read.next().await {
-        if message.is_text() {
-            let text = message.to_text()?;
-            println!("Received from {}: {}", player_id, text);
-
-            // TODO: Parse and handle message with event system
-            // This will be implemented when we integrate the event system
-        }
-    }
-
-    // Cleanup on disconnect
-    cleanup_player(player_id, &connections, &matches, &waiting_queue).await;
-    println!("Connection {} closed", player_id);
-
-    Ok(())
-}
-
-async fn cleanup_player(
-    player_id: Uuid,
-    connections: &ConnectionMap,
-    _matches: &MatchMap,
-    waiting_queue: &WaitingQueue,
-) {
-    // Remove from waiting queue
-    waiting_queue.lock().await.retain(|&id| id != player_id);
-
-    // Remove from connections
-    connections.lock().await.remove(&player_id);
-
-    println!("Cleaned up player {}", player_id);
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use uuid::Uuid;
-
-    #[tokio::test]
-    async fn test_send_message_to_nonexistent_player() {
-        let connections = new_connection_map();
-        let player_id = Uuid::new_v4();
-
-        let result = send_message_to_player(&connections, player_id, "test message").await;
-        assert!(result.is_ok(), "Should handle missing player gracefully");
-    }
-
-    #[tokio::test]
-    async fn test_broadcast_to_empty_connections() {
-        let connections = new_connection_map();
-
-        broadcast_to_all(&connections, "test broadcast").await;
-
-        let conn_map = connections.lock().await;
-        assert!(conn_map.is_empty(), "Connections should still be empty");
-    }
-
-    #[tokio::test]
-    async fn test_connection_cleanup() {
-        let connections = new_connection_map();
-        let matches = new_match_map();
-        let waiting_queue = new_waiting_queue();
-
-        let player_id = Uuid::new_v4();
-
-        {
-            waiting_queue.lock().await.push_back(player_id);
-            assert_eq!(waiting_queue.lock().await.len(), 1);
-        }
-
-        cleanup_player(player_id, &connections, &matches, &waiting_queue).await;
-
-        {
-            let queue = waiting_queue.lock().await;
-            assert!(
-                !queue.contains(&player_id),
-                "Player should be removed from waiting queue"
-            );
-        }
-    }
-}
--- a/server/src/events.rs
+++ b/server/src/events.rs
@@ -1,126 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use tokio::sync::Mutex;
-use tokio::sync::mpsc;
-use uuid::Uuid;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Step {
-    pub from: String,
-    pub to: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(tag = "type")]
-pub enum ClientEvent {
-    Join { username: String },
-    FindMatch,
-    Move { from: String, to: String },
-    Resign,
-    Chat { text: String },
-    RequestLegalMoves { fen: String },
-}
-
-#[derive(Debug)]
-pub enum ServerEvent {
-    PlayerJoined(Uuid, String),
-    PlayerLeft(Uuid),
-    PlayerJoinedQueue(Uuid),
-    PlayerJoinedMatch(Uuid, Uuid), // player_id, match_id
-    PlayerMove(Uuid, Step),
-    PlayerResigned(Uuid),
-    MatchCreated(Uuid, Uuid, Uuid), // match_id, white_id, black_id
-}
-
-pub struct EventSystem {
-    sender: mpsc::UnboundedSender<(Uuid, ClientEvent)>,
-    receiver: Arc<Mutex<mpsc::UnboundedReceiver<(Uuid, ClientEvent)>>>,
-}
-
-impl Clone for EventSystem {
-    fn clone(&self) -> Self {
-        Self {
-            sender: self.sender.clone(),
-            receiver: Arc::clone(&self.receiver),
-        }
-    }
-}
-
-impl EventSystem {
-    pub fn new() -> Self {
-        let (sender, receiver) = mpsc::unbounded_channel();
-        Self {
-            sender,
-            receiver: Arc::new(Mutex::new(receiver)),
-        }
-    }
-
-    pub async fn send_event(
-        &self,
-        player_id: Uuid,
-        event: ClientEvent,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        self.sender.send((player_id, event))?;
-        Ok(())
-    }
-
-    pub async fn next_event(&self) -> Option<(Uuid, ClientEvent)> {
-        let mut receiver = self.receiver.lock().await;
-        receiver.recv().await
-    }
-}
-
-impl Default for EventSystem {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use uuid::Uuid;
-
-    #[tokio::test]
-    async fn test_event_system_send_and_receive() {
-        let event_system = EventSystem::new();
-        let player_id = Uuid::new_v4();
-
-        let join_event = ClientEvent::Join {
-            username: "test_user".to_string(),
-        };
-
-        let send_result = event_system.send_event(player_id, join_event).await;
-        assert!(send_result.is_ok(), "Should send event successfully");
-
-        let received = event_system.next_event().await;
-        assert!(received.is_some(), "Should receive sent event");
-
-        let (received_id, received_event) = received.unwrap();
-        assert_eq!(received_id, player_id, "Should receive correct player ID");
-
-        match received_event {
-            ClientEvent::Join { username } => {
-                assert_eq!(username, "test_user", "Should receive correct username");
-            }
-            _ => panic!("Should receive Join event"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_event_system_clone() {
-        let event_system1 = EventSystem::new();
-        let event_system2 = event_system1.clone();
-
-        let player_id = Uuid::new_v4();
-        let event = ClientEvent::FindMatch;
-
-        event_system1.send_event(player_id, event).await.unwrap();
-
-        let received = event_system2.next_event().await;
-        assert!(
-            received.is_some(),
-            "Cloned event system should receive events"
-        );
-    }
-}
--- a/server/src/main.rs
+++ b/server/src/main.rs
@@ -1,54 +1,3 @@
-mod connection;
-mod events;
-mod matchmaking;
-use tokio::net::TcpListener;
-
-#[tokio::main]
-async fn main() -> anyhow::Result<()> {
-    let address = "0.0.0.0:9001";
-    let listener = TcpListener::bind(address).await?;
-    println!("Server running on ws://{}", address);
-
-    // Shared state initialization using the new helper functions
-    let connections = connection::new_connection_map();
-    let matches = connection::new_match_map();
-    let waiting_queue = connection::new_waiting_queue();
-
-    // Event system for communication between components
-    let event_system = events::EventSystem::new();
-
-    // Start matchmaking background task
-    let matchmaker = matchmaking::MatchmakingSystem::new(
-        connections.clone(),
-        matches.clone(),
-        waiting_queue.clone(),
-        event_system.clone(),
-    );
-    tokio::spawn(async move {
-        matchmaker.run().await;
-    });
-
-    // Main connection loop
-    while let Ok((stream, _)) = listener.accept().await {
-        let connections = connections.clone();
-        let matches = matches.clone();
-        let waiting_queue = waiting_queue.clone();
-        let event_system = event_system.clone();
-
-        tokio::spawn(async move {
-            if let Err(e) = connection::handle_connection(
-                stream,
-                connections,
-                matches,
-                waiting_queue,
-                event_system,
-            )
-            .await
-            {
-                eprintln!("Connection error: {}", e);
-            }
-        });
-    }
-
-    Ok(())
+fn main() {
+    println!("Hello, world!");
 }
--- a/server/src/matchmaking.rs
+++ b/server/src/matchmaking.rs
@@ -1,202 +0,0 @@
-use crate::connection::{ConnectionMap, GameMatch, MatchMap, WaitingQueue};
-use crate::events::EventSystem;
-use rand::random;
-use uuid::Uuid;
-
-pub struct MatchmakingSystem {
-    connections: ConnectionMap,
-    matches: MatchMap,
-    waiting_queue: WaitingQueue,
-    event_system: EventSystem,
-}
-
-impl MatchmakingSystem {
-    pub fn new(
-        connections: ConnectionMap,
-        matches: MatchMap,
-        waiting_queue: WaitingQueue,
-        event_system: EventSystem,
-    ) -> Self {
-        Self {
-            connections,
-            matches,
-            waiting_queue,
-            event_system,
-        }
-    }
-
-    pub async fn run(&self) {
-        loop {
-            self.try_create_match().await;
-            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-        }
-    }
-
-    async fn try_create_match(&self) {
-        let mut queue = self.waiting_queue.lock().await;
-
-        while queue.len() >= 2 {
-            let player1 = queue.pop_front().unwrap();
-            let player2 = queue.pop_front().unwrap();
-
-            let match_id = Uuid::new_v4();
-            let (white_player, black_player) = if random::<bool>() {
-                (player1, player2)
-            } else {
-                (player2, player1)
-            };
-
-            let game_match = GameMatch {
-                id: match_id,
-                player_white: white_player,
-                player_black: black_player,
-                board_state: "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1".to_string(),
-                move_history: Vec::new(),
-            };
-
-            // Store the match
-            self.matches.lock().await.insert(match_id, game_match);
-
-            // Update player connections
-            {
-                let mut conn_map = self.connections.lock().await;
-                if let Some(player) = conn_map.get_mut(&white_player) {
-                    player.current_match = Some(match_id);
-                }
-                if let Some(player) = conn_map.get_mut(&black_player) {
-                    player.current_match = Some(match_id);
-                }
-            }
-
-            // Notify players
-            self.notify_players(white_player, black_player, match_id)
-                .await;
-        }
-    }
-
-    async fn notify_players(&self, white: Uuid, black: Uuid, match_id: Uuid) {
-        let conn_map = self.connections.lock().await;
-
-        // Get opponent names
-        let white_name = conn_map
-            .get(&black)
-            .and_then(|c| c.username.as_deref())
-            .unwrap_or("Opponent");
-        let black_name = conn_map
-            .get(&white)
-            .and_then(|c| c.username.as_deref())
-            .unwrap_or("Opponent");
-
-        // Notify white player
-        if let Some(_) = conn_map.get(&white) {
-            let message = format!(
-                r#"{{"type": "match_found", "match_id": "{}", "opponent": "{}", "color": "white"}}"#,
-                match_id, black_name
-            );
-            let _ =
-                crate::connection::send_message_to_player(&self.connections, white, &message).await;
-        }
-
-        // Notify black player
-        if let Some(_) = conn_map.get(&black) {
-            let message = format!(
-                r#"{{"type": "match_found", "match_id": "{}", "opponent": "{}", "color": "black"}}"#,
-                match_id, white_name
-            );
-            let _ =
-                crate::connection::send_message_to_player(&self.connections, black, &message).await;
-        }
-
-        println!("Match created: {} (white) vs {} (black)", white, black);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::events::EventSystem;
-    use uuid::Uuid;
-
-    use crate::connection::new_connection_map;
-    use crate::connection::new_match_map;
-    use crate::connection::new_waiting_queue;
-
-    #[tokio::test]
-    async fn test_matchmaking_creates_matches() {
-        let connections = new_connection_map();
-        let matches = new_match_map();
-        let waiting_queue = new_waiting_queue();
-        let event_system = EventSystem::new();
-
-        let matchmaking = MatchmakingSystem::new(
-            connections.clone(),
-            matches.clone(),
-            waiting_queue.clone(),
-            event_system.clone(),
-        );
-
-        let player1 = Uuid::new_v4();
-        let player2 = Uuid::new_v4();
-
-        {
-            waiting_queue.lock().await.push_back(player1);
-            waiting_queue.lock().await.push_back(player2);
-        }
-
-        matchmaking.try_create_match().await;
-
-        {
-            let matches_map = matches.lock().await;
-            assert_eq!(matches_map.len(), 1, "Should create one match");
-
-            let game_match = matches_map.values().next().unwrap();
-            assert!(game_match.player_white == player1 || game_match.player_white == player2);
-            assert!(game_match.player_black == player1 || game_match.player_black == player2);
-            assert_ne!(
-                game_match.player_white, game_match.player_black,
-                "Players should be different"
-            );
-        }
-
-        {
-            let queue = waiting_queue.lock().await;
-            assert!(
-                queue.is_empty(),
-                "Waiting queue should be empty after matchmaking"
-            );
-        }
-    }
-
-    #[tokio::test]
-    async fn test_matchmaking_with_odd_players() {
-        let connections = new_connection_map();
-        let matches = new_match_map();
-        let waiting_queue = new_waiting_queue();
-        let event_system = EventSystem::new();
-
-        let matchmaking = MatchmakingSystem::new(
-            connections.clone(),
-            matches.clone(),
-            waiting_queue.clone(),
-            event_system.clone(),
-        );
-
-        let player1 = Uuid::new_v4();
-        {
-            waiting_queue.lock().await.push_back(player1);
-        }
-
-        matchmaking.try_create_match().await;
-
-        {
-            let matches_map = matches.lock().await;
-            assert!(
-                matches_map.is_empty(),
-                "Should not create match with only one player"
-            );
-
-            let queue = waiting_queue.lock().await;
-            assert_eq!(queue.len(), 1, "Should keep single player in queue");
-        }
-    }
-}
--- a/server/src/messages.rs
+++ b/server/src/messages.rs
@@ -1,36 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(tag = "type")]
-pub enum ServerMessage {
-    Welcome {
-        player_id: String,
-    },
-    MatchFound {
-        match_id: String,
-        opponent: String,
-        color: String,
-    },
-    GameStart {
-        fen: String,
-        white_time: u32,
-        black_time: u32,
-    },
-    MoveResult {
-        valid: bool,
-        from: String,
-        to: String,
-        new_fen: String,
-    },
-    OpponentMove {
-        from: String,
-        to: String,
-    },
-    GameEnd {
-        result: String,
-        reason: String,
-    },
-    Error {
-        reason: String,
-    },
-}
Author	SHA1	Message	Date
vargadavidlajos	6c2c9aeb10	added points 7-15 to rendszerterv.md	2025-11-15 20:19:35 +01:00
Bence	0dae3f9773	Rendszerterv első része az órán közösen megbeszéltek alapján	2025-11-12 11:20:54 +01:00