Нейронка выдала еще одно обновление.
Что нового:
1. До этого игрок и компьютер во время множественного взятия дамкой могли при рубке первой шашки проскочить пересекающую диагональ, на которой стоит доступная для рубки вторая шашка противника. Это является нарушением правил Русских шашек. Теперь в движок добавлена строгая проверка: если на линии приземления есть возможность продолжить бой, игра просто не позволит выбрать тупиковую клетку. Фильтр внедрен на уровне базового генератора ходов, поэтому поисковые алгоритмы ИИ теперь тоже учитывают это правило и строят свои ловушки абсолютно честно.
2. Добавил анимацию движения шашек, чтобы они не перескакивали от клетки к клетке моментально.
3. И САМОЕ ГЛАВНОЕ: Gemini 3.1 Pro переписал базовую функцию поиска фигур на доске (в битбордах): полностью отказался от тяжелой математики с 32-битным умножением и длинными битовыми сдвигами в пользу простой предвычисленной таблицы (LUT) на 256 байт.
Вот так код выглядел до:
const u8 multiplyDeBruijnBitPosition[32] = {
0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
};
static inline u8 getLSB(u32 v) {
return multiplyDeBruijnBitPosition[((u32)((v & -v) * 0x077CB531U)) >> 27];
}
Теперь он выглядит так:
// Таблица: для каждого байта (от 0 до 255) хранит индекс самого младшего установленного бита (0-7).
// Для 0 значение неважно, так как getLSB вызывается только для v != 0.
static const u8 LSB_TABLE_8BIT[256] = {
0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
};
static inline u8 getLSB(u32 v) {
// Разбиваем 32-битное число на части и ищем первый ненулевой байт, начиная с младшего.
// Это избавляет процессор от необходимости делать (v & -v) и умножение.
u32 lo = v & 0xFFFF;
if (lo) {
if (lo & 0xFF) {
return LSB_TABLE_8BIT[lo & 0xFF];
} else {
return 8 + LSB_TABLE_8BIT[lo >> 8];
}
} else {
u32 hi = v >> 16;
if (hi & 0xFF) {
return 16 + LSB_TABLE_8BIT[hi & 0xFF];
} else {
return 24 + LSB_TABLE_8BIT[hi >> 8];
}
}
}
Я ничего не понял, но это работает настолько круто, что до обновления ИИ думал, например, 12 секунд, то теперь он думает 7 секунд на глубине основного поиска в 5 ходов и на глубине форсированного поиска в 12 ходов. А если отключить форсированный поиск, то ИИ будет думать всего 4 секунды. Я в шоке. Нейросеть продолжает меня удивлять. Потом попробую попросить нейронку ускорить ИИ еще больше. Сможет ли она что-нибудь придумать? Если да, то можно будет смело увеличивать максимальную глубину основного поиска до 7 ходов, а не до 6, как сейчас.
Кстати, интересно, можно ли с помощью нейросети так же круто оптимизировать уже существующие игры, страдающие тормозами? Если она такой сложный алгоритм может настолько круто ускорять для слабого процессора раз за разом, то почему бы ей не ускорить обычную игрушку с простейшей логикой?
