Alby96andClaude Opus 5.5 3d394c01d3 F6: bilanciamento con i bot su simulate
Banco di prova ripetibile per tarare l'economia (ADR 0025, obiettivi O1–O14
scritti prima della taratura):

- railenterprise-tools balance: semi × difficoltà × bot × anni in parallelo,
  rapporto deterministico (rapporto.txt con gli obiettivi, anni/mesi/prezzi/
  esecuzioni.csv, tempi.txt); simulate --bot <id>.
- Bot giocatore (PlayerBot): l'agente delle IA con le personalità di
  ai.json → bots guida la compagnia del giocatore; pianifica per primo; non
  è salvato né nell'hash, il formato dei salvataggi non cambia.
- Le IA usano la compravendita in proprio (supera ADR 0016 §9) con una regola
  mensile deterministica e parametri in ai.json → trading.
- Agente corretto: un trasformatore è fonte solo con gli input alimentati
  (prima i bot fallivano su linee rimaste senza merce finite le scorte
  iniziali); la linea dei ricambi di una rete nuova esce dal budget iniziale
  se l'utile la ripaga entro planning.partsDeferYears.
- Dati: market.world volumeShare 0,5 → 1,0 ed elasticity 1,0 → 2,5;
  townBonus 1,8 → 3,0, townRoiFactor 0,5 → 0,35.

Matrice predefinita (72 esecuzioni da 12 anni, 533 s): obiettivi da 5 a 9
su 14; livello 2 del bot competente in «Imprenditore» al 4° anno (prima 7°),
nessun fallimento dei bot in «Apprendista» e «Imprenditore», prezzi medi tra
0,77 e 1,42 volte il base (prima 0,38–2,78). Restano aperti O7–O11.

EconomyTests.PriceRisesWhenDemandExceedsSupply: la soglia passa da 1,5 a
1,25 volte in 120 giorni perché il mondo a volume pieno ed elasticità 2,5
assorbe parte dello squilibrio (aumento misurato ~1,36). Accettazioni F2, F4
e F5 invariate e verdi; 222 test verdi.

Refs #47.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 16:30:31 +01:00

Rail Enterprise

Gestionale ferroviario visto dall'alto, ambientato dal 1850 in una regione immaginaria: binari con pendenze, trincee, ponti e gallerie; economia con prezzi globali e locali; pendolarismo di lavoratori e personale; manutenzione per componente di treni e industrie; concorrenti IA, borsa e scalate; un mondo che non finisce mai.

Il motore di gioco è headless e deterministico (C# su .NET 10) e gira sia dentro il gioco desktop (client Godot 4 .NET, che avvia un server locale) sia come server Linux in Docker.

Linea con ponte nel client

Scaricare

Ogni versione è sulla pagina Release:

File Per
RailEnterprise-<versione>-windows-x64.zip il gioco desktop: estrai e avvia RailEnterprise.exe («Partita locale» avvia il server in server/)
RailEnterprise-Server-<versione>-windows-x64.zip / -linux-x64.tar.gz il server senza Docker
immagine gitea.encke-hake.ts.net/balbosoft/rail-enterprise-server:<versione> il server in Docker / Unraid

Requisiti per lo sviluppo

  • .NET SDK 10.x (dotnet --version)
  • Godot 4.7 .NET come godot nel PATH (solo per avviare o esportare il client)
  • Docker (solo per l'immagine del server)

Compilare e provare

scripts/build.sh                 # controllo "zero NuGet" + build Release
scripts/test.sh                  # validazione dei dati + tutti i test
scripts/test.sh --skip-slow      # senza i test di accettazione pluriennali

Su Windows (PowerShell): ./scripts/build.ps1 -Test.

Avviare in locale

Server da sorgente (porta 7400, token prova, salvataggi in ./dati-locali):

dotnet run --project src/RailEnterprise.Server -c Release -- --port 7400 --token prova --data ./dati-locali

Poi http://localhost:7400/health e http://localhost:7400/metrics. Con --local il server sceglie una porta libera e stampa LISTENING <porta> (è il modo in cui lo avvia il client).

Server in Docker (dalla radice del repository):

docker compose -f docker/docker-compose.yml up -d --build

Variabili: RE_TOKEN (obbligatoria in rete), RE_DIFFICULTY, RE_SEED, RE_MAP_SIZE, RE_DATA_DIR (default /data), RE_AUTOSAVE_MIN, RE_TICK_MS, RE_LOG_LEVEL.

Client Godot:

dotnet build src/RailEnterprise.Server -c Release
dotnet build client/RailEnterprise.Client/RailEnterprise.Client.csproj
godot --path client/RailEnterprise.Client

Dal menu, «Partita locale» avvia il server compilato (src/RailEnterprise.Server/bin/Release/... oppure RE_SERVER_PATH); «Connetti a un server» usa indirizzo e token di un server già avviato.

Collaudi senza mani:

dotnet run --project src/RailEnterprise.Tools -- smoke --url ws://127.0.0.1:7400/ws --token prova
GODOT=/percorso/godot scripts/client-autopilot.sh

Strumenti

dotnet run --project src/RailEnterprise.Tools -- <comando>: validate-data, genmap, profile, simulate, bench, smoke, replay (vedi la Wiki).

Struttura

Cartella Contenuto
src/RailEnterprise.Core simulazione, dati, mappa, economia, rete ferroviaria, salvataggi
src/RailEnterprise.Protocol protocollo binario su WebSocket
src/RailEnterprise.Server server autorevole (Kestrel)
src/RailEnterprise.Tools railenterprise-tools
tests/RailEnterprise.Tests harness di test interno e scenari
client/RailEnterprise.Client client Godot
data/ parametri di gioco in JSON con schema
docker/ Dockerfile, compose, template Unraid
docs/ guida, GDD, architettura, protocollo, stato, ADR, schermate
reference/ immagini di riferimento visivo vincolanti (01–09)
.gitea/ workflow di CI e rilascio, modelli di PR e issue

CI e rilasci

  • CI (.gitea/workflows/ci.yml): su ogni PR e su main — zero NuGet, build, dati, test, server per Windows, client, immagine Docker con healthcheck.
  • Rilascio (.gitea/workflows/release.yml): git tag v0.6.0 && git push origin v0.6.0 pubblica la release con il gioco per Windows, i server e SHA256SUMS, e l'immagine Docker :<versione> (:latest per le versioni stabili).
  • Nightly (.gitea/workflows/nightly.yml): immagine :nightly da main ogni notte.

Dettagli in ADR 0014.

Il server parla WebSocket in chiaro: fuori da una rete privata mettilo dietro un reverse proxy con TLS ed esponi solo wss://.

Documentazione

  • docs/GUIDA.md — specifica operativa vincolante
  • docs/GDD.md — design del gioco
  • docs/ARCHITECTURE.md — architettura del codice
  • docs/PROTOCOL.md — protocollo di rete
  • docs/STATE.md — stato dei lavori
  • docs/adr/ — decisioni architetturali
  • Wiki — guida del giocatore e schermate
S
Description
Videogioco di treni con focus sulla crescita della propria impresa con una avanzata gestione economica
Readme
8.6 MiB
0 Stars 1 Watchers 0 Forks
2026-11-15 13:58:29 +01:00
Languages
C# 99.7%
Shell 0.2%