Представьте мир, где каждый персонаж живёт своей жизнью: принимает решения, взаимодействует с окружающей средой и даже эволюционирует. Где почва, растения и ресурсы подчиняются сложным алгоритмам, а нейронные сети управляют поведением тысяч существ. Это не сценарий для нового блокбастера — это проект, над которым я работаю.
В этой статье я расскажу, как с помощью NestJS, TypeORM и Tensorflow.js создаю виртуальную вселенную, которая “дышит” и развивается. Мы разберём:
-
Как моделировать сложные системы: от почвы до социальных взаимодействий.
-
Как обучать нейронные сети, чтобы мир менялся реалистично
-
Как организовать архитектуру проекта, чтобы он масштабировался и оставался поддерживаемым.
Если вы когда-либо мечтали создать что-то масштабное, что объединяет технологии, науку и творчество, — этот проект для вас. Давайте погрузимся в код, который оживляет целый мир!
Общий обзор архитектуры
В основе нашего проекта лежит NestJS как каркас серверного приложения, TypeORM для удобного взаимодействия с базой данных (PostgreSQL), а также Redis для кэширования и хранения быстрых операций (например, при генерации мира или при расчётах, которые нужно повторять часто).
Кроме того, мы используем tensorflow.js (или планируем использовать) для создания простых нейронных сетей, которые принимают “интеллектуальные” решения за обитателей мира, будь то животные, люди или другие существа.
Для упрощения понимания мы можем представить всю логику, как набор Service-классов (в NestJS), которые управляют сущностями (Entities) в базе данных:
-
World (Мир) — корневая сущность, описывающая параметры целого мира (размер, климатические настройки, сезон и т.д.).
-
WorldCell (Ячейка мира) — единица поверхности (или объёма) нашего мира с информацией о высоте, широте/долготе, климате и т.д.
-
Soil (Почва) — содержит данные о типе почвы, её влажности, кислотности, текстуре и т.д.
-
Resource (Ресурс) — описывает ресурсы, которые можно добывать или расходовать (уголь, рыба, золото и т.д.), а также их качество, количество и возобновляемость.
Каждая из этих сущностей связана с другими с помощью отношений OneToOne, OneToMany или ManyToOne (аннотации @OneToOne, @OneToMany, @ManyToOne из TypeORM).
Итак, приступим
Все в нашем мире начинается с самого мира, конечно же! :) Прежде чем углубиться в код, представьте себя на месте создателя новой планеты. Что бы вы точно хотели задать “на берегу”?
-
Размер мира: насколько большой будет ваша планета?
-
Отправная точка — так называемый seaLevel. Ведь мы должны понять, где пролегает граница между сушей и водой.
-
Время и его течение: длина суток, сезоны, “возраст” мира. Потому что без времени всё замрёт на месте!
Остановитесь на минутку (да-да, прямо сейчас!) и подумайте: что ещё для вас есть в нашем прекрасном мире? Возможно, вы захотите задать среднюю температуру, чтобы заранее решить, будет ли ваш мир суровым ледником или тропическим раем.
Ниже я привожу пример того, какие поля в сущности World точно нужны нам для начала — это как минимальный набор “кнопок управления”, с которых стоит начать.
Создаем сущность мира
Ниже модель в /src/world/entities/world.entity.ts
@Entity('worlds')
export class World {
@PrimaryGeneratedColumn()
id: number; // Уникальный идентификатор мира
@Column()
name: string; // Название мира, например "Земля-2"
@Column('int')
width: number; // Ширина мира (в ячейках)
@Column('int')
height: number; // Высота мира (в ячейках)
@Column('float')
seaLevel: number; // Уровень моря — то самое "0", от которого считаем воду или сушу
@Column({ type: 'timestamp' })
startDate: Date;
// Дата "зарождения" мира
@Column({ type: 'timestamp' })
currentDate: Date;
// Текущее "время" в мире; разницу можно считать как возраст
@Column('float', { default: 24 })
dayLength: number;
// Длина "суток" в часах
@Column('float', { default: 365 })
yearLength: number;
// Длина "года" в днях
@Column('float', { default: 23.5 })
axialTilt: number;
// Угол наклона оси вращения (связан с сезонами)
@Column('float', { default: 15 })
averageTemperature: number;
// Средняя температура мира (°C)
@Column({
type: 'enum',
enum: Season,
default: Season.SPRING,
})
currentSeason: Season;
// Текущий сезон (зима, весна, лето, осень)
@OneToMany(() => WorldCell, (cell) => cell.world, { cascade: true, onDelete: 'CASCADE' })
cells: WorldCell[]; // Объявляем связь с "ячейками мира" чуть позже про них поговорим
}
Почему именно такие поля?
-
width и height задают количество ячеек по горизонтали и вертикали. Каждый “кусочек” вашей виртуальной планеты будет описан в WorldCell.
-
seaLevel влияет на то, какая часть планеты окажется под водой. Если вы фанат подводных цивилизаций, можно задать уровень моря повыше. Если хотите больше суши — пониже.
-
startDate и currentDate помогут отслеживать возраст мира. К примеру, если ваше существо прожило 1000 “игровых лет”, это может открывать новые возможности развития или видоизменять ландшафт.
-
dayLength, yearLength и axialTilt задают базовые механики смены дня и ночи, сезонов и других климатических переменных.
-
averageTemperature — базовая точка: от неё мы будем “плясать” при вычислении реальной температуры в каждой ячейке (учитывая высоту, влажность и широту).
В следующей части мы рассмотрим другие важные составляющие мира — ячейки (WorldCell) и почву (Soil), ведь каждый кусочек поверхности нашей планеты имеет уникальный рельеф, влажность, температуру и даже тип грунта. Но об этом — чуть позже, в духе лучших традиций мировой журналистики!
А пока, если хочется сделать перерыв — самое время. Представьте, как в вашем ещё пустом мире тихо плещется океан на заданном вами уровне моря, ветер несёт тёплые ароматы будущих лесов, а солнечный свет (или лунный — кто знает, ведь мы ещё не решили?) заливает равнины. Красота, не правда ли?
в /src/world создадим сервис (world.service.ts) и контроллер (world.controller.ts), так как мы будем использовать круд-генератор чтобы не заморачивать над базовыми crud операциями (create (post) read (get) update, delete)
// src/world/world.service.ts
import { Injectable, BadRequestException, InternalServerErrorException } from '@nestjs/common';
import { TypeOrmCrudService } from '@dataui/crud-typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { World } from './entities/world.entity';
@Injectable()
export class WorldService extends TypeOrmCrudService<World> {
constructor(
@InjectRepository(World) public repo: Repository<World>,
private readonly soilService: SoilService,
private readonly resourcesService: ResourcesService,
) {
super(repo);
}
}// src/world/world.controller.ts
import { Body, Controller } from '@nestjs/common';
import { Crud, CrudController, Override } from '@dataui/crud';
import { World } from './entities/world.entity';
import { WorldService } from './world.service';
@Crud({
model: {
type: World,
},
// Можно задать какие методы CRUD включать или исключать
routes: {
only: [
'createOneBase',
'getManyBase',
'getOneBase',
'updateOneBase',
'replaceOneBase',
'deleteOneBase',
],
},
})
@Controller('api/worlds')
export class WorldController implements CrudController<World> {
constructor(public service: WorldService) {}
}
И сам world.module.ts
// src/world/world.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { World } from './entities/world.entity';
import { WorldService } from './world.service';
import { WorldController } from './world.controller';
@Module({
imports: [TypeOrmModule.forFeature([World])],
controllers: [WorldController],
providers: [WorldService],
exports: [WorldService],
})
export class WorldModule {}
Идём дальше: знакомимся с ячейкой мира (WorldCell)
мы разобрались, как рождается сам мир и какие параметры ему необходимы. Но что такое планета без её “кирпичиков” — участков суши и водной поверхности? Правильно, нам нужна структура, где каждый сантиметр (или километр) вашего виртуального пространства будет иметь уникальные координаты, климат и, конечно же, почву и ресурсы.
Изначально я думал создать континенты и просто к ним привязывать почву, но потом я подумал, нет, этот подход породит много бесполезной логики, например будет сложно уничтожить отдельный участок континента поэтому было логично создать просто ячейки.
Именно так мы и приходим к WorldCell. Представьте себе, что вы парите высоко над своим миром и смотрите вниз, а под вами миллионы таких ячеек. В каждой есть особая жизнь и своя история. Готовы погрузиться? Поехали!
Я не стал или поленился создавать отдельную папку для ячеек и вшил все в папку src/world
(/src/world/entities/world-cell.entity.ts). Не пугайтесь обилия аннотаций — это просто магия TypeORM, которая берёт на себя рутинную работу с базой данных.
@Entity()
export class WorldCell {
@PrimaryGeneratedColumn()
id: number; // Уникальный идентификатор ячейки
@Column('jsonb')
position: {
x: number; // Координата X
y: number; // Координата Y
z: number; // Высота/глубина относительно уровня моря
};
@Column('float')
latitude: number; // Широта ячейки
@Column('float')
longitude: number; // Долгота ячейки
@OneToOne(() => Soil, { nullable: false, cascade: true, onDelete: 'CASCADE' })
@JoinColumn()
soil: Soil; // Ссылка на объект почвы
@OneToMany(() => Resource, (resource) => resource.cell, { cascade: true, onDelete: 'CASCADE' })
resources: Resource[]; // Ресурсы, принадлежащие ячейке
@Column('jsonb')
climate: {
temperature: number; //Темппература
humidity: number; // Влажность
precipitation: number; // Осадки
windSpeed: number; // Скорость ветра
cloudCoverage: number; // Покрытие облаками
dayTemperature: number; // Дневная температура
nightTemperature: number;// Ночная температура
weatherCondition: string;// Погодное состояние
};
@Column('float')
elevation: number; // Высота/глубина относительно уровня моря
@Column('boolean')
isWater: boolean; // Является ли ячейка водой
@Column({ default: BiomeType.PLAINS })
biome: BiomeType; // Тип биома (лес, пустыня, тундра и т.д.)
@ManyToOne(() => World, (world) => world.cells, { onDelete: 'CASCADE' })
world: World; // Связь с миром, какому миру принадлежит ячейка
}
Что здесь важного:
-
Координаты и высота. Каждая ячейка “знает” своё место на карте: поля position.x, position.y, position.z.
-
Широта и долгота. Это классический географический подход: нам важно понимать, где конкретно находится ячейка относительно “глобуса”.
-
Почва (Soil). У каждой ячейки есть только одна почва (@OneToOne). Мы делаем cascade: true, чтобы автоматически сохранять почву вместе с ячейкой.
-
Ресурсы (Resource[]). В одной ячейке может быть множество ресурсов — уголь, рыба, золото... Всё зависит от вашей фантазии (и реалистичности).
-
Климат. Здесь заложена вся погода ячейки: температура, влажность, осадки и т.д. А поле weatherCondition вроде “sunny” или “storm” добавляет капельку атмосферы.
-
isWater — указываем, покрыта ли ячейка водой. Представьте, как где-то под слоями кода скрывается целый океан с богатым подводным миром (который мы, конечно, тоже можем симулировать!).
-
biome — назначаем биом (лес, пустыня, пляж...), чтобы при желании легко фильтровать ячейки.
Сразу создадим BiomeType в src/world/ biome.enum.ts
export enum BiomeType {
OCEAN = 'OCEAN',
DESERT = 'DESERT',
SAVANNA = 'SAVANNA',
FOREST = 'FOREST',
RAINFOREST = 'RAINFOREST',
TUNDRA = 'TUNDRA',
MOUNTAINS = 'MOUNTAINS',
PLAINS = 'PLAINS',
BEACH = 'BEACH',
SWAMP = 'SWAMP',
LAKE = 'LAKE',
}Контроллер и сервис для WorldCell
Мы хотим быстро “подружить” нашу сущность WorldCell с REST-запросами. Для этого воспользуемся повторяющейся логикой, которая уже есть в @dataui/crud — так мы экономим время и силы.
WorldCellController
// src/world/world-cell.controller.ts
import { Controller } from '@nestjs/common';
import { Crud, CrudController } from '@dataui/crud';
import { WorldCell } from './entities/world-cell.entity';
import { WorldCellService } from './world-cell.service';
@Crud({
model: { type: WorldCell },
})
@Controller('api/world-cells')
export class WorldCellController implements CrudController<WorldCell> {
constructor(public service: WorldCellService) {}
}
Сервис
// src/world/world-cell.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { TypeOrmCrudService } from '@dataui/crud-typeorm';
import { Repository } from 'typeorm';
import { WorldCell } from './entities/world-cell.entity';
@Injectable()
export class WorldCellService extends TypeOrmCrudService<WorldCell> {
constructor(@InjectRepository(WorldCell) public repo: Repository<WorldCell>) {
super(repo);
}
}
Module
// src/world/world-cell.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { WorldCell } from './entities/world-cell.entity';
import { WorldCellService } from './world-cell.service';
import { WorldCellController } from './world-cell.controller';
@Module({
imports: [TypeOrmModule.forFeature([WorldCell])],
controllers: [WorldCellController],
providers: [WorldCellService],
exports: [WorldCellService],
})
export class WorldCellModule {}
Мы с вами уже построили каркас мира и научились разбивать его на ячейки. Но любая планета без почвы (Soil) и ресурсов (Resource) будет выглядеть пустынной заготовкой, верно? В этом разделе мы займёмся самой “сочной” частью: тем, что лежит у нас под ногами (почва) и тем, что мы можем извлечь или вырастить (ресурсы).
Если честно, я сначала думал ограничиться “одним типом почвы” — дескать, везде будет глина. Но представьте, насколько быстро бы наскучила такая “однообразная” планета! Поэтому давайте подарим вашему миру разнообразие. Смотрите, как это устроено в коде:
@Entity('soils')
export class Soil {
@PrimaryGeneratedColumn()
id: number; // Уникальный идентификатор почвы
@Column({
type: 'enum',
enum: SoilType,
default: SoilType.SANDY,
})
type: SoilType;
// Тип почвы (песчаная, глинистая и т.д.)
@Column('float')
fertility: number;
// Плодородие (0-1)
@Column('float')
humidity: number;
// Влажность (0-1)
@Column('float')
pH: number;
// Уровень pH (0-14)
@Column('jsonb')
position: {
x: number;
y: number;
z: number;
};
@Column('float', { default: 0.05 })
organicMatter: number;
// Содержание органики (доля от 0 до 1)
@Column({ default: 'loose' })
texture: string;
// Текстура (loose, compact, rocky и т.д.)
@Column({ default: 'brown' })
color: string;
// Цвет почвы, можно хранить в HEX или использовать enum
@Column('float', { default: 0 })
erosionLevel: number;
// Уровень эрозии (0 — нет, выше — сильнее)
}
Помимо типа почвы (SANDY, CLAY, LOAMY и т.д.), у нас есть:
-
Плодородие (fertility) — вероятность успешного роста растений.
-
Влажность (humidity) и pH — ключевые факторы для живых организмов.
-
Органика (organicMatter) — чем больше её в почве, тем пышнее расцветает жизнь.
-
Эрозия (erosionLevel) — куда без износа и ветров, которые “съедают” почву со временем?
Согласитесь, уже от одной мысли о стольких параметрах хочется поскорее “раскидать” разные полоски чернозёма и засушливые пустыни по карте!
Сервис и контроллер для Soil
Разумеется, чтобы быстро работать с данными о почве через REST, мы используем те же подходы, что и раньше:
-
SoilController:
// src/soils/soil.controller.ts
import { Controller } from '@nestjs/common';
import { Crud, CrudController } from '@dataui/crud';
import { Soil } from './/entities/soils.entity';
import { SoilService } from './soil.service';
@Crud({
model: { type: Soil },
})
@Controller('api/soils')
export class SoilController implements CrudController<Soil> {
constructor(public service: SoilService) {}
}
-
SoilService:
// src/soils/soil.service.ts
import { Injectable } from '@nestjs/common';
import { TypeOrmCrudService } from '@dataui/crud-typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Soil } from './entities/soils.entity';
import { SoilType } from './soils.enum';
@Injectable()
export class SoilService extends TypeOrmCrudService<Soil> {
constructor(@InjectRepository(Soil) public repo: Repository<Soil>) {
super(repo);
}
}-
SoilModule: собирает “под одной крышей” репозиторий, сервис и контроллер.
// src/soils/soil.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Soil } from './entities/soils.entity';
import { SoilService } from './soil.service';
import { SoilController } from './soil.controller';
@Module({
imports: [TypeOrmModule.forFeature([Soil])],
controllers: [SoilController],
providers: [SoilService],
exports: [SoilService],
})
export class SoilModule {}
И наш enum для тип почв
// src/enums/soil.enum.ts
export enum SoilType {
SANDY = 'SANDY', // Песчаная почва
CLAY = 'CLAY', // Глинистая почва
LOAMY = 'LOAMY', // Суглинистая почва
PEATY = 'PEATY', // Торфяная почва
CHALKY = 'CHALKY', // Известковая почва
ROCKY = 'ROCKY', // Каменистая почва
ABYSSAL_CLAY = 'ABYSSAL_CLAY', // Глубоководная глинистая почва
SILT = 'SILT', // Иловая почва
NONE = 'NONE', // Без определённого типа (нет почвы)
}Ресурсы (Resource): всё, что мы можем добыть или потратить
В вашем мире могут быть полезные ископаемые, биологические (рыба, лес) ресурсы. Разнообразие ресурсов только украшает симуяцию, но пока я сам и (мой старенький компьютер) не потянет каждую деталь нашего прекрасного мира xD
@Entity('resources')
export class Resource {
@PrimaryGeneratedColumn()
id: number; // Уникальный идентификатор ресурса
@Column({
type: 'enum',
enum: ResourceType,
})
type: ResourceType;
// Тип ресурса (уголь, железо, рыба, золото и т.д.)
@Column('float')
quantity: number;
// Количество ресурса
@Column('float')
quality: number;
// Качество ресурса (0-1)
@Column('jsonb')
position: {
x: number;
y: number;
z: number;
};
@Column('float')
depth: number;
// Глубина относительно уровня моря (z - seaLevel)
@Column('boolean', { default: false })
isRenewable: boolean;
// Возобновляемый ресурс или нет
@Column('float', { default: 0 })
regenerationRate: number;
// Скорость восстановления (если ресурс возобновляемый)
@Column({ type: 'timestamp', nullable: true })
usedUpAt: Date | null;
// Дата, когда ресурс был полностью израсходован (null = ещё не израсходован)
@ManyToOne(() => WorldCell, (cell) => cell.resources, { nullable: false })
cell: WorldCell;
// Ссылка на ячейку
}
Разбираемся в деталях:
-
quantity: сколько ещё осталось “угля/рыбы/и т.д.”? Если ресурс невозобновляемый, мы можем уменьшать это значение и в итоге отметить ресурс как “исчерпан”.
-
quality: на одном участке можно найти “высококачественную руду” (quality ≈ 0.9) или “не очень” (quality ≈ 0.2). Это влияет на эффективность добычи.
-
isRenewable и regenerationRate: логика возобновляемых ресурсов (например, лес или рыба), где со временем запасы восстанавливаются.
-
usedUpAt: дата полного исчерпания. Удобно хранить, чтобы, к примеру, восстанавливать ресурс спустя заданный период времени или вести статистику.
И, как всегда, не забываем про контроллер и сервис — всё та же схема:
// src/resources/resource.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { TypeOrmCrudService } from '@dataui/crud-typeorm';
import { Resource } from './entities/resources.entity';
import { ResourceType } from './resource.enum';
import { BiomeType } from 'src/world/biome.enum';
import { WorldCell } from 'src/world/entities/world-cell.entity';
// Для seedrandom, если нужен детерминизм для ресурсов
import type { PRNG } from 'seedrandom';
@Injectable()
export class ResourcesService extends TypeOrmCrudService<Resource> {
constructor(@InjectRepository(Resource) public repo: Repository<Resource>) {
super(repo);
}
}// src/resources/resource.controller.ts
import { Controller } from '@nestjs/common';
import { Crud, CrudController } from '@dataui/crud';
import { Resource } from './entities/resources.entity';
import { ResourcesService } from './resource.service';
@Crud({
model: { type: Resource },
})
@Controller('api/resources')
export class ResourcesController implements CrudController<Resource> {
constructor(public service: ResourcesService) {}
}
// src/resources/resource.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Resource } from './entities/resources.entity';
import { ResourcesController } from './resource.controller';
import { ResourcesService } from './resource.service';
@Module({
imports: [TypeOrmModule.forFeature([Resource])],
controllers: [ResourcesController],
providers: [ResourcesService],
exports: [ResourcesService],
})
export class ResourceModule {}
Наш enum для типов ресурса
// src/enums/resource.enum.ts
export enum ResourceType {
COAL = 'COAL', // Уголь
IRON = 'IRON', // Железо
FISH = 'FISH', // Рыба
OIL = 'OIL', // Нефть
GAS = 'GAS', // Газ
FOREST = 'FOREST', // Лес
MINERALS = 'MINERALS', // Минералы
FRESH_WATER = 'FRESH_WATER', // Пресная вода
CORAL = 'CORAL', // Кораллы
KELP = 'KELP', // Водоросли (ламинария)
SALT = 'SALT', // Соль
GOLD = 'GOLD', // Золото
}Немного о типах (Enums)
В проекте мы используем несколько enum-типов (перечислений), чтобы код был более выразительным. Например:
-
SoilType (SANDY, CLAY, LOAMY…) — разнообразие видов почвы.
-
ResourceType (COAL, FISH, GOLD, FOREST…) — что мы “добываем” или “растим”.
-
BiomeType (FOREST, DESERT, OCEAN…) — это уже мы видели у WorldCell, указывая общий “ландшафт”.
Зачем это нужно?
Enums помогают избежать “магических строк” вроде "fish" или "sandy" — в вашем коде теперь всё чётко: ResourceType.FISH говорит сам за себя. Плюс, если вдруг добавите CRYSTALS или MAGIC_WATER, просто расширяете enum, и всё работает дальше без багов и путаницы.
Соединяем мозаику
Итак, к этому моменту у нас есть:
-
Мир (World), хранящий глобальные параметры и коллекцию ячеек.
-
Ячейки (WorldCell), каждая из которых знает свою позицию, биом, климат и содержит ссылку на почву (Soil) и ресурсы (Resource[]).
-
Почва (Soil), которая описывает химические и физические свойства грунта.
-
Ресурсы (Resource) — “полезности”, которые мы можем добывать или восстанавливать.
Всё это даёт сильную базу для нашего виртуального мира. Каждый элемент подключён к базе данных через TypeORM и управляется с помощью контроллеров из @dataui/crud, а значит, CRUD-операции уже готовы “из коробки”.
Как насчёт того, чтобы сделать небольшую паузу и представить, как ваш мир уже выглядит на карте? Где-то наверняка тянутся леса (FOREST), а в других местах бурлят реки или сокрыты богатые золотые жилы (GOLD). Согласитесь, разбросив такие данные, вы уже получаете мини-песочницу для будущих симуляций.
Пару функций до того как приступим к написанию AI
Знаю, вы все уже заждались момента оживить все это дело, я также торопился и думал, да что такое! Когда уже я дойду до создания ИИ и начну симуляцию (. Чтобы не томить вас ожиданиями, просто объясню что нам нужно: научится создавать мир и ячейки с ресурсами и почвой. Чтобы не делать это "руками" напишем пару методов (пока они самые базовые и тут не используем ИИ, может быть чуть позже добавим так как тут ему тоже место быть), вы также можете подумать об этом и написать свои мысли в комментариях.
Метод создания мира, я буду сразу предоставлять код каждый в своем методе чтобы было легко развивать его и чтобы все "было на своем месте" и рекомендую вам придерживаться это структуры. Итак погнали!
Генерация мира и ячеек: как всё оживает
Для создания динамичного и детализированного мира нам нужно написать несколько вспомогательных методов, которые будут:
-
Генерировать мир на основе входных данных (ширина, высота, seaLevel и т.д.)
-
Использовать алгоритмы многократно-октавного шума для создания естественных ландшафтов
-
Распределять почву и ресурсы по ячейкам
Файл: /src/world/world.service.ts
import { Injectable, BadRequestException, InternalServerErrorException } from '@nestjs/common';
import { TypeOrmCrudService } from '@dataui/crud-typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import seedrandom, { PRNG } from 'seedrandom';
import { createNoise2D } from 'simplex-noise';
import { World } from './entities/world.entity';
import { CreateWorldDto } from './dto/create-world.dto';
import { SoilService } from 'src/soils/soil.service';
import { ResourcesService } from 'src/resources/resource.service';
import { WorldCellService } from './world-cell.service';
import { WorldCell } from './entities/world-cell.entity';
import { BiomeType } from './biome.enum';
import { Season } from './entities/world.entity';
import { SoilType } from 'src/soils/soils.enum';
import { Soil } from 'src/soils/entities/soils.entity';
import { Resource } from 'src/resources/entities/resources.entity';
@Injectable()
export class WorldService extends TypeOrmCrudService<World> {
constructor(
@InjectRepository(World) public repo: Repository<World>,
private readonly soilService: SoilService,
private readonly resourcesService: ResourcesService,
private readonly worldCellService: WorldCellService,
) {
super(repo);
}
/**
* Генерация нового мира на основе CreateWorldDto с использованием транзакции.
*/
async createWorld(dto: CreateWorldDto): Promise<World> {
// Дополнительная валидация: не допускаем слишком большой мир.
if (dto.width * dto.height > 2_000_000) {
throw new BadRequestException('World too large for a single generation (max 2M cells)');
}
// Создаём seed-based PRNG для детерминированного случайного выбора.
const prng = seedrandom(dto.noiseSeed || 'default-seed');
try {
return await this.repo.manager.transaction(async manager => {
// 1. Создаем запись World в транзакции.
const world = manager.create(World, {
name: dto.name,
width: dto.width,
height: dto.height,
seaLevel: dto.seaLevel,
startDate: dto.startDate,
currentDate: dto.currentDate,
dayLength: dto.dayLength,
yearLength: dto.yearLength,
axialTilt: dto.axialTilt,
averageTemperature: dto.averageTemperature,
currentSeason: dto.currentSeason,
});
await manager.save(world);
// 2. Подготавливаем шумы для генерации высоты и влажности.
const elevationNoise2D = createNoise2D(prng);
const moistureNoise2D = createNoise2D(seedrandom(dto.noiseSeed ? dto.noiseSeed + '_moisture' : undefined));
// Массив для хранения генерируемых ячеек.
const worldCells: WorldCell[] = [];
// Отдельный массив для ресурсов.
const allResources: Resource[] = [];
// Параметры многооктавного шума.
const octaves = dto.octaves ?? 4;
const persistence = dto.persistence ?? 0.5;
const lacunarity = dto.lacunarity ?? 2.0;
// Генерируем ячейки мира.
for (let y = 0; y < dto.height; y++) {
for (let x = 0; x < dto.width; x++) {
const rawElev = this.multiOctaveNoise2D(elevationNoise2D, x, y, dto.noiseScale, octaves, persistence, lacunarity, prng);
const rawMoist = this.multiOctaveNoise2D(moistureNoise2D, x, y, dto.moistureNoiseScale, octaves, persistence, lacunarity, prng);
// Высота варьируется от -200 до +200.
const elevation = rawElev * 400 - 200;
const isWater = elevation < dto.seaLevel; // Если elevation < seaLevel, то ячейка водная.
// Пример расчета широты и долготы.
const latitude = (y / dto.height) * 180 - 90; // [-90..+90]
const longitude = (x / dto.width) * 360 - 180; // [-180..+180]
// Расчет температуры с учетом высоты, широты и сезона.
const temperature = this.calculateCellTemperature({
averageTemp: dto.averageTemperature,
elevation,
latitude,
season: dto.currentSeason,
}, prng);
// Определение биома на основе высоты, влажности и температуры.
const biome = this.determineBiome(elevation, rawMoist, temperature);
// Генерация почвы.
const soilType: SoilType = this.soilService.determineSoilType(
elevation, rawMoist, temperature, 7, isWater
);
const soil: Soil = this.soilService.createSoil({
soilType,
humidity: rawMoist,
elevation,
x,
y,
});
// Создаем ячейку мира.
const cell = new WorldCell();
cell.world = world;
cell.position = { x, y, z: elevation };
cell.latitude = latitude;
cell.longitude = longitude;
cell.soil = soil;
cell.isWater = isWater;
cell.elevation = elevation;
cell.biome = biome;
cell.climate = {
temperature,
humidity: rawMoist,
precipitation: rawMoist * 100,
windSpeed: 5,
cloudCoverage: 0.3,
dayTemperature: temperature + 5,
nightTemperature: temperature - 5,
weatherCondition: 'sunny',
};
worldCells.push(cell);
// Генерируем ресурсы для ячейки.
const cellResources = this.resourcesService.generateResourcesForCell(cell, prng);
allResources.push(...cellResources);
}
}
// 3. Сохраняем ячейки чанками для оптимизации памяти.
await this.chunkedSaveCells(worldCells, manager);
// 4. Сохраняем ресурсы чанками.
await this.chunkedSaveResources(allResources, manager);
return world;
});
} catch (err) {
throw new InternalServerErrorException(`World generation failed: ${err.message}`);
}
}
/**
* Многооктавный шум (2D) для генерации естественного ландшафта.
*/
private multiOctaveNoise2D(
noiseFn: (x: number, y: number) => number,
x: number,
y: number,
scale: number,
octaves: number,
persistence: number,
lacunarity: number,
prng: PRNG,
): number {
let amplitude = 1;
let frequency = 1;
let total = 0;
let maxValue = 0;
for (let i = 0; i < octaves; i++) {
const nx = (x * frequency) / scale;
const ny = (y * frequency) / scale;
// Приводим значение шума из диапазона [-1, 1] в [0, 1]
const val = (noiseFn(nx, ny) + 1) / 2;
total += val * amplitude;
maxValue += amplitude;
amplitude *= persistence;
frequency *= lacunarity;
}
return total / maxValue;
}
/**
* Простейшая логика расчета температуры с учетом высоты, широты и сезона.
*/
private calculateCellTemperature(
options: {
averageTemp: number;
elevation: number;
latitude: number;
season: Season;
},
prng: PRNG,
): number {
const { averageTemp, elevation, latitude, season } = options;
let temp = averageTemp;
// Эффект высоты: чем выше, тем холоднее.
const elevationEffect = -0.01 * elevation;
temp += elevationEffect;
// Эффект широты: ближе к полюсам температура ниже.
const latRatio = Math.abs(latitude) / 90;
const latitudeEffect = -15 * latRatio;
temp += latitudeEffect;
// Эффект сезона (пример для северного и южного полушарий)
const isNorthern = latitude >= 0;
let seasonOffset = 0;
switch (season) {
case Season.WINTER:
seasonOffset = isNorthern ? -10 : 5;
break;
case Season.SUMMER:
seasonOffset = isNorthern ? 5 : -10;
break;
case Season.SPRING:
case Season.AUTUMN:
seasonOffset = 0;
break;
}
temp += seasonOffset;
return temp;
}
/**
* Простое распределение биомов по параметрам высоты, влажности и температуры.
*/
private determineBiome(elevation: number, humidity: number, temperature: number): BiomeType {
if (elevation < -5) return BiomeType.OCEAN;
if (elevation >= -5 && elevation <= 5) return BiomeType.BEACH;
if (temperature < 0) return BiomeType.TUNDRA;
if (humidity < 0.2) return BiomeType.DESERT;
if (humidity < 0.4) return BiomeType.SAVANNA;
if (humidity < 0.6) return BiomeType.PLAINS;
if (humidity < 0.8) return BiomeType.FOREST;
return BiomeType.RAINFOREST;
}
/**
* Сохранение ячеек чанками для оптимизации.
*/
private async chunkedSaveCells(cells: WorldCell[], manager: any) {
const CHUNK_SIZE = 2000;
for (let i = 0; i < cells.length; i += CHUNK_SIZE) {
const chunk = cells.slice(i, i + CHUNK_SIZE);
await manager.save(WorldCell, chunk);
}
}
/**
* Сохранение ресурсов чанками.
*/
private async chunkedSaveResources(resources: Resource[], manager: any) {
const CHUNK_SIZE = 2000;
for (let i = 0; i < resources.length; i += CHUNK_SIZE) {
const chunk = resources.slice(i, i + CHUNK_SIZE);
await manager.save(Resource, chunk);
}
}
}
Объясняю
-
Проверка размера: если мир слишком большой (более двух миллионов ячеек), выбрасываем ошибку. Это пример простой валидации, чтобы обезопасить сервер от чрезмерной нагрузки.
-
seedrandom: используем библиотеку seedrandom, чтобы все наши «случайные» числа были воспроизводимы. Укажем в dto.noiseSeed любой seed — и при повторном запуске генерация мира даст тот же результат.
-
Транзакция: оборачиваем всё в manager.transaction(...), чтобы если что-то пойдёт не так (например, не хватило памяти), весь процесс откатился и в базе не осталось «полусгенерированных» данных.
Внутри транзакции делаем сразу несколько шагов:
1. Создаём сам World
-
С помощью manager.create(...) и manager.save(...) создаём новую запись в таблице world.
-
Поля подставляем из CreateWorldDto.
2. Готовим шумы для высоты и влажности
-
Используем simplex-noise (через createNoise2D(...)), чтобы получить двумерный шум.
-
Первый шум (elevationNoise2D) отвечает за рельеф (высоты гор, впадин и т.д.).
-
Второй (moistureNoise2D) — за влажность, от которой будет зависеть биом (леса, пустыни, болота…).
3. Генерация ячеек
-
Внутри двойного цикла (width * height) мы для каждой точки (x, y) генерируем высоту, влажность, температуру, определяем биом и тип почвы.
-
isWater вычисляем путём сравнения высоты ячейки с уровнем моря (seaLevel).
-
Собранные объекты WorldCell и Resource временно храним в массивах, чтобы потом сохранить их в базу скопом (чанками).
Многооктавный шум
-
Эта вспомогательная функция «наслаивает» несколько «октав» шума друг на друга. Так рельеф (или влажность) получается более натуральным, с деталями разных масштабов.
Расчёт температуры
-
Здесь мы простенько моделируем влияние высоты, широты и сезона на температуру.
-
В реальности можно «накрутить» куда более сложные условия а в будущем полноценную ИИ (я про учёт течений, влажности и т.д.).
Определение биома
-
Ещё одна «табличная» логика: на основании высоты, влажности и температуры решаем, какой биом присвоить ячейке.
-
Тут можно задавать пороги как угодно — реалистичность или сказочность целиком в наших руках.
Сохранение ячеек и ресурсов чанками
-
Чтобы не захлебнуться в десятках (или сотнях) тысяч ячеек, разбиваем их на партии по 2000–3000 штук и сохраняем последовательно.
-
Аналогично делаем с ресурсами.
Таким образом, метод createWorld создаёт целую «планету» за один проход, распределяя высоты, биомы, почву, ресурсы и многое другое.
Для валидации данных будем использовать dto
// src/world/dto/create-world.dto.ts
import { IsNotEmpty, IsNumber, IsOptional, IsString, Min, Max } from 'class-validator';
import { Season } from '../entities/world.entity';
export class CreateWorldDto {
@IsString()
@IsNotEmpty()
name: string;
@IsNumber()
@Min(1)
width: number;
@IsNumber()
@Min(1)
height: number;
@IsNumber()
// Условные ограничения
@Min(-500)
@Max(500)
seaLevel: number;
// Даты
startDate: Date;
currentDate: Date;
// Параметры "суток/года"
@IsNumber()
dayLength: number;
@IsNumber()
yearLength: number;
// Наклон оси
@IsNumber()
axialTilt: number;
// Базовая температура
@IsNumber()
averageTemperature: number;
// Текущий сезон
currentSeason: Season;
// Параметры шума
@IsNumber()
noiseScale: number; // масштаб шума для высоты
@IsOptional()
@IsString()
noiseSeed?: string; // seed для детерминированной генерации
@IsNumber()
moistureNoiseScale: number; // масштаб шума для влажности
// Дополнительные параметры октав, persistence и т.д.
@IsOptional()
@IsNumber()
octaves?: number;
@IsOptional()
@IsNumber()
persistence?: number;
@IsOptional()
@IsNumber()
lacunarity?: number;
}
-
Тут всё просто: определяем структуру запроса, валидируем типы и диапазоны (@Min, @Max и т.д.).
-
NestJS с помощью class-validator и class-transformer умеет автоматически проверять входящие данные и возвращать клиенту понятную ошибку, если что-то не так.
SoilService: добавим методы нужные для создания мира
// src/soils/soil.service.ts
import { Injectable } from '@nestjs/common';
import { TypeOrmCrudService } from '@dataui/crud-typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Soil } from './entities/soils.entity';
import { SoilType } from './soils.enum';
@Injectable()
export class SoilService extends TypeOrmCrudService<Soil> {
constructor(@InjectRepository(Soil) public repo: Repository<Soil>) {
super(repo);
}
/**
* Создаёт новый объект Soil на основе входных данных:
* - soilType (результат score или любой другой логики)
* - humidity
* - elevation
* - position
* - etc.
* При необходимости можно расширить логику (подбирать цвет, texture и т.д.)
*/
public createSoil(params: {
soilType: SoilType;
humidity: number;
elevation: number;
x: number;
y: number;
fertility?: number;
pH?: number;
}): Soil {
const soil = new Soil();
soil.type = params.soilType;
soil.fertility = params.fertility ?? this.randomInRange(0.3, 0.8);
soil.humidity = params.humidity;
soil.pH = params.pH ?? 7;
soil.position = { x: params.x, y: params.y, z: params.elevation };
soil.organicMatter = 0.05;
soil.texture = 'loose';
soil.color = 'brown';
soil.erosionLevel = 0;
return soil;
}
/**
* Если нужно доработать логику определения типа почвы (score),
* вы можете вызвать этот метод.
*/
public determineSoilType(
elevation: number,
humidity: number,
temperature: number,
pH: number,
isWater: boolean,
): SoilType { // здесь можно использовать пока также условия
// Возвращает SoilType
return SoilType.SANDY;
}
// Можно перенести randomInRange в утилиты, но для наглядности оставим внутри
private randomInRange(min: number, max: number) {
return Math.random() * (max - min) + min;
}
}
-
В методе createSoil создаём объект почвы с параметрами: fertility, humidity, pH, тип (soil.type) и т.д.
-
determineSoilType(...) — дополнительная логика, где по совокупности условий (elevation, вода/не вода, температура) выбирается конкретный SoilType (глина, песок, торф и т.д.). (мне было лень его дописать, так как хотел учесть много факторов и сделать это позже) извините :)
ResourcesService: ресурсы и их генерация
Аналогичная концепция: для каждого участка (ячейки) мы определяем, какие ресурсы там могут быть найдены.
// src/resources/resource.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { TypeOrmCrudService } from '@dataui/crud-typeorm';
import { Resource } from './entities/resources.entity';
import { ResourceType } from './resource.enum';
import { BiomeType } from 'src/world/biome.enum';
import { WorldCell } from 'src/world/entities/world-cell.entity';
// Для seedrandom, если нужен детерминизм для ресурсов
import type { PRNG } from 'seedrandom';
@Injectable()
export class ResourcesService extends TypeOrmCrudService<Resource> {
constructor(@InjectRepository(Resource) public repo: Repository<Resource>) {
super(repo);
}
/**
* Определяет возможные ресурсы в зависимости от биома, воды, высоты и т.д.
*/
public getPossibleResources(
biome: BiomeType,
isWater: boolean,
elevation: number,
): ResourceType[] {
if (isWater) {
return [ResourceType.FISH, ResourceType.OIL, ResourceType.GAS];
}
switch (biome) {
case BiomeType.DESERT:
return [ResourceType.OIL, ResourceType.GAS, ResourceType.MINERALS];
case BiomeType.FOREST:
return [ResourceType.FOREST, ResourceType.COAL, ResourceType.MINERALS];
case BiomeType.RAINFOREST:
return [ResourceType.FOREST, ResourceType.MINERALS];
case BiomeType.MOUNTAINS:
return [ResourceType.MINERALS, ResourceType.IRON, ResourceType.COAL];
case BiomeType.SAVANNA:
return [ResourceType.FOREST, ResourceType.MINERALS];
case BiomeType.TUNDRA:
return [ResourceType.GAS, ResourceType.MINERALS];
case BiomeType.PLAINS:
return [ResourceType.FOREST, ResourceType.MINERALS, ResourceType.FRESH_WATER];
default:
return [ResourceType.MINERALS];
}
}
/**
* Выбор случайного ресурса из списка (если нужна равная вероятность).
*/
public pickRandomResource(resources: ResourceType[], prng?: PRNG): ResourceType {
if (!resources.length) throw new Error('Empty resource array');
const idx = prng
? Math.floor(prng() * resources.length)
: Math.floor(Math.random() * resources.length);
return resources[idx];
}
/**
* Генерация ресурсов для конкретной ячейки.
* Можно улучшать логику, учитывать редкость, вероятность и т.д.
*/
public generateResourcesForCell(
cell: WorldCell,
prng?: PRNG,
): Resource[] {
const possible = this.getPossibleResources(cell.biome, cell.isWater, cell.elevation);
if (!possible.length) return [];
// Допустим, мы создаём 1 случайный ресурс из возможных.
// Или можно создать несколько: редкие, распространённые, и т.д.
const chosenType = this.pickRandomResource(possible, prng);
const quantity = prng ? prng() * 200 + 50 : Math.random() * 200 + 50;
const quality = prng ? prng() * 0.5 + 0.5 : Math.random() * 0.5 + 0.5;
const resource = new Resource();
resource.type = chosenType;
resource.quantity = quantity;
resource.quality = quality;
resource.position = cell.position; // или какие-то сдвиги
resource.depth = cell.isWater ? Math.abs(cell.elevation) : 0;
resource.isRenewable = false;
resource.regenerationRate = 0;
resource.usedUpAt = null;
resource.cell = cell;
return [resource];
}
/**
* Сохранение пакета ресурсов (с учётом chunk)
*/
public async saveResources(resources: Resource[]): Promise<void> {
const CHUNK_SIZE = 1000;
for (let i = 0; i < resources.length; i += CHUNK_SIZE) {
const chunk = resources.slice(i, i + CHUNK_SIZE);
await this.repo.save(chunk);
}
}
}
-
В зависимости от биома и других факторов (вода или суша, горы или равнины) возвращаем массив возможных типов ресурса.
-
Потом из этого массива выбираем один (или несколько) случайным образом (generateResourcesForCell)
-
quantity и quality тоже задаются случайно, чтобы один и тот же биом мог иметь разные объёмы ресурсов.
-
Можно доработать: вероятность появления редких ресурсов, лимиты, респаун и т.д.
Не забудем добавить сервисы а точнее их модули в world.module.ts
// src/world/world.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { World } from './entities/world.entity';
import { WorldService } from './world.service';
import { WorldController } from './world.controller';
import { WorldCellModule } from './world-cell.module';
import { ResourceModule } from 'src/resources/resource.module';
import { SoilModule } from 'src/soils/soil.module';
@Module({
imports: [TypeOrmModule.forFeature([World]), WorldCellModule, ResourceModule, SoilModule],
controllers: [WorldController],
providers: [WorldService],
exports: [WorldService],
})
export class WorldModule {}
А также дополним наш контроллер
// src/world/world.controller.ts
import { Body, Controller } from '@nestjs/common';
import { Crud, CrudController, Override } from '@dataui/crud';
import { World } from './entities/world.entity';
import { WorldService } from './world.service';
import { CreateWorldDto } from './dto/create-world.dto';
@Crud({
model: {
type: World,
},
// Настройки запросов:
query: {
// Отключить пагинацию по умолчанию (или оставить true, если нужно)
alwaysPaginate: false,
// Лимит и максимальный лимит для запросов ?limit=
limit: 50,
maxLimit: 1000,
// Описание связей (join), которые мы хотим подгружать автоматически
join: {
// Подгрузить ячейки (OneToMany)...
cells: {
eager: true, // подгрузить автоматически
},
// ...и внутри ячеек - почву (OneToOne)
'cells.soil': {
eager: true,
},
// ...и ресурсы (OneToMany)
'cells.resources': {
eager: true,
},
},
},
// Можно задать какие методы CRUD включать или исключать
routes: {
only: [
'createOneBase',
'getManyBase',
'getOneBase',
'updateOneBase',
'replaceOneBase',
'deleteOneBase',
],
// или, например, exclude: ['replaceOneBase', ...] - если не нужен PUT
},
})
@Controller('api/worlds')
export class WorldController implements CrudController<World> {
constructor(public service: WorldService) {}
// Переопределяем create, чтобы использовать нашу кастомную логику
@Override('createOneBase')
async createOne(@Body() dto: CreateWorldDto) {
return this.service.createWorld(dto);
}
}
Здесь мы просто настроили квери запросы чтобы получать все связанные сущности с нашем миром (ячейки у ячеек ресурсы и почвы) а также переопределяем метод crud generator для создания мира с помощью нашей логики теперь наконец сделав запрос POST по localhost:3000/api/worlds со следующими телом запроса:
{
"name": "MiniWorld",
"width": 30,
"height": 20,
"seaLevel": 0,
"startDate": "2025-01-01T00:00:00.000Z",
"currentDate": "2025-01-10T00:00:00.000Z",
"dayLength": 24,
"yearLength": 365,
"axialTilt": 23.5,
"averageTemperature": 15,
"currentSeason": "SPRING",
"noiseScale": 20,
"noiseSeed": "mySeed123",
"moistureNoiseScale": 20,
"octaves": 4,
"persistence": 0.5,
"lacunarity": 2
}И если визуализировать я получил это:
Я не давал никаких толком стилей и пока не заморачивался над тем как каждая почва будет выглядить, лишь разделил воду :)
Итак, ИИ!
Часть 1. AiService
Это наш «мозг» проекта, написанный с помощью TensorFlow.js (точнее, @tensorflow/tfjs-node). Он умеет:
-
Хранить и загружать тренировочные данные.
-
Создавать или загружать модель (слои, веса).
-
Обучать модель (метод trainModel()).
-
Делать предсказания (метод predictWeather()).
Все операции отрабатывают на сервере, а мы можем регулярно подкармливать эти данные и «дотренировывать» модель.
Основные поля
private model: tf.Sequential = null; // Наша нейросеть
private trainingDataPath = 'training-data.json'; // Путь к тренировочным данным
private trainingData: { inputs: number[][]; outputs: number[][] } = { inputs: [], outputs: [] };
private modelFolder = path.resolve(__dirname, '../../src/ai/model');
-
model: объект типа tf.Sequential — стандартная модель в TensorFlow.js, позволяющая добавлять слои и обучаться.
-
trainingDataPath: указывает на JSON-файл, где лежат тренировочные примеры (inputs / outputs). Чтобы после перезапуска сервера наш набор данных не пропадал.
-
trainingData: в памяти хранится двухмерный массив входов и выходов. Например, inputs может быть массивом векторов (каждый вектор — характеристики одной ячейки), а outputs — целевыми значениями (тот же климат, который мы хотим спрогнозировать).
-
modelFolder: папка, куда мы сохраняем (и откуда загружаем) файлы модели: model.json и weights.bin.
Жизненный цикл: onModuleInit()
public async onModuleInit() {
// 1) Загружаем training-data.json (если есть)
this.loadTrainingData();
// 2) Пытаемся загрузить модель (если уже обучали) или создаём новую
const modelJsonPath = path.join(this.modelFolder, 'model.json');
if (fs.existsSync(modelJsonPath)) {
Logger.log('Найден сохранённый model.json, пытаемся загрузить...', 'AiService');
this.model = (await tf.loadLayersModel('file://' + modelJsonPath)) as tf.Sequential;
Logger.log('Модель загружена из: ' + modelJsonPath, 'AiService');
} else {
Logger.log('Не найден model.json, создаём новую модель...', 'AiService');
this.model = this.createModel();
}
// 3) Компилируем модель
this.compileModel(this.model);
// 4) Если есть тренировочные данные, запускаем процесс обучения (по желанию)
if (this.trainingData.inputs.length > 0) {
Logger.log('Нашлись тренировочные данные, запускаем trainModel()...', 'AiService');
// await this.trainModel();
Logger.log('Обучение завершено.', 'AiService');
}
// 5) Сохраняем (обученную или только что созданную) модель на диск
await this.saveModel();
Logger.log('Модель сохранена после инициализации.', 'AiService');
}
Как только сервис поднимается (при запуске приложения NestJS), происходит следующее:
-
Загружаем датасет (если файл training-data.json существует).
-
Ищем модель model.json и веса weights.bin в modelFolder. Если найдены — загружаем, если нет — создаём новую архитектуру.
-
Компилируем модель — указываем оптимизатор, функцию потерь (loss) и т.д.
-
Если уже были тренировочные данные, можем сразу вызвать trainModel(). В примере этот вызов закомментирован, но логика показана.
-
Сохраняем итоговую модель на диск, чтобы она не потерялась.
Методы создания и компиляции модели
private createModel(): tf.Sequential {
const model = tf.sequential();
// Входной слой
model.add(tf.layers.dense({ units: 20, inputShape: [35], activation: 'sigmoid' }));
// Скрытые слои
model.add(tf.layers.dense({ units: 15, activation: 'sigmoid' }));
model.add(tf.layers.dense({ units: 10, activation: 'sigmoid' }));
// Выходной слой
model.add(tf.layers.dense({ units: 5, activation: 'sigmoid' }));
return model;
}
model.add(...): добавляем слои.
-
inputShape: [35] говорит, что каждый входной вектор имеет размерность 35 (т.е. 35 чисел, описывающих состояние ячейки/мира).
-
units: 20 в первом слое — это количество нейронов.
-
activation: 'sigmoid' означает функцию активации sigmoid. Можно использовать relu или любую другую.
private compileModel(model: tf.Sequential) {
model.compile({
optimizer: tf.train.adam(0.02),
loss: 'meanSquaredError',
});
}
-
compileModel задаёт оптимизатор (здесь adam с learning rate = 0.02) и функцию потерь (meanSquaredError). Это нужно, чтобы модель могла обучаться (fit).
Сохранение и загрузка модели
public async saveModel(): Promise<void> {
if (!fs.existsSync(this.modelFolder)) {
fs.mkdirSync(this.modelFolder, { recursive: true });
}
await this.model.save(`file://${this.modelFolder}`);
Logger.log('Модель сохранена в папку: ' + this.modelFolder, 'AiService');
}
При вызове model.save('file://...') TensorFlow.js создаёт внутри указанной папки:
-
model.json — описание архитектуры (слои, активации)
-
weights.bin — бинарник с весами.
private loadTrainingData() {
if (fs.existsSync(this.trainingDataPath)) {
const raw = fs.readFileSync(this.trainingDataPath, 'utf8');
this.trainingData = JSON.parse(raw);
Logger.log(`Загружено training-data.json: ${this.trainingData.inputs.length} записей.`, 'AiService');
} else {
Logger.warn('Файл training-data.json не найден, датасет пустой.', 'AiService');
}
}
-
Проверяем, есть ли JSON с примерами. Если да — считываем в trainingData.
Добавление и тренировка данных
public addTrainingData(input: number[], output: number[]) {
this.trainingData.inputs.push(input);
this.trainingData.outputs.push(output);
// при желании: this.saveTrainingData();
}
-
Когда у нас появляются новые примеры (какой-то input -> output), мы складываем их в trainingData.
-
Можно и сразу вызывать this.saveTrainingData() — чтобы данные не потерять.
public async trainModel() {
if (this.trainingData.inputs.length === 0) {
throw new Error('No training data available for training.');
}
const inputs = tf.tensor2d(this.trainingData.inputs);
const outputs = tf.tensor2d(this.trainingData.outputs);
Logger.log(`Начинаем обучение на ${this.trainingData.inputs.length} примерах...`, 'AiService');
await this.model.fit(inputs, outputs, {
epochs: 100,
batchSize: 32,
validationSplit: 0.2,
callbacks: {
onEpochEnd: (epoch, logs) => {
Logger.log(`Epoch ${epoch}: loss = ${logs.loss}`, 'AiService');
},
},
});
// Сохраняем датасет
this.saveTrainingData();
}
-
Преобразуем массивы inputs/outputs в тензоры (tf.tensor2d).
-
Обучаем — метод model.fit(...). Указываем:
-
количество эпох (epochs: 100),
-
размер батча (batchSize: 32),
-
долю валидации (validationSplit: 0.2 — 20% уходит на валидацию),
-
колбэки (логируем loss после каждой эпохи).
-
-
Сохраняем датасет, чтобы уже обученные данные не пропали.
Предсказания погоды нашего мира
public predictWeather(cell: WorldCell, world: World): number[] {
const input = tf.tensor2d([this.normalizeCellData(cell, world)]);
const prediction = this.model.predict(input) as tf.Tensor;
return Array.from(prediction.dataSync());
}
-
Чтобы сделать предсказание, мы сначала нормализуем данные ячейки и мира (т.е. превращаем их в вектор из 35 чисел).
-
Затем подаём этот вектор в модель (model.predict(...)). Результат — тензор, который мы приводим к обычному массиву.
-
В данном примере в выходном слое units: 5, значит модель возвращает массив из 5 чисел (temperature, humidity, precipitation, windSpeed, cloudCoverage — те же поля, что мы пытаемся предсказывать).
Нормализация
normalizeCellData(cell: WorldCell, world: World): number[] {
const timeOfDay = this.calculateTimeOfDay(world);
return [
cell.latitude / 90,
cell.longitude / 180,
cell.elevation / 10000,
...this.encodeBiome(cell.biome),
...this.encodeSoil(cell.soil.type),
cell.climate.temperature / 50,
cell.climate.humidity / 100,
cell.climate.precipitation / 100,
cell.climate.windSpeed / 100,
cell.climate.cloudCoverage,
...this.encodeSeason(world.currentSeason),
timeOfDay,
cell.soil.organicMatter,
cell.soil.erosionLevel,
];
}-
Широта (latitude / 90) и долгота (longitude / 180) приводятся к интервалу (-1..+1) или (0..1) — зависит от того, как вы будете интерпретировать, здесь сделано грубо для примера.
-
elevation и temperature масштабируем, чтобы модель «не пугалась» больших чисел.
-
encodeBiome, encodeSoil, encodeSeason делают one-hot кодирование: для каждой категории (например, BiomeType.FOREST, BiomeType.DESERT...) мы создаём вектор 0..1, где «1» стоит в позиции, соответствующей конкретному значению.
-
timeOfDay — синус (или любое другое кодирование часа), чтобы моделировать суточный цикл.
Все эти входные данные свёрстаны в один массив длиной 35 (у вас может быть другое количество, если биомов больше или меньше и т.д.).
Полный рабочий код
// src/ai/ai.service.ts
import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
import * as tf from '@tensorflow/tfjs-node';
import * as fs from 'fs';
import { WorldCell } from '../world/entities/world-cell.entity';
import { World } from '../world/entities/world.entity';
import { Season } from '../world/entities/world.entity';
import { BiomeType } from 'src/world/biome.enum';
import { SoilType } from 'src/soils/soils.enum';
import * as path from 'path';
@Injectable()
export class AiService implements OnModuleInit {
private model: tf.Sequential = null;
// Путь для JSON с тренировочными данными
private trainingDataPath = 'training-data.json';
// Собранные тренировочные данные (inputs, outputs)
private trainingData: { inputs: number[][]; outputs: number[][] } = {
inputs: [],
outputs: [],
};
// Папка для сохранения/загрузки модели
private modelFolder = path.resolve(__dirname, '../../src/ai/model');
constructor() {
// Здесь мы пока ничего не делаем. Модель загрузим в onModuleInit (async).
}
/**
* ----------------------
* Lifecycle Hook (NestJS)
* ----------------------
* Вызывается после создания инстанса сервиса,
* даёт возможность сделать асинхронную инициализацию.
*/
public async onModuleInit() {
// 1) Загружаем training-data.json, если он есть
this.loadTrainingData();
// 2) Пытаемся загрузить модель (файлы model.json/weights.bin) из modelFolder
const modelJsonPath = path.join(this.modelFolder, 'model.json');
if (fs.existsSync(modelJsonPath)) {
Logger.log('Найден сохранённый model.json, пытаемся загрузить...', 'AiService');
this.model = (await tf.loadLayersModel('file://' + modelJsonPath)) as tf.Sequential;
Logger.log('Модель загружена из: ' + modelJsonPath, 'AiService');
} else {
// Нет сохранённого файла — создаём новую «пустую» модель
Logger.log('Не найден model.json, создаём новую модель...', 'AiService');
this.model = this.createModel();
}
// 3) Компилируем модель (важно, если хотим её дообучать)
this.compileModel(this.model);
// 4) Если есть тренировочные данные, давайте сразу потренируем
if (this.trainingData.inputs.length > 0) {
Logger.log('Нашлись тренировочные данные, запускаем trainModel()...', 'AiService');
// await this.trainModel();
Logger.log('Обучение завершено.', 'AiService');
}
// 5) Сохраняем (обученную или пустую) модель на диск, чтобы в следующий раз она была
await this.saveModel();
Logger.log('Модель сохранена после инициализации.', 'AiService');
}
/**
* ----------------------
* Методы загрузки/сохранения модели и данных
* ----------------------
*/
/**
* Создаёт новую "пустую" (необученную) модель
* с заданной архитектурой, без компиляции.
*/
private createModel(): tf.Sequential {
const model = tf.sequential();
// Входной слой
model.add(tf.layers.dense({ units: 20, inputShape: [35], activation: 'sigmoid' }));
// Скрытые слои
model.add(tf.layers.dense({ units: 15, activation: 'sigmoid' }));
model.add(tf.layers.dense({ units: 10, activation: 'sigmoid' }));
// Выходной слой
model.add(tf.layers.dense({ units: 5, activation: 'sigmoid' }));
return model;
}
/**
* Компилирует модель (задаёт optimizer, loss), чтобы можно было вызывать fit().
* Нужно делать сразу после createModel() ИЛИ после loadLayersModel().
*/
private compileModel(model: tf.Sequential) {
model.compile({
optimizer: tf.train.adam(0.02),
loss: 'meanSquaredError',
});
}
/**
* Сохраняет текущую модель на диск (model.json + weights.bin)
*/
public async saveModel(): Promise<void> {
// Убедимся, что папка существует
if (!fs.existsSync(this.modelFolder)) {
fs.mkdirSync(this.modelFolder, { recursive: true });
}
// Сохраняем модель туда
await this.model.save(`file://${this.modelFolder}`);
Logger.log('Модель сохранена в папку: ' + this.modelFolder, 'AiService');
}
/**
* Загружает тренировочные данные из JSON-файла, если он существует.
*/
private loadTrainingData() {
if (fs.existsSync(this.trainingDataPath)) {
const raw = fs.readFileSync(this.trainingDataPath, 'utf8');
this.trainingData = JSON.parse(raw);
Logger.log(
`Загружено training-data.json: ${this.trainingData.inputs.length} записей.`,
'AiService',
);
} else {
Logger.warn('Файл training-data.json не найден, датасет пустой.', 'AiService');
}
}
/**
* Сохраняем текущие trainingData в файл (если добавляете новые примеры).
*/
private saveTrainingData() {
fs.writeFileSync(this.trainingDataPath, JSON.stringify(this.trainingData));
}
/**
* ----------------------
* Методы для обучения / предсказаний
* ----------------------
*/
/**
* Добавить новые примеры для обучения.
* Не забудьте потом trainModel().
*/
public addTrainingData(input: number[], output: number[]) {
this.trainingData.inputs.push(input);
this.trainingData.outputs.push(output);
// Можно сразу saveTrainingData()
// this.saveTrainingData();
}
/**
* Запустить процесс обучения модели на data в this.trainingData
*/
public async trainModel() {
if (this.trainingData.inputs.length === 0) {
throw new Error('No training data available for training.');
}
// Тенсоризуем
const inputs = tf.tensor2d(this.trainingData.inputs);
const outputs = tf.tensor2d(this.trainingData.outputs);
Logger.log(`Начинаем обучение на ${this.trainingData.inputs.length} примерах...`, 'AiService');
// fit() — асинхронное обучение
await this.model.fit(inputs, outputs, {
epochs: 100,
batchSize: 32,
validationSplit: 0.2,
callbacks: {
onEpochEnd: (epoch, logs) => {
Logger.log(`Epoch ${epoch}: loss = ${logs.loss}`, 'AiService');
},
},
});
// Сохраняем датасет (если вдруг он изменился)
this.saveTrainingData();
// (Можно сразу сохранить модель, но мы это сделаем в других местах.)
}
/**
* Прогноз погоды с помощью нейронной сети.
*/
public predictWeather(cell: WorldCell, world: World): number[] {
const input = tf.tensor2d([this.normalizeCellData(cell, world)]);
const prediction = this.model.predict(input) as tf.Tensor;
return Array.from(prediction.dataSync());
}
/**
* Служебные методы нормализации (из вашего же примера).
*/
normalizeCellData(cell: WorldCell, world: World): number[] {
const timeOfDay = this.calculateTimeOfDay(world);
return [
cell.latitude / 90,
cell.longitude / 180,
cell.elevation / 10000,
...this.encodeBiome(cell.biome),
...this.encodeSoil(cell.soil.type),
cell.climate.temperature / 50,
cell.climate.humidity / 100,
cell.climate.precipitation / 100,
cell.climate.windSpeed / 100,
cell.climate.cloudCoverage,
...this.encodeSeason(world.currentSeason),
timeOfDay,
cell.soil.organicMatter,
cell.soil.erosionLevel,
];
}
private encodeBiome(biome: BiomeType): number[] {
const allBiomes = Object.values(BiomeType);
return allBiomes.map(b => (b === biome ? 1 : 0));
}
private encodeSoil(soil: SoilType): number[] {
const allSoils = Object.values(SoilType);
return allSoils.map(s => (s === soil ? 1 : 0));
}
private encodeSeason(season: Season): number[] {
const allSeasons = Object.values(Season);
return allSeasons.map(s => (s === season ? 1 : 0));
}
private calculateTimeOfDay(world: World): number {
const hours = world.currentDate.getHours();
// нормализуем -1..1 (синус) или 0..1 — на ваше усмотрение
return Math.sin((hours / 24) * Math.PI * 2);
}
}
ai.module
import { Module } from '@nestjs/common';
import { AiService } from './ai.service';
// import { AiController } from './ai.controller';
@Module({
providers: [AiService],
exports: [AiService],
})
export class AiModule {}Как заставить это работать? И посмотреть на предсказания погоды условно через час у нашего мира
Лично я пошел очень рискованно :) Создал проект на реакт (код предоставлю ниже) и сервис для вебхуков, где передавал все данные и выывал методы. Давайте посмотрим
Часть 2. WebSocket (WorldGateway)
Теперь посмотрим, как эти предсказания и обучение «встраиваются» в реальную симуляцию. Мы используем декоратор @WebSocketGateway(...) из NestJS, чтобы открыть WebSocket-соединение для клиентов
Код расположен в src/world/world.gateway.ts.
// src/world/world.gateway.ts
import { Logger } from '@nestjs/common';
import {
WebSocketGateway,
WebSocketServer,
OnGatewayConnection,
OnGatewayDisconnect
} from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';
import { AiService } from 'src/ai/ai.service';
import { World } from 'src/world/entities/world.entity';
import { WorldService } from 'src/world/world.service';
import { WorldCellService } from 'src/world/world-cell.service';
@WebSocketGateway({
cors: { origin: '*' },
})
export class WorldGateway implements OnGatewayConnection, OnGatewayDisconnect {
@WebSocketServer()
server: Server;
private loadedWorld: World | null = null;
private simulationInterval: NodeJS.Timeout | null = null;
private simulationWeatherInterval: NodeJS.Timeout | null = null;
private simulationTrainingInterval: NodeJS.Timeout | null = null;
private saveCellsInterval: NodeJS.Timeout | null = null; // <-- Интервал для сохранения
constructor(
private readonly worldService: WorldService,
private readonly aiService: AiService,
private readonly worldCellService: WorldCellService, // <-- Инжектируем
) {}
async handleConnection(client: Socket) {
const worldIdStr = client.handshake.query.worldId as string;
const worldId = parseInt(worldIdStr, 10);
if (!worldId || Number.isNaN(worldId)) {
client.emit('error', 'Invalid or missing worldId');
client.disconnect();
return;
}
if (!this.loadedWorld) {
const found = await this.worldService.repo.findOne({
where: { id: worldId },
relations: ['cells', 'cells.resources', 'cells.soil'],
});
if (!found) {
client.emit('error', 'World not found');
client.disconnect();
return;
}
this.loadedWorld = found;
this.startSimulationInterval();
this.startAiWeatherInterval();
this.startAiTrainingInterval();
this.startSaveCellsInterval(); // <-- Запускаем интервал сохранения
}
Logger.log(`Client ${client.id} connected for world #${worldId}.`);
client.emit('worldUpdate', this.loadedWorld);
}
async handleDisconnect(client: Socket) {
Logger.log(`Client ${client.id} disconnected`);
const connectedCount = this.server.engine.clientsCount;
if (connectedCount === 0) {
// Останавливаем все интервалы, если никто не подключён
if (this.simulationInterval) {
clearInterval(this.simulationInterval);
this.simulationInterval = null;
}
if (this.simulationWeatherInterval) {
clearInterval(this.simulationWeatherInterval);
this.simulationWeatherInterval = null;
}
if (this.simulationTrainingInterval) {
clearInterval(this.simulationTrainingInterval);
this.simulationTrainingInterval = null;
}
if (this.saveCellsInterval) {
clearInterval(this.saveCellsInterval);
this.saveCellsInterval = null;
}
Logger.log('No more clients, stopped all intervals');
}
}
private startSimulationInterval() {
if (this.simulationInterval) return;
this.simulationInterval = setInterval(() => {
if (!this.loadedWorld) return;
const oldDate = this.loadedWorld.currentDate;
// + 10 минут каждый "тик"
const newDate = new Date(oldDate.getTime() + 600_000);
this.loadedWorld.currentDate = newDate;
this.collectTrainingData();
this.server.emit('worldUpdate', this.loadedWorld);
}, 1_000);
}
private startAiWeatherInterval() {
if (this.simulationWeatherInterval) return;
this.simulationWeatherInterval = setInterval(() => {
if (!this.loadedWorld) return;
// Прогноз и применение
this.loadedWorld.cells.forEach(cell => {
const [pTemp, pHum, pPrec, pWind, pCloud] =
this.aiService.predictWeather(cell, this.loadedWorld);
cell.climate.temperature = pTemp * 50;
cell.climate.humidity = pHum * 100;
cell.climate.precipitation = pPrec * 100;
cell.climate.windSpeed = pWind * 100;
cell.climate.cloudCoverage = pCloud;
});
this.server.emit('worldUpdate', this.loadedWorld);
}, 10_000);
}
private startAiTrainingInterval() {
if (this.simulationTrainingInterval) return;
this.simulationTrainingInterval = setInterval(async () => {
try {
if (!this.loadedWorld) return;
if (this.aiService['trainingData'].inputs.length === 0) {
return;
}
Logger.log('AI training interval: launching trainModel()...');
await this.aiService.trainModel();
Logger.log('AI training interval: trainModel() finished.');
} catch (err) {
Logger.error('Error in AI training interval: ' + err.message);
}
}, 300_000); // каждые 5 минут
}
/**
* ---------------------------
* Интервал сохранения в БД
* ---------------------------
* Каждые 5 минут (или реже, как решите) берём все ячейки
* из this.loadedWorld.cells и вызываем worldCellService.saveCells()
*/
private startSaveCellsInterval() {
if (this.saveCellsInterval) return;
// Раз в 5 минут, например
this.saveCellsInterval = setInterval(async () => {
if (!this.loadedWorld) return;
try {
Logger.log('Saving updated cells to DB...');
await this.worldCellService.saveCells(this.loadedWorld.cells);
Logger.log('Cells saved successfully.');
} catch (error) {
Logger.error('Error saving cells to DB: ' + error.message);
}
}, 300_000);
}
/**
* Собираем (input->output) для обучения
*/
private collectTrainingData() {
if (!this.loadedWorld) return;
this.loadedWorld.cells.forEach(cell => {
const input = this.aiService.normalizeCellData(cell, this.loadedWorld);
const output = [
cell.climate.temperature / 50,
cell.climate.humidity / 100,
cell.climate.precipitation / 100,
cell.climate.windSpeed / 100,
cell.climate.cloudCoverage,
];
this.aiService.addTrainingData(input, output);
});
}
}
-
Когда новый клиент подключается, он передаёт параметр worldId в client.handshake.query.
-
Валидируем worldId.
-
Если loadedWorld ещё не загружен (первый клиент), берём из базы мир c заданным id (и грузим связанные сущности: ячейки, почву, ресурсы).
-
Запускаем все интервалы (симуляцию, прогноз погоды, обучение AI, сохранение ячеек).
-
Отправляем клиенту событие worldUpdate с текущим миром.
handleDisconnect()
-
Если клиентов больше нет, то убиваем интервалы, чтобы сервер не расходовал ресурсы впустую.
Интервалы
startSimulationInterval()
-
Каждую секунду симулируем прохождение 10 минут внутриигрового времени (+600_000 мс).
-
collectTrainingData(): собираем новые входы-выходы для обучения (см. метод ниже).
-
Шлём клиентам обновлённый мир.
startAiWeatherInterval()
-
Каждые 10 секунд (например) делаем прогноз погоды для каждой ячейки:
-
predictWeather(cell, this.loadedWorld) возвращает массив из 5 чисел (0..1).
-
Преобразуем обратно в «реальные» величины (умножаем, например, на 50 для температуры, на 100 для влажности и т.д.).
-
Обновляем cell.climate, чтобы игроки (или симуляция) видели «изменившуюся» погоду.
-
startAiTrainingInterval()
-
Каждые 5 минут:
-
Проверяем, есть ли хоть какие-то примеры в trainingData.
-
Вызываем trainModel() — модель обучается прямо «на лету», используя накопленные данные.
-
(Можно потом снова сохранить модель, но в примере это не показано — возможно, вам захочется это сделать после каждого обучения.)
-
startSaveCellsInterval()
-
Каждые 5 минут сохраняем изменения в базе ( this.worldCellService.saveCells(...) ).
-
Это полезно, если за время симуляции cell.climate или другие поля поменялись, и мы не хотим потерять их при перезапуске сервера.
Метод collectTrainingData()
-
В каждом тике (раз в секунду, см. startSimulationInterval), для каждой ячейки:
-
Формируем input (35 чисел, нормализованных).
-
Формируем output — текущие значения температуры, влажности и т.д., но уже отнормированные.
-
addTrainingData() кладёт эти пары во внутренний массив trainingData.
-
-
Таким образом, модель постепенно накапливает данные о том, «какая погода была в конкретный момент времени», чтобы затем научиться воспроизводить (или предсказывать) эти зависимости.
-
Логично, что после накопления данных мы периодически (каждые 5 минут) делаем trainModel() (см. startAiTrainingInterval).
Выводы
-
AiService — это место, где живут методы работы с нейронной сетью: создание/загрузка модели, обучение, предсказание.
-
WorldGateway поднимает WebSocket-сервер и регулярно вызывает нужные методы:
-
Обновляет время (simulationInterval).
-
Применяет ИИ-прогноз (simulationWeatherInterval).
-
Обучает модель (simulationTrainingInterval).
-
Сохраняет изменения в БД (saveCellsInterval).
-
-
Каждый клиент, подключившись по сокету, получает текущее состояние мира (worldUpdate). А при каждом «тике» и других событиях мы снова рассылаем обновлённые данные.
Таким образом, всё завязано в один цикл: симуляция → сбор данных → обучение → прогноз → обновление ячеек → сохранение → и снова симуляция. Это позволяет нашим сущностям (ям, почвам, биомам и т.д.) постоянно изменяться и «учиться на собственном опыте», делая мир «живым».
Фронтенд
Развернули реакт, создали папку для компонентов закинули туда это
// src/components/PhaserWorldMap.jsx
import React, { useEffect, useRef } from "react";
import Phaser from "phaser";
function PhaserWorldMap({ world }) {
const phaserRef = useRef(null);
const gameRef = useRef(null);
// 1. Создаём Phaser Game **один раз** (при первом рендере).
useEffect(() => {
if (!phaserRef.current) return; // иногда бывает null при первом проходе
if (gameRef.current) return; // уже создано
const MainScene = new Phaser.Scene("MainScene");
MainScene.preload = function () {
// Загрузить ассеты, если нужны
};
MainScene.create = function () {
// При первом создании сцены рисуем «стартовое» состояние карты
this.drawMap(world);
};
// Допустим, напишем метод "drawMap" внутри сцены (ниже покажу пример)
MainScene.drawMap = function (worldData) {
// Очистить предыдущую графику, если есть
this.children.removeAll();
const cellSize = 32;
worldData.cells?.forEach((cell) => {
const xPix = cell.position.x * cellSize;
const yPix = cell.position.y * cellSize;
// Цвет - упрощённо
const color = cell.isWater ? 0x0000ff : 0x228b22;
const graphics = this.add.graphics();
graphics.fillStyle(color, 1);
graphics.fillRect(xPix, yPix, cellSize, cellSize);
// (необязательно) Нарисовать "resourceType" как букву
if (cell.resources && cell.resources.length > 0) {
const resourceLetter = cell.resources[0].type[0] || "R";
this.add.text(xPix + 8, yPix + 8, resourceLetter, {
color: "#000000",
fontSize: "16px",
});
}
});
};
const config = {
type: Phaser.AUTO,
width: world.width * 32,
height: world.height * 32,
parent: phaserRef.current,
scene: MainScene,
backgroundColor: "#222222",
};
gameRef.current = new Phaser.Game(config);
}, [world]);
// Обратите внимание, иногда стоит [] (пусто),
// если точно не хотим пересоздавать,
// но можно оставить [world],
// тогда нужно аккуратно не пересоздавать Game,
// а лишь обновлять.
// 2. «Обновляем» сцену при изменении "world"
useEffect(() => {
if (!gameRef.current) return;
const scene = gameRef.current.scene.getScene("MainScene");
if (!scene || !scene.drawMap) return;
// Вызовем scene.drawMap(world)
// (не пересоздавая саму сцену!).
scene.drawMap(world);
}, [world]);
return (
<div style={{ width: "fit-content", margin: "0 auto" }}>
<div ref={phaserRef} />
</div>
);
}
export default PhaserWorldMap;
В App.jsx вызвали
// src/App.jsx
import React, { useEffect, useState } from "react";
import "./App.css";
import PhaserWorldMap from "./components/PhaserWorldMap";
// 1) Импорт socket.io-client (или другой WebSocket-библиотеки)
import { io } from "socket.io-client";
function App() {
const [worldData, setWorldData] = useState(null);
// Пример базовых полей, которые хотим отобразить в "шапке"
// Можно расширять (averageTemperature, dayLength и т.д.)
const [worldStats, setWorldStats] = useState({
name: "",
width: 0,
height: 0,
seaLevel: 0,
currentSeason: "",
startDate: "",
currentDate: "",
});
useEffect(() => {
// 2) Подключаемся к бэкенду по REST, чтобы первоначально получить мир /api/worlds/2
fetch("/api/worlds/2")
.then((response) => response.json())
.then((data) => {
setWorldData(data);
// Сохраним часть полей в worldStats:
setWorldStats({
name: data.name,
width: data.width,
height: data.height,
seaLevel: data.seaLevel,
currentSeason: data.currentSeason,
startDate: data.startDate,
currentDate: data.currentDate,
});
})
.catch((error) => {
console.error("Ошибка при загрузке мира:", error);
});
// 3) Настраиваем подключение к WebSocket / Socket.io
// Допустим, наш бэкенд работает на http://localhost:100000
const socket = io("http://localhost:3000", {
// Если нужно, прокиньте параметры cors, auth, path и т.д.
query: { worldId: 2 },
});
// 4) Подписываемся на события от сервера
socket.on("connect", () => {
console.log("Socket connected!", socket.id);
// Можно что-то отправить на сервер, если нужно
// socket.emit("getWorldUpdates", { worldId: 2 });
});
socket.on("worldUpdate", (updatedWorld) => {
console.log("Received worldUpdate:", updatedWorld);
// Допустим, сервер шлёт обновлённое состояние мира
setWorldData(updatedWorld);
setWorldStats({
name: updatedWorld.name,
width: updatedWorld.width,
height: updatedWorld.height,
seaLevel: updatedWorld.seaLevel,
currentSeason: updatedWorld.currentSeason,
startDate: updatedWorld.startDate,
currentDate: updatedWorld.currentDate,
});
});
socket.on("disconnect", () => {
console.log("Socket disconnected");
});
// 5) Чистим ресурсы при размонтировании
return () => {
socket.disconnect();
};
}, []);
return (
<div className="App">
<header>
<h1>World: {worldStats.name}</h1>
<ul>
<li>Width: {worldStats.width}</li>
<li>Height: {worldStats.height}</li>
<li>Sea level: {worldStats.seaLevel}</li>
<li>Season: {worldStats.currentSeason}</li>
<li>Start Date: {new Date(worldStats.startDate).toLocaleString()}</li>
<li>
Current Date: {new Date(worldStats.currentDate).toLocaleString()}
</li>
</ul>
</header>
{/* Отрисовываем карту, если данные мира загружены */}
{worldData ? (
<PhaserWorldMap world={worldData} />
) : (
<p>Loading world...</p>
)}
</div>
);
}
export default App;
Лично я с первой итерации получил training-data.json размером в 57600 данных
Код очень сырой, так как много времени и сил было потрачено на разработку и первоначальную архитектуру проекта, в следующей части мы уже полностью углубимся в обучение, дообучение, модели научим ее работать с еще большими данными и факторами и возможно (даже скорее всего) докачаем наши методы которые точно ждут нашего ИИ.
В написании статьи помогал ChatGPT, надеюсь вам было не утомительно! И очень интересно. Ниже я предоставлю пример работы ИИ на данном этапе и будем закругляться!
ВНИМАНИЕ! Ниже я предоставлю 2 json, вы можете их ПРОПУСТИТЬ, так как я ниже напишу нормальный (более понятный, на человеческом) отчет
Входные данные мира
{
"id": 2,
"name": "MiniWorld",
"width": 30,
"height": 20,
"seaLevel": 0,
"startDate": "2025-01-01T00:00:00.000Z",
"currentDate": "2025-01-11T10:57:00.000Z",
"dayLength": 24,
"yearLength": 365,
"axialTilt": 23.5,
"averageTemperature": 15,
"currentSeason": "SPRING",
"cells": [
{
"id": 101,
"position": {
"x": 0,
"y": 0,
"z": 0
},
"latitude": -90,
"longitude": -180,
"climate": {
"humidity": 0.5,
"windSpeed": 5,
"temperature": 0,
"cloudCoverage": 0.3,
"precipitation": 50,
"dayTemperature": 5,
"nightTemperature": -5,
"weatherCondition": "sunny"
},
"elevation": 0,
"isWater": false,
"biome": "BEACH",
"soil": {
"id": 101,
"type": "SANDY",
"fertility": 0.67765948444575,
"humidity": 0.5,
"pH": 7,
"position": {
"x": 0,
"y": 0,
"z": 0
},
"organicMatter": 0.05,
"texture": "loose",
"color": "brown",
"erosionLevel": 0
},
"resources": [
{
"id": 101,
"type": "MINERALS",
"quantity": 220.05513249290865,
"quality": 0.8039897245442311,
"position": {
"x": 0,
"y": 0,
"z": 0
},
"depth": 0,
"isRenewable": false,
"regenerationRate": 0,
"usedUpAt": null
}
]
},
{
"id": 102,
"position": {
"x": 1,
"y": 0,
"z": -69.54081361897903
},
"latitude": -90,
"longitude": -168,
"climate": {
"humidity": 0.5048159625083585,
"windSpeed": 5,
"temperature": 0.6954081361897906,
"cloudCoverage": 0.3,
"precipitation": 50.48159625083585,
"dayTemperature": 5.695408136189791,
"nightTemperature": -4.304591863810209,
"weatherCondition": "sunny"
},
"elevation": -69.54081361897903,
"isWater": true,
"biome": "OCEAN",
"soil": {
"id": 102,
"type": "SANDY",
"fertility": 0.48918544536173497,
"humidity": 0.5048159625083585,
"pH": 7,
"position": {
"x": 1,
"y": 0,
"z": -69.54081361897903
},
"organicMatter": 0.05,
"texture": "loose",
"color": "brown",
"erosionLevel": 0
},
"resources": [
{
"id": 102,
"type": "OIL",
"quantity": 186.75966337990002,
"quality": 0.8311845992885536,
"position": {
"x": 1,
"y": 0,
"z": -69.54081361897903
},
"depth": 69.54081361897903,
"isRenewable": false,
"regenerationRate": 0,
"usedUpAt": null
}
]
},
{
"id": 103,
"position": {
"x": 2,
"y": 0,
"z": -92.98645625300959
},
"latitude": -90,
"longitude": -156,
"climate": {
"humidity": 0.5310527234411956,
"windSpeed": 5,
"temperature": 0.9298645625300956,
"cloudCoverage": 0.3,
"precipitation": 53.105272344119555,
"dayTemperature": 5.929864562530096,
"nightTemperature": -4.070135437469904,
"weatherCondition": "sunny"
},
"elevation": -92.98645625300959,
"isWater": true,
"biome": "OCEAN",
"soil": {
"id": 103,
"type": "SANDY",
"fertility": 0.33888396602334475,
"humidity": 0.5310527234411956,
"pH": 7,
"position": {
"x": 2,
"y": 0,
"z": -92.98645625300959
},
"organicMatter": 0.05,
"texture": "loose",
"color": "brown",
"erosionLevel": 0
},
"resources": [
{
"id": 103,
"type": "OIL",
"quantity": 139.28842001806015,
"quality": 0.5089263989828476,
"position": {
"x": 2,
"y": 0,
"z": -92.98645625300959
},
"depth": 92.98645625300959,
"isRenewable": false,
"regenerationRate": 0,
"usedUpAt": null
}
]
},
{
"id": 104,
"position": {
"x": 3,
"y": 0,
"z": -102.03005240794396
},
"latitude": -90,
"longitude": -144,
"climate": {
"humidity": 0.5366057027666208,
"windSpeed": 5,
"temperature": 1.0203005240794383,
"cloudCoverage": 0.3,
"precipitation": 53.66057027666208,
"dayTemperature": 6.020300524079438,
"nightTemperature": -3.9796994759205617,
"weatherCondition": "sunny"
},
"elevation": -102.03005240794396,
"isWater": true,
"biome": "OCEAN",
"soil": {
"id": 104,
"type": "SANDY",
"fertility": 0.3864691360492472,
"humidity": 0.5366057027666208,
"pH": 7,
"position": {
"x": 3,
"y": 0,
"z": -102.03005240794396
},
"organicMatter": 0.05,
"texture": "loose",
"color": "brown",
"erosionLevel": 0
},
"resources": [
{
"id": 104,
"type": "OIL",
"quantity": 68.8677749036174,
"quality": 0.6309700930634006,
"position": {
"x": 3,
"y": 0,
"z": -102.03005240794396
},
"depth": 102.03005240794396,
"isRenewable": false,
"regenerationRate": 0,
"usedUpAt": null
}
]
},То, что я получил
{
"id": 2,
"name": "MiniWorld",
"width": 30,
"height": 20,
"seaLevel": 0,
"startDate": "2025-01-01T00:00:00.000Z",
"currentDate": "2025-01-11T10:57:00.000Z",
"dayLength": 24,
"yearLength": 365,
"axialTilt": 23.5,
"averageTemperature": 15,
"currentSeason": "SPRING",
"cells": [
{
"id": 101,
"position": {
"x": 0,
"y": 0,
"z": 0
},
"latitude": -90,
"longitude": -180,
"climate": {
"humidity": 0.4709193017333746,
"windSpeed": 4.722989350557327,
"temperature": 0.15460985014215112,
"cloudCoverage": 0.31382104754447937,
"precipitation": 47.45621085166931,
"dayTemperature": 5,
"nightTemperature": -5,
"weatherCondition": "sunny"
},
"elevation": 0,
"isWater": false,
"biome": "BEACH",
"soil": {
"id": 101,
"type": "SANDY",
"fertility": 0.67765948444575,
"humidity": 0.5,
"pH": 7,
"position": {
"x": 0,
"y": 0,
"z": 0
},
"organicMatter": 0.05,
"texture": "loose",
"color": "brown",
"erosionLevel": 0
},
"resources": [
{
"id": 101,
"type": "MINERALS",
"quantity": 220.05513249290865,
"quality": 0.8039897245442311,
"position": {
"x": 0,
"y": 0,
"z": 0
},
"depth": 0,
"isRenewable": false,
"regenerationRate": 0,
"usedUpAt": null
}
]
},
{
"id": 102,
"position": {
"x": 1,
"y": 0,
"z": -69.54081361897903
},
"latitude": -90,
"longitude": -168,
"climate": {
"humidity": 0.6216044072061777,
"windSpeed": 4.757331684231758,
"temperature": 0.9571045637130737,
"cloudCoverage": 0.3122412860393524,
"precipitation": 61.863261461257935,
"dayTemperature": 5.695408136189791,
"nightTemperature": -4.304591863810209,
"weatherCondition": "sunny"
},
"elevation": -69.54081361897903,
"isWater": true,
"biome": "OCEAN",
"soil": {
"id": 102,
"type": "SANDY",
"fertility": 0.48918544536173497,
"humidity": 0.5048159625083585,
"pH": 7,
"position": {
"x": 1,
"y": 0,
"z": -69.54081361897903
},
"organicMatter": 0.05,
"texture": "loose",
"color": "brown",
"erosionLevel": 0
},
"resources": [
{
"id": 102,
"type": "OIL",
"quantity": 186.75966337990002,
"quality": 0.8311845992885536,
"position": {
"x": 1,
"y": 0,
"z": -69.54081361897903
},
"depth": 69.54081361897903,
"isRenewable": false,
"regenerationRate": 0,
"usedUpAt": null
}
]
},
{
"id": 103,
"position": {
"x": 2,
"y": 0,
"z": -92.98645625300959
},
"latitude": -90,
"longitude": -156,
"climate": {
"humidity": 0.6704418919980526,
"windSpeed": 4.765862599015236,
"temperature": 1.201796717941761,
"cloudCoverage": 0.3118155002593994,
"precipitation": 66.00560545921326,
"dayTemperature": 5.929864562530096,
"nightTemperature": -4.070135437469904,
"weatherCondition": "sunny"
},
"elevation": -92.98645625300959,
"isWater": true,
"biome": "OCEAN",
"soil": {
"id": 103,
"type": "SANDY",
"fertility": 0.33888396602334475,
"humidity": 0.5310527234411956,
"pH": 7,
"position": {
"x": 2,
"y": 0,
"z": -92.98645625300959
},
"organicMatter": 0.05,
"texture": "loose",
"color": "brown",
"erosionLevel": 0
},
"resources": [
{
"id": 103,
"type": "OIL",
"quantity": 139.28842001806015,
"quality": 0.5089263989828476,
"position": {
"x": 2,
"y": 0,
"z": -92.98645625300959
},
"depth": 92.98645625300959,
"isRenewable": false,
"regenerationRate": 0,
"usedUpAt": null
}
]
},
{
"id": 104,
"position": {
"x": 3,
"y": 0,
"z": -102.03005240794396
},
"latitude": -90,
"longitude": -144,
"climate": {
"humidity": 0.6817700807005167,
"windSpeed": 4.767860844731331,
"temperature": 1.2995658442378044,
"cloudCoverage": 0.31171512603759766,
"precipitation": 67.01587438583374,
"dayTemperature": 6.020300524079438,
"nightTemperature": -3.9796994759205617,
"weatherCondition": "sunny"
},
"elevation": -102.03005240794396,
"isWater": true,
"biome": "OCEAN",
"soil": {
"id": 104,
"type": "SANDY",
"fertility": 0.3864691360492472,
"humidity": 0.5366057027666208,
"pH": 7,
"position": {
"x": 3,
"y": 0,
"z": -102.03005240794396
},
"organicMatter": 0.05,
"texture": "loose",
"color": "brown",
"erosionLevel": 0
},
"resources": [
{
"id": 104,
"type": "OIL",
"quantity": 68.8677749036174,
"quality": 0.6309700930634006,
"position": {
"x": 3,
"y": 0,
"z": -102.03005240794396
},
"depth": 102.03005240794396,
"isRenewable": false,
"regenerationRate": 0,
"usedUpAt": null
}
]
},Сравнения начало 11 января 5 утра попросили предсказать погоду через час
Ячейка 101
Biome: BEACH
isWater: false // не вода
До (примерные значения)
Влажность (humidity): 0.50
Скорость ветра (windSpeed): 5.0
Температура (temperature): 0.0
Облачность (cloudCoverage): 0.30
Осадки (precipitation): 50.0
После
Влажность (humidity): 0.4709193017333746
Скорость ветра (windSpeed): 4.722989350557327
Температура (temperature): 0.15460985014215112
Облачность (cloudCoverage): 0.31382104754447937
Осадки (precipitation): 47.45621085166931
Изменения
Влажность: 0.50 → 0.47 (снижение на ~0.03)
Скорость ветра: 5.00 → 4.72 (–0.28)
Температура: 0.00 → 0.15 (+0.15)
Облачность: 0.30 → 0.31 (+0.014)
Осадки: 50.00 → 47.46 (–2.54)
Заключение
Спасибо всем, кто дочитал до конца, если у вас есть желание писать код со мной, или вносить свои идеи в проект, пишите об этом, в целом статьи такого рода я никогда не писал и научного прежде не делал в своей работе, поэтому я буду рад услышать какой-то фидбэк по статье и конструктивную критику :) Если будет желающие помочь с проектом или как то в нем поучаствовать, дайте знать залью на GitLab xD
Поддержать проект
Этот проект — моя страсть, и я вкладываю в него всё своё время и силы. Если вам нравится то, что я делаю, и вы хотите поддержать развитие виртуальной вселенной, вы можете сделать это через:
USDT (TRC-20): TLAUmEiqEoJoXGHu6MwouNXQ3VPfAH7PqG
VISA: 4278310027661388 NIKOLAY KUZIYEV
MASTERCARD: 5397170000110891 NIKOLAY KUZIYEV
Ваша поддержка поможет мне уделять больше времени проекту и делиться с вами новыми достижениями!
Автор: NicholasKuzya
