multirepo
This commit is contained in:
azykov@mail.ru
@@ -0,0 +1,4 @@
|
||||
node_modules
|
||||
dist
|
||||
*.tsbuildinfo
|
||||
.DS_Store
|
||||
@@ -0,0 +1,245 @@
|
||||
# Resource Graph Engine — документация движка
|
||||
|
||||
Этот файл описывает **логику симуляции** (пакет `src/engine`, `src/types`, `src/utils`), а не конкретную игру. Он написан как справочник для разработки НА БАЗЕ этого движка (в том числе с помощью Claude) — здесь зафиксированы точные контракты, инварианты и неочевидные архитектурные решения, которые нужно знать, чтобы не сломать существующую логику при добавлении нового контента.
|
||||
|
||||
Слой представления (`src/components`, `src/ui`, `App.tsx`) — это ОДНА конкретная демо-визуализация (React + SVG + автолэйаут ELK). Движок от неё не зависит: `Game`/`Behaviour`/сериализация не импортируют ничего из React/DOM. Полностью описан отдельным разделом в конце.
|
||||
|
||||
## Ключевые понятия
|
||||
|
||||
| Термин | Где определён | Смысл |
|
||||
|---|---|---|
|
||||
| `Resource` | `src/types/resource.ts` | Строковый union-тип названий ресурсов (`'tree' \| 'wood' \| 'stone'` на момент написания). Добавление нового ресурса — это просто расширение union'а. |
|
||||
| `Unit` | `src/types/unit.ts` | Узел мира: `{ id, name, behaviour }`. `id` — идентификатор *слота в мире* (для UI/сохранения расположения), `name` — отображаемое имя. |
|
||||
| `Behaviour` | `src/engine/behaviours/base.ts` | Абстрактный класс — фактическая симулируемая сущность. **У `Behaviour` есть СВОЙ `id`, отдельный от `Unit.id`.** Связи (`inputLinks`) ссылаются на `Behaviour.id`, а не на `Unit.id`. |
|
||||
| `Game` | `src/engine/game.ts` | Контейнер: `time: Decimal` + `nodes: Unit[]`, метод `tick(deltaTime)` — единственная точка входа симуляции. |
|
||||
|
||||
Важный нюанс, который легко перепутать: в `prefabs/game.ts` узел с `Unit.id = 'sawmill'` содержит `Behaviour` с `id: 'sawmill.1'`; связи других узлов указывают `target: 'sawmill.1'` (id поведения), не `'sawmill'`.
|
||||
|
||||
Все числа в симуляции — `Decimal` из [`break_eternity.js`](https://github.com/Patashu/break_eternity.js) (для больших чисел инкремental-игр), а не `number`. Публичные API принимают `DecimalSource = Decimal | number | string`. Только шаг тика (`deltaTime` в `Game.tick`/`Behaviour.tick`) — обычный `number`.
|
||||
|
||||
## Модель поведения (`Behaviour`)
|
||||
|
||||
```ts
|
||||
abstract class Behaviour {
|
||||
readonly id: string;
|
||||
readonly kind: string; // 'converter' | 'storage' | ...
|
||||
readonly inputLinks: BehaviourLink[]; // BehaviourLink = { target: string, resource: Resource }
|
||||
|
||||
abstract get inputs(): Resource[]; // какие ресурсы принимает (для сокетов/UI)
|
||||
abstract get outputs(): Resource[]; // какие ресурсы отдаёт (для сокетов/UI)
|
||||
|
||||
abstract take(resource, amount): Decimal; // публичный: забрать (ограничено наличием)
|
||||
protected abstract give(resource, amount): void; // защищённый: положить (без ограничений)
|
||||
abstract getStorage(): Partial<Resources>; // снимок текущих запасов
|
||||
abstract reset(): void; // обнулить запасы (не связи/id)
|
||||
|
||||
abstract tick(
|
||||
deltaTime: number,
|
||||
resolve: (id: string) => Behaviour | undefined,
|
||||
fairShare: (sourceId: string, resource: Resource) => Decimal,
|
||||
): void;
|
||||
}
|
||||
```
|
||||
|
||||
**`take()` — единственный публичный способ отобрать ресурс.** Всегда возвращает `min(amount, реально_доступное)`, никогда не уходит в минус. `give()` защищённый — положить ресурс в поведение может только оно само (изнутри `tick()`, после `take()` у источника). Это значит: **толкать (push) ресурс в чужое поведение нельзя** — можно только объявить связь (`inputLinks`) и на своём тике *вытягивать (pull)* у источника.
|
||||
|
||||
### Односвязность входа (важное ограничение)
|
||||
|
||||
`inputLinks` — плоский список `{target, resource}`. Оба текущих поведения ищут связь через `inputLinks.find(l => l.resource === X)` — **берётся первая** подходящая по ресурсу связь. Следствие: **один вход поведения может брать один и тот же ресурс только из ОДНОГО источника.** Если нужно смешивать один и тот же ресурс из нескольких источников в одном поведении — текущий код этого не поддерживает, нужно расширять `find` на что-то вроде списка/суммирования. Fan-*out* (один источник → много потребителей одного ресурса) поддерживается полностью, см. ниже.
|
||||
|
||||
### Порядок связи `resource`
|
||||
|
||||
`BehaviourLink.resource` используется дважды одним и тем же значением: и как ключ в собственных `inputRates`/`acceptsResources` этого поведения, и как аргумент `source.take(link.resource, ...)`. **Переименования ресурса через связь нет** — если A принимает `wood` от B, у B тоже должно быть `wood` (не `plank`, не что-то ещё).
|
||||
|
||||
## Тик игры (`Game.tick(deltaTime)`)
|
||||
|
||||
```ts
|
||||
tick(deltaTime: number) {
|
||||
time += deltaTime;
|
||||
|
||||
// 1. Топологический порядок: источник тикает раньше потребителя.
|
||||
for (const behaviour of orderByDependency(nodes)) {
|
||||
behaviour.tick(deltaTime, resolve, fairShare);
|
||||
snapshots[behaviour.id] = behaviour.getStorage(); // фиксируем "после этого тика"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
1. **Топологическая сортировка** (`src/utils/behaviourSort.ts`, DFS по `inputLinks`) гарантирует, что производитель тикает раньше своего потребителя — благодаря этому ресурс, произведённый в этом тике, может быть **потреблён по всей цепочке в тот же самый тик**, а не с задержкой в один тик.
|
||||
- **Циклические связи**: если граф содержит цикл (A тянет у B, B тянет у A), DFS обрывает цикл в первом же уже-посещённом узле и просто использует порядок обхода как есть — без ошибки, но без гарантии полной синхронности: одно из рёбер цикла всегда будет видеть состояние источника с *предыдущего* тика, а не текущего. На практике для DAG (обычный ресурсный граф без циклов) это не проявляется.
|
||||
|
||||
2. **`resolve(id)`** — поиск `Behaviour` по его `id` (не `Unit.id`!) среди всех узлов игры.
|
||||
|
||||
3. **Честное разделение (`fairShare`)** решает проблему конкуренции: если несколько поведений связаны с одним и тем же (`source`, `resource`), при заборе ресурса "кто первый в порядке тика — тот и съел всё" было бы недетерминированным-по-смыслу (хотя технически воспроизводимым) багом. Вместо этого:
|
||||
- Перед началом тика подсчитывается **`claimantCounts`** — сколько *разных* поведений ссылаются на каждую пару (`target`, `resource`). Это статическая информация (связи не меняются после создания), пересчитывается заново каждый тик, но не может измениться в рамках одной игры без ручного редактирования `inputLinks`.
|
||||
- После того как поведение отработало свой `tick()`, его текущий запас (`getStorage()`) сохраняется в `snapshots` — этот снимок **фиксирован до конца тика**, даже когда несколько потребителей после этого будут его "есть".
|
||||
- `fairShare(sourceId, resource)` возвращает:
|
||||
- `Decimal.dInf` (без ограничения), если претендент один или ни одного;
|
||||
- `snapshot[resource] / claimantCount`, если претендентов несколько.
|
||||
- Каждый потребитель обязан ограничивать свой запрос к источнику через `min(желаемое, fairShare(...))`, ПЕРЕД вызовом `source.take(...)`.
|
||||
- **Это буквальное равное деление, не max-min fairness.** Если один потребитель хочет меньше своей доли — остаток НЕ перераспределяется другим в этот же тик, а просто остаётся у источника до следующего. Пример (один источник даёт 10, два потребителя хотят 10 и 3): первый получит ровно 5 (свою долю), второй — все свои 3; 2 единицы останутся у источника.
|
||||
- **Реализация нового `Behaviour` обязана сама вызывать `fairShare` и ограничивать запрос** — это не гарантируется автоматически на уровне `take()`.
|
||||
|
||||
## `Converter` (`src/engine/behaviours/converter.ts`)
|
||||
|
||||
Узел с рецептом: раз в `cycleLength` секунд (по игровому времени, не по количеству тиков) атомарно списывает `inputRates` и начисляет `outputRates` в собственный буфер (`storage`).
|
||||
|
||||
Поля: `cycleTime: Decimal` (прогресс внутри текущего цикла, мутируется), `cycleLength: Decimal`, `inputRates: Partial<Resources>`, `outputRates: Partial<Resources>` (оба — ставки *за один цикл*, не в секунду).
|
||||
|
||||
### Алгоритм `tick(deltaTime, resolve, fairShare)`
|
||||
|
||||
```
|
||||
idealCycleTime = cycleTime + deltaTime
|
||||
reserveCycles = ceil(idealCycleTime / cycleLength) // сколько циклов "хочется" покрыть запасом наперёд
|
||||
newCycleTime = idealCycleTime
|
||||
|
||||
для каждого (resource, rate) из inputRates (rate != 0):
|
||||
target = rate * reserveCycles // сколько нужно НАКОПИТЬ, чтобы не тормозить
|
||||
shortfall = max(0, target - storage[resource])
|
||||
если shortfall > 0 И есть связь на resource:
|
||||
source = resolve(link.target)
|
||||
request = min(shortfall, fairShare(link.target, link.resource))
|
||||
give(resource, source.take(link.resource, request)) // забираем ОДНИМ куском, не по чуть-чуть
|
||||
|
||||
// прогресс не может опережать САМЫЙ дефицитный ингредиент:
|
||||
newCycleTime = min(newCycleTime, storage[resource] * cycleLength / rate)
|
||||
|
||||
cycleTime = newCycleTime
|
||||
affordableCycles = floor(cycleTime / cycleLength)
|
||||
если affordableCycles > 0:
|
||||
списать affordableCycles * inputRates[*] из storage
|
||||
начислить affordableCycles * outputRates[*] в storage
|
||||
cycleTime -= affordableCycles * cycleLength
|
||||
```
|
||||
|
||||
Три свойства, которые важно понимать при отладке/расширении:
|
||||
|
||||
1. **"Забрать всё сразу, а не по чуть-чуть".** `reserveCycles` округляется ВВЕРХ (`ceil`), а не пропорционально прошедшей доле цикла. Это специально: как только у источника появляется достаточно ресурса, конвертер выгребает его одним рывком (весь нужный на текущий+грядущий циклы объём), а не тянет дробно по мере хода времени. Визуально в UI это выглядит так, будто буфер конвертера "телепортируется" с 0 сразу на полную ставку в момент, когда источник произвёл ресурс.
|
||||
|
||||
2. **`cycleTime` не может "врать".** Прогресс `newCycleTime` ограничивается снизу для КАЖДОГО входного ресурса формулой `have * cycleLength / rate` — то есть таймер физически не может показывать больше прогресса, чем оправдано самым дефицитным ингредиентом. Если ресурсов не хватает, `cycleTime` просто перестаёт расти (стоит на месте) до следующего тика, когда источник, возможно, произведёт ещё. **Никакого "долга" не копится**: если конвертер голодал 50 тиков подряд, при появлении ресурса он не обработает мгновенно 50 циклов — `cycleTime` всё это время не рос, а как только ресурс появился, продвинется ровно настолько, насколько хватит того, что реально забрано.
|
||||
|
||||
3. **Один вызов `tick()` может закрыть НЕСКОЛЬКО циклов сразу**, если `deltaTime` большой (например, при офлайн-прогрессе одним большим тиком) и ресурсов хватает — `affordableCycles` не ограничен единицей. Это специально сделано так, чтобы `game.tick(1000)` (один большой шаг) и 10 000×`game.tick(0.1)` (много маленьких) давали **математически тот же результат** (с точностью до погрешности накопления `number` при многократном сложении `deltaTime`, см. раздел "Подводные камни"). Из этого следует практическая рекомендация: **офлайн-прогресс лучше считать одним большим `tick()`**, а не циклом из множества маленьких — так быстрее (не зависит от числа "прошедших" циклов) и точнее.
|
||||
|
||||
Пустые `inputRates`/`outputRates` — нормальный случай: чистый источник (пустые входы) или чистый потребитель/поглотитель (пустые выходы).
|
||||
|
||||
## `Storage` (`src/engine/behaviours/storage.ts`)
|
||||
|
||||
Пассивный буфер **без собственной скорости**: и приём, и выдача ресурса ограничены только противоположной стороной.
|
||||
|
||||
Поля: `capacity: Decimal | undefined` (лимит, **на каждый ресурс отдельно**, не общий на всё хранилище), `acceptsResources: Resource[]` (какие ресурсы вообще может держать), `items: Partial<Resources>`.
|
||||
|
||||
### Алгоритм `tick(deltaTime, resolve, fairShare)`
|
||||
|
||||
`deltaTime` не используется — скорость не зависит от времени.
|
||||
|
||||
```
|
||||
для каждого resource из acceptsResources:
|
||||
если нет связи на этот resource — пропустить
|
||||
source = resolve(link.target)
|
||||
room = capacity ? max(0, capacity - items[resource]) : Infinity
|
||||
request = min(room, fairShare(link.target, link.resource))
|
||||
give(resource, source.take(link.resource, request))
|
||||
```
|
||||
|
||||
То есть на каждом тике `Storage` пытается забрать у источника **столько, сколько есть места** (или сколько источник готов дать — что меньше), одним куском, без ограничения по скорости. С другой стороны, любой узел, который свяжется со `Storage` как со своим источником, вызовет `storage.take()`, которое отдаст **сколько попросят, ограничено только фактическим наличием** — тоже без собственного лимита скорости `Storage`.
|
||||
|
||||
`capacity` не задан (`undefined`) → ёмкость бесконечна для всех принимаемых ресурсов.
|
||||
|
||||
## Данные и сериализация (`src/types/serialization.ts`, `src/engine/saveLoad.ts`)
|
||||
|
||||
```ts
|
||||
type SerializedGame = {
|
||||
time: DecimalSource;
|
||||
nodes: SerializedNode[]; // { id, name, behaviour }
|
||||
}
|
||||
|
||||
type SerializedBehaviour = {
|
||||
id: string;
|
||||
inputLinks: { pins: { target: string, resource: Resource }[] };
|
||||
} & (SerializedConverter | SerializedStorage);
|
||||
|
||||
type SerializedConverter = {
|
||||
kind: 'converter';
|
||||
cycleTime?: DecimalSource; // по умолчанию 0
|
||||
storage?: Partial<Record<Resource, DecimalSource>>; // по умолчанию {}
|
||||
rules: {
|
||||
cycleLength: DecimalSource;
|
||||
inputRates?: Partial<Record<Resource, DecimalSource>>;
|
||||
outputRates?: Partial<Record<Resource, DecimalSource>>;
|
||||
}
|
||||
}
|
||||
|
||||
type SerializedStorage = {
|
||||
kind: 'storage';
|
||||
capacity?: DecimalSource; // по умолчанию бесконечность
|
||||
acceptsResources: Resource[];
|
||||
items: Partial<Record<Resource, DecimalSource>>;
|
||||
}
|
||||
```
|
||||
|
||||
Пример из `src/prefabs/game.ts` (полный рабочий граф — лес → лесопилка → два склада, второй склад забирает камень с той же связи, что и первый, демонстрируя `fairShare`):
|
||||
|
||||
```ts
|
||||
{
|
||||
id: 'forest', name: 'Лес',
|
||||
behaviour: {
|
||||
id: 'forest.1', kind: 'converter',
|
||||
inputLinks: { pins: [] },
|
||||
rules: { cycleLength: 1, outputRates: { tree: 1, stone: 0.1 } },
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'sawmill', name: 'Лесопилка',
|
||||
behaviour: {
|
||||
id: 'sawmill.1', kind: 'converter',
|
||||
inputLinks: { pins: [{ resource: 'tree', target: 'forest.1' }] },
|
||||
rules: { cycleLength: 1.8, inputRates: { tree: 1 }, outputRates: { wood: 2 } },
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'shop', name: 'Магазин',
|
||||
behaviour: {
|
||||
id: 'shop.1', kind: 'storage',
|
||||
inputLinks: { pins: [
|
||||
{ resource: 'wood', target: 'sawmill.1' },
|
||||
{ resource: 'stone', target: 'forest.1' }, // делит 'stone' с shop2 через fairShare
|
||||
] },
|
||||
acceptsResources: ['wood', 'stone'],
|
||||
items: {},
|
||||
},
|
||||
},
|
||||
```
|
||||
|
||||
API верхнего уровня: `serializeBehaviour`/`deserializeBehaviour` (диспетчер по `kind`), `serialize`/`deserialize` (весь `Game`), `serializeToString`/`deserializeFromString` (JSON), `save`/`load` (localStorage, ключ `` `${saveParams.path}_incgane` `` — `saveParams.path` можно менять, чтобы держать несколько независимых сохранений/слотов).
|
||||
|
||||
`Game.reset()` обнуляет `time` и вызывает `reset()` у каждого поведения (обнуляет только запасы — `cycleTime`, связи, ставки и id не трогает). `Game.clone()` — неглубокая копия с новым `Object.create`, нужна исключительно чтобы React увидел изменение ссылки после мутирующего `tick()`/`reset()`.
|
||||
|
||||
## Как расширять движок
|
||||
|
||||
### Добавить новый ресурс
|
||||
1. Добавить строку в union `Resource` (`src/types/resource.ts`).
|
||||
2. Добавить запись в `ResourceDescriptions` (`src/ui/resource.ts`) — `label`/`color`/`icon` для UI. Это **не часть движка**, но без неё UI упадёт при попытке отрисовать сокет/буфер с новым ресурсом (обращение по ключу без проверки).
|
||||
|
||||
### Добавить новый тип `Behaviour`
|
||||
1. Отнаследоваться от `Behaviour` (`src/engine/behaviours/base.ts`), реализовать все абстрактные члены: `inputs`, `outputs`, `take`, `give`, `getStorage`, `reset`, `tick`.
|
||||
2. В `tick()` — если поведение вообще что-то тянет через `inputLinks`, обязательно ограничивать запрос через переданный `fairShare(sourceId, resource)` (см. `Converter`/`Storage` как образец), иначе честное деление между несколькими потребителями не будет работать для этого нового типа.
|
||||
3. Добавить новый `kind`-литерал в тип `SerializedBehaviour` (объединение в `src/types/serialization.ts`) и обработать его в обоих `switch` в `src/engine/saveLoad.ts` (`serializeBehaviour` и `deserializeBehaviour`) — если забыть один из двух, поведение либо не сохранится, либо не восстановится при загрузке, без ошибки компиляции (проверьте оба места вручную).
|
||||
4. Если нужна собственная визуализация внутри карточки (как `ConverterCardInfo` для прогресс-бара конвертера) — расширить `BehaviourCard.tsx` условием по `behaviour.kind`, аналогично существующему `behaviour.kind === 'converter' && <ConverterCardInfo .../>`.
|
||||
|
||||
## Подводные камни
|
||||
|
||||
- **`Decimal` не бесконечно точен для обычных чисел.** Для величин масштаба `layer === 0` (не гипер-больших чисел) `break_eternity.js` внутри использует обычный JS `double` — привычные артефакты вроде `0.1 + 0.1 + 0.1 !== 0.3` воспроизводятся и здесь. Смена `number` → `Decimal`/строка это не лечит. Для отображения использовать `.toStringWithDecimalPlaces(n)`, а не сырой `.toString()`.
|
||||
- **Много маленьких тиков ≠ побитово один большой тик**, только математически эквивалентны — расхождение исключительно из-за многократного накопления `deltaTime` (см. выше), не из-за самого алгоритма `Converter`/`Storage`. Для офлайн-прогресса предпочитать один большой `tick(суммарное_время)`.
|
||||
- **`fairShare` не защищает от общего перерасхода**, если реализация нового `Behaviour` игнорирует его и вызывает `take()` напрямую без ограничения — на это нет проверки времени компиляции.
|
||||
- **Порядок узлов в `nodes` влияет на результат только в графах с циклами** (см. раздел про топосортировку); для обычного ациклического графа результат от порядка не зависит.
|
||||
- Тип `Resources = Record<Resource, Decimal>` (не `Partial`), но фактически везде в рантайме используется как `Partial<Resources>` — обращение по ключу может вернуть `undefined`, поэтому по всему движку принят паттерн `storage[resource] ?? Decimal.dZero`.
|
||||
|
||||
## Слой представления (не часть движка, но идёт в комплекте)
|
||||
|
||||
- `src/ui/graph.ts` — раскладка графа на плоскости через `elkjs` (слоистый layout, направление `LEFT`), асинхронно (`build2dNodes`).
|
||||
- `src/ui/resource.ts` — `ResourceDescriptions`: цвет/иконка/подпись на ресурс, для сокетов и буферов.
|
||||
- `src/components/GameCanvas.tsx` — измеряет реальные центры карточек/сокетов через DOM (`getBoundingClientRect`) после раскладки, чтобы линии связей (`LinkLine.tsx`) рисовались точно между сокетами, а не между условными координатами узла.
|
||||
- `src/components/BehaviourCard.tsx` — карточка узла: сокеты, буферы (`getDisplayInfo().storages`), для конвертера — прогресс-бар (`ConverterCardInfo.tsx`, использует `cycleTime.div(cycleLength)`), плюс отладочный YAML-дамп `info.raw`.
|
||||
- `src/App.tsx` — хранит единственный `Game` в `useState`, персистит в localStorage при каждом изменении, `handleTick` вызывает `game.tick(1/10)` + `setGame(game.clone())` (тик размером `0.1` игровой секунды на клик).
|
||||
|
||||
Ничего в `src/engine`/`src/types`/`src/utils` не импортирует из `src/components`/`src/ui`/React — движок можно использовать (или перенести под другой рендер) без этого слоя.
|
||||
@@ -0,0 +1,12 @@
|
||||
<!doctype html>
|
||||
<html lang="ru">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>Граф ресурсов — тиковая симуляция</title>
|
||||
</head>
|
||||
<body>
|
||||
<div id="root"></div>
|
||||
<script type="module" src="/src/main.tsx"></script>
|
||||
</body>
|
||||
</html>
|
||||
Generated
+1796
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,26 @@
|
||||
{
|
||||
"name": "@incgame/resource-graph-sim",
|
||||
"private": true,
|
||||
"version": "0.1.0",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"dev": "vite",
|
||||
"build": "tsc -b && vite build",
|
||||
"preview": "vite preview"
|
||||
},
|
||||
"dependencies": {
|
||||
"break_eternity.js": "^2.1.3",
|
||||
"elkjs": "^0.12.0",
|
||||
"react": "^18.3.1",
|
||||
"react-dom": "^18.3.1",
|
||||
"yaml": "^2.9.0",
|
||||
"@incgame/engine": "file:../engine"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/react": "^18.3.12",
|
||||
"@types/react-dom": "^18.3.1",
|
||||
"@vitejs/plugin-react": "^4.3.3",
|
||||
"typescript": "^5.6.3",
|
||||
"vite": "^5.4.10"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,147 @@
|
||||
import { useEffect, useState } from 'react';
|
||||
import Topbar from './components/Topbar';
|
||||
import { GameCanvas } from './components/GameCanvas';
|
||||
import { load, save } from './saveLoad';
|
||||
import { defaultGame } from './prefabs/game';
|
||||
import { Game, deserializeGame } from '@incgame/engine';
|
||||
|
||||
export type Selection = { kind: 'node'; id: string } | null;
|
||||
|
||||
export default function App() {
|
||||
const [game, setGame] = useState<Game>(() => load());
|
||||
const [selected, setSelected] = useState<Selection>(null);
|
||||
|
||||
useEffect(() => save(game), [game]);
|
||||
// useEffect(() => saveTickCount(tickCount), [tickCount]);
|
||||
|
||||
function handleTick() {
|
||||
game.tick(1.0 / 10);
|
||||
setGame(game.clone());
|
||||
}
|
||||
|
||||
function handleReset() {
|
||||
const ok = window.confirm(
|
||||
'Обнулить все значения и таймеры? Настройки узлов и связей не изменятся.'
|
||||
);
|
||||
if (!ok)
|
||||
return;
|
||||
|
||||
game.reset();
|
||||
setGame(game.clone());
|
||||
}
|
||||
|
||||
function handleInitialize() {
|
||||
const ok = window.confirm(
|
||||
'Удалить все объекты и начать игру с начала?'
|
||||
);
|
||||
if (!ok)
|
||||
return;
|
||||
|
||||
setGame(deserializeGame(defaultGame()));
|
||||
}
|
||||
|
||||
// function handleAddNode(kind: NodeKind) {
|
||||
// const idNum = game.nextId + 1;
|
||||
// const id = `${kind}-${idNum}`;
|
||||
// const node: SimNode = {
|
||||
// id,
|
||||
// label: kindLabel(kind),
|
||||
// x: 60 + (game.nodes.length * 25) % 600,
|
||||
// y: 60 + (game.nodes.length * 47) % 400,
|
||||
// capacity: kind === 'storage' ? 100 : null,
|
||||
// behavior: BEHAVIOR_DEFAULTS[kind],
|
||||
// };
|
||||
// setGame((prev) => ({ ...prev, nextId: idNum, nodes: [...prev.nodes, node] }));
|
||||
// setBuffers((prev) => ({ ...prev, [id]: {} }));
|
||||
// setSelected({ kind: 'node', id });
|
||||
// }
|
||||
|
||||
// function handleRemoveNode(id: string) {
|
||||
// setGame((prev) => ({
|
||||
// ...prev,
|
||||
// nodes: prev.nodes.filter((n) => n.id !== id),
|
||||
// edges: prev.edges.filter((e) => e.from !== id && e.to !== id),
|
||||
// }));
|
||||
// setBuffers((prev) => {
|
||||
// const next = { ...prev };
|
||||
// delete next[id];
|
||||
// return next;
|
||||
// });
|
||||
// setSelected((s) => (s && s.id === id ? null : s));
|
||||
// }
|
||||
|
||||
// function handleAddEdge() {
|
||||
// if (game.nodes.length < 2) return;
|
||||
// const idNum = game.nextId + 1;
|
||||
// const id = `e-${idNum}`;
|
||||
// const edge: SimEdge = {
|
||||
// id,
|
||||
// from: game.nodes[0].id,
|
||||
// to: game.nodes[1].id,
|
||||
// resource: 'wood',
|
||||
// rate: 1,
|
||||
// priority: 0,
|
||||
// };
|
||||
// setGame((prev) => ({ ...prev, nextId: idNum, edges: [...prev.edges, edge] }));
|
||||
// setSelected({ kind: 'edge', id });
|
||||
// }
|
||||
|
||||
// function handleRemoveEdge(id: string) {
|
||||
// setGame((prev) => ({ ...prev, edges: prev.edges.filter((e) => e.id !== id) }));
|
||||
// setSelected((s) => (s && s.id === id ? null : s));
|
||||
// }
|
||||
|
||||
// function handleUpdateNode(id: string, patch: Partial<SimNode>) {
|
||||
// setGame((prev) => ({
|
||||
// ...prev,
|
||||
// nodes: prev.nodes.map((n) => (n.id === id ? { ...n, ...patch } : n)),
|
||||
// }));
|
||||
// }
|
||||
|
||||
// function handleUpdateNodeBehavior(id: string, behavior: Behavior) {
|
||||
// handleUpdateNode(id, { behavior });
|
||||
// }
|
||||
|
||||
// function handleUpdateEdge(id: string, patch: Partial<SimEdge>) {
|
||||
// setGame((prev) => ({
|
||||
// ...prev,
|
||||
// edges: prev.edges.map((e) => (e.id === id ? { ...e, ...patch } : e)),
|
||||
// }));
|
||||
// }
|
||||
|
||||
// function handleDragNode(id: string, x: number, y: number) {
|
||||
// handleUpdateNode(id, { x, y });
|
||||
// }
|
||||
|
||||
return (
|
||||
<div id="app">
|
||||
<Topbar
|
||||
time={game.time}
|
||||
onTick={handleTick}
|
||||
onReset={handleReset}
|
||||
onInitialize={handleInitialize}
|
||||
/>
|
||||
|
||||
<div className="main">
|
||||
<GameCanvas
|
||||
game={game}
|
||||
selected={selected}
|
||||
onSelectNode={(id) => setSelected({ kind: 'node', id })}
|
||||
/>
|
||||
{/* <Sidebar
|
||||
game={game}
|
||||
selected={selected}
|
||||
onSelectNode={(id) => setSelected({ kind: 'node', id })}
|
||||
onSelectEdge={(id) => setSelected({ kind: 'edge', id })}
|
||||
onAddNode={handleAddNode}
|
||||
onAddEdge={handleAddEdge}
|
||||
onRemoveNode={handleRemoveNode}
|
||||
onRemoveEdge={handleRemoveEdge}
|
||||
onUpdateNode={handleUpdateNode}
|
||||
onUpdateNodeBehavior={handleUpdateNodeBehavior}
|
||||
onUpdateEdge={handleUpdateEdge}
|
||||
/> */}
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
import { forwardRef } from 'react';
|
||||
import { GraphNode } from '../ui/graph';
|
||||
import { ResourceDescriptions } from '../ui/resource';
|
||||
import { ConverterCardInfo } from './ConverterCardInfo';
|
||||
import { Game, Behaviour, Converter, Resource } from '@incgame/engine';
|
||||
import * as yaml from 'yaml';
|
||||
|
||||
|
||||
interface Props {
|
||||
game: Game;
|
||||
position: GraphNode['position'];
|
||||
behaviour: Behaviour,
|
||||
selected: boolean;
|
||||
onSelect: () => void;
|
||||
onSocketRef?: (type: 'input' | 'output', index: number, el: HTMLDivElement | null) => void;
|
||||
}
|
||||
|
||||
export const BehaviourCard = forwardRef<HTMLDivElement, Props>(function NodeCard({ position, behaviour, selected, onSelect, onSocketRef }, ref) {
|
||||
function handleClick() {
|
||||
onSelect();
|
||||
}
|
||||
|
||||
const info = behaviour.getDisplayInfo();
|
||||
const inputSockets = info.sockets.filter((s) => s.type === 'input');
|
||||
const outputSockets = info.sockets.filter((s) => s.type === 'output');
|
||||
|
||||
return (
|
||||
<div
|
||||
ref={ref}
|
||||
className={`node node--${behaviour.kind}${selected ? ' is-selected' : ''}`}
|
||||
style={{ left: position.x, top: position.y }}
|
||||
onClick={handleClick}
|
||||
>
|
||||
<div className="unit__sockets unit__sockets--input">
|
||||
{
|
||||
inputSockets.map((socket) => (
|
||||
<div
|
||||
key={`input.${socket.index}`}
|
||||
ref={(el) => onSocketRef?.('input', socket.index, el)}
|
||||
className="unit__socket"
|
||||
style={{ background: ResourceDescriptions[socket.resource].color }}
|
||||
title={`${ResourceDescriptions[socket.resource].label} (вход)`}
|
||||
/>
|
||||
))
|
||||
}
|
||||
</div>
|
||||
<div className="unit__sockets unit__sockets--output">
|
||||
{
|
||||
outputSockets.map((socket) => (
|
||||
<div
|
||||
key={`output.${socket.index}`}
|
||||
ref={(el) => onSocketRef?.('output', socket.index, el)}
|
||||
className="unit__socket"
|
||||
style={{ background: ResourceDescriptions[socket.resource].color }}
|
||||
title={`${ResourceDescriptions[socket.resource].label} (выход)`}
|
||||
/>
|
||||
))
|
||||
}
|
||||
</div>
|
||||
<div className="unit__id">#{behaviour.id}</div>
|
||||
<div className="unit__kind">{behaviour.kind}</div>
|
||||
{
|
||||
Object.entries(info.storages).map(([name, storage]) => (
|
||||
<div className="unit__resources" key={name}>
|
||||
<div>{name}</div>
|
||||
{
|
||||
Object.entries(storage)
|
||||
.map(([rt, v]) => `${ResourceDescriptions[rt as Resource].icon}${v.toStringWithDecimalPlaces(4)}`).join(' ')
|
||||
}
|
||||
</div>
|
||||
))
|
||||
}
|
||||
{/* <div className="unit__links">
|
||||
{info.links.map((link) => <div key={`${link.target}/${link.resource}`}>→{link.target}/{link.resource}</div>)}
|
||||
</div> */}
|
||||
{
|
||||
behaviour.kind === 'converter' && <ConverterCardInfo converter={behaviour as Converter} />
|
||||
}
|
||||
<div className="unit__debug" style={{ fontSize: '75%', whiteSpace: 'pre' }}>{yaml.stringify(info.raw, undefined, 4)}</div>
|
||||
</div>
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,14 @@
|
||||
import { Converter } from "@incgame/engine";
|
||||
|
||||
type Props = {
|
||||
converter: Converter;
|
||||
}
|
||||
|
||||
export const ConverterCardInfo = function ({ converter }: Props) {
|
||||
return <>
|
||||
<div className="unit__converter__progress">
|
||||
<div className="unit__converter__progress_bar" style={{ width: `${converter.cycleTime.div(converter.cycleLength).mul(100).toFixed(2)}%` }} />
|
||||
<div className="unit__converter__progress_info">{converter.cycleTime.toFixed(4)} of {converter.cycleLength.toFixed(4)}</div>
|
||||
</div>
|
||||
</>
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
import type { Selection } from '../App';
|
||||
import { BehaviourCard } from './BehaviourCard';
|
||||
import { build2dNodes, GraphNode } from '../ui/graph';
|
||||
import { useEffect, useLayoutEffect, useRef, useState } from 'react';
|
||||
import { LinkLine } from './LinkLine';
|
||||
import { Game } from '@incgame/engine';
|
||||
|
||||
interface Props {
|
||||
game: Game;
|
||||
selected: Selection;
|
||||
onSelectNode: (id: string) => void;
|
||||
}
|
||||
|
||||
export const GameCanvas = function ({
|
||||
game,
|
||||
selected,
|
||||
onSelectNode,
|
||||
}: Props) {
|
||||
|
||||
const canvasRef = useRef<HTMLDivElement>(null);
|
||||
const nodeElsRef = useRef<Map<string, HTMLDivElement>>(new Map());
|
||||
const socketElsRef = useRef<Map<string, HTMLDivElement>>(new Map());
|
||||
const [size, setSize] = useState({ width: 0, height: 0 });
|
||||
const [centers, setCenters] = useState<Record<string, { x: number, y: number }>>({});
|
||||
const [socketCenters, setSocketCenters] = useState<Record<string, { x: number, y: number }>>({});
|
||||
|
||||
useEffect(() => {
|
||||
const el = canvasRef.current;
|
||||
if (!el) return;
|
||||
const observer = new ResizeObserver(([entry]) => {
|
||||
const { width, height } = entry.contentRect;
|
||||
setSize({ width, height });
|
||||
});
|
||||
observer.observe(el);
|
||||
return () => observer.disconnect();
|
||||
}, []);
|
||||
|
||||
const [graphNodes, setNodes2d] = useState<GraphNode[]>([]);
|
||||
|
||||
useEffect(() => {
|
||||
let cancelled = false;
|
||||
build2dNodes(game.nodes, { width: size.width, height: size.height, padding: 40 })
|
||||
.then((result) => {
|
||||
if (!cancelled) setNodes2d(result);
|
||||
});
|
||||
return () => { cancelled = true; };
|
||||
}, [game.nodes, size.width, size.height]);
|
||||
|
||||
useLayoutEffect(() => {
|
||||
const worldEl = canvasRef.current;
|
||||
if (!worldEl) return;
|
||||
const worldRect = worldEl.getBoundingClientRect();
|
||||
|
||||
function centerOf(el: HTMLDivElement) {
|
||||
const rect = el.getBoundingClientRect();
|
||||
return {
|
||||
x: rect.left - worldRect.left + rect.width / 2,
|
||||
y: rect.top - worldRect.top + rect.height / 2,
|
||||
};
|
||||
}
|
||||
|
||||
const nextCenters: Record<string, { x: number, y: number }> = {};
|
||||
const nextSocketCenters: Record<string, { x: number, y: number }> = {};
|
||||
for (const graphNode of graphNodes) {
|
||||
const el = nodeElsRef.current.get(graphNode.entity.id);
|
||||
if (el) nextCenters[graphNode.entity.id] = centerOf(el);
|
||||
|
||||
for (const socket of graphNode.entity.getDisplayInfo().sockets) {
|
||||
const socketKey = `${graphNode.entity.id}.${socket.type}.${socket.index}`;
|
||||
const socketEl = socketElsRef.current.get(socketKey);
|
||||
if (socketEl) nextSocketCenters[socketKey] = centerOf(socketEl);
|
||||
}
|
||||
}
|
||||
setCenters(nextCenters);
|
||||
setSocketCenters(nextSocketCenters);
|
||||
}, [graphNodes]);
|
||||
|
||||
function withCenter(graphNode: GraphNode): GraphNode {
|
||||
const center = centers[graphNode.entity.id];
|
||||
return center ? { ...graphNode, position: center } : graphNode;
|
||||
}
|
||||
|
||||
function withSocket(graphNode: GraphNode, type: 'input' | 'output', resource: string): GraphNode {
|
||||
const socket = graphNode.entity.getDisplayInfo().sockets
|
||||
.find((s) => s.type === type && s.resource === resource);
|
||||
const center = socket && socketCenters[`${graphNode.entity.id}.${type}.${socket.index}`];
|
||||
return center ? { ...graphNode, position: center } : withCenter(graphNode);
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="world-wrap">
|
||||
<div id="world" ref={canvasRef}>
|
||||
{
|
||||
graphNodes.map((graphNode) =>
|
||||
graphNode.entity.inputLinks.map((link, idx) => {
|
||||
const target = graphNodes.find((gn) => gn.entity.id === link.target);
|
||||
return target && (
|
||||
<LinkLine
|
||||
game={game}
|
||||
key={`${graphNode.entity.id}.${idx}`}
|
||||
from={{ node: withSocket(graphNode, 'input', link.resource), resource: link.resource }}
|
||||
to={{ node: withSocket(target, 'output', link.resource), resource: link.resource }}
|
||||
/>
|
||||
);
|
||||
}))
|
||||
}
|
||||
{
|
||||
graphNodes.map((graphNode) => (
|
||||
<BehaviourCard
|
||||
ref={(el) => {
|
||||
if (el)
|
||||
nodeElsRef.current.set(graphNode.entity.id, el);
|
||||
else
|
||||
nodeElsRef.current.delete(graphNode.entity.id);
|
||||
}}
|
||||
onSocketRef={(type, index, el) => {
|
||||
const socketKey = `${graphNode.entity.id}.${type}.${index}`;
|
||||
if (el)
|
||||
socketElsRef.current.set(socketKey, el);
|
||||
else
|
||||
socketElsRef.current.delete(socketKey);
|
||||
}}
|
||||
game={game}
|
||||
key={graphNode.entity.id}
|
||||
position={graphNode.position}
|
||||
behaviour={graphNode.entity}
|
||||
selected={selected?.kind === 'node' && selected.id === graphNode.entity.id}
|
||||
onSelect={() => onSelectNode(graphNode.entity.id)}
|
||||
/>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
import { Game, Resource } from "@incgame/engine";
|
||||
import { GraphNode } from "../ui/graph";
|
||||
|
||||
type Props = {
|
||||
game: Game,
|
||||
from: { node: GraphNode, resource: Resource },
|
||||
to: { node: GraphNode, resource: Resource },
|
||||
}
|
||||
|
||||
export const LinkLine = function ({ from, to }: Props) {
|
||||
const markerId = `node-line-arrow-${from.node.entity.id}-${to.node.entity.id}`.replace(/[^a-zA-Z0-9_-]/g, '_');
|
||||
|
||||
const fromSocket = from.node.entity.getDisplayInfo().sockets.find((s) => s.type === 'input' && s.resource == from.resource);
|
||||
const toSocket = to.node.entity.getDisplayInfo().sockets.find((s) => s.type === 'output' && s.resource == to.resource);
|
||||
|
||||
if (!fromSocket || !toSocket)
|
||||
return null;
|
||||
|
||||
return (
|
||||
<svg>
|
||||
<defs>
|
||||
<marker
|
||||
id={markerId}
|
||||
viewBox="0 0 10 10"
|
||||
refX="9"
|
||||
refY="5"
|
||||
markerWidth="6"
|
||||
markerHeight="6"
|
||||
orient="auto-start-reverse"
|
||||
>
|
||||
<path d="M0,0 L10,5 L0,10 z" fill="white" />
|
||||
</marker>
|
||||
</defs>
|
||||
<line
|
||||
x1={from.node.position.x}
|
||||
y1={from.node.position.y}
|
||||
x2={to.node.position.x}
|
||||
y2={to.node.position.y}
|
||||
stroke="white"
|
||||
strokeWidth={2}
|
||||
markerStart={`url(#${markerId})`}
|
||||
/>
|
||||
</svg>
|
||||
);
|
||||
};
|
||||
@@ -0,0 +1,79 @@
|
||||
import type Decimal from 'break_eternity.js';
|
||||
import { useEffect, useRef } from 'react';
|
||||
import type { PointerEvent } from 'react';
|
||||
|
||||
interface Props {
|
||||
time: Decimal;
|
||||
onTick: () => void;
|
||||
onReset: () => void;
|
||||
onInitialize: () => void;
|
||||
}
|
||||
|
||||
const HOLD_TICK_INTERVAL_MS = 1000;
|
||||
const MIN_TICK_INTERVAL_MS = 50;
|
||||
|
||||
export default function Topbar({ time, onTick, onReset, onInitialize }: Props) {
|
||||
const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
|
||||
// Mutable, not React state: doTick reschedules itself via setTimeout, so it must always read
|
||||
// and write the CURRENT speed directly — a value captured in a render's closure (e.g. via
|
||||
// useState) would stay frozen for the lifetime of that closure, since nothing ever forces
|
||||
// doTick to be re-created from a fresh render while a hold is in progress.
|
||||
const speedRef = useRef(HOLD_TICK_INTERVAL_MS);
|
||||
|
||||
function stopHolding() {
|
||||
if (timeoutRef.current !== null) {
|
||||
clearTimeout(timeoutRef.current);
|
||||
timeoutRef.current = null;
|
||||
}
|
||||
speedRef.current = HOLD_TICK_INTERVAL_MS;
|
||||
}
|
||||
|
||||
function doTick() {
|
||||
onTick();
|
||||
speedRef.current = Math.max(MIN_TICK_INTERVAL_MS, Math.pow(speedRef.current, 0.97));
|
||||
timeoutRef.current = setTimeout(doTick, speedRef.current);
|
||||
}
|
||||
|
||||
function startHolding(e: PointerEvent<HTMLButtonElement>) {
|
||||
if (e.button !== 0)
|
||||
return;
|
||||
e.currentTarget.setPointerCapture(e.pointerId);
|
||||
stopHolding();
|
||||
doTick();
|
||||
}
|
||||
|
||||
useEffect(() => {
|
||||
window.addEventListener('blur', stopHolding);
|
||||
return () => {
|
||||
window.removeEventListener('blur', stopHolding);
|
||||
stopHolding();
|
||||
};
|
||||
}, []);
|
||||
|
||||
return (
|
||||
<div className="topbar">
|
||||
<h1 className="topbar__title">
|
||||
Граф ресурсов
|
||||
<span>детерминированная тиковая симуляция</span>
|
||||
</h1>
|
||||
<div className="tick-counter">
|
||||
Время <b>{time.toStringWithDecimalPlaces(4)}</b>
|
||||
</div>
|
||||
<div className="spacer" />
|
||||
<button className="btn" onClick={onInitialize}>
|
||||
Initialize
|
||||
</button>
|
||||
<button className="btn" onClick={onReset}>
|
||||
Reset
|
||||
</button>
|
||||
<button
|
||||
className="btn btn--primary"
|
||||
onPointerDown={startHolding}
|
||||
onPointerUp={stopHolding}
|
||||
onPointerCancel={stopHolding}
|
||||
>
|
||||
Tick ▶
|
||||
</button>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,503 @@
|
||||
:root {
|
||||
--bg: #201f1c;
|
||||
--panel: #29271f;
|
||||
--panel-2: #322f26;
|
||||
--line: #4a4536;
|
||||
--grid-line: rgba(196, 178, 138, 0.08);
|
||||
--ink: #e9e2d2;
|
||||
--ink-dim: #a89f8a;
|
||||
--accent-source: #7fae6a;
|
||||
--accent-storage: #a89f8a;
|
||||
--accent-converter: #d9a441;
|
||||
--accent-consumer: #c15a4e;
|
||||
--edge-color: #8a8a8a;
|
||||
--danger: #c15a4e;
|
||||
--mono: 'IBM Plex Mono', ui-monospace, monospace;
|
||||
--display: 'Space Grotesk', ui-sans-serif, sans-serif;
|
||||
}
|
||||
|
||||
* {
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
html,
|
||||
body,
|
||||
#root {
|
||||
margin: 0;
|
||||
height: 100%;
|
||||
background: var(--bg);
|
||||
color: var(--ink);
|
||||
font-family: var(--mono);
|
||||
font-size: 10pt;
|
||||
}
|
||||
|
||||
#app {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
height: 100vh;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------- top bar --- */
|
||||
|
||||
.topbar {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 20px;
|
||||
padding: 12px 20px;
|
||||
background: var(--panel);
|
||||
border-bottom: 1px solid var(--line);
|
||||
flex-shrink: 0;
|
||||
}
|
||||
|
||||
.topbar__title {
|
||||
font-family: var(--display);
|
||||
font-weight: 700;
|
||||
font-size: 150%;
|
||||
letter-spacing: 0.06em;
|
||||
text-transform: uppercase;
|
||||
color: var(--ink);
|
||||
margin: 0;
|
||||
border-right: 1px solid var(--line);
|
||||
padding-right: 16px;
|
||||
}
|
||||
|
||||
.topbar__title span {
|
||||
display: block;
|
||||
font-family: var(--mono);
|
||||
font-weight: 400;
|
||||
letter-spacing: 0.04em;
|
||||
color: var(--ink-dim);
|
||||
text-transform: none;
|
||||
margin-top: 2px;
|
||||
}
|
||||
|
||||
.tick-counter {
|
||||
font-family: var(--mono);
|
||||
color: var(--ink-dim);
|
||||
background: var(--panel-2);
|
||||
border: 1px solid var(--line);
|
||||
padding: 6px 12px;
|
||||
border-radius: 3px;
|
||||
}
|
||||
|
||||
.tick-counter b {
|
||||
color: var(--accent-converter);
|
||||
}
|
||||
|
||||
.spacer {
|
||||
flex: 1;
|
||||
}
|
||||
|
||||
.btn {
|
||||
font-family: var(--mono);
|
||||
font-weight: 500;
|
||||
letter-spacing: 0.03em;
|
||||
border: 1px solid var(--line);
|
||||
background: var(--panel-2);
|
||||
color: var(--ink);
|
||||
padding: 9px 16px;
|
||||
border-radius: 3px;
|
||||
cursor: pointer;
|
||||
transition: border-color 0.12s, transform 0.05s;
|
||||
}
|
||||
|
||||
.btn:hover {
|
||||
border-color: var(--ink-dim);
|
||||
}
|
||||
|
||||
.btn:active {
|
||||
transform: translateY(1px);
|
||||
}
|
||||
|
||||
.btn:focus-visible {
|
||||
outline: 2px solid var(--accent-converter);
|
||||
outline-offset: 2px;
|
||||
}
|
||||
|
||||
.btn--primary {
|
||||
background: var(--accent-converter);
|
||||
border-color: var(--accent-converter);
|
||||
color: #201f1c;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
.btn--primary:hover {
|
||||
border-color: #f0c169;
|
||||
}
|
||||
|
||||
.btn--danger {
|
||||
background: transparent;
|
||||
border-color: var(--danger);
|
||||
color: var(--danger);
|
||||
margin-top: 14px;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.btn--danger:hover {
|
||||
background: rgba(193, 90, 78, 0.12);
|
||||
}
|
||||
|
||||
.btn--ghost {
|
||||
background: transparent;
|
||||
border-style: dashed;
|
||||
color: var(--ink-dim);
|
||||
width: 100%;
|
||||
margin-top: 4px;
|
||||
}
|
||||
|
||||
.btn--icon {
|
||||
padding: 4px 8px;
|
||||
}
|
||||
|
||||
select {
|
||||
font-family: var(--mono);
|
||||
background: var(--panel-2);
|
||||
color: var(--ink);
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 3px;
|
||||
padding: 8px 10px;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------- main --- */
|
||||
|
||||
.main {
|
||||
flex: 1;
|
||||
display: flex;
|
||||
min-height: 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------- world --- */
|
||||
|
||||
.world-wrap {
|
||||
flex: 1;
|
||||
overflow: auto;
|
||||
position: relative;
|
||||
background-color: var(--bg);
|
||||
background-image:
|
||||
linear-gradient(var(--grid-line) 1px, transparent 1px),
|
||||
linear-gradient(90deg, var(--grid-line) 1px, transparent 1px);
|
||||
background-size: 24px 24px;
|
||||
}
|
||||
|
||||
#world {
|
||||
position: relative;
|
||||
width: 1600px;
|
||||
height: 900px;
|
||||
}
|
||||
|
||||
#world>svg {
|
||||
position: absolute;
|
||||
top: 0;
|
||||
left: 0;
|
||||
width: 1600px;
|
||||
height: 900px;
|
||||
pointer-events: none;
|
||||
}
|
||||
|
||||
#world>svg line {
|
||||
pointer-events: stroke;
|
||||
}
|
||||
|
||||
.node {
|
||||
position: absolute;
|
||||
background: var(--panel);
|
||||
border: 1px solid var(--line);
|
||||
border-left: 4px solid var(--accent-storage);
|
||||
border-radius: 4px;
|
||||
padding: 0.25em 0.5em;
|
||||
cursor: grab;
|
||||
user-select: none;
|
||||
box-shadow: 0 2px 6px rgba(0, 0, 0, 0.35);
|
||||
touch-action: none;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 0.25em;
|
||||
}
|
||||
|
||||
.node:active {
|
||||
cursor: grabbing;
|
||||
}
|
||||
|
||||
.node.is-selected {
|
||||
border-left-width: 4px;
|
||||
outline: 1.5px dashed var(--ink);
|
||||
outline-offset: 3px;
|
||||
}
|
||||
|
||||
.node--source {
|
||||
border-left-color: var(--accent-source);
|
||||
}
|
||||
|
||||
.node--storage {
|
||||
border-left-color: var(--accent-storage);
|
||||
}
|
||||
|
||||
.node--converter {
|
||||
border-left-color: var(--accent-converter);
|
||||
}
|
||||
|
||||
.node--consumer {
|
||||
border-left-color: var(--accent-consumer);
|
||||
}
|
||||
|
||||
.unit__id {
|
||||
font-family: var(--display);
|
||||
font-weight: 200;
|
||||
color: var(--ink);
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
|
||||
.unit__title {
|
||||
font-family: var(--display);
|
||||
font-weight: 600;
|
||||
font-size: 125%;
|
||||
color: var(--ink);
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
|
||||
.unit__kind {
|
||||
letter-spacing: 0.05em;
|
||||
text-transform: uppercase;
|
||||
color: var(--ink-dim);
|
||||
}
|
||||
|
||||
.unit__resources {
|
||||
background: #171613;
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 3px;
|
||||
padding: 4px 6px;
|
||||
letter-spacing: 0.02em;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.unit__links {
|
||||
background: #171613;
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 3px;
|
||||
padding: 4px 6px;
|
||||
letter-spacing: 0.02em;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.unit__converter__progress {
|
||||
font-size: 75%;
|
||||
background: #171613;
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 3px;
|
||||
padding: 1px 6px;
|
||||
letter-spacing: 0.02em;
|
||||
white-space: nowrap;
|
||||
position: relative;
|
||||
overflow: hidden;
|
||||
min-height: 10px;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
}
|
||||
|
||||
.unit__converter__progress_bar {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
z-index: 1;
|
||||
background: linear-gradient(90deg, var(--accent-converter), #f0c169);
|
||||
opacity: 0.3;
|
||||
transition: width 0.15s ease-out;
|
||||
}
|
||||
|
||||
.unit__converter__progress_info {
|
||||
position: relative;
|
||||
z-index: 2;
|
||||
color: var(--ink);
|
||||
}
|
||||
|
||||
.unit__sockets {
|
||||
position: absolute;
|
||||
top: 0;
|
||||
bottom: 0;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
gap: 6px;
|
||||
}
|
||||
|
||||
.unit__sockets--input {
|
||||
left: -5px;
|
||||
}
|
||||
|
||||
.unit__sockets--output {
|
||||
right: -5px;
|
||||
}
|
||||
|
||||
.unit__socket {
|
||||
width: 10px;
|
||||
height: 10px;
|
||||
border-radius: 50%;
|
||||
border: 1.5px solid var(--panel);
|
||||
box-shadow: 0 0 0 1px var(--edge-color);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------ sidebar --- */
|
||||
|
||||
.sidebar {
|
||||
width: 340px;
|
||||
flex-shrink: 0;
|
||||
background: var(--panel);
|
||||
border-left: 1px solid var(--line);
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
overflow-y: auto;
|
||||
}
|
||||
|
||||
.sidebar__section {
|
||||
padding: 14px 16px;
|
||||
border-bottom: 1px solid var(--line);
|
||||
}
|
||||
|
||||
.sidebar__section--grow {
|
||||
flex: 1;
|
||||
border-bottom: none;
|
||||
}
|
||||
|
||||
.sidebar__section h4 {
|
||||
font-family: var(--display);
|
||||
font-size: 11px;
|
||||
letter-spacing: 0.08em;
|
||||
text-transform: uppercase;
|
||||
color: var(--ink-dim);
|
||||
margin: 0 0 8px;
|
||||
}
|
||||
|
||||
.sidebar__list {
|
||||
list-style: none;
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
max-height: 140px;
|
||||
overflow-y: auto;
|
||||
}
|
||||
|
||||
.sidebar__list li {
|
||||
padding: 6px 8px;
|
||||
font-size: 11.5px;
|
||||
border-radius: 3px;
|
||||
cursor: pointer;
|
||||
color: var(--ink-dim);
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
|
||||
.sidebar__list li:hover {
|
||||
background: var(--panel-2);
|
||||
color: var(--ink);
|
||||
}
|
||||
|
||||
.sidebar__list li.is-active {
|
||||
background: var(--panel-2);
|
||||
color: var(--accent-converter);
|
||||
}
|
||||
|
||||
#sidebar-content {
|
||||
padding: 16px 0 0;
|
||||
flex: 1;
|
||||
overflow-y: auto;
|
||||
}
|
||||
|
||||
#sidebar-content h3 {
|
||||
font-family: var(--display);
|
||||
font-size: 13px;
|
||||
color: var(--ink);
|
||||
margin: 0 0 14px;
|
||||
word-break: break-all;
|
||||
}
|
||||
|
||||
.hint {
|
||||
color: var(--ink-dim);
|
||||
font-size: 11.5px;
|
||||
line-height: 1.5;
|
||||
}
|
||||
|
||||
.field {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 5px;
|
||||
margin-bottom: 12px;
|
||||
font-size: 11px;
|
||||
color: var(--ink-dim);
|
||||
}
|
||||
|
||||
.field input,
|
||||
.field select {
|
||||
font-family: var(--mono);
|
||||
font-size: 12px;
|
||||
background: var(--panel-2);
|
||||
color: var(--ink);
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 3px;
|
||||
padding: 7px 9px;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.field input:focus-visible,
|
||||
.field select:focus-visible {
|
||||
outline: 2px solid var(--accent-converter);
|
||||
outline-offset: 1px;
|
||||
}
|
||||
|
||||
.coord-row {
|
||||
display: flex;
|
||||
gap: 8px;
|
||||
}
|
||||
|
||||
.coord-row input {
|
||||
width: 50%;
|
||||
}
|
||||
|
||||
.recipe-box {
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 4px;
|
||||
padding: 10px;
|
||||
margin-bottom: 12px;
|
||||
background: var(--panel-2);
|
||||
}
|
||||
|
||||
.recipe-box__title {
|
||||
font-size: 10.5px;
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 0.06em;
|
||||
color: var(--ink-dim);
|
||||
margin-bottom: 8px;
|
||||
}
|
||||
|
||||
.recipe-row {
|
||||
display: flex;
|
||||
gap: 6px;
|
||||
margin-bottom: 6px;
|
||||
align-items: center;
|
||||
}
|
||||
|
||||
.recipe-row select {
|
||||
flex: 1.4;
|
||||
}
|
||||
|
||||
.recipe-row input {
|
||||
flex: 1;
|
||||
}
|
||||
|
||||
::-webkit-scrollbar {
|
||||
width: 9px;
|
||||
height: 9px;
|
||||
}
|
||||
|
||||
::-webkit-scrollbar-track {
|
||||
background: var(--bg);
|
||||
}
|
||||
|
||||
::-webkit-scrollbar-thumb {
|
||||
background: var(--line);
|
||||
border-radius: 5px;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
import React from 'react';
|
||||
import ReactDOM from 'react-dom/client';
|
||||
import App from './App';
|
||||
import './index.css';
|
||||
|
||||
ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render(
|
||||
<React.StrictMode>
|
||||
<App />
|
||||
</React.StrictMode>
|
||||
);
|
||||
@@ -0,0 +1,81 @@
|
||||
import { SerializedGame } from "@incgame/engine";
|
||||
|
||||
export const defaultGame: () => SerializedGame = () => ({
|
||||
time: 0,
|
||||
nodes: [
|
||||
{
|
||||
id: 'forest',
|
||||
name: 'Лес',
|
||||
behaviour: {
|
||||
id: 'forest.1',
|
||||
kind: 'converter',
|
||||
inputLinks: { pins: [] },
|
||||
rules: {
|
||||
cycleLength: 1,
|
||||
outputRates: { tree: 1, stone: 0.1 },
|
||||
}
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'sawmill',
|
||||
name: 'Лесопилка',
|
||||
behaviour: {
|
||||
id: 'sawmill.1',
|
||||
kind: 'converter',
|
||||
inputLinks: {
|
||||
pins: [
|
||||
{
|
||||
resource: 'tree',
|
||||
target: 'forest.1',
|
||||
},
|
||||
]
|
||||
},
|
||||
rules: {
|
||||
cycleLength: 1.8,
|
||||
inputRates: { tree: 1 },
|
||||
outputRates: { wood: 2 },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'shop',
|
||||
name: 'Магазин',
|
||||
behaviour: {
|
||||
id: 'shop.1',
|
||||
kind: 'storage',
|
||||
inputLinks: {
|
||||
pins: [
|
||||
{
|
||||
resource: 'wood',
|
||||
target: 'sawmill.1',
|
||||
},
|
||||
{
|
||||
resource: 'stone',
|
||||
target: 'forest.1',
|
||||
}
|
||||
]
|
||||
},
|
||||
acceptsResources: ['wood', 'stone'],
|
||||
items: {},
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'shop2',
|
||||
name: 'Магазин 2',
|
||||
behaviour: {
|
||||
id: 'shop.2',
|
||||
kind: 'storage',
|
||||
inputLinks: {
|
||||
pins: [
|
||||
{
|
||||
resource: 'stone',
|
||||
target: 'forest.1',
|
||||
}
|
||||
]
|
||||
},
|
||||
acceptsResources: ['stone'],
|
||||
items: {},
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
@@ -0,0 +1,25 @@
|
||||
import { defaultGame } from "./prefabs/game";
|
||||
import { Game, serializeGameToString, deserializeGame, deserializeGameFromString } from '@incgame/engine';
|
||||
|
||||
export const saveParams = {
|
||||
path: 'default',
|
||||
}
|
||||
|
||||
const KEY_GAME = 'incgame';
|
||||
|
||||
export function save(game: Game) {
|
||||
localStorage.setItem(`${saveParams.path}_${KEY_GAME}`, serializeGameToString(game));
|
||||
}
|
||||
|
||||
export function load(): Game {
|
||||
try {
|
||||
const raw = localStorage.getItem(`${saveParams.path}_${KEY_GAME}`);
|
||||
if (raw)
|
||||
return deserializeGameFromString(raw);
|
||||
} catch (e) {
|
||||
console.warn('Не удалось прочитать игру из localStorage', e);
|
||||
}
|
||||
const fresh = deserializeGame(defaultGame());
|
||||
save(fresh);
|
||||
return fresh;
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
import ELK, { ElkNode } from "elkjs/lib/elk.bundled.js";
|
||||
import { Unit, Behaviour } from "@incgame/engine";
|
||||
|
||||
const elk = new ELK();
|
||||
|
||||
const UNIT_WIDTH = 200;
|
||||
const NODE_HEIGHT = 150;
|
||||
|
||||
export type GraphNode = {
|
||||
position: { x: number, y: number };
|
||||
kind: 'behaviour';
|
||||
entity: Behaviour;
|
||||
}
|
||||
|
||||
export async function build2dNodes(units: Unit[], area: { width: number, height: number, padding: number }): Promise<GraphNode[]> {
|
||||
const entitiesById = new Map(units.map((unit) => [unit.behaviour.id, unit.behaviour]));
|
||||
|
||||
const graph: ElkNode = {
|
||||
id: "root",
|
||||
layoutOptions: {
|
||||
"elk.algorithm": "layered",
|
||||
"elk.direction": "LEFT",
|
||||
"elk.spacing.nodeNode": "100",
|
||||
"elk.layered.spacing.nodeNodeBetweenLayers": "100",
|
||||
},
|
||||
children: units.map((unit) => ({
|
||||
id: unit.behaviour.id,
|
||||
width: UNIT_WIDTH,
|
||||
height: NODE_HEIGHT,
|
||||
})),
|
||||
edges: units.flatMap((node) =>
|
||||
node.behaviour.inputLinks.map((link, idx) => ({
|
||||
id: `${node.behaviour.id}->${link.target}.${idx}`,
|
||||
sources: [node.behaviour.id],
|
||||
targets: [link.target],
|
||||
}))
|
||||
),
|
||||
};
|
||||
|
||||
const layout = await elk.layout(graph);
|
||||
|
||||
return (layout.children ?? []).map((child) => ({
|
||||
position: {
|
||||
x: (child.x ?? 0) + area.padding,
|
||||
y: (child.y ?? 0) + area.padding,
|
||||
},
|
||||
kind: 'behaviour',
|
||||
entity: entitiesById.get(child.id)!,
|
||||
}));
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
import { Resource } from "@incgame/engine";
|
||||
|
||||
export type ResourceDescription = {
|
||||
id: Resource;
|
||||
label: string;
|
||||
color: string;
|
||||
icon: string;
|
||||
}
|
||||
|
||||
export const ResourceDescriptions: Record<ResourceDescription['id'], ResourceDescription> = {
|
||||
tree: { id: 'tree', label: 'Дерево', color: '#b98249', icon: '🌲' },
|
||||
wood: { id: 'wood', label: 'Бревно', color: '#c9c209', icon: '🪵' },
|
||||
// iron: { id: 'iron', label: 'Железо', color: '#9aa7b0', icon: '⛓' },
|
||||
stone: { id: 'stone', label: 'Камень', color: '#8a8a8a', icon: '🪨' },
|
||||
// gold: { id: 'gold', label: 'Золото', color: '#d9b64e', icon: '💰' },
|
||||
// knowledge: { id: 'knowledge', label: 'Знание', color: '#7d8bf0', icon: '📖' },
|
||||
};
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2020",
|
||||
"useDefineForClassFields": true,
|
||||
"lib": ["ES2020", "DOM", "DOM.Iterable"],
|
||||
"module": "ESNext",
|
||||
"skipLibCheck": true,
|
||||
"moduleResolution": "bundler",
|
||||
"allowImportingTsExtensions": true,
|
||||
"resolveJsonModule": true,
|
||||
"isolatedModules": true,
|
||||
"noEmit": true,
|
||||
"jsx": "react-jsx",
|
||||
"strict": true,
|
||||
"noUnusedLocals": true,
|
||||
"noUnusedParameters": true,
|
||||
"noFallthroughCasesInSwitch": true
|
||||
},
|
||||
"include": ["src"]
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"files": [],
|
||||
"references": [
|
||||
{ "path": "./tsconfig.app.json" },
|
||||
{ "path": "./tsconfig.node.json" }
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"composite": true,
|
||||
"skipLibCheck": true,
|
||||
"module": "ESNext",
|
||||
"moduleResolution": "bundler",
|
||||
"allowSyntheticDefaultImports": true,
|
||||
"strict": true
|
||||
},
|
||||
"include": ["vite.config.ts"]
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import path from 'node:path';
|
||||
import { defineConfig } from 'vite';
|
||||
import react from '@vitejs/plugin-react';
|
||||
|
||||
const rootDir = path.dirname(fileURLToPath(import.meta.url));
|
||||
const engineDir = path.resolve(rootDir, '../engine');
|
||||
|
||||
export default defineConfig({
|
||||
plugins: [react()],
|
||||
resolve: {
|
||||
// Follow the node_modules symlink to the real sibling directory, so Vite's dev server
|
||||
// watches and transforms the actual engine source files (not a frozen pre-bundled copy).
|
||||
preserveSymlinks: false,
|
||||
},
|
||||
optimizeDeps: {
|
||||
// Treat @incgame/engine as first-party source, not a vendor dependency to pre-bundle once
|
||||
// and cache — otherwise edits to the engine package wouldn't trigger HMR until a full
|
||||
// dev-server restart.
|
||||
exclude: ['@incgame/engine'],
|
||||
},
|
||||
server: {
|
||||
fs: {
|
||||
// The engine package lives outside this project's root (a sibling directory reached
|
||||
// through a node_modules symlink); allow Vite to serve/watch files from there too.
|
||||
allow: [rootDir, engineDir],
|
||||
},
|
||||
},
|
||||
});
|
||||
Reference in New Issue
Block a user