diff --git a/.github/workflows/dispatcher.yml b/.github/workflows/dispatcher.yml index fed6504..0524127 100644 --- a/.github/workflows/dispatcher.yml +++ b/.github/workflows/dispatcher.yml @@ -26,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 diff --git a/.github/workflows/engine_test.yml b/.github/workflows/engine_test.yml index 4590631..78683a4 100644 --- a/.github/workflows/engine_test.yml +++ b/.github/workflows/engine_test.yml @@ -1,7 +1,6 @@ name: Engine Tests on: - pull_request: workflow_dispatch: workflow_call: @@ -10,8 +9,6 @@ jobs: runs-on: self-hosted steps: - - uses: actions/checkout@v4 - - name: Run Engine tests run: | bash .github/workflows/test.sh engine/ diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index b3044b9..76e25a0 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -1,7 +1,6 @@ name: Release build on: - pull_request: workflow_dispatch: workflow_call: diff --git a/.github/workflows/server_test.yml b/.github/workflows/server_test.yml index f39eae5..7583a32 100644 --- a/.github/workflows/server_test.yml +++ b/.github/workflows/server_test.yml @@ -1,7 +1,6 @@ name: Server Tests on: - pull_request: workflow_dispatch: workflow_call: @@ -10,8 +9,6 @@ jobs: runs-on: self-hosted steps: - - uses: actions/checkout@v4 - - name: Run Server tests run: | bash .github/workflows/test.sh server/ diff --git a/.github/workflows/test.sh b/.github/workflows/test.sh index 1191005..856d6c5 100755 --- a/.github/workflows/test.sh +++ b/.github/workflows/test.sh @@ -30,8 +30,13 @@ 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 diff --git a/.github/workflows/ui_test.yml b/.github/workflows/ui_test.yml index 114283a..c20ad98 100644 --- a/.github/workflows/ui_test.yml +++ b/.github/workflows/ui_test.yml @@ -1,7 +1,6 @@ name: UI Tests on: - pull_request: workflow_dispatch: workflow_call: @@ -10,8 +9,6 @@ jobs: runs-on: self-hosted steps: - - uses: actions/checkout@v4 - - name: Run UI tests run: | bash .github/workflows/test.sh ui/ diff --git a/.github/workflows/upload_data.yml b/.github/workflows/upload_data.yml index 6cfe426..c0ab435 100644 --- a/.github/workflows/upload_data.yml +++ b/.github/workflows/upload_data.yml @@ -20,33 +20,77 @@ jobs: echo "$GOOGLE_SERVICE_ACCOUNT_JSON" > service_account.json python <<'PYCODE' - import gspread, json, time, subprocess + import gspread, json, 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() - worksheet = sh.worksheet(project) + if project == "master": + isMaster = True + + engine_data = [] + server_data = [] + ui_data = [] + master_data = [] - # project name - data = lines[1:] + for entry in lines: + if not isMaster and entry == "engine": + project = "engine" + elif not isMaster and entry == "server": + project = "server" + elif not isMaster and entry == "ui": + project = "ui" - #blank rows - existing_rows = len(worksheet.get_all_values()) - start_row = existing_rows + 3 + if project == "engine" and entry != "engine": + engine_data.append(entry) + elif project == "server" and entry != "server": + server_data.append(entry) + elif project == "ui" and entry != "ui": + ui_data.append(entry) + elif project == "master" and entry != "master": + master_data.append(entry) - # Split data into columns (by spaces) - rows_to_append = [row.split() for row in data] + print("PRINTING FILTERED DATA\n\n") + print(f"engine\n{engine_data}") + print(f"server\n{server_data}") + print(f"ui\n{ui_data}") + print(f"master\n{master_data}") + print("\n\n\n") - for i, row in enumerate(rows_to_append): - worksheet.insert_row(row, start_row + i) + 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 diff --git a/Docs/kovspec.md b/Docs/kovspec.md new file mode 100644 index 0000000..a90794f --- /dev/null +++ b/Docs/kovspec.md @@ -0,0 +1,125 @@ +# Követelmény-specifikáció + +## 1. Áttekintés + +A jelen dokumentum célja, hogy bemutassa a CastlingCreations megrendelésére készülő Knightly nevű alkalmazás alapvető céljait, funkcionális és nem funkcionális követelményeinek áttekintését, valamint a fejlesztés kontextusát. + +A Knightly egy modern, digitális sakkalkalmazás, amely kezdetben helyi hálózaton (LAN) keresztül teszi lehetővé két játékos számára, hogy valós időben mérkőzzenek meg egymással. A rendszer egy grafikus felhasználói felületen keresztül biztosítja a játék indítását, a szerver futtatását és a másik félhez történő csatlakozást. + +A projekt hosszú távú célja, hogy a Knightly egy online platformmá fejlődjön, amely hasonló módon működik, mint a népszerű sakkportálok (pl. chess.com): a felhasználók fiókot hozhatnak létre, bejelentkezhetnek, és egy központi szerveren keresztül kereshetnek, illetve indíthatnak mérkőzéseket. + +A fejlesztés első szakasza azonban a LAN-alapú verzió megvalósítására koncentrál, amely a sakkjátszma logikai alapjainak, a játékállapot kezelésének és a hálózati kommunikáció modelljének megvalósítását célozza. A későbbi online verzió ezekre az alapokra építkezve bővíthető tovább. + +## 2. Vágyálom rendszer +A vágyálom rendszer célja egy teljes körű, modern online sakkplatform létrehozása, amely nemcsak a klasszikus sakkjáték digitális megvalósítását kínálja, hanem egy közösségi, versenyképes és kényelmes felhasználói élményt is biztosít. A hosszú távú cél, hogy a rendszer működése és felépítése a nagyobb nemzetközi sakkoldalakhoz (például a chess.com-hoz vagy a lichess.org-hoz) hasonló legyen, de saját, könnyen kezelhető és letisztult felülettel. + +A felhasználók a rendszerben saját profilt hozhatnak létre, amellyel be tudnak jelentkezni, és részt vehetnek online mérkőzéseken más játékosok ellen. A rendszer automatikusan párosítaná őket ellenfelekkel, de lehetőséget adna arra is, hogy barátokat hívjanak meg privát meccsekre. A lejátszott mérkőzések mentésre kerülnének, így a játékosok bármikor visszanézhetnék vagy elemezhetnék azokat. + +A játék mellett a felhasználók statisztikákat is láthatnának magukról, például nyerési arányt, aktuális értékszámot (rating), leggyakoribb megnyitásokat, illetve fejlődési tendenciát az idő során. A rendszer ezen felül egy egyszerű chat funkciót is tartalmazna, hogy a játékosok kommunikálhassanak egymással a játszmák közben vagy akár azokon kívül is. + +A vágyálom rendszer alapját egy központi szerver képezné, amely kezeli a felhasználói fiókokat, a bejelentkezéseket, a matchmaking folyamatot, valamint a játékok futását és szinkronizálását. A szerver a kliensalkalmazásokkal valós idejű adatkapcsolatot tartana fenn, így a játék során minden lépés azonnal megjelenne a másik játékosnál is. + +A platform célja a megbízható és folyamatos működés, akár nagyobb terhelés mellett is. A rendszer fejlesztése során kiemelt szempont lenne a biztonság (adatvédelem, csalás elleni védelem), a stabil hálózati kommunikáció, valamint a bővíthetőség – például ranglisták, versenyek vagy mobilalkalmazás későbbi integrálásának lehetősége. + +Összességében a vágyálom rendszer egy minden szempontból teljes értékű, közösségorientált sakkalkalmazás lenne, amely a mostani, helyi hálózaton működő változatból fejlődne tovább egy interneten keresztül bárhonnan elérhető platformmá. +## 4. Rendszer követelmények + +A rendszer célja egy kétjátékos sakkalkalmazás megvalósítása, amely alapvetően hálózati kapcsolat (LAN vagy internet) segítségével biztosítja a valós idejű játékot. A rendszer kliens–szerver architektúrán alapul, ahol az egyes komponensek jól elkülönülten, meghatározott feladatokat látnak el. + +### 4.1 Kötelező funkcionális követelmények + +A rendszernek az alábbi alapvető funkciókat mindenképpen biztosítania kell: +- Két játékos közötti sakkjátszma lebonyolítása, a hivatalos sakk szabályai alapján. +- A játékosok felváltva tehetnek lépéseket, a lépések érvényességét a kliens oldali logika ellenőrzi. +- A rendszer valós időben szinkronizálja a két kliens állapotát (mindkét fél ugyanazt a táblát látja). +- A játék vége (sakkmatt, patt, idő lejárta) automatikusan felismerésre kerül. +- A szerver egyidejűleg több játékot is képes kezelni (külön szobákban vagy sessionökben). +- A játékosok elindíthatnak új meccset, illetve befejezett játék után visszatérhetnek a főmenübe. +- A rendszer minden játékban egyedi azonosítót (Game ID) használ a játékállapot nyomon követéséhez. +- A kliens értesítéseket kap az ellenfél lépéseiről és a játék állapotváltozásairól. + +### 4.2 Kliens oldali követelmények + +A kliens felelős a játékos felhasználói élményéért, a grafikus megjelenítésért és a játéklogika helyi működéséért. + +A kliensnek tudnia kell: +- A sakk tábla és a figurák megjelenítése, lépések kezelése (egérkattintás vagy billentyűparancsok). +- Lépések érvényesítése és elküldése a szervernek. +- A szervertől érkező események (ellenfél lépése, állapotváltozás) feldolgozása és megjelenítése. +- Hibák és megszakadt kapcsolat kezelése (újracsatlakozási lehetőség). +- Saját IP vagy szerver cím megadása LAN esetén. +- Alapvető menürendszer (csatlakozás, szerverindítás, új játék, kilépés). +- A hálózati kommunikáció egységes formátumban történjen (pl. JSON alapú üzenetek). + +### 4.3 Szerver oldali követelmények + +A szerver feladata a kliensek közti kommunikáció kezelése, az állapotok szinkronizálása és a játék logikai integritásának megőrzése. + +A szervernek tudnia kell: +- Kapcsolatok fogadása és kezelése több kliens esetén is. +- Új játék (session) létrehozása és azonosító kiosztása. +- Üzenetek továbbítása a kliensek között (pl. lépés, visszajelzés, játék vége). +- A játékállapot naprakészen tartása és küldése mindkét félnek. +- Kapcsolat megszakadása esetén az érintett játék szüneteltetése vagy lezárása. +- Üzenetformátumok ellenőrzése és hibás adatok elutasítása. +- Kliensazonosítás és egyszerű hitelesítés (pl. játékosnév alapján). +- A kommunikáció biztonságos kezelése (üzenetduplikáció, szinkronizációs hibák elkerülése). + +### 4.4 A komponensek közti kommunikáció (szerződések) + +A rendszer komponensei egy meghatározott üzenetprotokollon keresztül kommunikálnak egymással. +A kommunikáció kétirányú, valós idejű, és az alábbi szerződések szerint zajlik: + +A kliens minden lépést csak akkor hajt végre a felhasználói felületen, ha a szervertől visszaigazolást kapott az érvényességéről. +A szerver az üzeneteket sorosítva, FIFO-elv szerint dolgozza fel, és broadcastolja a változásokat az adott játékhoz tartozó összes kliensnek. + +### 4.5 Nem funkcionális követelmények + +- Megbízhatóság: a rendszernek stabilan kell működnie hálózati késleltetés és csomagvesztés esetén is. +- Teljesítmény: a szerver legalább 10 párhuzamos játékot képes kezelni érezhető lassulás nélkül. +- Biztonság: a kliens csak a szerver által engedélyezett parancsokat hajthatja végre. +- Bővíthetőség: a rendszer felépítése moduláris legyen, hogy később könnyen kiterjeszthető legyen (pl. online matchmaking). +- Platformfüggetlenség: a kliens és a szerver futtatható legyen Windows, Linux és esetleg webes környezetben. +- Karbantarthatóság: kódmodulok (logika, hálózat, UI) elkülönítése, jól dokumentált interfészekkel. + +### 4.6 Minimális technikai elvárások + +- Programozási nyelv: Rust, C#, Python vagy más, hálózati alkalmazásokra alkalmas nyelv. +- Kommunikációs protokoll: TCP vagy WebSocket alapú kapcsolat. +- Adatcsere formátum: JSON. +- Grafikus felület: desktop GUI (pl. egérvezérlés, drag & drop lépés). +- Követelmény kliensoldalon: legalább 4 GB RAM, modern operációs rendszer. +- Követelmény szerveroldalon: 1 CPU mag, 512 MB RAM, állandó hálózati kapcsolat. + +## 5. Követelménylista + +### Szerver +| Név | Verzió | Leírás | +| --- | ------ | ------ | +| **WebSocket** | 1.0 | A szerver és a kliens között folyamatos kétirányú kommunikációt biztosít. A kapcsolat létrejötte után a szerver valós időben képes fogadni és továbbítani az eseményeket (pl. lépés végrehajtása, állapotfrissítés). Hiba esetén a kapcsolat automatikusan újraépül. | +| **Kapcsolatok csoportosítása** | 1.0 | A szerver figyeli az elérhető, szabad klienseket, majd két szabad kapcsolatot automatikusan összerendel egy meccsbe. A csoportosítás után a játékosok azonos „room”-ba kerülnek, és a szerver biztosítja az egymás közötti adatkommunikációt. | +| **Kommunikáció az engine-nel** | 1.0 | A szerver a játékosoktól érkező lépéseket és játékinformációkat továbbítja az engine-nek feldolgozásra. Az engine válasza után a szerver visszaküldi az eredményt a klienseknek (pl. érvényes lépés, matt, patt). A kommunikáció aszinkron módon zajlik, válaszidő-ellenőrzéssel. | +| **Kommunikáció a UI-al** | 1.0 | A szerver WebSocket-en keresztül adatokat továbbít a felhasználói felület és az engine között. A UI által kért műveletek (pl. új meccs létrehozása, állapotlekérés) feldolgozását a szerver közvetíti.| +### Engine +| Név | Verzió | Leírás | +| --- | ------ | ------ | +| **Bitboard** | 1.0 | A játék táblaállapotát bitműveletekkel reprezentálja a hatékonyság érdekében. Minden bábu típus és szín külön bitmask-on kerül tárolásra, lehetővé téve a gyors lekérdezéseket és lépésellenőrzéseket. | +| **Lépésgenerálás LUT** | 1.0 | Előre kiszámított lookup táblák segítségével gyorsítja a lépésgenerálást és szabályellenőrzést. Ez csökkenti a számítási időt, és optimalizálja az engine teljesítményét. | +| **Lépésgenerálás** | 1.0 | A különböző bábutípusok (gyalog, bástya, futó, stb.) lépési logikáját valósítja meg. A függvények ellenőrzik a lépés érvényességét, figyelembe véve az aktuális állást, sakkhelyzetet és speciális szabályokat (pl. sáncolás, en passant). | +| **Util függvények** | 1.0 | Segédfüggvények az engine belső működéséhez, például raycast műveletek, bitműveleti maszkok kezelése, valamint logikai ellenőrzések a lépések és ütések számításához. | + +### UI +| Név | Verzió | Leírás | +| --- | ------ | ------ | +| **Belépés** | 1.0 | A felhasználó a kezdőképernyőn keresztül adhatja meg a nevét lokális játékhoz, vagy hitelesítheti magát online játékmód esetén. Hibás adatok esetén a rendszer figyelmeztetést küld. | +| **Főmenü** | 1.0 | Az alkalmazás központi navigációs felülete, ahol a felhasználó meccset kereshet, új játékot indíthat lokálisan, vagy beállításokat módosíthat. A menü megjeleníti az aktuális státuszt (online/offline). | +| **Játék** | 1.0 | A játékfelület megjeleníti a táblát, bábukat, lépéseket, és az aktuális játékállást. Támogatja mind az online, mind a lokális módot. A felület kezeli az interakciókat (lépéskattintás, visszavonás, végeredmény kijelzés). | +| **Kommunikáció a szerverrel** | 1.0 | A kliens a szerveren keresztül kommunikál az engine-nel. A UI felel az üzenetek küldéséért (lépés, új játék, visszajelzés), valamint a szervertől kapott események vizuális megjelenítéséért. | + + +### GitHub Actions (CI/CD) +| Név | Leírás | +| --- | ------ | +| Folyamatos tesztelés | A projekt minden commit után automatikusan tesztelődik. A pipeline lefuttatja a teszteket, és értesítést küld hibás build esetén. | +| Folyamatos integráció | Az új funkciók beolvadásakor a rendszer automatikusan integrálja a változtatásokat, új buildet hoz létre, és frissíti a fejlesztői környezetet. | +| Tesztadatok | A tesztadatok legyenek elérhetőek egy táblázatban, dátummal ellátva. (Google Sheets) | diff --git a/engine/Cargo.toml b/engine/Cargo.toml index 43489a8..15addf3 100644 --- a/engine/Cargo.toml +++ b/engine/Cargo.toml @@ -4,3 +4,4 @@ version = "0.1.0" edition = "2024" [dependencies] +once_cell = "1.19" \ No newline at end of file diff --git a/engine/src/bitboard.rs b/engine/src/bitboard.rs new file mode 100644 index 0000000..67d128d --- /dev/null +++ b/engine/src/bitboard.rs @@ -0,0 +1,2 @@ +mod attackmaps; +mod utils; \ No newline at end of file diff --git a/engine/src/bitboard/attackmaps.rs b/engine/src/bitboard/attackmaps.rs new file mode 100644 index 0000000..f7fe35f --- /dev/null +++ b/engine/src/bitboard/attackmaps.rs @@ -0,0 +1,252 @@ +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[] +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[][] +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[] +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[][] +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]); + } + } +} \ No newline at end of file diff --git a/engine/src/bitboard/utils.rs b/engine/src/bitboard/utils.rs new file mode 100644 index 0000000..a30e503 --- /dev/null +++ b/engine/src/bitboard/utils.rs @@ -0,0 +1,99 @@ +#[inline(always)] +pub fn pop_lsb(value: &mut u64) -> usize { + let idx = value.trailing_zeros() as usize; + *value &= !(1 << idx); + return idx; +} + +#[inline(always)] +pub fn pop_msb(value: &mut u64) -> usize { + let idx = 63 - value.leading_zeros() as usize; + *value &= !(1 << idx); + return idx; +} + +const RANK_NUMBERS: [char; 8] = ['1', '2', '3', '4', '5', '6', '7', '8']; +const FILE_LETTERS: [char; 8] = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']; +pub fn notation_from_square_number(sq: u8) -> String { + let row = sq / 8; + let col = sq % 8; + let mut notation = String::new(); + + let row_not = RANK_NUMBERS[row as usize]; + let col_not = FILE_LETTERS[col as usize]; + + notation.push(col_not); + notation.push(row_not); + return notation; +} + + +// <----- TESTS -----> + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn pop_lsb_test() { + + // test setup + let test_values: [u64; 6] = [ + 0x8000_0000_0000_0000, + 0x4E91_CF05_713E_451B, + 0xD588_2D58_6962_34B0, + 0x9581_3335_DCAB_1DD4, + 0xBEAC_DBE0_903A_AC00, + 0x01E8_C895_A6F0_0000 + ]; + let expected_values: [usize; 6] = [63, 0, 4, 2, 10, 20]; + + // tests + for index in 0..6 { + let mut test_value = test_values[index]; + assert_eq!(pop_lsb(&mut test_value), expected_values[index]) + } + } + + #[test] + fn pop_msb_test() { + // test setup + let test_values: [u64; 6] = [ + 0x86D6_8EB0_96A8_8D1C, + 0x0000_0000_0000_0001, + 0x3809_24AF_A7AE_8129, + 0x0277_DA36_3B31_86D9, + 0x0000_C1C3_201C_0DB1, + 0x0000_0203_0DE4_E944 + ]; + let expected_values: [usize; 6] = [63, 0, 61, 57, 47, 41]; + + // tests + for index in 0..6 { + let mut test_value = test_values[index]; + assert_eq!(pop_msb(&mut test_value), expected_values[index]) + } + } + + #[test] + fn notation_from_square_number_test() { + // test setup + let square_indices: [u8; 8] = [1, 12, 22, 27, 32, 47, 53, 58]; + let notations: [String; 8] = [ + String::from("b1"), + String::from("e2"), + String::from("g3"), + String::from("d4"), + String::from("a5"), + String::from("h6"), + String::from("f7"), + String::from("c8") + ]; + + // tests + for index in 0..8 { + let notation = notation_from_square_number(square_indices[index].clone()); + assert_eq!(notation, notations[index]); + } + } +} \ No newline at end of file diff --git a/engine/src/main.rs b/engine/src/main.rs index e7a11a9..3555c81 100644 --- a/engine/src/main.rs +++ b/engine/src/main.rs @@ -1,3 +1,5 @@ +mod bitboard; + fn main() { println!("Hello, world!"); }