🎮 Weighted Random в играх, которые ты знаешь

Эта механика везде — просто под разными названиями:

🃏 Gacha-игры (Genshin Impact, Honkai)
Ставки в 0.6% на 5★ — это weighted random с очень маленьким весом редкого предмета.
Плюс «pity system» — счётчик, который повышает вес при неудаче.

⚔️ Diablo / Path of Exile
Аффиксы предметов тянутся из пула с разными весами. Редкий аффикс просто
имеет вес 1 против 1000 у обычного.

🌍 Minecraft
Структуры биомов, дроп мобов, содержимое сундуков — всё таблицы весов.
В коде это буквально называется loot tables.

🎰 Pokémon
Скрытые способности (Hidden Ability) — 1 шанс из 150. Шансы на природу —
равные, но можно изменить через синхронизацию.

Суть одна — ты уже знаешь как это работает под капотом.

#мат_геймдев #геймдизайн #рандом #МатРазбор

Да, я только понял, что забыл комменты привязать XD В следующих постах будет)

🚨 Ошибка недели: почему твой weighted random врёт

Классическая ловушка — веса заданы через float и суммируются с погрешностью:

float[] weights = { 0.1f, 0.3f, 0.6f }; // кажется, сумма = 1.0
// На самом деле: 0.99999994f из-за float-арифметики

Если ты делишь на сумму для нормализации — погрешность накапливается. Последний элемент может никогда не выпасть или выпадать чуть реже.

Два способа починить:

1. Используй int-веса — целые числа не теряют точность:

int[] weights = { 60, 30, 10 }; // вместо 0.6f, 0.3f, 0.1f

2. Последний элемент — всегда fallback, а не результат сравнения:

for (int i = 0; i < weights.Length; i++)
    if (roll < cumulative[i]) return i;
return weights.Length - 1; // если погрешность съела край — возвращаем последний

Маленькая деталь — но именно такие баги живут в проде годами и порой приводят к непредсказуемым последствиям.

#мат_геймдев #ОшибкаНедели #рандом

📋 Итог блока «Рандом» — что мы разобрали и где это использовать

За прошлую неделю — три концепции, которые покрывают основные задачи с дропом предметов в геймдеве:

Weighted Random
Простой и читаемый. Выбор по умолчанию для лутбоксов, таблиц дропа, спавна мобов.

Alias Method
O(1) после предподготовки. Когда вызовов тысячи в секунду.

Binary Search + кеш
Компромисс. Быстрее обычного, проще Alias.


На следующей неделе открываем новую тему — Физика столкновений. Поехали 👇

#мат_геймдев #ДайджестМесяца #рандом

👾 Физика столкновений: зачем разбираться, если движок всё делает сам?

Коллайдеры Unity или Godot — это удобно. Ставишь Box Collider, игра работает.
Но рано или поздно случается одно из двух:

• Персонаж проваливается сквозь пол на высокой скорости
• Хитбоксы не совпадают с визуалом и игроки злятся
• Нужна кастомная физика — платформер кастомной физикой
top-down с трением, пинбол-механика


У меня было такое, что мне это пригодилось для кастомных рейкастов в VR, когда нужно было переключаться по тысячам вершин графа которые движутся в пространстве.

Тогда понимание математики за коллайдерами — не академизм, а рабочий инструмент.

На этой неделе разбираем:
— AABB: самый быстрый прямоугольный коллайдер
— Circle: идеален для снарядов и мячей
— Вектор отражения: отскок без магии

#мат_геймдев #МатРазбор #физика

📊 AABB — прямоугольник против прямоугольника без тригонометрии

AABB (Axis-Aligned Bounding Box) — прямоугольник, стороны которого
параллельны осям координат. Никакого поворота.

Проверка столкновения двух AABB — четыре сравнения чисел:

struct AABB
{
    public float minX, maxX, minY, maxY;
}

bool Overlaps(AABB a, AABB b)
{
    return a.maxX > b.minX &&  // a не левее b
           a.minX < b.maxX &&  // a не правее b
           a.maxY > b.minY &&  // a не ниже b
           a.minY < b.maxY;    // a не выше b
}

Никакого корня квадратного, никаких синусов. Четыре сравнения.
Это причина, по которой большинство игровых движков используют AABB
для первичной проверки (broad phase) даже у сложных объектов.

Минус: не работает если объект повёрнут. Для поворота — OBB или SAT.
Но для большинства платформеров и top-down игр AABB хватает с головой.

#мат_геймдев #МатРазбор #физика #коллайдеры

🤔 Загадка: почему быстрый персонаж проваливается сквозь пол?

Коллайдеры настроены правильно. На низкой скорости всё работает.
Но разогнать персонажа — и он прошивает платформу насквозь.

Пауза — подумай секунду.

...

Ответ: Tunneling (туннелирование).

Физика в играх дискретная: каждый кадр объект перемещается на velocity * deltaTime.
Если объект за один кадр перемещается дальше, чем толщина коллайдера —
движок просто не замечает пересечения. Объект был над полом, стал под ним.
Столкновения не было.

Три решения:
1. Continuous collision detection (CCD) — движок проверяет весь путь, не точку.
Дорого по производительности.
2. Ограничить максимальную скорость так, чтобы за кадр объект не мог
пролететь сквозь коллайдер.
3. Raycast в направлении движения перед шагом — рукопашная CCD.

Знал о туннелировании раньше? 👇

#мат_геймдев #физика #коллайдеры #ОшибкаНедели

📊 Circle-коллайдер: почему он лучше AABB для снарядов

AABB — быстрый, но у него слабое место: он прямоугольный.
Пуля, мяч, персонаж в top-down — у них нет углов. AABB даёт ложные
столкновения в углах, которых визуально нет.

Circle решает это элегантно. Проверка столкновения двух окружностей —
одно вычитание и одно сравнение:

bool CirclesOverlap(Vector2 posA, float rA, Vector2 posB, float rB)
{
    float dx = posA.x - posB.x;
    float dy = posA.y - posB.y;
    float distSq = dx * dx + dy * dy;       // квадрат расстояния
    float radiusSum = rA + rB;
    return distSq < radiusSum * radiusSum;   // без корня — быстрее
}

Никакой тригонометрии. Корень не нужен — сравниваем квадраты.

Когда выбирать Circle:
• снаряды (пули, фаерболы) — форма симметрична
• мячи, монеты, бонусы — очевидно
• персонажи в top-down — нет чёткой «передней» стороны

Когда выбирать AABB:
• платформы, стены, тайлы — прямоугольные по природе
• хитбоксы, которые должны «прижиматься» к форме спрайта

На практике движки используют их вместе: AABB — быстрая первичная
проверка (broad phase), Circle или Polygon — точная (narrow phase).

#мат_геймдев #МатРазбор #физика #коллайдеры

📊 Вектор отражения: как математика делает отскок

Мяч летит в стену. Как посчитать направление после отскока?

Интуиция подсказывает: «отразить угол». Но угол — это арктангенс,
градусы, неудобно. Есть формула, которая работает через векторы:

R = V - 2 * (V · N) * N

Где:
V — вектор направления до удара
N — нормаль поверхности (перпендикуляр к стене, единичный вектор)
R — вектор направления после отскока

Vector2 Reflect(Vector2 velocity, Vector2 normal)
{
    // normal должен быть нормализован
    float dot = Vector2.Dot(velocity, normal);
    return velocity - 2f * dot * normal;
}

// Примеры нормалей:
// Пол (горизонтальная поверхность) → normal = Vector2.up    (0, 1)
// Стена справа                     → normal = Vector2.left  (-1, 0)
// Наклонная платформа 45°          → normal = new Vector2(-0.707f, 0.707f)

// Использование:
ballVelocity = Reflect(ballVelocity, wallNormal);

В Unity это уже встроено:

ballVelocity = Vector2.Reflect(ballVelocity, wallNormal);

Но понимать формулу важно — потому что Reflect работает для любого угла.
Не только для горизонтальных/вертикальных стен, но и для наклонных
поверхностей, движущихся платформ, рикошетов.

Откуда формула? V · N — это «насколько вектор V направлен вдоль N».
2 * (V · N) * N — это та часть V, которую нужно «отзеркалить».
Вычитаем её из V дважды — получаем отражение.

#мат_геймдев #МатРазбор #физика #векторы

Отражение векторов - Интерактив
https://wreath-violet-94758009.figma.site/

Я пока думаю в каком формате делать всякие интерактивные штуки чтобы было проще воспринимать формулы и код. Гифки там или интерактивные сайты. Для последнего надо бюджет на тачку и домен для этого дела выделить, а пока не до того) Экспериментально из любопытства собрал в ИИ фигмы интерактив объясняющий пост выше.

Как решение задачи стоящей не совсем подходит, но в целом инструмент забавный кстати говоря.

#мат_геймдев #МатРазбор #физика #векторы

🎲 Откуда берётся «случайность» в компьютере?

Спойлер: её нет. Компьютер генерирует числа по формуле — детерминированно,
шаг за шагом. Такая последовательность называется псевдослучайной (PRNG).

Простейший PRNG — линейный конгруэнтный генератор (LCG):

next = (a * current + c) % m

Три магических константы a, c, m — и каждый вызов выдаёт «новое» число.

Пример на пальцах (a=1664525, c=1013904223, m=2^32):

uint state = 42; // начальное значение (сид)

uint NextRandom()
{
    state = 1664525u * state + 1013904223u;
    return state;
}

Вызови три раза — получишь три разных числа. Вызови снова с state=42 — те же три.

Почему это важно для геймдева:
→ Ты контролируешь «случайность» через начальное значение (seed)
→ Один и тот же seed = один и тот же мир / один и тот же дроп
→ Это основа воспроизводимых миров, реплеев и читов через save-scumming

Unity использует System.Random под капотом — тот же принцип, чуть сложнее.
Godot — свой Mersenne Twister. Но идея одна: формула + стартовое число.

Существуют ГСЧ, основанные на сборе энтропии — они «более случайные», и главная задача таких генераторов — быть непредсказуемыми. Применяются они там, где взлом или предсказуемость недопустимы: в криптографии, защите данных, онлайн-сервисах. Это область весьма сложных идей и алгоритмов: получить по-настоящему случайное, равновероятно распределённое число от 0 до 1 — задача совсем не тривиальная.

Вообще важно понимать природу случайности — это абстрактное понятие, придуманное человеком. Я когда-то задумывался: бросить монетку 50 на 50 — спорное утверждение. Ведь по сути невозможно поставить чистый эксперимент, который бы это достоверно доказал. Так что под случайностью мы скорее понимаем непредсказуемость. И псевдослучайность по примеру выше работает как настоящая случайность ровно до тех пор, пока ты не знаешь, как она устроена.

Если тема интересна — расскажу про ТГСЧ и КГПСЧ: генераторы, которые используются в защите данных и криптографии. Ну и хорошими постами делись с друзьями — «нам нужно больше золота подписчиков».

#мат_геймдев #МатРазбор #рандом

🌱 Seed-рандом: один номер — весь мир

Minecraft. Ты вводишь число при создании мира и получаешь конкретный ландшафт.
Через год вводишь то же число — тот же ландшафт. Это seed.

Seed — это просто начальное значение для PRNG. Пока генератор тот же,
последовательность всегда идентична.

Практический паттерн: отдельный генератор для каждой системы

public class SeededRandom
{
    private System.Random rng;
    public int Seed { get; private set; }

    public SeededRandom(int seed)
    {
        Seed = seed;
        rng = new System.Random(seed);
    }

    public int Next(int min, int max) => rng.Next(min, max);
    public float NextFloat()          => (float)rng.NextDouble();
}

// Каждый регион карты — свой генератор:
var dungeonRng  = new SeededRandom(worldSeed ^ 0xDEAD);
var lootRng     = new SeededRandom(worldSeed ^ 0xBEEF);
var enemyRng    = new SeededRandom(worldSeed ^ 0xCAFE);

XOR с разными константами гарантирует, что генераторы идут по разным дорожкам,
но оба воспроизводимы при известном worldSeed.

Три применения:
→ Процедурные карты — один seed = один мир
→ Реплеи — записываешь только ввод игрока + seed, а не весь стейт
→ Отладка — нашёл баг? Скажи seed разработчику, он воспроизведёт

#мат_геймдев #МатРазбор #рандом

🏰 Процедурная генерация: рандом с правилами

«Процедурная генерация» — не просто случайные числа. Это рандом,
ограниченный правилами так, чтобы результат был играбелен.

Простейший пример — комнатный dungeon:

Шаг 1. Создай сетку N×M, заполни стенами (1).
Шаг 2. Попробуй разместить K случайных прямоугольников-комнат.
Если прямоугольник не пересекается с уже размещёнными — добавь.
Шаг 3. Соедини центры соседних комнат коридорами (L-образный тоннель).
Шаг 4. Поставь старт в первую комнату, выход — в последнюю.

void GenerateDungeon(int seed)
{
    var rng = new SeededRandom(seed);
    var rooms = new List<RectInt>();

    for (int i = 0; i < MAX_ROOMS; i++)
    {
        int w = rng.Next(MIN_SIZE, MAX_SIZE);
        int h = rng.Next(MIN_SIZE, MAX_SIZE);
        int x = rng.Next(1, width  - w - 1);
        int y = rng.Next(1, height - h - 1);
        var room = new RectInt(x, y, w, h);

        if (!rooms.Any(r => r.Overlaps(room)))
        {
            CarveRoom(room);
            if (rooms.Count > 0)
                CarveCorridors(rooms.Last(), room, rng);
            rooms.Add(room);
        }
    }
}

Секрет «не сломанного» уровня: правила ограничивают, рандом заполняет.
Именно это делает Spelunky, Enter the Gungeon, Dead Cells — каждый запуск свой,
но всегда проходимый.

#мат_геймдев #МатРазбор #процедурнаяГенерация

🗺️ Два других способа генерировать уровни

Комнатный dungeon — самый простой метод.
Вот ещё два, которые дают другой визуальный стиль.

BSP (Binary Space Partitioning)
Делит пространство пополам рекурсивно, как оригами.
Каждая «половинка» становится комнатой. Переходы между ними — двери.
Результат: более прямоугольные, «архитектурные» уровни.
Используют: Nethack, классические roguelike.

Корень → [левая половина] [правая половина]
         ↓                   ↓
         [комн.] [комн.]   [комн.] [комн.]

Cellular Automata (клеточные автоматы)
Заполни сетку случайными стенами/полом (50/50).
Потом повтори правило N раз:
«Если у клетки ≥ 5 соседей-стен — она стена, иначе — пол»
Результат: органичные пещеры, плавные очертания.
Используют: Dwarf Fortress, Don't Starve для биомов.

// Один шаг клеточного автомата
for (int x = 1; x < w-1; x++)
for (int y = 1; y < h-1; y++)
{
    int walls = CountWallNeighbors(x, y);
    nextGrid[x,y] = walls >= 5 ? 1 : 0;
}

Выбор метода зависит от стиля игры:
→ Dungeon / RPG → комнаты или BSP
→ Survival / Open world → cellular automata

#мат_геймдев #МатРазбор #процедурнаяГенерация

🌊 Wave Function Collapse: квантовая физика в генерации уровней

В квантовой механике частица до измерения находится в суперпозиции — она одновременно может быть в нескольких состояниях. Как только ты её измеряешь, волновая функция «схлопывается» в одно конкретное.

В алгоритме ровно та же метафора.

Каждая клетка сетки до заполнения — это суперпозиция всех возможных тайлов: лес, вода, скала, дорога... Как только ты её «наблюдаешь» (выбираешь тайл) — она схлопывается в одно состояние. И это схлопывание мгновенно влияет на соседей — сужает их варианты. Точь-в-точь как квантовая запутанность.

Берёшь набор тайлов и правила: «рядом с водой — только берег, рядом с берегом — трава». Потом заполняешь сетку, соблюдая эти правила. Результат: уровень выглядит как нарисованный вручную — потому что правила берутся из реального образца.

Алгоритм в трёх шагах:

1. Наблюдение — выбери клетку с минимальной энтропией (меньше всего вариантов) и «схлопни» её.

2. Распространение — пройдись по соседям и удали варианты, которые теперь противоречат правилам.

3. Повтори — пока вся сетка не схлопнется.

Физики здесь нет — это чистая метафора. Но название точное: именно так это и ощущается изнутри.

Используют: Caves of Qud, Bad North, Townscaper.

#мат_геймдев #МатРазбор #процедурнаяГенерация

🎮 3 игры с крутой процедурной генерацией — что под капотом

Spelunky (2009)
Уровень = 4×4 блока 10×8 клеток.
Каждый блок — один из заранее нарисованных шаблонов (rooms), выбранный рандомно.
Гарантия проходимости: один «опорный» маршрут через блоки всегда есть.
Вывод: случайность + ручные шаблоны = игровой баланс сохранён.

Dead Cells (2018)
Уровни — не случайные, а сборные из готовых секций.
Секции заранее дизайнерски проработаны, порядок и детали — рандомные.
Вывод: меньше математики, больше контроля над feel.

No Man's Sky (2016)
Планеты, существа, растения — из параметрических «рецептов».
Один seed → 18 квинтиллионов планет. Математика через noise-функции и L-системы.
Вывод: глубокая процедурка требует огромных систем параметров.

Общий урок: в хороших играх процедурка никогда не работает одна —
всегда есть ручная работа, которая задаёт рамки. Даже когда я участвовал в разработке Vector 2, там были огромные Yaml генераторы задающие правила генерации уровней, чтобы рандом был интересным.

#мат_геймдев #МатРазбор #процедурнаяГенерация

⚙️ Rigidbody изнутри: что реально происходит под капотом

Добавляешь Rigidbody — объект начинает падать. Три переменных делают это.

Mass (масса) — сопротивление изменению скорости.
F = m × a. Одна и та же сила разгоняет лёгкий мяч быстрее, чем танк.
В Unity mass не влияет на скорость свободного падения. Зато влияет при AddForce и столкновениях.

Drag — «воздушное сопротивление», гасит линейную скорость.
Каждый кадр: velocity *= (1 - drag × deltaTime)
Drag = 0 → летит вечно. Drag = 5 → тормозит быстро.

Angular drag — то же самое, но для вращения.
Angular velocity — скорость вращения в рад/сек.

// Снаряд с закруткой
var rb = bullet.GetComponent<Rigidbody>();
rb.mass           = 0.02f;
rb.drag           = 0.01f;
rb.angularDrag    = 0f;
rb.linearVelocity = transform.forward * 50f;
rb.angularVelocity= transform.forward * 30f; // закрутка

#мат_геймдев #МатРазбор #физика #rigidbody

🎯 Rigidbody: настройки для пяти типовых объектов

Одни параметры для пули и для пера — не работает. Вот справочная таблица.

Пуля / снаряд
Mass: 0.01–0.05 · Drag: 0.01 · Angular drag: 0
Gravity: off (или своя) · Collision Detection: Continuous

Игровой персонаж (без CharacterController)
Mass: 70 · Drag: 3–5 · Angular drag: высокий (нет кувырков)
Gravity: on · Constraints: заморозить вращение X и Z

Физический куб / ящик
Mass: 1–10 · Drag: 0.1 · Angular drag: 0.1
Обычные настройки, всё разрешено

Тяжёлый объект (валун, машина)
Mass: 500+ · Drag: 0.5 · Angular drag: 0.5
Высокая масса = сложнее сдвинуть

Перо / листок
Mass: 0.001 · Drag: 10–15 · Angular drag: 10
Высокий drag имитирует сопротивление воздуха

#мат_геймдев #КодПодСкопой #физика #rigidbody

🐛 #ОшибкаНедели: Is Kinematic — что это вообще значит

Новички часто видят Is Kinematic и включают его, не понимая зачем.
Разберём один раз и навсегда.

Обычный Rigidbody: управляется физикой.
Гравитация тянет вниз, AddForce работает, другие тела толкают его.

Is Kinematic = true: объект управляется кодом/анимацией, не физикой.
Гравитация игнорируется. AddForce не работает.
Но он всё ещё участвует в коллизиях — отталкивает другие тела.

❌ Типичная ошибка: включить Is Kinematic у персонажа, потом удивляться,
почему прыжок не работает.

✅ Когда нужен Kinematic:
→ Платформа, которая движется по скрипту
→ Дверь, управляемая анимацией
→ Враг, которого двигают по NavMesh, но у которого есть коллайдер
→ Объект, управляемый в FixedUpdate вручную

Правило: Kinematic = «я сам двигаю объект», обычный = «физика двигает объект».

#мат_геймдев #ОшибкаНедели #физика #rigidbody

🚀 Velocity, acceleration, friction: Ньютон в аркадной игре

transform.position += speed — работает, но ощущается как деревяшка.
Вот почему и как это исправить.

Три переменных физически честной модели движения:

position     — где объект сейчас
velocity     — скорость и направление движения
acceleration — как быстро меняется скорость

Каждый кадр (интеграция Эйлера):

velocity += acceleration * Time.deltaTime;
velocity *= (1f - friction  * Time.deltaTime); // трение гасит
position += velocity       * Time.deltaTime;

Платформер без Rigidbody — конкретный код:

Vector2 velocity = Vector2.zero;
const float ACCEL   = 80f;
const float FRICTION= 12f;
const float GRAVITY = 30f;
const float JUMP    = 15f;

void Update()
{
    float input = Input.GetAxis("Horizontal");
    velocity.x += input * ACCEL * Time.deltaTime;
    velocity.x *= 1f - FRICTION * Time.deltaTime;

    if (!isGrounded) velocity.y -= GRAVITY * Time.deltaTime;
    if (isGrounded && Input.GetKeyDown(KeyCode.Space))
        velocity.y = JUMP;

    transform.position += (Vector3)(velocity * Time.deltaTime);
}

Результат: персонаж разгоняется и плавно тормозит.
Это и есть основа game feel.

#мат_геймдев #МатРазбор #физика

🎲 Демо к статье: WFC + Entropy Bias

Рисуете тепловую карту — получаете уровень.

- W_d — плотность врагов
- W_r — распределение лута
- W_e — точки входа/выхода

Алгоритм решает CSP с весами из вашей карты. Коллапс волновой функции смещается энтропийным биасом под заданные зоны.

👉 Открыть мини-апп по кнопке

🖥 С ПК в фулскрине удобнее.