added points 7-15 to rendszerterv.md

.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
 

.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/

.github/workflows/release.yml

@@ -1,6 +1,7 @@
 name: Release build
 
 on:
+  pull_request:
   workflow_dispatch:
   workflow_call:
 

.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/

.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

.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/

.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":
+          worksheet = sh.worksheet(project)
-              isMaster = True
 
-          engine_data = []
+          # project name
-          server_data = []
+          data = lines[1:]
-          ui_data = []
-          master_data = []
 
-          for entry in lines:
+          #blank rows
-              if not isMaster and entry == "engine":
+          existing_rows = len(worksheet.get_all_values())
-                  project = "engine"
+          start_row = existing_rows + 3
-              elif not isMaster and entry == "server":
-                  project = "server"
-              elif not isMaster and entry == "ui":
-                  project = "ui"
 
-              if project == "engine" and entry != "engine":
+          # Split data into columns (by spaces)
-                  engine_data.append(entry)
+          rows_to_append = [row.split() for row in data]
-              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)
 
-          print("PRINTING FILTERED DATA\n\n")
+          for i, row in enumerate(rows_to_append):
-          print(f"engine\n{engine_data}")
+              worksheet.insert_row(row, start_row + i)
-          print(f"server\n{server_data}")
-          print(f"ui\n{ui_data}")
-          print(f"master\n{master_data}")
-          print("\n\n\n")
-
-          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"))
 
+          print(f"Uploaded {len(rows_to_append)} rows to '{project}' tab.")
           PYCODE

Docs/kovspec.md

@@ -1,187 +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á.
-
-## 3. Igényelt funkciók
-
-### Alapok
-- Két játékos közti sakkjátszma lebonyolítása.
-- Teljes szabályrendszer megvalósítása (érvényes lépések, sakk/sakkmatt/patt felismerése).
-- Új játék indítása.
-- Játékosok nevének megadása a játszma elején.
-- Felhasználóbarát grafikus felület (UI) – látható tábla, figurák, órák, státuszjelzések.
-- Játékoslépések vizuális kiemelése (pl. kijelölt mező, lehetséges lépések megjelenítése).
-- A játék állapotának kijelzése (folyamatban, sakk, matt, döntetlen).
-  
-### LAN és hálózati funkciók
-- „Szerver indítása” funkció – a játékos hostként indíthat egy helyi szervert.
-- „Csatlakozás” funkció – másik játékos IP-cím alapján tud csatlakozni.
-- Helyi hálózaton keresztüli valós idejű kommunikáció.
-- LAN játék automatikus felfedezése (broadcast keresés).
-- Játék mentése és visszatöltése hálózati módban.
-
-### Online vágyálom funkciók
-- Felhasználói regisztráció és bejelentkezés.
-- Jelszóval védett fiókok, email- vagy OAuth-alapú hitelesítés (Google, GitHub stb.).
-- Profiloldal megtekintése (név, avatar, statisztikák, értékszám).
-- Automatikus matchmaking rendszer.
-- Kézi játékindítás – meghívó küldése barátnak.
-- Játszmák mentése és visszajátszása.
-- Játszmaelemzés – lépések listázása, hibák kiemelése.
-- Webes felület vagy mobilalkalmazás támogatása.
-- Játék előzményeinek és statisztikáinak megtekintése (győzelmek, vereségek, döntetlenek).
-- Automatikus szervermentés és adatbázis szinkronizáció.
-
-### Felhasználói felület
-- Letisztult, reszponzív, platformfüggetlen felület (asztali és webes verzió).
-- Sötét/világos téma lehetősége.
-- Egyéni figurakészlet vagy tábla kinézet választása.
-- Animált figuramozgások.
-- Egérrel és billentyűzettel is vezérelhető játék.
-- Hangjelzések a lépésekhez és az idő lejártához.
-- Lépéselőzmények (move list) megjelenítése oldalt.
-- Tábla forgatásának lehetősége (pl. a fehér vagy fekete nézőpontból).
-- Állapotjelzők (sakk, matt, döntetlen, várakozás az ellenfélre).
-- Teljes képernyős mód.
-
-### Technikai / fejlesztői funkciók
-- Kliens–szerver architektúra.
-- REST API vagy WebSocket alapú kommunikáció.
-- Adatbázis a felhasználói adatok és meccsek tárolására (pl. SQLite, PostgreSQL, MongoDB).
-- Logolási és hibakezelési rendszer.
-- Automatikus mentés és adatvisszaállítás.
-- Verziókezelés (Git).
-- Tesztelhető, moduláris kódszerkezet (külön modulok: logika, UI, hálózat, adat).
-- Cross-platform működés (Windows, Linux, esetleg web).
-
-### További funkciók
-- Egyszemélyes mód (ember vs. gép, AI-bot).
-- Több nehézségi szintű AI.
-- Oktató mód (javasolt lépések, hibák magyarázata).
-- Hivatalos FEN/PGN formátum export/import.
-- Beépített sakkfeladványok, kihívások.
-- Érintéses vezérlés mobilon.
-- Többnyelvű felület (pl. magyar, angol).
-
-## 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) |

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).

engine/Cargo.toml

@@ -4,4 +4,3 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-once_cell = "1.19"

engine/src/bitboard.rs

@@ -1,9 +0,0 @@
-mod attackmaps;
-mod utils;
-mod legality;
-mod checkinfo;
-mod attacks;
-mod bitmove;
-mod movebuffer;
-
-pub mod board;

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]);
-    }
-  }
-}

engine/src/bitboard/attacks.rs

@@ -1,89 +0,0 @@
-use super::board::Board;
-use super::attackmaps::*;
-
-impl Board {
-
-  const RANK_2: u64 = 0x0000_0000_0000_FF00;
-  const RANK_7: u64 = 0x00FF_0000_0000_0000;
-
-  pub fn get_pseudo_pawn_moves(&self, sq: u32) -> u64 {
-    let pawn: u64 = 1 << sq;
-    let mut move_mask: u64 = 0u64;
-    let move_offset: i8 = 8 - 16 * self.side_to_move as i8;
-
-    let next_sq: u64 = if move_offset > 0 {pawn << move_offset} else {pawn >> -move_offset};
-    if (self.occupancy[2] & next_sq) == 0 {
-      move_mask |= next_sq;
-
-      if (self.side_to_move == 0 && pawn & Self::RANK_2 != 0)
-        || (self.side_to_move == 1 && pawn & Self::RANK_7 != 0) {
-
-        let next_sq: u64 = if move_offset > 0 {next_sq << move_offset} else {next_sq >> -move_offset};
-        if (self.occupancy[2] & next_sq) == 0 {
-          move_mask |= next_sq;
-        }
-      }
-    }
-
-    return move_mask;
-  }
-  #[inline]
-  pub fn get_pseudo_knight_moves(&self, sq: u32) -> u64 {
-    return KNIGHT_ATTACK_MAP[sq as usize];
-  }
-  #[inline]
-  pub fn get_pseudo_king_moves(&self, sq: u32) -> u64 {
-    return KING_ATTACK_MAP[sq as usize];
-  }
-  #[inline]
-  pub fn get_pseudo_pawn_captures(&self, sq: u32) -> u64 {
-    return PAWN_ATTACK_MAP[sq as usize][self.side_to_move as usize];
-  }
-  #[inline]
-  pub fn get_pseudo_opponent_pawn_captures(&self, sq: u32) -> u64 {
-    return PAWN_ATTACK_MAP[sq as usize][1 - self.side_to_move as usize];
-  }
-  #[inline]
-  pub fn get_pseudo_bishop_moves(&self, sq: u32) -> u64 {
-    let mut  moves = 0u64;
-    let sq  = sq as usize;
-    let occupancy = self.occupancy[2];
-    moves |= get_raycast_from_square_in_direction(occupancy, sq, 1);
-    moves |= get_raycast_from_square_in_direction(occupancy, sq, 3);
-    moves |= get_raycast_from_square_in_direction(occupancy, sq, 5);
-    moves |= get_raycast_from_square_in_direction(occupancy, sq, 7);
-
-    return moves;
-  }
-  #[inline]
-  pub fn get_pseudo_rook_moves(&self, sq: u32) -> u64 {
-    let mut moves: u64 = 0u64;
-    let occupancy = self.occupancy[2];
-    let sq = sq as usize;
-    moves |= get_raycast_from_square_in_direction(occupancy, sq, 0);
-    moves |= get_raycast_from_square_in_direction(occupancy, sq, 2);
-    moves |= get_raycast_from_square_in_direction(occupancy, sq, 4);
-    moves |= get_raycast_from_square_in_direction(occupancy, sq, 6);
-
-    return moves;
-  }
-  #[inline(always)]
-  pub fn get_pseudo_queen_moves(&self, sq: u32) -> u64 {
-    return self.get_pseudo_bishop_moves(sq) | self.get_pseudo_rook_moves(sq);
-  }
-}
-
-#[inline(always)]
-pub fn get_raycast_from_square_in_direction(occupancy: u64, sq: usize, dir: usize) -> u64 {
-  let is_up: bool = dir / 4 == 0;
-  let mut ray: u64 = RAY_TABLE[sq][dir];
-  let blockers: u64 = occupancy & ray;
-
-  if blockers != 0 {
-    let first_blocker: u32 = if is_up { blockers.trailing_zeros() } else { 63 - blockers.leading_zeros() };
-
-    ray &= !RAY_TABLE[first_blocker as usize][dir];
-  }
-
-  return ray;
-}

engine/src/bitboard/bitmove.rs

@@ -1,77 +0,0 @@
-use super::utils::*;
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub struct BitMove {
-
-  move_type: BitMoveType,
-  from_square: u8,
-  to_square: u8,
-  promotion_piece: Option<u8>
-}
-
-impl BitMove {
-
-  #[inline]
-  pub fn quiet(from: u8, to: u8, promotion_piece: Option<u8>) -> Self {
-    return Self {
-      move_type: BitMoveType::Quiet,
-      from_square: from,
-      to_square: to,
-      promotion_piece: promotion_piece
-    };
-  }
-  #[inline]
-  pub fn capture(from: u8, to: u8, promotion_piece: Option<u8>) -> Self {
-    return Self {
-      move_type: BitMoveType::Capture,
-      from_square: from,
-      to_square: to,
-      promotion_piece: promotion_piece
-    };
-  }
-  #[inline]
-  pub fn castle(from: u8, to: u8) -> Self {
-    return Self {
-      move_type: BitMoveType::Castle,
-      from_square: from,
-      to_square: to,
-      promotion_piece: None
-    };
-  }
-
-  #[inline(always)]
-  pub fn move_type(&self) -> BitMoveType {
-    return self.move_type;
-  }
-  #[inline(always)]
-  pub fn from_square(&self) -> u8 {
-    return self.from_square;
-  }
-  #[inline(always)]
-  pub fn to_square(&self) -> u8 {
-    return self.to_square;
-  }
-  #[inline(always)]
-  pub fn promotion_piece(&self) -> Option<u8> {
-    return self.promotion_piece;
-  }
-
-  pub fn uci_notation(&self) -> String {
-    let mut notation = notation_from_square_number(self.from_square());
-    notation.push_str(&notation_from_square_number(self.to_square()));
-
-    if let Some(promotion_piece) = self.promotion_piece {
-      notation.push(get_character_by_piece_id(promotion_piece).to_ascii_lowercase());
-    }
-
-    return notation;
-  }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub enum BitMoveType {
-  Quiet,
-  Capture,
-  Castle,
-  EnPassant
-}

engine/src/bitboard/board.rs

@@ -1,182 +0,0 @@
-use super::utils::try_get_square_number_from_notation;
-
-pub struct Board {
-  pub(in super) bitboards: [u64; 12],     // 0-5 -> white pieces (P, N, B, R, Q, K), 6-11 -> black pieces (p, n, b, r, q, k)
-  pub(in super) piece_board: [u8; 64],    // same as board indexes, 12 -> empty square
-  pub(in super) occupancy: [u64; 3],      // 0 -> white, 1 -> black, 2 -> combined
-  pub(in super) castling_rights: u8,      // 0b0000_KQkq
-  pub(in super) pinned_squares: [u8; 64], // 0 -> E-W, 1 -> NE-SW, 2 -> N-S, 3 -> SE-NW, 4 -> no pin
-  pub(in super) pin_mask: u64,            // 1 -> pin, 0 -> no pin
-  pub(in super) en_passant_square: u64,   // 1 -> ep square, 0 -> no ep square
-  pub(in super) side_to_move: u8          // 0 -> white to play, 1 -> black to play
-}
-
-impl Board {
-
-  pub fn new_clear() -> Self {
-    let mut bit_board: Self = Self {
-      bitboards: [0x0000_0000_0000_0000; 12],
-      piece_board: [12; 64],
-      occupancy: [0x0000_0000_0000_0000; 3],
-      castling_rights: 0b0000_0000,
-      pinned_squares: [4; 64],
-      pin_mask: 0u64,
-      en_passant_square: 0x0000_0000_0000_0000,
-      side_to_move: 0
-    };
-
-    return bit_board;
-  }
-  pub fn new() -> Self {
-    let mut bit_board: Board = Self {
-      bitboards: [0x0000_0000_0000_FF00,
-                0x0000_0000_0000_0042,
-                0x0000_0000_0000_0024,
-                0x0000_0000_0000_0081,
-                0x0000_0000_0000_0008,
-                0x0000_0000_0000_0010,
-                0x00FF_0000_0000_0000,
-                0x4200_0000_0000_0000,
-                0x2400_0000_0000_0000,
-                0x8100_0000_0000_0000,
-                0x0800_0000_0000_0000,
-                0x1000_0000_0000_0000],
-      piece_board: [12; 64],
-      occupancy: [0; 3],
-      castling_rights: 0b0000_1111,
-      pinned_squares: [4; 64],
-      pin_mask: 0u64,
-      en_passant_square: 0x0000_0000_0000_0000,
-      side_to_move: 0
-    };
-    bit_board.calc_occupancy();
-    bit_board.calc_piece_board();
-
-    return bit_board;
-  }
-  pub fn build(fen: &str) -> Self {
-    let mut board: Board = Board::new_clear();
-
-    let mut col: i32 = 0;
-    let mut row: i32 = 7;
-    let pieces: [char; 12] = ['p', 'n', 'b', 'r', 'q', 'k', 'P', 'N', 'B', 'R', 'Q', 'K'];
-    let mut coming_up: &str = fen;
-
-    for (i, c) in coming_up.chars().enumerate() {
-      if pieces.contains(&c) {
-        // board.place_piece(row*8 + col, c);
-        col += 1;
-      }
-      else if ('1'..='8').contains(&c) {
-        col += c.to_string().parse::<i32>().unwrap();
-      }
-      else if c == '/' {
-        row -= 1;
-        col = 0;
-      }
-      else {
-        coming_up = &coming_up[i+1..];
-        break;
-      }
-    }
-    board.calc_occupancy();
-    
-    match coming_up.chars().next().unwrap() {
-      'w' => board.side_to_move = 0,
-      'b' => board.side_to_move = 1,
-       _  => panic!("invalid fen notation / to be handled later")
-    }
-    coming_up = &coming_up[2..];
-
-    for (i, c) in coming_up.chars().enumerate() {
-      match c {
-        'K' => board.castling_rights |= 1 << 3,
-        'Q' => board.castling_rights |= 1 << 2,
-        'k' => board.castling_rights |= 1 << 1,
-        'q' => board.castling_rights |= 1,
-        '-' => {
-          coming_up = &coming_up[i+2..];
-          break;
-        }
-         _  => {
-          coming_up = &coming_up[i+1..];
-          break;
-        }
-      }
-    }
-    match coming_up.chars().next().unwrap() {
-      '-' => {
-          coming_up = &coming_up[1..];
-        }
-       _  => {
-          let notation = coming_up.split(' ').next().unwrap();
-          if let Ok(epsq_index) = try_get_square_number_from_notation(notation) {
-            board.en_passant_square = 1 << epsq_index;
-          }
-       }
-    }
-    board.calc_pinned_squares();
-    board.calc_piece_board();
-
-    return board;
-  }
-
-  #[inline(always)]
-  pub fn bitboards(&self, index: usize) -> u64 {
-    return self.bitboards[index];
-  }
-  #[inline(always)]
-  pub fn piece_board(&self, sq: u8) -> u8 {
-    return self.piece_board[sq as usize];
-  }
-  #[inline(always)]
-  pub fn occupancy(&self, side: usize) -> u64 {
-    return self.occupancy[side];
-  }
-  #[inline(always)]
-  pub fn castling_rights(&self) -> u8 {
-    return self.castling_rights;
-  }
-  #[inline(always)]
-  pub fn pinned_squares(&self, sq: usize) -> u8 {
-    return self.pinned_squares[sq];
-  }
-  #[inline(always)]
-  pub fn pin_mask(&self) -> u64 {
-    return self.pin_mask;
-  }
-  #[inline(always)]
-  pub fn en_passant_square(&self) -> u64 {
-    return self.en_passant_square;
-  }
-  #[inline(always)]
-  pub fn side_to_move(&self) -> u8 {
-    return self.side_to_move;
-  }
-
-  #[inline(always)]
-  pub fn current_king_square(&self) -> u32 {
-    return if self.side_to_move == 0 { self.bitboards[5].trailing_zeros() } else { self.bitboards[11].trailing_zeros() };
-  }
-
-  fn calc_occupancy(&mut self) {
-    self.occupancy = [0u64; 3];
-    for b in 0..6 {
-      self.occupancy[0] |= self.bitboards[b];
-    }
-    for b in 6..12 {
-      self.occupancy[1] |= self.bitboards[b];
-    }
-    self.occupancy[2] = self.occupancy[0] | self.occupancy[1];
-  }
-  fn calc_piece_board(&mut self) {
-    for sq in 0..64 {
-      for b in 0..12 {
-        if (self.bitboards[b as usize] & 1 << sq) != 0 {
-          self.piece_board[sq] = b;
-        }
-      }
-    }
-  }
-
-}

engine/src/bitboard/checkinfo.rs

@@ -1,21 +0,0 @@
-
-pub struct CheckInfo {
-  pub check_count: u8,
-  pub move_mask: u64
-}
-
-impl CheckInfo {
-
-  pub fn new() -> Self {
-    return Self {
-      check_count: 0,
-      move_mask: 0xFFFF_FFFF_FFFF_FFFF
-    }
-  }
-
-  #[inline(always)]
-  pub fn add_checker(&mut self, move_mask: u64) {
-    self.move_mask &= move_mask;
-    self.check_count += 1;
-  }
-}

engine/src/bitboard/legality.rs

@@ -1,48 +0,0 @@
-use super::board::Board;
-use super::attackmaps::RAY_TABLE;
-
-impl Board {
-
-  pub(in super) fn calc_pinned_squares(&mut self) {
-    self.pinned_squares = [4; 64];
-    self.pin_mask = 0u64;
-
-    let friendly_pieces: u64 = self.occupancy[self.side_to_move as usize];
-    let offset: usize = 6 * self.side_to_move as usize;
-    let king_board: u64 = self.bitboards[5 + offset];
-    let king_sq: u32 = king_board.trailing_zeros();
-    let opponent_queen_bishop_mask: u64 = self.bitboards[8 - offset] | self.bitboards[10 - offset];
-    let opponent_queen_rook_mask: u64 = self.bitboards[9 - offset] | self.bitboards[10 - offset];
-
-    // Queen-Rook directions
-    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_rook_mask, 0);
-    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_rook_mask, 2);
-    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_rook_mask, 4);
-    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_rook_mask, 6);
-
-    // Queen-Bishop directions
-    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_bishop_mask, 1);
-    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_bishop_mask, 3);
-    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_bishop_mask, 5);
-    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_bishop_mask, 7);
-  }
-
-  pub(in super) fn set_pinned_in_ray_direction(&mut self, king_sq: u32, friendly_pieces: u64, attackers: u64, dir: u8) {
-    let is_up: bool = dir / 4 == 0;
-    let mask: u64 = RAY_TABLE[king_sq as usize][dir as usize];
-    let blockers: u64 = self.occupancy[2] & mask;
-    if blockers == 0 { return; }
-    let first_blocker_sq: u32 = if is_up { blockers.trailing_zeros() } else { 63 - blockers.leading_zeros() };
-    if (friendly_pieces & 1 << first_blocker_sq) != 0 {
-      let blockers: u64 = blockers & !(1 << first_blocker_sq);
-      if blockers == 0 { return; }
-      let second_blocker_sq: u32 = if is_up { blockers.trailing_zeros() } else { 63 - blockers.leading_zeros() };
-
-      if (attackers & 1 << second_blocker_sq) != 0 {
-        self.pinned_squares[first_blocker_sq as usize] = dir % 4;
-        self.pin_mask |= 1 << first_blocker_sq;
-      }
-    }
-  }
-
-}

engine/src/bitboard/movebuffer.rs

@@ -1,44 +0,0 @@
-use super::bitmove::BitMove;
-
-pub struct MoveBuffer {
-
-  buffer: [BitMove; 256],
-  count: usize
-}
-
-impl MoveBuffer {
-
-  pub fn new() -> Self {
-    return Self {
-      buffer: [BitMove::quiet(0, 0, None); 256],
-      count: 0
-    };
-  }
-
-  #[inline]
-  pub fn add(&mut self, bitmove: BitMove) {
-    self.buffer[self.count] = bitmove;
-    self.count += 1;
-  }
-  #[inline]
-  pub fn append(&mut self, other: &MoveBuffer) {
-    self.buffer[self.count..self.count + other.count()].copy_from_slice(other.contents());
-    self.count += other.count();
-  }
-  #[inline(always)]
-  pub fn clear(&mut self) {
-    self.count = 0;
-  }
-  #[inline(always)]
-  pub fn count(&self) -> usize{
-    return self.count;
-  }
-  #[inline(always)]
-  pub fn get(&self, idx: usize) -> &BitMove {
-    return &self.buffer[idx];
-  }
-  #[inline(always)]
-  pub fn contents(&self) -> &[BitMove] {
-    return &self.buffer[0..self.count];
-  } 
-}

engine/src/bitboard/utils.rs

@@ -1,125 +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;
-}
-
-pub fn try_get_square_number_from_notation(notation: &str) -> Result<u8, ()> {
-
-  let file = match notation.chars().nth(0).unwrap() {
-    'a' => 0,
-    'b' => 1,
-    'c' => 2,
-    'd' => 3,
-    'e' => 4,
-    'f' => 5,
-    'g' => 6,
-    'h' => 7,
-     _  => { return Result::Err(()); }
-  };
-  if let Some(rank) = notation.chars().nth(1) {
-    return Result::Ok(file + 8 * (rank.to_digit(10).unwrap() as u8) - 8);
-  }
-  else {
-    return Result::Err(());
-  }
-}
-
-const PIECE_CHARACTERS: [char; 12] = ['P', 'N', 'B', 'R', 'Q', 'K', 'p', 'n', 'b', 'r', 'q', 'k'];
-pub fn get_character_by_piece_id(id: u8) -> char {
-  return PIECE_CHARACTERS[id as usize];
-}
-
-
-// <----- 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]);
-    }
-  }
-}

engine/src/boardsquare.rs

@@ -1,32 +0,0 @@
-
-pub struct BoardSquare {
-  pub x: usize,
-  pub y: usize
-}
-
-impl BoardSquare {
-
-  pub fn new() -> Self {
-    return Self{
-      x: 0,
-      y: 0
-    };
-  }
-
-  pub fn from_coord(x: usize, y: usize) -> Self {
-    
-    #[cfg(debug_assertions)]
-    {
-      if x > 7 {
-        println!("Warning: x coordinate of square is bigger than 7, it might not be on the board!");
-      }
-      if y > 7 {
-        println!("Warning: y coordinate of square is bigger than 7, it might not be on the board!");
-      }
-    }
-    return Self {
-      x: x,
-      y: y
-    };
-  }
-}

engine/src/chessmove.rs

@@ -1,71 +0,0 @@
-use crate::piecetype;
-
-use super::boardsquare::BoardSquare;
-use super::piecetype::PieceType;
-use super::movetype::MoveType;
-
-
-pub struct ChessMove {
-  pub move_type: MoveType,
-  pub piece_type: PieceType,
-  pub from_square: BoardSquare,
-  pub to_square: BoardSquare,
-  pub rook_from: BoardSquare,
-  pub rook_to: BoardSquare,
-  pub promotion_piece: Option<PieceType>
-}
-
-impl ChessMove {
-
-  pub fn quiet(
-    piece_type: PieceType,
-    from_square: BoardSquare,
-    to_square: BoardSquare,
-    promotion_piece: Option<PieceType>
-  ) -> Self {
-    return Self {
-      move_type: MoveType::Quiet,
-      piece_type: piece_type,
-      from_square: from_square,
-      to_square: to_square,
-      rook_from: BoardSquare::new(),
-      rook_to: BoardSquare::new(),
-      promotion_piece: promotion_piece
-    }
-  }
-
-  pub fn capture(
-    piece_type: PieceType,
-    from_square: BoardSquare,
-    to_square: BoardSquare,
-    promotion_piece: Option<PieceType>
-  ) -> Self {
-    return Self {
-      move_type: MoveType::Capture,
-      piece_type: piece_type,
-      from_square: from_square,
-      to_square: to_square,
-      rook_from: BoardSquare::new(),
-      rook_to: BoardSquare::new(),
-      promotion_piece: promotion_piece
-    }
-  }
-
-  pub fn castle(
-    piece_type: PieceType,
-    from_square: BoardSquare,
-    to_square: BoardSquare,
-    rook_from: BoardSquare,
-    rook_to: BoardSquare
-  ) -> Self {
-    return Self {
-      move_type: MoveType::Quiet,
-      piece_type: piece_type,
-      from_square: from_square,
-      to_square: to_square,
-      rook_from: rook_from,
-      rook_to: rook_to,
-      promotion_piece: None
-    }
-  }
-}

engine/src/gameend.rs

@@ -1,6 +0,0 @@
-
-pub enum GameEnd {
-  WhiteWon(String),
-  BlackWon(String),
-  Draw(String)
-}

engine/src/lib.rs

@@ -1,24 +0,0 @@
-mod bitboard;
-pub mod chessmove;
-pub mod piecetype;
-pub mod boardsquare;
-pub mod movetype;
-pub mod gameend;
-
-use chessmove::ChessMove;
-use gameend::GameEnd;
-
-pub fn get_available_moves(fen: &str) -> Vec<ChessMove> {
-  println!("get_available_moves answered");
-  return vec![];
-}
-
-pub fn is_game_over(fen: &str) -> Option<GameEnd> {
-  println!("is_game_over answered");
-  return None;
-}
-
-pub fn get_board_after_move(fen: &str, chess_move: &ChessMove) -> String {
-  println!("get_board_after_move answered");
-  return String::from("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
-}

engine/src/main.rs

@@ -1,5 +1,3 @@
-mod bitboard;
-
 fn main() {
     println!("Hello, world!");
 }

engine/src/movetype.rs

@@ -1,7 +0,0 @@
-
-pub enum MoveType {
-  Quiet,
-  Capture,
-  Castle,
-  EnPassant
-}

engine/src/piecetype.rs

@@ -1,15 +0,0 @@
-
-pub enum PieceType {
-  WhitePawn,
-  WhiteKnight,
-  WhiteBishop,
-  WhiteRook,
-  WhiteQueen,
-  WhiteKing,
-  BlackPawn,
-  BlackKnight,
-  BlackBishop,
-  BlackRook,
-  BlackQueen,
-  BlackKing
-}

server/Cargo.toml

@@ -4,13 +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"

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"
-            );
-        }
-    }
-}

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"
-        );
-    }
-}

server/src/main.rs

@@ -1,54 +1,3 @@
-mod connection;
+fn main() {
-mod events;
+    println!("Hello, world!");
-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(())
 }

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");
-        }
-    }
-}

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,
-    },
-}

ui/Cargo.toml

@@ -4,7 +4,3 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-eframe = "0.33.0"
-egui = "0.33.0"
-tokio-tungstenite = "0.28.0"
-winit = "0.30.12"

ui/src/main.rs

@@ -1,431 +1,3 @@
-use eframe::egui;
+fn main() {
-
+    println!("Hello, world!");
-fn main() -> eframe::Result<()> {
-    let options = eframe::NativeOptions{
-        viewport: egui::ViewportBuilder::default()
-            .with_fullscreen(true)
-            .with_min_inner_size(egui::vec2(800.0, 600.0)) // Minimum width, height
-            .with_inner_size(egui::vec2(7680.0, 4320.0)), // Initial size
-        ..Default::default()
-    };
-    eframe::run_native(
-    "Knightly",
-    options,
-    Box::new(|cc| {
-        let mut fonts = egui::FontDefinitions::default();
-        fonts.font_data.insert(
-            "symbols".to_owned(),
-            egui::FontData::from_static(include_bytes!("../fonts/DejaVuSans.ttf")).into(),
-        );
-        fonts
-            .families
-            .entry(egui::FontFamily::Proportional)
-            .or_default()
-            .insert(0, "symbols".to_owned());
-        cc.egui_ctx.set_fonts(fonts);
-        Ok(Box::new(ChessApp::default()))
-    }),
-)
-}
-
-#[derive(Clone, Copy, PartialEq, Debug)]
-enum Piece {
-    King(char),
-    Queen(char),
-    Rook(char),
-    Bishop(char),
-    Knight(char),
-    Pawn(char),
-    Empty,
-}
-
-impl Piece {
-    fn symbol(&self) -> &'static str {
-        match self {
-            Piece::King('w') => "♔",
-            Piece::Queen('w') => "♕",
-            Piece::Rook('w') => "♖",
-            Piece::Bishop('w') => "♗",
-            Piece::Knight('w') => "♘",
-            Piece::Pawn('w') => "♙",
-            Piece::King('b') => "♚",
-            Piece::Queen('b') => "♛",
-            Piece::Rook('b') => "♜",
-            Piece::Bishop('b') => "♝",
-            Piece::Knight('b') => "♞",
-            Piece::Pawn('b') => "♟︎",
-            Piece::Empty => "",
-            _ => "",
-        }
-    }
-}
-
-#[derive(PartialEq, Debug)]
-enum Turn {
-    White,
-    Black,
-}
-
-enum AppState {
-    MainMenu,
-    InGame,
-    Settings,
-}
-
-struct ChessApp {
-    fullscreen: bool,
-    resolutions: Vec<(u32, u32)>,
-    selected_resolution: usize,
-    state: AppState,
-    board: [[Piece; 8]; 8],
-    selected: Option<(usize, usize)>,
-    turn: Turn,
-    pending_settings: PendingSettings,
-    server_port: String,
-}
-
-#[derive(Default)]
-struct PendingSettings {
-    fullscreen: bool,
-    selected_resolution: usize,
-    server_port: String,
-}
-
-impl Default for ChessApp {
-    fn default() -> Self {
-        Self {
-            fullscreen: true,
-            resolutions: vec![
-                (1280, 720),
-                (1600, 900),
-                (1920, 1080),
-                (2560, 1440),
-                (3840, 2160),
-                (7680, 4320),
-            ],
-            selected_resolution: 2, // Default to 1920x1080
-            state: AppState::MainMenu,
-            board: Self::starting_board(),
-            selected: None,
-            turn: Turn::White,
-            pending_settings: PendingSettings::default(),
-            server_port: "8080".to_string(), // Default port
-        }
-    }
-}
-
-impl ChessApp {
-    fn starting_board() -> [[Piece; 8]; 8] {
-        use Piece::*;
-        [
-            [
-                Rook('b'),
-                Knight('b'),
-                Bishop('b'),
-                Queen('b'),
-                King('b'),
-                Bishop('b'),
-                Knight('b'),
-                Rook('b'),
-            ],
-            [Pawn('b'); 8],
-            [Empty; 8],
-            [Empty; 8],
-            [Empty; 8],
-            [Empty; 8],
-            [Pawn('w'); 8],
-            [
-                Rook('w'),
-                Knight('w'),
-                Bishop('w'),
-                Queen('w'),
-                King('w'),
-                Bishop('w'),
-                Knight('w'),
-                Rook('w'),
-            ],
-        ]
-    }
-
-    fn handle_click(&mut self, row: usize, col: usize) {
-        if let Some((r, c)) = self.selected {
-            let piece = self.board[r][c];
-            self.board[r][c] = Piece::Empty;
-            self.board[row][col] = piece;
-            self.selected = None;
-            self.turn = if self.turn == Turn::White {
-                Turn::Black
-            } else {
-                Turn::White
-            };
-        } else {
-            if self.board[row][col] != Piece::Empty {
-                self.selected = Some((row, col));
-            }
-        }
-    }
-
-    fn apply_settings(&mut self, ctx: &egui::Context) {
-        self.fullscreen = self.pending_settings.fullscreen;
-        self.selected_resolution = self.pending_settings.selected_resolution;
-        self.server_port = self.pending_settings.server_port.clone();
-        
-        if let Some(resolution) = self.resolutions.get(self.selected_resolution) {
-            ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(
-                egui::Vec2::new(resolution.0 as f32, resolution.1 as f32)
-            ));
-        }
-        
-        ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(self.fullscreen));
-    }
-
-    fn enter_settings(&mut self) {
-        self.pending_settings.fullscreen = self.fullscreen;
-        self.pending_settings.selected_resolution = self.selected_resolution;
-        self.pending_settings.server_port = self.server_port.clone();
-        self.state = AppState::Settings;
-    }
-}
-
-impl eframe::App for ChessApp {
-    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        match self.state {
-            AppState::MainMenu => {
-                egui::CentralPanel::default().show(ctx, |ui| {
-                    ui.vertical_centered(|ui| {
-                        ui.heading("♞ Knightly ♞");
-                        ui.add_space(30.0);
-
-                        if ui.add_sized([300.0, 60.0], egui::Button::new("Play")).clicked() {
-                            self.state = AppState::InGame;
-                        }
-                        ui.add_space(8.0);
-                        
-                        if ui.add_sized([300.0, 60.0], egui::Button::new("Settings")).clicked() {
-                            self.enter_settings();
-                        }
-                        ui.add_space(8.0);
-                        
-                        if ui
-                            .add_sized([300.0, 60.0], egui::Button::new("Quit"))
-                            .clicked()
-                        {
-                            std::process::exit(0);
-                        }
-                    });
-                });
-            }
-
-            AppState::Settings => {
-                egui::CentralPanel::default().show(ctx, |ui| {
-                    ui.vertical_centered(|ui| {
-                        ui.heading("Settings");
-                        ui.add_space(30.0);
-
-                        // Fullscreen toggle
-                        ui.horizontal(|ui| {
-                            ui.label("Fullscreen:");
-                            if ui.checkbox(&mut self.pending_settings.fullscreen, "").changed() {
-                                // If enabling fullscreen, we might want to disable resolution selection
-                            }
-                        });
-                        ui.add_space(10.0);
-
-                        // Resolution dropdown
-                        ui.horizontal(|ui| {
-                            ui.label("Resolution:");
-                            egui::ComboBox::new("resolution_combo", "")
-                                .selected_text(format!(
-                                    "{}x{}",
-                                    self.resolutions[self.pending_settings.selected_resolution].0,
-                                    self.resolutions[self.pending_settings.selected_resolution].1
-                                ))
-                                .show_ui(ui, |ui| {
-                                    for (i, &(width, height)) in self.resolutions.iter().enumerate() {
-                                        ui.selectable_value(
-                                            &mut self.pending_settings.selected_resolution,
-                                            i,
-                                            format!("{}x{}", width, height),
-                                        );
-                                    }
-                                });
-                        });
-                        ui.add_space(10.0);
-
-                        // Server port input field
-                        ui.horizontal(|ui| {
-                            ui.label("Local Server Port:");
-                            ui.add(egui::TextEdit::singleline(&mut self.pending_settings.server_port)
-                                .desired_width(100.0)
-                                .hint_text("8080"));
-                        });
-                        ui.add_space(30.0);
-
-                        // Apply and Cancel buttons
-                        ui.horizontal(|ui| {
-                            if ui.add_sized([140.0, 40.0], egui::Button::new("Apply")).clicked() {
-                                self.apply_settings(ctx);
-                                self.state = AppState::MainMenu;
-                            }
-                            
-                            if ui.add_sized([140.0, 40.0], egui::Button::new("Cancel")).clicked() {
-                                self.state = AppState::MainMenu;
-                            }
-                        });
-                    });
-                });
-            }
-
-            AppState::InGame => {
-                egui::TopBottomPanel::top("menu_bar").show(ctx, |ui| {
-                    ui.horizontal(|ui| {
-                        if ui.button("Main Menu").clicked() {
-                            self.state = AppState::MainMenu;
-                        }
-                        if ui.button("Settings").clicked() {
-                            self.enter_settings();
-                        }
-                        if ui.button("New Game").clicked() {
-                            *self = ChessApp::default();
-                            self.state = AppState::InGame;
-                        }
-                        ui.separator();
-                        ui.label(format!("Turn: {:?}", self.turn));
-                    });
-                });
-                
-                egui::CentralPanel::default().show(ctx, |ui| {
-                    ui.vertical_centered(|ui| {
-                        let full_avail = ui.available_rect_before_wrap();
-                        let board_tile = (full_avail.width().min(full_avail.height())) / 8.0;
-                        let board_size = board_tile * 8.0;
-                        
-                        // Create a child UI at the board position
-                        let (response, painter) = ui.allocate_painter(
-                            egui::Vec2::new(board_size, board_size),
-                            egui::Sense::click()
-                        );
-                        
-                        let board_rect = egui::Rect::from_center_size(
-                            full_avail.center(),
-                            egui::vec2(board_size, board_size)
-                        );
-                        
-                        // Draw the chess board
-                        let tile_size = board_size / 8.0;
-                        for row in 0..8 {
-                            for col in 0..8 {
-                                let color = if (row + col) % 2 == 0 {
-                                    egui::Color32::from_rgb(100, 97, 97)
-                                } else {
-                                    egui::Color32::from_rgb(217, 217, 217)
-                                };
-                                
-                                let rect = egui::Rect::from_min_size(
-                                    egui::Pos2::new(
-                                        board_rect.min.x + col as f32 * tile_size,
-                                        board_rect.min.y + row as f32 * tile_size
-                                    ),
-                                    egui::Vec2::new(tile_size, tile_size)
-                                );
-                                
-                                painter.rect_filled(rect, 0.0, color);
-                                
-                                // Draw piece
-                                let piece = self.board[row][col];
-                                if piece != Piece::Empty {
-                                    let symbol = piece.symbol();
-                                    let font_id = egui::FontId::proportional(tile_size * 0.75);
-                                    painter.text(
-                                        rect.center(),
-                                        egui::Align2::CENTER_CENTER,
-                                        symbol,
-                                        font_id,
-                                        if matches!(piece, Piece::King('w') | Piece::Queen('w') | Piece::Rook('w') | Piece::Bishop('w') | Piece::Knight('w') | Piece::Pawn('w')) {
-                                            egui::Color32::WHITE
-                                        } else {
-                                            egui::Color32::BLACK
-                                        }
-                                    );
-                                }
-                                
-                                // Draw selection highlight
-                                if self.selected == Some((row, col)) {
-                                    painter.rect_stroke(
-                                        rect, 
-                                        0.0, 
-                                        egui::Stroke::new(3.0, egui::Color32::RED),
-                                        egui::StrokeKind::Inside
-                                    );
-                                }
-                                
-                                // Handle clicks
-                                if ui.ctx().input(|i| i.pointer.primary_clicked()) {
-                                    let click_pos = ui.ctx().input(|i| i.pointer.interact_pos()).unwrap();
-                                    if rect.contains(click_pos) {
-                                        self.handle_click(row, col);
-                                    }
-                                }
-                            }
-                        }
-                    });
-                });
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn test_initial_board_setup() {
-        let app = ChessApp::default();
-        assert!(matches!(app.board[0][0], Piece::Rook('b')));
-        assert!(matches!(app.board[7][0], Piece::Rook('w')));
-
-        assert!(matches!(app.board[1][0], Piece::Pawn('b')));
-        assert!(matches!(app.board[6][0], Piece::Pawn('w')));
-    }
-    
-    #[test]
-    fn test_piece_symbols() {
-        assert_eq!(Piece::King('w').symbol(), "♔");
-        assert_eq!(Piece::King('b').symbol(), "♚");
-        assert_eq!(Piece::Empty.symbol(), "");
-    }
-    
-    #[test]
-    fn test_piece_selection() {
-        let mut app = ChessApp::default();
-        app.handle_click(6, 0);
-        assert_eq!(app.selected, Some((6, 0)));
-        app.handle_click(6, 0);
-        assert_eq!(app.selected, None);
-    }
-    
-    #[test]
-    fn test_piece_movement() {
-        let mut app = ChessApp::default();
-        // Select and move a piece
-        app.handle_click(6, 0); // Select white pawn
-        app.handle_click(5, 0); // Move to empty square
-        assert_eq!(app.board[6][0], Piece::Empty);
-        assert!(matches!(app.board[5][0], Piece::Pawn('w')));
-    }
-
-    #[test]
-    fn test_turn_switching() {
-        let mut app = ChessApp::default();
-        assert_eq!(app.turn, Turn::White);
-        app.handle_click(6, 0); // White selects
-        app.handle_click(5, 0); // White moves
-        assert_eq!(app.turn, Turn::Black); // Should now be Black's turn
-    }
-    
-    #[test]
-    fn test_server_port_default() {
-        let app = ChessApp::default();
-        assert_eq!(app.server_port, "8080");
-    }
 }