MrGeorgen/chess
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

not working: check

Browse Source
This commit is contained in:
MrGeorgen
2024-03-17 22:04:13 +01:00
parent 2e813e5744
commit 1b779b7667
10 changed files with 198 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/findMagicNumber.c
View File

@ -1,14 +1,14 @@
#include <chess/types.h>
#include <bits/stdint-least.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdint.h>
#include "chess/generated/moveConsts.h"
#include <chess/bitboard.h>
#include <chess/print.h>
#include <inttypes.h>
#include <assert.h>
#include <chess/magic.h>
#include <chess/generated/moveConsts.h>
#define MAX_BITS 12
#define MAX_SIZE (1 << MAX_BITS)
@ -35,27 +35,12 @@ static uint_least8_t countOnes(uint_least64_t n) {
}
static void printerMagic(FILE *file, struct magic_t magic) {
fprintf(file, "{ NULL, %" PRIuLEAST64 ", %" PRIuLEAST64 ", %" PRIuLEAST8 "}", magic.mask, magic.magicNumber, magic.shift);
fprintf(file, "{ 0, %" PRIuLEAST64 "u, %" PRIuLEAST64 "u, %" PRIuLEAST8 "}", magic.mask, magic.magicNumber, magic.shift);
}
static uint_least64_t slidingMovementMask(const uint_least8_t *direction, uint_least8_t directionLength,
uint_least8_t field, uint_least64_t blockMask) {
defineDirectionOffset;
const uint_least8_t *localDirectionOffset = DIRECTION_OFFSET + field * DIRECTION_LENGTH;
uint_least64_t movementMask = 0;
for(uint_least8_t j = 0; j < directionLength; ++j) {
const int_least8_t modifier = DIRECTION_MODIFIER[direction[j]];
for(uint_least8_t currentField = field + modifier, i = 0;
i < localDirectionOffset[direction[j]]; ++i, currentField += modifier) {
movementMask = bitsetSet(movementMask, currentField);
if(bitsetGet(blockMask, currentField)) break;
}
}
return movementMask;
}
static bool tryMagicNum(uint_least8_t field, struct magic_t *magic, uint_least64_t magicNumber,
const uint_least64_t *preClacAttack) {
const uint_least64_t *preClacAttack, const uint_least8_t *direction) {
preClacAttack += field * MAX_SIZE;
bool usedMagic = false;
if(countOnes((magic->mask * magicNumber) & 0xFF00000000000000ULL) < 6) return false;
@ -65,20 +50,21 @@ static bool tryMagicNum(uint_least8_t field, struct magic_t *magic, uint_least64
attackTable[i] = UINT_LEAST64_MAX;
}
bool validMagic = true;
uint_least64_t pieceArangement = 0;
uint_least64_t pieceArrangement = 0;
size_t j = 0;
do {
const uint_least32_t i = (pieceArangement * magicNumber) >> shift;
const uint_least64_t i = (pieceArrangement * magicNumber) >> shift;
const uint_least64_t storedAttack = attackTable[i];
const uint_least64_t calcAttack = preClacAttack[j];
//assert(slidingMovementMask(direction, 4, field, pieceArrangement) == calcAttack);
if(storedAttack != UINT_LEAST64_MAX && storedAttack != calcAttack) {
validMagic = false;
break;
}
attackTable[i] = calcAttack;
pieceArangement = (pieceArangement - magic->mask) & magic->mask;
pieceArrangement = (pieceArrangement - magic->mask) & magic->mask;
++j;
} while(pieceArangement != 0);
} while(pieceArrangement != 0);
if(validMagic) {
magic->shift = shift;
magic->magicNumber = magicNumber;
@ -95,26 +81,26 @@ static void initMagicField(uint_least64_t *attackMask, struct magic_t *magicTabl
attackMask += field * MAX_SIZE;
magic->mask = slidingMovementMask(direction, directionLength, field, 0);
magic->shift = 64 - MAX_BITS - 1;
uint_least64_t pieceArangement = 0;
uint_least64_t pieceArrangement = 0;
size_t i = 0;
do {
attackMask[i] = slidingMovementMask(direction, directionLength, field, pieceArangement);
pieceArangement = (pieceArangement - magic->mask) & magic->mask;
assert(i < MAX_SIZE);
attackMask[i] = slidingMovementMask(direction, directionLength, field, pieceArrangement);
assert(countOnes(attackMask[i]) <= 12);
pieceArrangement = (pieceArrangement - magic->mask) & magic->mask;
++i;
} while(pieceArangement != 0);
} while(pieceArrangement != 0);
}
int main() {
const uint_least8_t rookDirection[] = {NORTH, SOUTH, EAST, WEST};
const uint_least8_t bishopDirection[] = {NORTHEAST, NORTHWEST, SOUTHEAST, SOUTHWEST};
struct magic_t rookMagicTable[TOTAL_BOARD_SIZE] = {};
struct magic_t bishopMagicTable[TOTAL_BOARD_SIZE] = {};
uint_least64_t *attackMask = malloc(ATTACK_TABLE_LENGTH * sizeof *attackMask);
uint_least64_t *rookAttackMask = attackMask;
uint_least64_t *bishopAttackMask = attackMask + TOTAL_BOARD_SIZE * MAX_SIZE;
for(uint_least8_t field = 0; field < TOTAL_BOARD_SIZE; ++field) {
initMagicField(rookAttackMask, rookMagicTable, field, rookDirection, LENGTH(rookDirection));
initMagicField(bishopAttackMask, bishopMagicTable, field, bishopDirection, LENGTH(bishopDirection));
initMagicField(rookAttackMask, rookMagicTable, field, ROOK_DIRECTION, LENGTH(ROOK_DIRECTION));
initMagicField(bishopAttackMask, bishopMagicTable, field, BISHOP_DIRECTION, LENGTH(BISHOP_DIRECTION));
}
srand(time(NULL));
for(;;) {
@ -123,11 +109,11 @@ int main() {
for(uint_least8_t field = 0; field < TOTAL_BOARD_SIZE; ++field) {
{
struct magic_t *magic = rookMagicTable + field;
isMagic |= tryMagicNum(field, magic, magicNumber, rookAttackMask);
isMagic |= tryMagicNum(field, magic, magicNumber, rookAttackMask, ROOK_DIRECTION);
}
{
struct magic_t *magic = bishopMagicTable + field;
isMagic |= tryMagicNum(field, magic, magicNumber, bishopAttackMask);
isMagic |= tryMagicNum(field, magic, magicNumber, bishopAttackMask, BISHOP_DIRECTION);
}
}
if(isMagic) {