diff --git a/.gitea/ISSUE_TEMPLATE/bug.yml b/.gitea/ISSUE_TEMPLATE/bug.yml new file mode 100644 index 0000000..5d412f8 --- /dev/null +++ b/.gitea/ISSUE_TEMPLATE/bug.yml @@ -0,0 +1,31 @@ +name: Difetto +about: Qualcosa non funziona nel gioco, nel server o negli strumenti +title: "[Difetto] " +labels: ["bug"] +body: + - type: textarea + id: cosa + attributes: + label: Cosa succede + description: Cosa hai visto e cosa ti aspettavi. + validations: + required: true + - type: textarea + id: passi + attributes: + label: Come riprodurlo + description: Passi, seme della mappa, difficoltà, salvataggio o registro dei comandi (--record) se disponibili. + - type: input + id: versione + attributes: + label: Versione + description: Versione del gioco o tag dell'immagine Docker. + - type: dropdown + id: dove + attributes: + label: Dove + options: + - Gioco desktop (partita locale) + - Server Docker + - Strumenti (railenterprise-tools) + - Altro diff --git a/.gitea/ISSUE_TEMPLATE/funzionalita.yml b/.gitea/ISSUE_TEMPLATE/funzionalita.yml new file mode 100644 index 0000000..6985191 --- /dev/null +++ b/.gitea/ISSUE_TEMPLATE/funzionalita.yml @@ -0,0 +1,17 @@ +name: Funzionalità +about: Un lavoro della roadmap o una nuova idea +title: "[F?] " +labels: ["enhancement"] +body: + - type: textarea + id: obiettivo + attributes: + label: Obiettivo + description: Cosa deve fare e quale sezione di docs/GUIDA.md copre. + validations: + required: true + - type: textarea + id: accettazione + attributes: + label: Criteri di accettazione + description: Test o misure che dicono quando è finito. diff --git a/.gitea/PULL_REQUEST_TEMPLATE.md b/.gitea/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..dbe7e14 --- /dev/null +++ b/.gitea/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,16 @@ +## Cosa cambia e perché + + + +## Fase + + + +## Verifica + +- [ ] `scripts/build.sh` verde (zero NuGet, warning come errori) +- [ ] `scripts/test.sh` verde (indica eventuali test lunghi saltati) +- [ ] `docs/STATE.md` aggiornato se cambia lo stato della fase +- [ ] ADR in `docs/adr/` per ogni decisione non coperta dalla guida +- [ ] Nessun numero magico nella simulazione (parametri in `data/*.json`), determinismo rispettato +- [ ] Schermate in `docs/screenshots/` se cambia l'interfaccia diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml new file mode 100644 index 0000000..1350b1c --- /dev/null +++ b/.gitea/workflows/ci.yml @@ -0,0 +1,104 @@ +name: CI + +# Gitea Actions (ADR 0014). Il runner è act_runner in modalità Docker sul server Linux che ospita Gitea: ogni job +# gira in un container. I job .NET usano l'immagine dell'SDK e fanno il checkout con git, perché le azioni JavaScript +# richiedono Node.js, assente in quell'immagine. Nessuna cache e nessun artefatto: il risultato è il verde o il rosso. +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +env: + DOTNET_NOLOGO: "1" + DOTNET_CLI_TELEMETRY_OPTOUT: "1" + DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1" + BUILD_CPUS: "4" + +jobs: + build: + name: Build e test + runs-on: ubuntu-latest + container: + image: mcr.microsoft.com/dotnet/sdk:10.0 + timeout-minutes: 90 + defaults: + run: + shell: bash + steps: + - name: Checkout + env: + TOKEN: ${{ github.token }} + run: | + git config --global --add safe.directory "$PWD" + git init -q . + git remote add origin "${{ github.server_url }}/${{ github.repository }}.git" + git -c http.extraheader="Authorization: basic $(printf 'x-access-token:%s' "$TOKEN" | base64 -w0)" fetch -q --depth=1 origin "${{ github.sha }}" + git checkout -q FETCH_HEAD + git log -1 --format='%h %s' + + # Core e Protocol compilano anche per net8.0 (client Godot): serve il targeting pack 8.0, che l'SDK 10 scarica + # da solo come pacchetto di riferimento. Nessun PackageReference è ammesso (check-nuget). + - name: Zero pacchetti NuGet + run: scripts/check-nuget.sh + + - name: Build Release (warning come errori) + run: dotnet build RailEnterprise.sln -c Release -m:"$BUILD_CPUS" -nologo + + - name: Validazione dei dati + run: dotnet run --project src/RailEnterprise.Tools -c Release --no-build -- validate-data --data data + + # Sulle PR i test lunghi (accettazioni pluriennali) si saltano; su main gira la suite completa. + - name: Test + run: | + if [ "${{ github.event_name }}" = "pull_request" ]; then + dotnet run --project tests/RailEnterprise.Tests -c Release --no-build -- --skip-slow + else + dotnet run --project tests/RailEnterprise.Tests -c Release --no-build + fi + + # Il server per Windows (quello che il gioco desktop avvia da «server/») si compila anche qui. + - name: Server Windows x64 (compilazione incrociata) + run: dotnet publish src/RailEnterprise.Server -c Release -r win-x64 --self-contained -p:ReServerOnly=true -o out/server-win-x64 -nologo + + # Il client Godot compila con il proprio SDK (Godot.NET.Sdk da NuGet, unica eccezione ammessa): basta dotnet. + - name: Client Godot (compilazione C#) + run: dotnet build client/RailEnterprise.Client/RailEnterprise.Client.csproj -c Release -nologo + + docker: + name: Immagine Docker + needs: build + runs-on: ubuntu-latest + timeout-minutes: 45 + env: + NAME: re-ci-${{ github.run_id }} + steps: + - name: Checkout + env: + TOKEN: ${{ github.token }} + run: | + git config --global --add safe.directory "$PWD" + git init -q . + git remote add origin "${{ github.server_url }}/${{ github.repository }}.git" + git -c http.extraheader="Authorization: basic $(printf 'x-access-token:%s' "$TOKEN" | base64 -w0)" fetch -q --depth=1 origin "${{ github.sha }}" + git checkout -q FETCH_HEAD + + - name: Build dell'immagine + run: docker build -f docker/Dockerfile -t "$NAME:ci" . + + # Il container del job e quello del server non condividono la rete: la prova usa l'healthcheck interno. + - name: Prova di avvio (/health) + run: | + docker run -d --name "$NAME" -e RE_TOKEN=ci "$NAME:ci" + for i in $(seq 1 60); do + if docker exec "$NAME" dotnet RailEnterprise.Server.dll --healthcheck; then echo "server sano"; exit 0; fi + sleep 2 + done + docker logs "$NAME" | tail -50 + exit 1 + + - name: Pulizia + if: always() + run: | + docker rm -f "$NAME" 2> /dev/null || true + docker image rm "$NAME:ci" 2> /dev/null || true diff --git a/.gitea/workflows/nightly.yml b/.gitea/workflows/nightly.yml new file mode 100644 index 0000000..eae70d4 --- /dev/null +++ b/.gitea/workflows/nightly.yml @@ -0,0 +1,55 @@ +name: Immagine nightly + +# L'immagine del server di main come :nightly nel registro container di Gitea (ADR 0014). Mai una release. +on: + schedule: + - cron: "37 2 * * *" + workflow_dispatch: + +permissions: + contents: read + packages: write + +env: + PUBLIC_URL: ${{ vars.PUBLIC_URL || 'https://gitea.encke-hake.ts.net' }} + +jobs: + nightly: + if: github.ref == 'refs/heads/main' + runs-on: ubuntu-latest + timeout-minutes: 60 + steps: + - name: Checkout + env: + TOKEN: ${{ github.token }} + run: | + git config --global --add safe.directory "$PWD" + git init -q . + git remote add origin "${{ github.server_url }}/${{ github.repository }}.git" + git -c http.extraheader="Authorization: basic $(printf 'x-access-token:%s' "$TOKEN" | base64 -w0)" fetch -q --depth=1 origin "${{ github.sha }}" + git checkout -q FETCH_HEAD + + - name: Accesso al registro + env: + REGISTRY: ${{ vars.REGISTRY }} + USER: ${{ vars.REGISTRY_USER || github.actor }} + TOKEN: ${{ secrets.REGISTRY_TOKEN || github.token }} + run: | + registry="${REGISTRY:-$(printf '%s' "$PUBLIC_URL" | sed -E 's#^[a-z]+://##; s#/.*$##')}" + owner="$(printf '%s' "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')" + { echo "REGISTRY_HOST=$registry"; echo "IMAGE=$registry/$owner/rail-enterprise-server"; } >> "$GITHUB_ENV" + if ! printf '%s' "$TOKEN" | docker login "$registry" -u "$USER" --password-stdin; then + echo "::error title=Registro::Accesso a $registry rifiutato: serve il segreto REGISTRY_TOKEN." + exit 1 + fi + + - name: Build e push + run: | + docker build -f docker/Dockerfile --build-arg RE_VERSION="0.0.0-nightly.${{ github.run_number }}" -t "$IMAGE:nightly" . + docker push "$IMAGE:nightly" + + - name: Pulizia + if: always() + run: | + docker image rm "$IMAGE:nightly" 2> /dev/null || true + docker logout "$REGISTRY_HOST" || true diff --git a/.gitea/workflows/release.yml b/.gitea/workflows/release.yml new file mode 100644 index 0000000..258a2b7 --- /dev/null +++ b/.gitea/workflows/release.yml @@ -0,0 +1,213 @@ +name: Release + +# Un tag vMAJOR.MINOR.PATCH[-PRERELEASE] costruisce, prova e pubblica tutto (ADR 0014): +# - sulla release Gitea: il gioco desktop per Windows (client Godot + server locale in «server/»), il server per +# Windows e per Linux, SHA256SUMS e le note di rilascio; +# - nel registro container di Gitea: l'immagine del server con il tag della versione e, per le versioni stabili, :latest. +# La versione viene dal tag e sovrascrive quella di Directory.Build.props, che resta la versione di sviluppo. +on: + push: + tags: ["v*"] + workflow_dispatch: + inputs: + tag: + description: "Tag esistente da (ri)pubblicare, per esempio v0.6.0" + required: true + +permissions: + contents: write + packages: write + +env: + DOTNET_NOLOGO: "1" + DOTNET_CLI_TELEMETRY_OPTOUT: "1" + BUILD_CPUS: "4" + TAG: ${{ github.event.inputs.tag || github.ref_name }} + PUBLIC_URL: ${{ vars.PUBLIC_URL || 'https://gitea.encke-hake.ts.net' }} + # Versione di Godot .NET usata per esportare il client (deve coincidere con Godot.NET.Sdk nel csproj del client). + GODOT_VERSION: "4.7.2" + GODOT_MIRROR: ${{ vars.GODOT_MIRROR || 'https://github.com/godotengine/godot-builds/releases/download' }} + +jobs: + release: + name: Build, test e pubblicazione + runs-on: ubuntu-latest + container: + image: mcr.microsoft.com/dotnet/sdk:10.0 + timeout-minutes: 150 + defaults: + run: + shell: bash + outputs: + version: ${{ steps.version.outputs.version }} + prerelease: ${{ steps.version.outputs.prerelease }} + steps: + - name: Versione + id: version + run: | + semver='^v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-[0-9A-Za-z.-]+)?$' + if [[ ! "$TAG" =~ $semver ]]; then + echo "::error title=Release::Il tag '$TAG' non è vMAJOR.MINOR.PATCH o vMAJOR.MINOR.PATCH-PRERELEASE" + exit 1 + fi + version="${TAG#v}" + prerelease=false + if [[ "$version" == *-* ]]; then prerelease=true; fi + echo "version=$version" >> "$GITHUB_OUTPUT" + echo "prerelease=$prerelease" >> "$GITHUB_OUTPUT" + { echo "VERSION=$version"; echo "PRERELEASE=$prerelease"; } >> "$GITHUB_ENV" + + # Storia completa e tag: le note di rilascio elencano i commit dal tag precedente. + - name: Checkout + env: + TOKEN: ${{ github.token }} + run: | + git config --global --add safe.directory "$PWD" + git init -q . + git remote add origin "${{ github.server_url }}/${{ github.repository }}.git" + git -c http.extraheader="Authorization: basic $(printf 'x-access-token:%s' "$TOKEN" | base64 -w0)" fetch -q --tags origin + git checkout -q "refs/tags/$TAG" + git log -1 --format='%h %s' + + - name: Strumenti di sistema + run: | + apt-get update -qq + DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends unzip zip curl jq libfontconfig1 > /dev/null + + - name: Build e test + run: | + scripts/check-nuget.sh + dotnet build RailEnterprise.sln -c Release -m:"$BUILD_CPUS" -nologo -p:Version="$VERSION" + dotnet run --project src/RailEnterprise.Tools -c Release --no-build -- validate-data --data data + dotnet run --project tests/RailEnterprise.Tests -c Release --no-build + + - name: Server autonomi (win-x64, linux-x64) + run: | + for rid in win-x64 linux-x64; do + dotnet publish src/RailEnterprise.Server -c Release -r "$rid" --self-contained -p:ReServerOnly=true \ + -p:Version="$VERSION" -o "out/server-$rid" -nologo + done + + # Godot .NET senza interfaccia esporta il client per Windows. Il server per Windows va in «server/» accanto al + # gioco: è lì che LocalServerLauncher lo cerca per la partita locale. + - name: Gioco desktop per Windows (esportazione Godot) + run: | + set -euo pipefail + tools="$RUNNER_TEMP/godot" + mkdir -p "$tools" + base="$GODOT_MIRROR/$GODOT_VERSION-stable" + curl -fsSL -o "$tools/godot.zip" "$base/Godot_v$GODOT_VERSION-stable_mono_linux_x86_64.zip" + curl -fsSL -o "$tools/templates.tpz" "$base/Godot_v$GODOT_VERSION-stable_mono_export_templates.tpz" + unzip -q "$tools/godot.zip" -d "$tools" + godot="$(find "$tools" -type f -name "Godot_v*_mono_linux.x86_64" | head -n1)" + chmod +x "$godot" + templates="$HOME/.local/share/godot/export_templates/$GODOT_VERSION.stable.mono" + mkdir -p "$templates" + unzip -q "$tools/templates.tpz" -d "$tools/tpl" + cp -r "$tools/tpl/templates/." "$templates/" + cd client/RailEnterprise.Client + mkdir -p export/windows + "$godot" --headless --import || true + "$godot" --headless --export-release "Windows Desktop" export/windows/RailEnterprise.exe + test -f export/windows/RailEnterprise.exe + cp -r "../../out/server-win-x64" export/windows/server + + - name: Pacchetti + run: | + set -euo pipefail + mkdir -p out/release + (cd client/RailEnterprise.Client/export/windows && zip -qr "$OLDPWD/out/release/RailEnterprise-$VERSION-windows-x64.zip" .) + (cd out/server-win-x64 && zip -qr "$OLDPWD/out/release/RailEnterprise-Server-$VERSION-windows-x64.zip" .) + tar -C out/server-linux-x64 -czf "out/release/RailEnterprise-Server-$VERSION-linux-x64.tar.gz" . + cp docker/docker-compose.yml "out/release/docker-compose.yml" + cp docker/unraid-template.xml "out/release/unraid-template.xml" + (cd out/release && sha256sum -- * > SHA256SUMS && cat SHA256SUMS) + + - name: Note di rilascio + run: | + prev="$(git describe --tags --abbrev=0 "$TAG^" 2> /dev/null || true)" + owner="$(printf '%s' "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')" + host="$(printf '%s' "$PUBLIC_URL" | sed -E 's#^[a-z]+://##; s#/.*$##')" + { + echo "## Rail Enterprise $VERSION" + echo + echo "- **Gioco desktop (Windows x64):** scarica \`RailEnterprise-$VERSION-windows-x64.zip\`, estrai e avvia \`RailEnterprise.exe\`. «Partita locale» avvia da sola il server in \`server/\`." + echo "- **Server Docker:** \`docker pull $host/$owner/rail-enterprise-server:$VERSION\` (vedi \`docker-compose.yml\` e \`unraid-template.xml\`)." + echo "- **Server senza Docker:** \`RailEnterprise-Server-$VERSION-*.zip|tar.gz\`, poi \`RailEnterprise.Server --data ./dati\` con \`RE_TOKEN\` impostato." + echo + if [ -n "$prev" ]; then echo "### Modifiche da $prev"; else echo "### Modifiche"; fi + echo + git log --no-merges --format='- %s (%h)' ${prev:+$prev..}"$TAG" + } > out/release-notes.md + cat out/release-notes.md + + # Creata come bozza, pubblicata quando tutti i file sono caricati. + - name: Release Gitea + env: + TOKEN: ${{ github.token }} + run: | + set -euo pipefail + api="${{ github.server_url }}/api/v1/repos/${{ github.repository }}" + auth="Authorization: token $TOKEN" + existing="$(curl -fsS -H "$auth" "$api/releases/tags/$TAG" 2> /dev/null | jq -r '.id // empty' || true)" + if [ -n "$existing" ]; then curl -fsS -X DELETE -H "$auth" "$api/releases/$existing"; fi + body="$(jq -n --arg tag "$TAG" --arg name "Rail Enterprise $VERSION" --rawfile body out/release-notes.md \ + --argjson pre "$PRERELEASE" '{tag_name:$tag, name:$name, body:$body, draft:true, prerelease:$pre}')" + id="$(curl -fsS -X POST -H "$auth" -H 'Content-Type: application/json' -d "$body" "$api/releases" | jq -r .id)" + for f in out/release/*; do + name="$(basename "$f")" + curl -fsS -X POST -H "$auth" -F "attachment=@$f" "$api/releases/$id/assets?name=$name" > /dev/null + echo "caricato $name" + done + curl -fsS -X PATCH -H "$auth" -H 'Content-Type: application/json' -d '{"draft":false}' "$api/releases/$id" > /dev/null + echo "Release pubblicata: $PUBLIC_URL/${{ github.repository }}/releases/tag/$TAG" + + image: + name: Immagine del server + needs: release + runs-on: ubuntu-latest + timeout-minutes: 60 + env: + VERSION: ${{ needs.release.outputs.version }} + PRERELEASE: ${{ needs.release.outputs.prerelease }} + steps: + - name: Checkout + env: + TOKEN: ${{ github.token }} + run: | + git config --global --add safe.directory "$PWD" + git init -q . + git remote add origin "${{ github.server_url }}/${{ github.repository }}.git" + git -c http.extraheader="Authorization: basic $(printf 'x-access-token:%s' "$TOKEN" | base64 -w0)" fetch -q --depth=1 origin "refs/tags/$TAG:refs/tags/$TAG" + git checkout -q "refs/tags/$TAG" + + - name: Accesso al registro + env: + REGISTRY: ${{ vars.REGISTRY }} + USER: ${{ vars.REGISTRY_USER || github.actor }} + TOKEN: ${{ secrets.REGISTRY_TOKEN || github.token }} + run: | + registry="${REGISTRY:-$(printf '%s' "$PUBLIC_URL" | sed -E 's#^[a-z]+://##; s#/.*$##')}" + owner="$(printf '%s' "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')" + { echo "REGISTRY_HOST=$registry"; echo "IMAGE=$registry/$owner/rail-enterprise-server"; } >> "$GITHUB_ENV" + if ! printf '%s' "$TOKEN" | docker login "$registry" -u "$USER" --password-stdin; then + # il token del workflow (utente gitea-actions) non può scrivere i pacchetti di un'organizzazione + echo "::error title=Registro::Accesso a $registry rifiutato. Serve il segreto REGISTRY_TOKEN (organizzazione o repository): un token di un utente che può scrivere i pacchetti (scope package: read e write)." + exit 1 + fi + + - name: Build e push + run: | + docker build -f docker/Dockerfile --build-arg RE_VERSION="$VERSION" -t "$IMAGE:$VERSION" . + docker push "$IMAGE:$VERSION" + # Compose e Unraid seguono :latest, che si muove solo con le versioni stabili. + if [ "$PRERELEASE" != "true" ]; then + docker tag "$IMAGE:$VERSION" "$IMAGE:latest" + docker push "$IMAGE:latest" + fi + + - name: Pulizia + if: always() + run: | + docker image rm "$IMAGE:$VERSION" "$IMAGE:latest" 2> /dev/null || true + docker logout "$REGISTRY_HOST" || true diff --git a/.gitignore b/.gitignore index 6b4f75a..c466060 100644 --- a/.gitignore +++ b/.gitignore @@ -428,11 +428,11 @@ FodyWeavers.xsd *.msm *.msp -# --- Via Ferrea --- +# --- Rail Enterprise --- # Godot .godot/ -client/ViaFerrea.Client/.godot/ -client/ViaFerrea.Client/export/ +client/RailEnterprise.Client/.godot/ +client/RailEnterprise.Client/export/ # Output degli strumenti e dei test /out/ /artifacts/ @@ -442,6 +442,6 @@ docker/data/ # Salvataggi locali di sviluppo /saves/ # Dati copiati nel progetto Godot dalla build del client -client/ViaFerrea.Client/data/ +client/RailEnterprise.Client/data/ # Traduzioni generate da Godot importando strings.csv -client/ViaFerrea.Client/assets/i18n/*.translation +client/RailEnterprise.Client/assets/i18n/*.translation diff --git a/CLAUDE.md b/CLAUDE.md index af22e37..37a6150 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,4 +1,4 @@ -# CLAUDE.md — Via Ferrea +# CLAUDE.md — Rail Enterprise Gestionale ferroviario dall'alto: motore headless in C# (.NET 10), server ASP.NET Core in Docker, client Godot 4 .NET. La specifica vincolante è `docs/GUIDA.md`; lo stato dei lavori è in `docs/STATE.md`. Leggili entrambi a inizio sessione. @@ -8,8 +8,8 @@ La specifica vincolante è `docs/GUIDA.md`; lo stato dei lavori è in `docs/STAT ``` scripts/build.sh # check-nuget + build Release della soluzione scripts/test.sh [filtri] # build + validate-data + tutti i test (--skip-slow, --serial) -dotnet run --project tests/ViaFerrea.Tests -- --list -dotnet run --project src/ViaFerrea.Tools -- # validate-data, genmap, profile, simulate, bench, replay +dotnet run --project tests/RailEnterprise.Tests -- --list +dotnet run --project src/RailEnterprise.Tools -- # validate-data, genmap, profile, simulate, bench, replay ``` ## Regole non negoziabili @@ -25,14 +25,21 @@ dotnet run --project src/ViaFerrea.Tools -- # validate-data, genmap, ## Flusso di lavoro - Una fase alla volta (sezione 16 della guida). Fine fase: build verde, test verdi, `docs/STATE.md` aggiornato, commit `F: `. -- Nuovi test nel harness interno (`[Test]`, `Assert`), un file per area in `tests/ViaFerrea.Tests//`. +- Nuovi test nel harness interno (`[Test]`, `Assert`), un file per area in `tests/RailEnterprise.Tests//`. - I test lunghi si marcano `[Test(Slow = true)]`. +## Gitea, CI e rilasci + +- Repository `BalboSoft/Rail_Enterprise` su Gitea (`gitea.encke-hake.ts.net`, in LAN `192.168.30.23:3000`). Il progetto si chiamava «Via Ferrea»: il nome attuale è «Rail Enterprise» ovunque (ADR 0014). +- Ogni lavoro ha una issue nel milestone della sua fase (F0…F7, «Infrastruttura») e nel progetto «Roadmap»; PR verso `main` con `.gitea/PULL_REQUEST_TEMPLATE.md`, merge con la CI verde. +- `.gitea/workflows/ci.yml` (PR e main), `release.yml` (tag `vX.Y.Z`: gioco Windows + server + immagine Docker), `nightly.yml`. Segreto di organizzazione `REGISTRY_TOKEN`. +- La Wiki su Gitea (guida del giocatore, schermate) si aggiorna quando cambia l'interfaccia. + ## Mappa del codice -- `src/ViaFerrea.Core` — Common, Time, Data, Map, Economy, Rail, Commands, Simulation, Persistence (vedi `docs/ARCHITECTURE.md`). -- `src/ViaFerrea.Protocol` — frame e messaggi (vedi `docs/PROTOCOL.md`). -- `src/ViaFerrea.Server` — GameLoop, sessioni WebSocket, API HTTP. -- `src/ViaFerrea.Tools` — `viaferrea-tools`. -- `client/ViaFerrea.Client` — progetto Godot. -- `reference/` — immagini di riferimento visivo vincolanti. +- `src/RailEnterprise.Core` — Common, Time, Data, Map, Economy, Rail, Commands, Simulation, Persistence (vedi `docs/ARCHITECTURE.md`). +- `src/RailEnterprise.Protocol` — frame e messaggi (vedi `docs/PROTOCOL.md`). +- `src/RailEnterprise.Server` — GameLoop, sessioni WebSocket, API HTTP. +- `src/RailEnterprise.Tools` — `railenterprise-tools`. +- `client/RailEnterprise.Client` — progetto Godot. +- `reference/` — immagini di riferimento visivo vincolanti (01–09: mappa, binari, treni, edifici, palette, mercato, industria, scalata, connessione). diff --git a/Directory.Build.props b/Directory.Build.props index 0a4edb0..923ca33 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -1,5 +1,5 @@ - + 0.1.0 @@ -9,9 +9,9 @@ true true true - Via Ferrea - Via Ferrea - Via Ferrea + Rail Enterprise + Rail Enterprise + Rail Enterprise it;en false diff --git a/README.md b/README.md index 0284725..e8d8730 100644 --- a/README.md +++ b/README.md @@ -1,63 +1,101 @@ -# Via Ferrea +# 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 client desktop (Godot 4 .NET) sia come server Linux in Docker. +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. -## Requisiti +![Linea con ponte nel client](docs/screenshots/f3-linea-con-ponte.jpg) + +## Scaricare + +Ogni versione è sulla pagina [Release](https://gitea.encke-hake.ts.net/BalboSoft/Rail_Enterprise/releases): + +| File | Per | +|---|---| +| `RailEnterprise--windows-x64.zip` | il gioco desktop: estrai e avvia `RailEnterprise.exe` («Partita locale» avvia il server in `server/`) | +| `RailEnterprise-Server--windows-x64.zip` / `-linux-x64.tar.gz` | il server senza Docker | +| immagine `gitea.encke-hake.ts.net/balbosoft/rail-enterprise-server:` | il server in Docker / Unraid | + +## Requisiti per lo sviluppo - .NET SDK 10.x (`dotnet --version`) -- Godot 4 .NET, versione stabile più recente, come `godot` nel PATH (solo per il client) +- 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 +```bash +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: `./scripts/build.ps1 -Test`. +Su Windows (PowerShell): `./scripts/build.ps1 -Test`. + +## Avviare in locale + +**Server da sorgente** (porta 7400, token `prova`, salvataggi in `./dati-locali`): + +```bash +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 ` (è il modo in cui lo avvia il client). + +**Server in Docker** (dalla radice del repository): + +```bash +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**: + +```bash +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**: + +```bash +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 -- `: `validate-data`, `genmap`, `profile`, `simulate`, `bench`, `smoke`, `replay` (vedi la [Wiki](https://gitea.encke-hake.ts.net/BalboSoft/Rail_Enterprise/wiki)). ## Struttura | Cartella | Contenuto | |---|---| -| `src/ViaFerrea.Core` | simulazione, dati, mappa, economia, rete ferroviaria, salvataggi | -| `src/ViaFerrea.Protocol` | protocollo binario su WebSocket | -| `src/ViaFerrea.Server` | server autorevole (Kestrel) | -| `src/ViaFerrea.Tools` | `viaferrea-tools`: validate-data, genmap, profile, simulate, bench, smoke, replay | -| `tests/ViaFerrea.Tests` | harness di test interno e scenari | -| `client/ViaFerrea.Client` | client Godot | +| `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 | -| `reference/` | immagini di riferimento visivo | +| `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 | -## Server e client in locale +## CI e rilasci -``` -dotnet run --project src/ViaFerrea.Server -- --local --token prova # stampa LISTENING -dotnet build client/ViaFerrea.Client/ViaFerrea.Client.csproj # poi apri client/ViaFerrea.Client con Godot 4.7 .NET -``` +- **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 `:` (`:latest` per le versioni stabili). +- **Nightly** (`.gitea/workflows/nightly.yml`): immagine `:nightly` da `main` ogni notte. -Dal menu del client, «Partita locale» avvia da solo il server compilato (`src/ViaFerrea.Server/bin/...` oppure `VF_SERVER_PATH`). -Collaudi senza mani: `dotnet run --project src/ViaFerrea.Tools -- smoke --url ws://127.0.0.1:7400/ws --token prova` -contro un server in esecuzione; `GODOT=/percorso/godot scripts/client-autopilot.sh` per il client con schermate. +Dettagli in [ADR 0014](docs/adr/0014-nome-ci-e-rilasci.md). -![Linea con ponte nel client](docs/screenshots/f3-linea-con-ponte.jpg) - -## Server in Docker - -``` -docker compose -f docker/docker-compose.yml up -d # oppure scripts/publish-image.sh per il registry Gitea -curl http://localhost:7400/health -curl http://localhost:7400/metrics -``` - -Variabili principali: `VF_TOKEN` (obbligatoria in rete), `VF_DIFFICULTY`, `VF_SEED`, `VF_MAP_SIZE`, `VF_DATA_DIR` (default `/data`). - -Il server parla WebSocket in chiaro: per l'uso fuori da una rete privata mettilo dietro un reverse proxy con TLS (per esempio Caddy, Traefik o Nginx Proxy Manager su Unraid) ed esponi solo `wss://`. +Il server parla WebSocket in chiaro: fuori da una rete privata mettilo dietro un reverse proxy con TLS ed esponi solo `wss://`. ## Documentazione @@ -67,3 +105,4 @@ Il server parla WebSocket in chiaro: per l'uso fuori da una rete privata mettilo - `docs/PROTOCOL.md` — protocollo di rete - `docs/STATE.md` — stato dei lavori - `docs/adr/` — decisioni architetturali +- [Wiki](https://gitea.encke-hake.ts.net/BalboSoft/Rail_Enterprise/wiki) — guida del giocatore e schermate diff --git a/ViaFerrea.sln b/RailEnterprise.sln similarity index 87% rename from ViaFerrea.sln rename to RailEnterprise.sln index 138ff9a..6c30e08 100644 --- a/ViaFerrea.sln +++ b/RailEnterprise.sln @@ -5,17 +5,17 @@ VisualStudioVersion = 17.0.31903.59 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ViaFerrea.Core", "src\ViaFerrea.Core\ViaFerrea.Core.csproj", "{D50BCC13-4F79-4DB1-BD16-5E7576006DA9}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RailEnterprise.Core", "src\RailEnterprise.Core\RailEnterprise.Core.csproj", "{D50BCC13-4F79-4DB1-BD16-5E7576006DA9}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ViaFerrea.Protocol", "src\ViaFerrea.Protocol\ViaFerrea.Protocol.csproj", "{7582B640-61C0-47F8-9A2E-B3607B01FD35}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RailEnterprise.Protocol", "src\RailEnterprise.Protocol\RailEnterprise.Protocol.csproj", "{7582B640-61C0-47F8-9A2E-B3607B01FD35}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ViaFerrea.Server", "src\ViaFerrea.Server\ViaFerrea.Server.csproj", "{D9E37057-86E8-4DDE-B3DA-EDC44F4EAE30}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RailEnterprise.Server", "src\RailEnterprise.Server\RailEnterprise.Server.csproj", "{D9E37057-86E8-4DDE-B3DA-EDC44F4EAE30}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ViaFerrea.Tools", "src\ViaFerrea.Tools\ViaFerrea.Tools.csproj", "{509F4E00-74B7-4FFB-84E0-3CB1F671A70E}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RailEnterprise.Tools", "src\RailEnterprise.Tools\RailEnterprise.Tools.csproj", "{509F4E00-74B7-4FFB-84E0-3CB1F671A70E}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0AB3BF05-4346-4AA6-1389-037BE0695223}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ViaFerrea.Tests", "tests\ViaFerrea.Tests\ViaFerrea.Tests.csproj", "{BE4E0868-2350-4C87-968E-E424D4DEB1C5}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RailEnterprise.Tests", "tests\RailEnterprise.Tests\RailEnterprise.Tests.csproj", "{BE4E0868-2350-4C87-968E-E424D4DEB1C5}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/client/ViaFerrea.Client/ViaFerrea.Client.csproj b/client/RailEnterprise.Client/RailEnterprise.Client.csproj similarity index 75% rename from client/ViaFerrea.Client/ViaFerrea.Client.csproj rename to client/RailEnterprise.Client/RailEnterprise.Client.csproj index fd5c0b0..27fb652 100644 --- a/client/ViaFerrea.Client/ViaFerrea.Client.csproj +++ b/client/RailEnterprise.Client/RailEnterprise.Client.csproj @@ -1,13 +1,13 @@ net8.0 true - ViaFerrea.Client + RailEnterprise.Client enable enable latest @@ -16,8 +16,8 @@ - - + + diff --git a/client/ViaFerrea.Client/assets/fonts/BigShouldersDisplay-ExtraBold.ttf b/client/RailEnterprise.Client/assets/fonts/BigShouldersDisplay-ExtraBold.ttf similarity index 100% rename from client/ViaFerrea.Client/assets/fonts/BigShouldersDisplay-ExtraBold.ttf rename to client/RailEnterprise.Client/assets/fonts/BigShouldersDisplay-ExtraBold.ttf diff --git a/client/ViaFerrea.Client/assets/fonts/BigShouldersDisplay-ExtraBold.ttf.import b/client/RailEnterprise.Client/assets/fonts/BigShouldersDisplay-ExtraBold.ttf.import similarity index 100% rename from client/ViaFerrea.Client/assets/fonts/BigShouldersDisplay-ExtraBold.ttf.import rename to client/RailEnterprise.Client/assets/fonts/BigShouldersDisplay-ExtraBold.ttf.import diff --git a/client/ViaFerrea.Client/assets/fonts/IBMPlexSans-Regular.ttf b/client/RailEnterprise.Client/assets/fonts/IBMPlexSans-Regular.ttf similarity index 100% rename from client/ViaFerrea.Client/assets/fonts/IBMPlexSans-Regular.ttf rename to client/RailEnterprise.Client/assets/fonts/IBMPlexSans-Regular.ttf diff --git a/client/ViaFerrea.Client/assets/fonts/IBMPlexSans-Regular.ttf.import b/client/RailEnterprise.Client/assets/fonts/IBMPlexSans-Regular.ttf.import similarity index 100% rename from client/ViaFerrea.Client/assets/fonts/IBMPlexSans-Regular.ttf.import rename to client/RailEnterprise.Client/assets/fonts/IBMPlexSans-Regular.ttf.import diff --git a/client/ViaFerrea.Client/assets/fonts/IBMPlexSans-SemiBold.ttf b/client/RailEnterprise.Client/assets/fonts/IBMPlexSans-SemiBold.ttf similarity index 100% rename from client/ViaFerrea.Client/assets/fonts/IBMPlexSans-SemiBold.ttf rename to client/RailEnterprise.Client/assets/fonts/IBMPlexSans-SemiBold.ttf diff --git a/client/ViaFerrea.Client/assets/fonts/IBMPlexSans-SemiBold.ttf.import b/client/RailEnterprise.Client/assets/fonts/IBMPlexSans-SemiBold.ttf.import similarity index 100% rename from client/ViaFerrea.Client/assets/fonts/IBMPlexSans-SemiBold.ttf.import rename to client/RailEnterprise.Client/assets/fonts/IBMPlexSans-SemiBold.ttf.import diff --git a/client/ViaFerrea.Client/assets/fonts/OFL.txt b/client/RailEnterprise.Client/assets/fonts/OFL.txt similarity index 100% rename from client/ViaFerrea.Client/assets/fonts/OFL.txt rename to client/RailEnterprise.Client/assets/fonts/OFL.txt diff --git a/client/ViaFerrea.Client/assets/i18n/strings.csv b/client/RailEnterprise.Client/assets/i18n/strings.csv similarity index 96% rename from client/ViaFerrea.Client/assets/i18n/strings.csv rename to client/RailEnterprise.Client/assets/i18n/strings.csv index 1f1b9a2..f048574 100644 --- a/client/ViaFerrea.Client/assets/i18n/strings.csv +++ b/client/RailEnterprise.Client/assets/i18n/strings.csv @@ -282,7 +282,7 @@ Seleziona un treno,,Select a train Seleziona un treno e un deposito,,Select a train and a depot Sentiment del mercato,,Market sentiment Serve un deposito,,A depot is required -Server locale non trovato: compila src/ViaFerrea.Server o imposta VF_SERVER_PATH.,,Local server not found: build src/ViaFerrea.Server or set VF_SERVER_PATH. +Server locale non trovato: compila src/RailEnterprise.Server o imposta RE_SERVER_PATH.,,Local server not found: build src/RailEnterprise.Server or set RE_SERVER_PATH. Servizi,,Services Servono almeno due fermate,,At least two stops are needed Soddisfazione,,Satisfaction @@ -314,7 +314,7 @@ Veicoli,,Vehicles Velocità,,Speed Vendi,,Sell Verde,,Green -Via Ferrea,,Via Ferrea +Rail Enterprise,,Rail Enterprise a piedi,,on foot abitanti,,inhabitants agli azionisti; i dividendi alzano il sentiment del titolo.,,to shareholders; dividends raise the share's sentiment. diff --git a/client/ViaFerrea.Client/assets/i18n/strings.csv.import b/client/RailEnterprise.Client/assets/i18n/strings.csv.import similarity index 100% rename from client/ViaFerrea.Client/assets/i18n/strings.csv.import rename to client/RailEnterprise.Client/assets/i18n/strings.csv.import diff --git a/client/ViaFerrea.Client/assets/shaders/terrain.gdshader b/client/RailEnterprise.Client/assets/shaders/terrain.gdshader similarity index 100% rename from client/ViaFerrea.Client/assets/shaders/terrain.gdshader rename to client/RailEnterprise.Client/assets/shaders/terrain.gdshader diff --git a/client/ViaFerrea.Client/assets/shaders/terrain.gdshader.uid b/client/RailEnterprise.Client/assets/shaders/terrain.gdshader.uid similarity index 100% rename from client/ViaFerrea.Client/assets/shaders/terrain.gdshader.uid rename to client/RailEnterprise.Client/assets/shaders/terrain.gdshader.uid diff --git a/client/ViaFerrea.Client/assets/theme/icon.svg b/client/RailEnterprise.Client/assets/theme/icon.svg similarity index 100% rename from client/ViaFerrea.Client/assets/theme/icon.svg rename to client/RailEnterprise.Client/assets/theme/icon.svg diff --git a/client/ViaFerrea.Client/assets/theme/icon.svg.import b/client/RailEnterprise.Client/assets/theme/icon.svg.import similarity index 100% rename from client/ViaFerrea.Client/assets/theme/icon.svg.import rename to client/RailEnterprise.Client/assets/theme/icon.svg.import diff --git a/client/ViaFerrea.Client/export_presets.cfg b/client/RailEnterprise.Client/export_presets.cfg similarity index 86% rename from client/ViaFerrea.Client/export_presets.cfg rename to client/RailEnterprise.Client/export_presets.cfg index 77b67ee..7c4d18b 100644 --- a/client/ViaFerrea.Client/export_presets.cfg +++ b/client/RailEnterprise.Client/export_presets.cfg @@ -8,7 +8,7 @@ custom_features="" export_filter="all_resources" include_filter="data/*.json, data/schema/*.json, assets/i18n/*.csv, assets/fonts/*.ttf, assets/fonts/OFL.txt" exclude_filter="" -export_path="export/windows/ViaFerrea.exe" +export_path="export/windows/RailEnterprise.exe" encryption_include_filters="" encryption_exclude_filters="" encrypt_pck=false @@ -21,8 +21,8 @@ custom_template/release="" debug/export_console_wrapper=1 binary_format/embed_pck=false binary_format/architecture="x86_64" -application/product_name="Via Ferrea" -application/company_name="Via Ferrea" +application/product_name="Rail Enterprise" +application/company_name="Rail Enterprise" application/file_description="Gestionale ferroviario dall'alto" dotnet/include_scripts_content=false dotnet/include_debug_symbols=false @@ -38,7 +38,7 @@ custom_features="" export_filter="all_resources" include_filter="data/*.json, data/schema/*.json, assets/i18n/*.csv, assets/fonts/*.ttf, assets/fonts/OFL.txt" exclude_filter="" -export_path="export/linux/ViaFerrea.x86_64" +export_path="export/linux/RailEnterprise.x86_64" encrypt_pck=false encrypt_directory=false diff --git a/client/ViaFerrea.Client/project.godot b/client/RailEnterprise.Client/project.godot similarity index 83% rename from client/ViaFerrea.Client/project.godot rename to client/RailEnterprise.Client/project.godot index b349c49..0462d43 100644 --- a/client/ViaFerrea.Client/project.godot +++ b/client/RailEnterprise.Client/project.godot @@ -1,11 +1,11 @@ -; File di progetto di Godot 4: client di Via Ferrea (rendering, input, interfaccia). +; File di progetto di Godot 4: client di Rail Enterprise (rendering, input, interfaccia). ; Nessuna logica di gioco: il server è autorevole (docs/GUIDA.md, sezione 14.3). config_version=5 [application] -config/name="Via Ferrea" +config/name="Rail Enterprise" config/description="Gestionale ferroviario dall'alto" run/main_scene="res://scenes/Main.tscn" config/features=PackedStringArray("4.7", "C#", "GL Compatibility") @@ -21,7 +21,7 @@ window/stretch/aspect="expand" [dotnet] -project/assembly_name="ViaFerrea.Client" +project/assembly_name="RailEnterprise.Client" [internationalization] diff --git a/client/ViaFerrea.Client/scenes/Main.tscn b/client/RailEnterprise.Client/scenes/Main.tscn similarity index 100% rename from client/ViaFerrea.Client/scenes/Main.tscn rename to client/RailEnterprise.Client/scenes/Main.tscn diff --git a/client/ViaFerrea.Client/scripts/App/AutoPilot.cs b/client/RailEnterprise.Client/scripts/App/AutoPilot.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/App/AutoPilot.cs rename to client/RailEnterprise.Client/scripts/App/AutoPilot.cs index 2c7f22d..c1838e4 100644 --- a/client/ViaFerrea.Client/scripts/App/AutoPilot.cs +++ b/client/RailEnterprise.Client/scripts/App/AutoPilot.cs @@ -1,15 +1,15 @@ using Godot; -using ViaFerrea.Client.Hud; -using ViaFerrea.Client.Map; -using ViaFerrea.Client.Net; -using ViaFerrea.Client.Screens; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Client.Hud; +using RailEnterprise.Client.Map; +using RailEnterprise.Client.Net; +using RailEnterprise.Client.Screens; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Client.App; +namespace RailEnterprise.Client.App; /// /// Pilota automatico per il collaudo del client (-- --autopilot cartella): nella partita diff --git a/client/ViaFerrea.Client/scripts/App/AutoPilot.cs.uid b/client/RailEnterprise.Client/scripts/App/AutoPilot.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/App/AutoPilot.cs.uid rename to client/RailEnterprise.Client/scripts/App/AutoPilot.cs.uid diff --git a/client/ViaFerrea.Client/scripts/App/GodotDataSource.cs b/client/RailEnterprise.Client/scripts/App/GodotDataSource.cs similarity index 93% rename from client/ViaFerrea.Client/scripts/App/GodotDataSource.cs rename to client/RailEnterprise.Client/scripts/App/GodotDataSource.cs index 6e27de0..3d965bd 100644 --- a/client/ViaFerrea.Client/scripts/App/GodotDataSource.cs +++ b/client/RailEnterprise.Client/scripts/App/GodotDataSource.cs @@ -1,7 +1,7 @@ using Godot; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Client.App; +namespace RailEnterprise.Client.App; /// File dati del gioco dentro il progetto Godot (res://data, copiati dalla build del client). public sealed class GodotDataSource(string root = "res://data") : IDataSource diff --git a/client/ViaFerrea.Client/scripts/App/GodotDataSource.cs.uid b/client/RailEnterprise.Client/scripts/App/GodotDataSource.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/App/GodotDataSource.cs.uid rename to client/RailEnterprise.Client/scripts/App/GodotDataSource.cs.uid diff --git a/client/ViaFerrea.Client/scripts/App/Localization.cs b/client/RailEnterprise.Client/scripts/App/Localization.cs similarity index 97% rename from client/ViaFerrea.Client/scripts/App/Localization.cs rename to client/RailEnterprise.Client/scripts/App/Localization.cs index 5908b47..9f5c166 100644 --- a/client/ViaFerrea.Client/scripts/App/Localization.cs +++ b/client/RailEnterprise.Client/scripts/App/Localization.cs @@ -1,6 +1,6 @@ using Godot; -namespace ViaFerrea.Client.App; +namespace RailEnterprise.Client.App; /// /// Testi dell'interfaccia: la lingua sorgente è l'italiano (le chiavi sono i testi italiani), diff --git a/client/ViaFerrea.Client/scripts/App/Localization.cs.uid b/client/RailEnterprise.Client/scripts/App/Localization.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/App/Localization.cs.uid rename to client/RailEnterprise.Client/scripts/App/Localization.cs.uid diff --git a/client/ViaFerrea.Client/scripts/App/Palette.cs b/client/RailEnterprise.Client/scripts/App/Palette.cs similarity index 98% rename from client/ViaFerrea.Client/scripts/App/Palette.cs rename to client/RailEnterprise.Client/scripts/App/Palette.cs index 08aa03a..23e616d 100644 --- a/client/ViaFerrea.Client/scripts/App/Palette.cs +++ b/client/RailEnterprise.Client/scripts/App/Palette.cs @@ -1,6 +1,6 @@ using Godot; -namespace ViaFerrea.Client.App; +namespace RailEnterprise.Client.App; /// Palette dell'immagine di riferimento 05: interfaccia blu-ardesia con accento ambra, mappa cartografica chiara. public static class Palette diff --git a/client/ViaFerrea.Client/scripts/App/Palette.cs.uid b/client/RailEnterprise.Client/scripts/App/Palette.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/App/Palette.cs.uid rename to client/RailEnterprise.Client/scripts/App/Palette.cs.uid diff --git a/client/ViaFerrea.Client/scripts/App/UiTheme.cs b/client/RailEnterprise.Client/scripts/App/UiTheme.cs similarity index 99% rename from client/ViaFerrea.Client/scripts/App/UiTheme.cs rename to client/RailEnterprise.Client/scripts/App/UiTheme.cs index 1016826..29ba875 100644 --- a/client/ViaFerrea.Client/scripts/App/UiTheme.cs +++ b/client/RailEnterprise.Client/scripts/App/UiTheme.cs @@ -1,6 +1,6 @@ using Godot; -namespace ViaFerrea.Client.App; +namespace RailEnterprise.Client.App; /// /// Tema dell'interfaccia costruito in codice dalla palette (immagine 05): titoli in Big Shoulders diff --git a/client/ViaFerrea.Client/scripts/App/UiTheme.cs.uid b/client/RailEnterprise.Client/scripts/App/UiTheme.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/App/UiTheme.cs.uid rename to client/RailEnterprise.Client/scripts/App/UiTheme.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Hud/Minimap.cs b/client/RailEnterprise.Client/scripts/Hud/Minimap.cs similarity index 95% rename from client/ViaFerrea.Client/scripts/Hud/Minimap.cs rename to client/RailEnterprise.Client/scripts/Hud/Minimap.cs index 7498b55..4484454 100644 --- a/client/ViaFerrea.Client/scripts/Hud/Minimap.cs +++ b/client/RailEnterprise.Client/scripts/Hud/Minimap.cs @@ -1,10 +1,10 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Map; -using ViaFerrea.Core.Map; -using ViaFerrea.Protocol.Client; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Map; +using RailEnterprise.Core.Map; +using RailEnterprise.Protocol.Client; -namespace ViaFerrea.Client.Hud; +namespace RailEnterprise.Client.Hud; /// Minimappa: terreno ridotto, linee, città e rettangolo della vista; un clic centra la mappa. public partial class Minimap : Control diff --git a/client/ViaFerrea.Client/scripts/Hud/Minimap.cs.uid b/client/RailEnterprise.Client/scripts/Hud/Minimap.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Hud/Minimap.cs.uid rename to client/RailEnterprise.Client/scripts/Hud/Minimap.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Hud/Ticker.cs b/client/RailEnterprise.Client/scripts/Hud/Ticker.cs similarity index 89% rename from client/ViaFerrea.Client/scripts/Hud/Ticker.cs rename to client/RailEnterprise.Client/scripts/Hud/Ticker.cs index 4fb6eb6..5f983ae 100644 --- a/client/ViaFerrea.Client/scripts/Hud/Ticker.cs +++ b/client/RailEnterprise.Client/scripts/Hud/Ticker.cs @@ -1,9 +1,9 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Protocol.Messages; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Protocol.Messages; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Hud; +namespace RailEnterprise.Client.Hud; /// Notiziario in basso (immagine 01): «Notizie» e gli ultimi eventi che scorrono. public partial class Ticker : PanelContainer diff --git a/client/ViaFerrea.Client/scripts/Hud/Ticker.cs.uid b/client/RailEnterprise.Client/scripts/Hud/Ticker.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Hud/Ticker.cs.uid rename to client/RailEnterprise.Client/scripts/Hud/Ticker.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Hud/Toolbar.cs b/client/RailEnterprise.Client/scripts/Hud/Toolbar.cs similarity index 98% rename from client/ViaFerrea.Client/scripts/Hud/Toolbar.cs rename to client/RailEnterprise.Client/scripts/Hud/Toolbar.cs index fc32bd9..779b81f 100644 --- a/client/ViaFerrea.Client/scripts/Hud/Toolbar.cs +++ b/client/RailEnterprise.Client/scripts/Hud/Toolbar.cs @@ -1,8 +1,8 @@ using Godot; -using ViaFerrea.Client.App; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Hud; +namespace RailEnterprise.Client.Hud; /// Strumenti e pannelli della barra sinistra (immagine 01). public enum Tool { None, Track, Station, Signal, Depot, Trains, Lines, Maintenance, Employment, Industries, Market, Companies, Finance, Demolish } diff --git a/client/ViaFerrea.Client/scripts/Hud/Toolbar.cs.uid b/client/RailEnterprise.Client/scripts/Hud/Toolbar.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Hud/Toolbar.cs.uid rename to client/RailEnterprise.Client/scripts/Hud/Toolbar.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Hud/TopBar.cs b/client/RailEnterprise.Client/scripts/Hud/TopBar.cs similarity index 97% rename from client/ViaFerrea.Client/scripts/Hud/TopBar.cs rename to client/RailEnterprise.Client/scripts/Hud/TopBar.cs index a40a1d6..5c328dd 100644 --- a/client/ViaFerrea.Client/scripts/Hud/TopBar.cs +++ b/client/RailEnterprise.Client/scripts/Hud/TopBar.cs @@ -1,9 +1,9 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Hud; +namespace RailEnterprise.Client.Hud; /// Barra superiore (immagine 01): compagnia e livello, data, velocità, cassa, patrimonio, rating, stato del server. public partial class TopBar : PanelContainer diff --git a/client/ViaFerrea.Client/scripts/Hud/TopBar.cs.uid b/client/RailEnterprise.Client/scripts/Hud/TopBar.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Hud/TopBar.cs.uid rename to client/RailEnterprise.Client/scripts/Hud/TopBar.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Main.cs b/client/RailEnterprise.Client/scripts/Main.cs similarity index 88% rename from client/ViaFerrea.Client/scripts/Main.cs rename to client/RailEnterprise.Client/scripts/Main.cs index 12d14a8..2c2d1aa 100644 --- a/client/ViaFerrea.Client/scripts/Main.cs +++ b/client/RailEnterprise.Client/scripts/Main.cs @@ -1,11 +1,11 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Client.Screens; -using ViaFerrea.Core.Data; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Client.Screens; +using RailEnterprise.Core.Data; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client; +namespace RailEnterprise.Client; /// /// Nodo radice: tema e traduzioni, dati del gioco, passaggio tra menu, collegamento e partita; @@ -26,7 +26,7 @@ public partial class Main : Node string locale = (string)cfg.GetValue("ui", "locale", "it"); Localization.Load(locale); GetWindow().Theme = UiTheme.Build(); - GetWindow().Title = "Via Ferrea"; + GetWindow().Title = "Rail Enterprise"; try { _data = GodotDataSource.LoadGameData(); @@ -42,9 +42,9 @@ public partial class Main : Node { // collaudo: mappa piccola e seme fisso per il server locale _autopilot = i + 1 < args.Length ? args[i + 1] : ProjectSettings.GlobalizePath("user://autopilot"); - System.Environment.SetEnvironmentVariable("VF_MAP_SIZE", "64"); - System.Environment.SetEnvironmentVariable("VF_SEED", "3"); - System.Environment.SetEnvironmentVariable("VF_AUTOSAVE_MIN", "0"); + System.Environment.SetEnvironmentVariable("RE_MAP_SIZE", "64"); + System.Environment.SetEnvironmentVariable("RE_SEED", "3"); + System.Environment.SetEnvironmentVariable("RE_AUTOSAVE_MIN", "0"); StartLocal(); } } @@ -102,7 +102,7 @@ public partial class Main : Node string? server = LocalServerLauncher.FindServer(); if (server is null) { - ShowMenu(T("Server locale non trovato: compila src/ViaFerrea.Server o imposta VF_SERVER_PATH.")); + ShowMenu(T("Server locale non trovato: compila src/RailEnterprise.Server o imposta RE_SERVER_PATH.")); return; } if (_screen is MenuScreen menu) menu.SetStatus(T("Avvio del server locale…")); diff --git a/client/ViaFerrea.Client/scripts/Main.cs.uid b/client/RailEnterprise.Client/scripts/Main.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Main.cs.uid rename to client/RailEnterprise.Client/scripts/Main.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Map/EntityLayer.cs b/client/RailEnterprise.Client/scripts/Map/EntityLayer.cs similarity index 98% rename from client/ViaFerrea.Client/scripts/Map/EntityLayer.cs rename to client/RailEnterprise.Client/scripts/Map/EntityLayer.cs index dc011e6..2722d41 100644 --- a/client/ViaFerrea.Client/scripts/Map/EntityLayer.cs +++ b/client/RailEnterprise.Client/scripts/Map/EntityLayer.cs @@ -1,10 +1,10 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Core.Map; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Client.App; +using RailEnterprise.Core.Map; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Client.Map; +namespace RailEnterprise.Client.Map; /// /// Entità sulla mappa (immagine 04): case con tetti in coppi sulle celle d'abitato, impronte diff --git a/client/ViaFerrea.Client/scripts/Map/EntityLayer.cs.uid b/client/RailEnterprise.Client/scripts/Map/EntityLayer.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Map/EntityLayer.cs.uid rename to client/RailEnterprise.Client/scripts/Map/EntityLayer.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Map/LabelLayer.cs b/client/RailEnterprise.Client/scripts/Map/LabelLayer.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/Map/LabelLayer.cs rename to client/RailEnterprise.Client/scripts/Map/LabelLayer.cs index 9dba0e2..ad99262 100644 --- a/client/ViaFerrea.Client/scripts/Map/LabelLayer.cs +++ b/client/RailEnterprise.Client/scripts/Map/LabelLayer.cs @@ -1,9 +1,9 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Core.Common; -using ViaFerrea.Protocol.Client; +using RailEnterprise.Client.App; +using RailEnterprise.Core.Common; +using RailEnterprise.Protocol.Client; -namespace ViaFerrea.Client.Map; +namespace RailEnterprise.Client.Map; /// /// Etichette a dimensione costante sullo schermo: città in Big Shoulders Display con gli abitanti, diff --git a/client/ViaFerrea.Client/scripts/Map/LabelLayer.cs.uid b/client/RailEnterprise.Client/scripts/Map/LabelLayer.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Map/LabelLayer.cs.uid rename to client/RailEnterprise.Client/scripts/Map/LabelLayer.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Map/MapScale.cs b/client/RailEnterprise.Client/scripts/Map/MapScale.cs similarity index 97% rename from client/ViaFerrea.Client/scripts/Map/MapScale.cs rename to client/RailEnterprise.Client/scripts/Map/MapScale.cs index 9344b93..d345167 100644 --- a/client/ViaFerrea.Client/scripts/Map/MapScale.cs +++ b/client/RailEnterprise.Client/scripts/Map/MapScale.cs @@ -1,7 +1,7 @@ using Godot; -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Client.Map; +namespace RailEnterprise.Client.Map; /// /// Scala dei simboli: a zoom ravvicinato binari e treni hanno le misure della guida in metri diff --git a/client/ViaFerrea.Client/scripts/Map/MapScale.cs.uid b/client/RailEnterprise.Client/scripts/Map/MapScale.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Map/MapScale.cs.uid rename to client/RailEnterprise.Client/scripts/Map/MapScale.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Map/MapView.cs b/client/RailEnterprise.Client/scripts/Map/MapView.cs similarity index 98% rename from client/ViaFerrea.Client/scripts/Map/MapView.cs rename to client/RailEnterprise.Client/scripts/Map/MapView.cs index 8dc9773..af604ec 100644 --- a/client/ViaFerrea.Client/scripts/Map/MapView.cs +++ b/client/RailEnterprise.Client/scripts/Map/MapView.cs @@ -1,7 +1,7 @@ using Godot; -using ViaFerrea.Client.Net; +using RailEnterprise.Client.Net; -namespace ViaFerrea.Client.Map; +namespace RailEnterprise.Client.Map; /// /// Vista della mappa: Node2D con Camera2D e i livelli (terreno, opere e binari, entità, treni, diff --git a/client/ViaFerrea.Client/scripts/Map/MapView.cs.uid b/client/RailEnterprise.Client/scripts/Map/MapView.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Map/MapView.cs.uid rename to client/RailEnterprise.Client/scripts/Map/MapView.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Map/TerrainLayer.cs b/client/RailEnterprise.Client/scripts/Map/TerrainLayer.cs similarity index 98% rename from client/ViaFerrea.Client/scripts/Map/TerrainLayer.cs rename to client/RailEnterprise.Client/scripts/Map/TerrainLayer.cs index 347dea3..ce8f78f 100644 --- a/client/ViaFerrea.Client/scripts/Map/TerrainLayer.cs +++ b/client/RailEnterprise.Client/scripts/Map/TerrainLayer.cs @@ -1,9 +1,9 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Core.Map; -using ViaFerrea.Protocol.Client; +using RailEnterprise.Client.App; +using RailEnterprise.Core.Map; +using RailEnterprise.Protocol.Client; -namespace ViaFerrea.Client.Map; +namespace RailEnterprise.Client.Map; /// /// Terreno a chunk (immagine 01): colori per tipo di cella e fascia altimetrica, ombreggiatura diff --git a/client/ViaFerrea.Client/scripts/Map/TerrainLayer.cs.uid b/client/RailEnterprise.Client/scripts/Map/TerrainLayer.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Map/TerrainLayer.cs.uid rename to client/RailEnterprise.Client/scripts/Map/TerrainLayer.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Map/ToolOverlay.cs b/client/RailEnterprise.Client/scripts/Map/ToolOverlay.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/Map/ToolOverlay.cs rename to client/RailEnterprise.Client/scripts/Map/ToolOverlay.cs index dd67953..71f3261 100644 --- a/client/ViaFerrea.Client/scripts/Map/ToolOverlay.cs +++ b/client/RailEnterprise.Client/scripts/Map/ToolOverlay.cs @@ -1,9 +1,9 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Core.Rail; -using ViaFerrea.Protocol.Client; +using RailEnterprise.Client.App; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol.Client; -namespace ViaFerrea.Client.Map; +namespace RailEnterprise.Client.Map; /// Sagome degli strumenti: tracciato in corso con l'anteprima delle opere, stazione o deposito da posare, fermate di una linea. public partial class ToolOverlay : Node2D diff --git a/client/ViaFerrea.Client/scripts/Map/ToolOverlay.cs.uid b/client/RailEnterprise.Client/scripts/Map/ToolOverlay.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Map/ToolOverlay.cs.uid rename to client/RailEnterprise.Client/scripts/Map/ToolOverlay.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Map/TrackLayer.cs b/client/RailEnterprise.Client/scripts/Map/TrackLayer.cs similarity index 97% rename from client/ViaFerrea.Client/scripts/Map/TrackLayer.cs rename to client/RailEnterprise.Client/scripts/Map/TrackLayer.cs index 24cd83b..bdcdc72 100644 --- a/client/ViaFerrea.Client/scripts/Map/TrackLayer.cs +++ b/client/RailEnterprise.Client/scripts/Map/TrackLayer.cs @@ -1,10 +1,10 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Core.Rail; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Client.App; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Client.Map; +namespace RailEnterprise.Client.Map; /// /// Binari e opere (immagini 01 e 02): massicciata #bfb79f, traversine #5b4a39 ogni 5,3 unità, diff --git a/client/ViaFerrea.Client/scripts/Map/TrackLayer.cs.uid b/client/RailEnterprise.Client/scripts/Map/TrackLayer.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Map/TrackLayer.cs.uid rename to client/RailEnterprise.Client/scripts/Map/TrackLayer.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Map/TrainLayer.cs b/client/RailEnterprise.Client/scripts/Map/TrainLayer.cs similarity index 97% rename from client/ViaFerrea.Client/scripts/Map/TrainLayer.cs rename to client/RailEnterprise.Client/scripts/Map/TrainLayer.cs index 26c0329..d91fa55 100644 --- a/client/ViaFerrea.Client/scripts/Map/TrainLayer.cs +++ b/client/RailEnterprise.Client/scripts/Map/TrainLayer.cs @@ -1,12 +1,12 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Rail; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Client.Map; +namespace RailEnterprise.Client.Map; /// /// Treni dall'alto (immagine 03): locomotiva scura con dettagli ambra, carri e carrozze con le diff --git a/client/ViaFerrea.Client/scripts/Map/TrainLayer.cs.uid b/client/RailEnterprise.Client/scripts/Map/TrainLayer.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Map/TrainLayer.cs.uid rename to client/RailEnterprise.Client/scripts/Map/TrainLayer.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Net/GameSession.cs b/client/RailEnterprise.Client/scripts/Net/GameSession.cs similarity index 95% rename from client/ViaFerrea.Client/scripts/Net/GameSession.cs rename to client/RailEnterprise.Client/scripts/Net/GameSession.cs index c1b4f08..f1c01be 100644 --- a/client/ViaFerrea.Client/scripts/Net/GameSession.cs +++ b/client/RailEnterprise.Client/scripts/Net/GameSession.cs @@ -1,11 +1,11 @@ using Godot; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Data; -using ViaFerrea.Protocol; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Data; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Client.Net; +namespace RailEnterprise.Client.Net; /// /// Sessione di gioco del client: connessione, copia locale del mondo, esiti dei comandi e diff --git a/client/ViaFerrea.Client/scripts/Net/GameSession.cs.uid b/client/RailEnterprise.Client/scripts/Net/GameSession.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Net/GameSession.cs.uid rename to client/RailEnterprise.Client/scripts/Net/GameSession.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Net/LocalServerLauncher.cs b/client/RailEnterprise.Client/scripts/Net/LocalServerLauncher.cs similarity index 88% rename from client/ViaFerrea.Client/scripts/Net/LocalServerLauncher.cs rename to client/RailEnterprise.Client/scripts/Net/LocalServerLauncher.cs index 8779cdb..f8526d2 100644 --- a/client/ViaFerrea.Client/scripts/Net/LocalServerLauncher.cs +++ b/client/RailEnterprise.Client/scripts/Net/LocalServerLauncher.cs @@ -1,7 +1,7 @@ using System.Diagnostics; using Godot; -namespace ViaFerrea.Client.Net; +namespace RailEnterprise.Client.Net; /// /// Partita locale: avvia il server come processo figlio con --local --token, legge @@ -14,22 +14,22 @@ public sealed class LocalServerLauncher : IDisposable public int Port { get; private set; } public string Token { get; } = Guid.NewGuid().ToString("N"); - /// Percorso del server: variabile VF_SERVER_PATH, cartella «server» accanto al gioco, build del repository. + /// Percorso del server: variabile RE_SERVER_PATH, cartella «server» accanto al gioco, build del repository. public static string? FindServer() { - string? env = System.Environment.GetEnvironmentVariable("VF_SERVER_PATH"); + string? env = System.Environment.GetEnvironmentVariable("RE_SERVER_PATH"); if (!string.IsNullOrWhiteSpace(env) && File.Exists(env)) return env; string exeDir = Path.GetDirectoryName(OS.GetExecutablePath()) ?? "."; - foreach (string name in new[] { "ViaFerrea.Server.exe", "ViaFerrea.Server", "ViaFerrea.Server.dll" }) + foreach (string name in new[] { "RailEnterprise.Server.exe", "RailEnterprise.Server", "RailEnterprise.Server.dll" }) { string candidate = Path.Combine(exeDir, "server", name); if (File.Exists(candidate)) return candidate; } - // sviluppo: il progetto Godot sta in client/ViaFerrea.Client, il server in src/ + // sviluppo: il progetto Godot sta in client/RailEnterprise.Client, il server in src/ string project = ProjectSettings.GlobalizePath("res://"); foreach (string config in new[] { "Release", "Debug" }) { - string candidate = Path.GetFullPath(Path.Combine(project, "..", "..", "src", "ViaFerrea.Server", "bin", config, "net10.0", "ViaFerrea.Server.dll")); + string candidate = Path.GetFullPath(Path.Combine(project, "..", "..", "src", "RailEnterprise.Server", "bin", config, "net10.0", "RailEnterprise.Server.dll")); if (File.Exists(candidate)) return candidate; } return null; diff --git a/client/ViaFerrea.Client/scripts/Net/LocalServerLauncher.cs.uid b/client/RailEnterprise.Client/scripts/Net/LocalServerLauncher.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Net/LocalServerLauncher.cs.uid rename to client/RailEnterprise.Client/scripts/Net/LocalServerLauncher.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/CompaniesPanel.cs b/client/RailEnterprise.Client/scripts/Panels/CompaniesPanel.cs similarity index 99% rename from client/ViaFerrea.Client/scripts/Panels/CompaniesPanel.cs rename to client/RailEnterprise.Client/scripts/Panels/CompaniesPanel.cs index 6bc6d33..17ad6bf 100644 --- a/client/ViaFerrea.Client/scripts/Panels/CompaniesPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/CompaniesPanel.cs @@ -1,14 +1,14 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// /// Compagnie e borsa (sezione 12, pannello a tutto schermo con palette e componenti dell'immagine diff --git a/client/ViaFerrea.Client/scripts/Panels/CompaniesPanel.cs.uid b/client/RailEnterprise.Client/scripts/Panels/CompaniesPanel.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/CompaniesPanel.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/CompaniesPanel.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/EmploymentPanel.cs b/client/RailEnterprise.Client/scripts/Panels/EmploymentPanel.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/Panels/EmploymentPanel.cs rename to client/RailEnterprise.Client/scripts/Panels/EmploymentPanel.cs index 287f3a8..4cc9525 100644 --- a/client/ViaFerrea.Client/scripts/Panels/EmploymentPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/EmploymentPanel.cs @@ -1,13 +1,13 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// /// Registro degli impieghi (sezione 9): convenzioni proposte dalle industrie (accetta o rifiuta), diff --git a/client/ViaFerrea.Client/scripts/Panels/EmploymentPanel.cs.uid b/client/RailEnterprise.Client/scripts/Panels/EmploymentPanel.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/EmploymentPanel.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/EmploymentPanel.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/Fmt.cs b/client/RailEnterprise.Client/scripts/Panels/Fmt.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/Panels/Fmt.cs rename to client/RailEnterprise.Client/scripts/Panels/Fmt.cs index e815d0d..86ec593 100644 --- a/client/ViaFerrea.Client/scripts/Panels/Fmt.cs +++ b/client/RailEnterprise.Client/scripts/Panels/Fmt.cs @@ -1,9 +1,9 @@ using System.Globalization; -using ViaFerrea.Core.Common; -using ViaFerrea.Protocol.Client; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Core.Common; +using RailEnterprise.Protocol.Client; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// /// Formati numerici dell'interfaccia (immagine 05): separatore delle migliaia con il punto, diff --git a/client/ViaFerrea.Client/scripts/Panels/Fmt.cs.uid b/client/RailEnterprise.Client/scripts/Panels/Fmt.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/Fmt.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/Fmt.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/IndustryPanel.cs b/client/RailEnterprise.Client/scripts/Panels/IndustryPanel.cs similarity index 98% rename from client/ViaFerrea.Client/scripts/Panels/IndustryPanel.cs rename to client/RailEnterprise.Client/scripts/Panels/IndustryPanel.cs index 83225f9..e0b4914 100644 --- a/client/ViaFerrea.Client/scripts/Panels/IndustryPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/IndustryPanel.cs @@ -1,14 +1,14 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// /// Industrie (sezione 11): elenco delle industrie della regione e pannello del proprietario diff --git a/client/ViaFerrea.Client/scripts/Panels/IndustryPanel.cs.uid b/client/RailEnterprise.Client/scripts/Panels/IndustryPanel.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/IndustryPanel.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/IndustryPanel.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/InfoPanel.cs b/client/RailEnterprise.Client/scripts/Panels/InfoPanel.cs similarity index 97% rename from client/ViaFerrea.Client/scripts/Panels/InfoPanel.cs rename to client/RailEnterprise.Client/scripts/Panels/InfoPanel.cs index 46e93ca..c0094bd 100644 --- a/client/ViaFerrea.Client/scripts/Panels/InfoPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/InfoPanel.cs @@ -1,11 +1,11 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// Scheda dell'entità selezionata (treno, stazione, industria, città) come nel pannello destro dell'immagine 01. public partial class InfoPanel : VBoxContainer @@ -197,7 +197,7 @@ public partial class InfoPanel : VBoxContainer } default: { - AddChild(UiTheme.TitleLabel(T("Via Ferrea"), 38)); + AddChild(UiTheme.TitleLabel(T("Rail Enterprise"), 38)); var help = UiTheme.Text(T("Scegli uno strumento a sinistra oppure fai clic su un treno, una stazione, un'industria o una città per vederne la scheda."), 14, Palette.TextSecondary); help.AutowrapMode = TextServer.AutowrapMode.WordSmart; AddChild(help); diff --git a/client/ViaFerrea.Client/scripts/Panels/InfoPanel.cs.uid b/client/RailEnterprise.Client/scripts/Panels/InfoPanel.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/InfoPanel.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/InfoPanel.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/LinesPanel.cs b/client/RailEnterprise.Client/scripts/Panels/LinesPanel.cs similarity index 94% rename from client/ViaFerrea.Client/scripts/Panels/LinesPanel.cs rename to client/RailEnterprise.Client/scripts/Panels/LinesPanel.cs index 23481cd..a2495b2 100644 --- a/client/ViaFerrea.Client/scripts/Panels/LinesPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/LinesPanel.cs @@ -1,12 +1,12 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// Linee: fermate scelte con un clic sulle stazioni, nome e colore, attesa del pieno alla prima fermata. public partial class LinesPanel : VBoxContainer diff --git a/client/ViaFerrea.Client/scripts/Panels/LinesPanel.cs.uid b/client/RailEnterprise.Client/scripts/Panels/LinesPanel.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/LinesPanel.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/LinesPanel.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/MaintenancePanel.cs b/client/RailEnterprise.Client/scripts/Panels/MaintenancePanel.cs similarity index 98% rename from client/ViaFerrea.Client/scripts/Panels/MaintenancePanel.cs rename to client/RailEnterprise.Client/scripts/Panels/MaintenancePanel.cs index e15210d..1aeaa88 100644 --- a/client/ViaFerrea.Client/scripts/Panels/MaintenancePanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/MaintenancePanel.cs @@ -1,12 +1,12 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Protocol.Messages; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Protocol.Messages; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// /// Officine (sezione 10.3): politica della flotta, avvisi, flotta ordinata per condizione con la diff --git a/client/ViaFerrea.Client/scripts/Panels/MaintenancePanel.cs.uid b/client/RailEnterprise.Client/scripts/Panels/MaintenancePanel.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/MaintenancePanel.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/MaintenancePanel.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/PanelKit.cs b/client/RailEnterprise.Client/scripts/Panels/PanelKit.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/Panels/PanelKit.cs rename to client/RailEnterprise.Client/scripts/Panels/PanelKit.cs index 06238cb..b4a4c02 100644 --- a/client/ViaFerrea.Client/scripts/Panels/PanelKit.cs +++ b/client/RailEnterprise.Client/scripts/Panels/PanelKit.cs @@ -1,7 +1,7 @@ using Godot; -using ViaFerrea.Client.App; +using RailEnterprise.Client.App; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// Mattoni comuni dei pannelli laterali. public static class PanelKit diff --git a/client/ViaFerrea.Client/scripts/Panels/PanelKit.cs.uid b/client/RailEnterprise.Client/scripts/Panels/PanelKit.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/PanelKit.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/PanelKit.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/ProfileChart.cs b/client/RailEnterprise.Client/scripts/Panels/ProfileChart.cs similarity index 94% rename from client/ViaFerrea.Client/scripts/Panels/ProfileChart.cs rename to client/RailEnterprise.Client/scripts/Panels/ProfileChart.cs index 2c81384..a04d6c1 100644 --- a/client/ViaFerrea.Client/scripts/Panels/ProfileChart.cs +++ b/client/RailEnterprise.Client/scripts/Panels/ProfileChart.cs @@ -1,9 +1,9 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Map; -using ViaFerrea.Core.Rail; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Map; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// Grafico altimetrico del tracciato: terreno, quota del binario e opere colorate (pannello TrackProfile). public partial class ProfileChart : Control diff --git a/client/ViaFerrea.Client/scripts/Panels/ProfileChart.cs.uid b/client/RailEnterprise.Client/scripts/Panels/ProfileChart.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/ProfileChart.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/ProfileChart.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/SeriesChart.cs b/client/RailEnterprise.Client/scripts/Panels/SeriesChart.cs similarity index 97% rename from client/ViaFerrea.Client/scripts/Panels/SeriesChart.cs rename to client/RailEnterprise.Client/scripts/Panels/SeriesChart.cs index 52cde24..3279154 100644 --- a/client/ViaFerrea.Client/scripts/Panels/SeriesChart.cs +++ b/client/RailEnterprise.Client/scripts/Panels/SeriesChart.cs @@ -1,8 +1,8 @@ using Godot; -using ViaFerrea.Client.App; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// /// Grafico di una serie (come ProfileChart): linea con area per i prezzi mensili delle azioni, diff --git a/client/ViaFerrea.Client/scripts/Panels/SeriesChart.cs.uid b/client/RailEnterprise.Client/scripts/Panels/SeriesChart.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/SeriesChart.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/SeriesChart.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/SimplePanels.cs b/client/RailEnterprise.Client/scripts/Panels/SimplePanels.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/Panels/SimplePanels.cs rename to client/RailEnterprise.Client/scripts/Panels/SimplePanels.cs index da868e6..d450940 100644 --- a/client/ViaFerrea.Client/scripts/Panels/SimplePanels.cs +++ b/client/RailEnterprise.Client/scripts/Panels/SimplePanels.cs @@ -1,11 +1,11 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// Strumento stazione: numero di binari, nome facoltativo, costo stimato; clic sulla mappa per posarla. public partial class StationPanel : VBoxContainer diff --git a/client/ViaFerrea.Client/scripts/Panels/SimplePanels.cs.uid b/client/RailEnterprise.Client/scripts/Panels/SimplePanels.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/SimplePanels.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/SimplePanels.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/TrackPanel.cs b/client/RailEnterprise.Client/scripts/Panels/TrackPanel.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/Panels/TrackPanel.cs rename to client/RailEnterprise.Client/scripts/Panels/TrackPanel.cs index 2c8649c..c896a92 100644 --- a/client/ViaFerrea.Client/scripts/Panels/TrackPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/TrackPanel.cs @@ -1,11 +1,11 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Rail; -using ViaFerrea.Protocol.Client; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol.Client; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// /// Strumento binari: classe, ponti, gallerie, doppio binario, elettrificazione e quota; anteprima diff --git a/client/ViaFerrea.Client/scripts/Panels/TrackPanel.cs.uid b/client/RailEnterprise.Client/scripts/Panels/TrackPanel.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/TrackPanel.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/TrackPanel.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Panels/TrainsPanel.cs b/client/RailEnterprise.Client/scripts/Panels/TrainsPanel.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/Panels/TrainsPanel.cs rename to client/RailEnterprise.Client/scripts/Panels/TrainsPanel.cs index f72fc92..cbf8293 100644 --- a/client/ViaFerrea.Client/scripts/Panels/TrainsPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/TrainsPanel.cs @@ -1,14 +1,14 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Net; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Rail; -using ViaFerrea.Protocol.Messages; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol.Messages; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Panels; +namespace RailEnterprise.Client.Panels; /// /// Treni: acquisto dei veicoli in un deposito, composizione, assegnazione alle linee, rientro. diff --git a/client/ViaFerrea.Client/scripts/Panels/TrainsPanel.cs.uid b/client/RailEnterprise.Client/scripts/Panels/TrainsPanel.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Panels/TrainsPanel.cs.uid rename to client/RailEnterprise.Client/scripts/Panels/TrainsPanel.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Screens/ChronicleScreen.cs b/client/RailEnterprise.Client/scripts/Screens/ChronicleScreen.cs similarity index 97% rename from client/ViaFerrea.Client/scripts/Screens/ChronicleScreen.cs rename to client/RailEnterprise.Client/scripts/Screens/ChronicleScreen.cs index 9cdf698..fd61e00 100644 --- a/client/ViaFerrea.Client/scripts/Screens/ChronicleScreen.cs +++ b/client/RailEnterprise.Client/scripts/Screens/ChronicleScreen.cs @@ -1,11 +1,11 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Panels; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Panels; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Screens; +namespace RailEnterprise.Client.Screens; /// /// Cronaca finale (12.3), a tutto schermo sopra la partita: storia della compagnia anno per anno diff --git a/client/ViaFerrea.Client/scripts/Screens/ChronicleScreen.cs.uid b/client/RailEnterprise.Client/scripts/Screens/ChronicleScreen.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Screens/ChronicleScreen.cs.uid rename to client/RailEnterprise.Client/scripts/Screens/ChronicleScreen.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Screens/ConnectScreen.cs b/client/RailEnterprise.Client/scripts/Screens/ConnectScreen.cs similarity index 96% rename from client/ViaFerrea.Client/scripts/Screens/ConnectScreen.cs rename to client/RailEnterprise.Client/scripts/Screens/ConnectScreen.cs index a6db5a9..167682f 100644 --- a/client/ViaFerrea.Client/scripts/Screens/ConnectScreen.cs +++ b/client/RailEnterprise.Client/scripts/Screens/ConnectScreen.cs @@ -1,8 +1,8 @@ using Godot; -using ViaFerrea.Client.App; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Screens; +namespace RailEnterprise.Client.Screens; /// /// Collegamento a un server (immagine 09 non fornita: palette e componenti dell'immagine 05). diff --git a/client/ViaFerrea.Client/scripts/Screens/ConnectScreen.cs.uid b/client/RailEnterprise.Client/scripts/Screens/ConnectScreen.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Screens/ConnectScreen.cs.uid rename to client/RailEnterprise.Client/scripts/Screens/ConnectScreen.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Screens/GameScreen.cs b/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs similarity index 98% rename from client/ViaFerrea.Client/scripts/Screens/GameScreen.cs rename to client/RailEnterprise.Client/scripts/Screens/GameScreen.cs index e555629..c594bd4 100644 --- a/client/ViaFerrea.Client/scripts/Screens/GameScreen.cs +++ b/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs @@ -1,18 +1,18 @@ using Godot; -using ViaFerrea.Client.App; -using ViaFerrea.Client.Hud; -using ViaFerrea.Client.Map; -using ViaFerrea.Client.Net; -using ViaFerrea.Client.Panels; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Rail; -using ViaFerrea.Protocol; -using ViaFerrea.Protocol.Messages; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using RailEnterprise.Client.Hud; +using RailEnterprise.Client.Map; +using RailEnterprise.Client.Net; +using RailEnterprise.Client.Panels; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Messages; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Screens; +namespace RailEnterprise.Client.Screens; /// /// Partita: mappa con i livelli, HUD (barra superiore, strumenti, pannello destro con minimappa, diff --git a/client/ViaFerrea.Client/scripts/Screens/GameScreen.cs.uid b/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Screens/GameScreen.cs.uid rename to client/RailEnterprise.Client/scripts/Screens/GameScreen.cs.uid diff --git a/client/ViaFerrea.Client/scripts/Screens/MenuScreen.cs b/client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs similarity index 92% rename from client/ViaFerrea.Client/scripts/Screens/MenuScreen.cs rename to client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs index d6f736b..72a4fdd 100644 --- a/client/ViaFerrea.Client/scripts/Screens/MenuScreen.cs +++ b/client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs @@ -1,8 +1,8 @@ using Godot; -using ViaFerrea.Client.App; -using static ViaFerrea.Client.App.Localization; +using RailEnterprise.Client.App; +using static RailEnterprise.Client.App.Localization; -namespace ViaFerrea.Client.Screens; +namespace RailEnterprise.Client.Screens; /// Menu iniziale: partita locale (server figlio), collegamento a un server, lingua, uscita. public partial class MenuScreen : Control @@ -26,7 +26,7 @@ public partial class MenuScreen : Control var col = new VBoxContainer { CustomMinimumSize = new Vector2(440, 0) }; col.AddThemeConstantOverride("separation", 14); center.AddChild(col); - col.AddChild(UiTheme.TitleLabel("Via Ferrea", 96)); + col.AddChild(UiTheme.TitleLabel("Rail Enterprise", 96)); col.AddChild(UiTheme.Text(T("Gestionale ferroviario dall'alto"), 18, Palette.TextSecondary)); col.AddChild(new Control { CustomMinimumSize = new Vector2(0, 20) }); var local = UiTheme.Primary(T("Partita locale")); diff --git a/client/ViaFerrea.Client/scripts/Screens/MenuScreen.cs.uid b/client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs.uid similarity index 100% rename from client/ViaFerrea.Client/scripts/Screens/MenuScreen.cs.uid rename to client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs.uid diff --git a/docker/Dockerfile b/docker/Dockerfile index 2c90672..4699913 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -1,18 +1,20 @@ -# Immagine del server di Via Ferrea (guida, sezione 14.4). -# Build dalla radice del repository: docker build -f docker/Dockerfile -t via-ferrea-server . +# Immagine del server di Rail Enterprise (guida, sezione 14.4). +# Build dalla radice del repository: docker build -f docker/Dockerfile -t rail-enterprise-server . FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build WORKDIR /src COPY . . -RUN dotnet publish src/ViaFerrea.Server -c Release -o /app -p:VfServerOnly=true +# versione dell'immagine: dal tag di rilascio (release.yml), altrimenti quella di Directory.Build.props +ARG RE_VERSION= +RUN dotnet publish src/RailEnterprise.Server -c Release -o /app -p:ReServerOnly=true ${RE_VERSION:+-p:Version=$RE_VERSION} FROM mcr.microsoft.com/dotnet/aspnet:10.0 WORKDIR /app COPY --from=build /app . # l'immagine .NET 10 è Ubuntu 24.04: useradd al posto di adduser (ADR 0009) -RUN useradd --system --user-group --no-create-home --shell /usr/sbin/nologin vf && mkdir -p /data && chown vf /data -USER vf -ENV VF_PORT=7400 VF_DATA_DIR=/data ASPNETCORE_URLS=http://0.0.0.0:7400 ASPNETCORE_HTTP_PORTS= +RUN useradd --system --user-group --no-create-home --shell /usr/sbin/nologin rail && mkdir -p /data && chown rail /data +USER rail +ENV RE_PORT=7400 RE_DATA_DIR=/data ASPNETCORE_URLS=http://0.0.0.0:7400 ASPNETCORE_HTTP_PORTS= EXPOSE 7400 VOLUME /data -HEALTHCHECK --interval=30s --timeout=5s CMD ["dotnet","ViaFerrea.Server.dll","--healthcheck"] -ENTRYPOINT ["dotnet","ViaFerrea.Server.dll"] +HEALTHCHECK --interval=30s --timeout=5s CMD ["dotnet","RailEnterprise.Server.dll","--healthcheck"] +ENTRYPOINT ["dotnet","RailEnterprise.Server.dll"] diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml index 4a87a2b..f164774 100644 --- a/docker/docker-compose.yml +++ b/docker/docker-compose.yml @@ -1,16 +1,16 @@ -# Server di Via Ferrea con docker compose (dalla cartella docker/: docker compose up -d). +# Server di Rail Enterprise con docker compose (dalla cartella docker/: docker compose up -d). services: - via-ferrea: - image: via-ferrea-server:latest + rail-enterprise: + image: rail-enterprise-server:latest build: context: .. dockerfile: docker/Dockerfile - container_name: via-ferrea + container_name: rail-enterprise ports: - "7400:7400" volumes: - ./data:/data environment: - VF_TOKEN: "${VF_TOKEN:-cambiami}" - VF_DIFFICULTY: "${VF_DIFFICULTY:-imprenditore}" + RE_TOKEN: "${RE_TOKEN:-cambiami}" + RE_DIFFICULTY: "${RE_DIFFICULTY:-imprenditore}" restart: unless-stopped diff --git a/docker/unraid-template.xml b/docker/unraid-template.xml index b7000d4..40b388d 100644 --- a/docker/unraid-template.xml +++ b/docker/unraid-template.xml @@ -1,18 +1,18 @@ - + - via-ferrea - gitea.lan:3000/utente/via-ferrea-server:latest - http://gitea.lan:3000/utente/-/packages/container/via-ferrea-server + rail-enterprise + gitea.encke-hake.ts.net/balbosoft/rail-enterprise-server:latest + https://gitea.encke-hake.ts.net/BalboSoft/-/packages/container/rail-enterprise-server/latest bridge bash false - Server autorevole di Via Ferrea, gestionale ferroviario dall'alto. I client si collegano via WebSocket su ws://[IP]:7400/ws con il token indicato; i salvataggi stanno nella cartella dei dati. + Server autorevole di Rail Enterprise, gestionale ferroviario dall'alto. I client si collegano via WebSocket su ws://[IP]:7400/ws con il token indicato; i salvataggi stanno nella cartella dei dati. GameServers: http://[IP]:[PORT:7400]/health 7400 - /mnt/user/appdata/via-ferrea - - imprenditore + /mnt/user/appdata/rail-enterprise + + imprenditore diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index ee9ba46..806b22a 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -1,16 +1,16 @@ -# Via Ferrea — Architettura +# Rail Enterprise — Architettura Questo documento descrive come è fatto il codice. Va aggiornato a ogni fase: le parti non ancora implementate sono marcate *(pianificato, Fn)*. ## 1. Progetti e dipendenze ``` -ViaFerrea.Core (net10.0; net8.0) simulazione deterministica, dati, mappa, economia, rete, salvataggi -ViaFerrea.Protocol (net10.0; net8.0) frame binari, messaggi, SpanWriter/SpanReader → Core -ViaFerrea.Server (net10.0, Web SDK) Kestrel, WebSocket, GameLoop, API HTTP, autosave → Core, Protocol -ViaFerrea.Tools (net10.0) viaferrea-tools: validate-data, genmap, profile, simulate, bench, smoke, replay → Core, Protocol -ViaFerrea.Tests (net10.0) harness interno, test di unità, scenari → Core, Protocol, Server -client/ViaFerrea.Client (Godot .NET) rendering, input, UI; anteprime con Core → Core, Protocol +RailEnterprise.Core (net10.0; net8.0) simulazione deterministica, dati, mappa, economia, rete, salvataggi +RailEnterprise.Protocol (net10.0; net8.0) frame binari, messaggi, SpanWriter/SpanReader → Core +RailEnterprise.Server (net10.0, Web SDK) Kestrel, WebSocket, GameLoop, API HTTP, autosave → Core, Protocol +RailEnterprise.Tools (net10.0) railenterprise-tools: validate-data, genmap, profile, simulate, bench, smoke, replay → Core, Protocol +RailEnterprise.Tests (net10.0) harness interno, test di unità, scenari → Core, Protocol, Server +client/RailEnterprise.Client (Godot .NET) rendering, input, UI; anteprime con Core → Core, Protocol ``` Regole: @@ -23,15 +23,15 @@ Regole: | Namespace | Contenuto | |---|---| -| `ViaFerrea.Core.Common` | `Rng` (xoshiro256**), `StableHash`, `XxHash64`, `DMath` (funzioni trascendenti deterministiche), `Money`, identità tipizzate, `Vec2`. | -| `ViaFerrea.Core.Time` | `GameClock`, `GameDate`, costanti di calendario. | -| `ViaFerrea.Core.Data` | Definizioni immutabili caricate da `data/*.json` (`GameData`), contesto JSON con source generator, validatore di schema e validatore semantico. | -| `ViaFerrea.Core.Map` | `Terrain` (altezze `ushort` in decimetri, tipi cella `byte`, larghezza dei fiumi), `MapGenerator` (ADR 0005), `ValueNoise`, `TerrainSampler`, `NameGenerator`, chunk 64×64. | -| `ViaFerrea.Core.Economy` | Città, industrie, hub, mercato, compagnie, registro contabile a partita doppia, finanza. | -| `ViaFerrea.Core.Rail` | `TrackGeometry` (raccordi), `TrackPlanner` (profilo a 25 m, opere, costi, tempi, vincoli per era), `RailNetwork` (nodi, archi campionati, stazioni, depositi, cantieri, indice spaziale), `Pathfinder` (A* sugli archi orientati), veicoli, treni, linee, pacchetti, `LineGraph` con maschere dei carichi (ADR 0007, 0008). | -| `ViaFerrea.Core.Commands` | Comandi di gioco (record immutabili) ed esiti. Sono l'unico modo di cambiare il mondo dall'esterno, anche per le IA. | -| `ViaFerrea.Core.Simulation` | `World`, `WorldContext`, `SystemPipeline` e `Systems/`, `WorldFactory`, `IndustryPlacer`, `CommandProcessor` e gestori dei comandi, `Corporate` (fusioni, liquidazioni, fine partita), `Estimators` (stime condivise da IA e tooltip), `ChronicleReport`, `Ai/` (agenti delle compagnie IA, ricerca del percorso sulle celle), eventi in uscita. | -| `ViaFerrea.Core.Persistence` | `SaveWriter`/`SaveReader`, `SaveFile` (Brotli), `StateHasher`. | +| `RailEnterprise.Core.Common` | `Rng` (xoshiro256**), `StableHash`, `XxHash64`, `DMath` (funzioni trascendenti deterministiche), `Money`, identità tipizzate, `Vec2`. | +| `RailEnterprise.Core.Time` | `GameClock`, `GameDate`, costanti di calendario. | +| `RailEnterprise.Core.Data` | Definizioni immutabili caricate da `data/*.json` (`GameData`), contesto JSON con source generator, validatore di schema e validatore semantico. | +| `RailEnterprise.Core.Map` | `Terrain` (altezze `ushort` in decimetri, tipi cella `byte`, larghezza dei fiumi), `MapGenerator` (ADR 0005), `ValueNoise`, `TerrainSampler`, `NameGenerator`, chunk 64×64. | +| `RailEnterprise.Core.Economy` | Città, industrie, hub, mercato, compagnie, registro contabile a partita doppia, finanza. | +| `RailEnterprise.Core.Rail` | `TrackGeometry` (raccordi), `TrackPlanner` (profilo a 25 m, opere, costi, tempi, vincoli per era), `RailNetwork` (nodi, archi campionati, stazioni, depositi, cantieri, indice spaziale), `Pathfinder` (A* sugli archi orientati), veicoli, treni, linee, pacchetti, `LineGraph` con maschere dei carichi (ADR 0007, 0008). | +| `RailEnterprise.Core.Commands` | Comandi di gioco (record immutabili) ed esiti. Sono l'unico modo di cambiare il mondo dall'esterno, anche per le IA. | +| `RailEnterprise.Core.Simulation` | `World`, `WorldContext`, `SystemPipeline` e `Systems/`, `WorldFactory`, `IndustryPlacer`, `CommandProcessor` e gestori dei comandi, `Corporate` (fusioni, liquidazioni, fine partita), `Estimators` (stime condivise da IA e tooltip), `ChronicleReport`, `Ai/` (agenti delle compagnie IA, ricerca del percorso sulle celle), eventi in uscita. | +| `RailEnterprise.Core.Persistence` | `SaveWriter`/`SaveReader`, `SaveFile` (Brotli), `StateHasher`. | ## 3. Il tick @@ -90,14 +90,14 @@ Requisito: stesso seme + stessi comandi agli stessi tick ⇒ stesso hash di stat ## 6. Economia e contabilità -- Entità in `ViaFerrea.Core.Economy`: `Town`, `Industry`, `Hub`, `ResourceSite`, `Company` (con `Loan`), `CommuteContract`, `Market`, `Tariffs`. +- Entità in `RailEnterprise.Core.Economy`: `Town`, `Industry`, `Hub`, `ResourceSite`, `Company` (con `Loan`), `CommuteContract`, `Market`, `Tariffs`. - Ogni movimento di denaro passa dal registro (`MoneyLedger.Transfer`) tra conti: compagnie, industrie e il conto `Esterno` (famiglie, clienti delle tariffe, mercato mondiale). La somma di tutti i saldi è sempre zero: è l'invariante «denaro» dei test. Le voci del conto economico delle compagnie (`LedgerEntry`) si accumulano per mese e per anno. - Ogni unità di merce sta in un magazzino tracciato (industrie, città, pacchetti in stazione e a bordo dei treni) e `GoodsCounters` registra prodotto, consumato, deperito, importato, esportato: giacenza = prodotto + importato − consumato − deperito − esportato. È l'invariante «merci». - Interpretazioni delle formule della guida: ADR 0004. ## 7. Salvataggi -- `SaveFile`: intestazione `VFSV` leggibile senza decomprimere, corpo Brotli scritto da `WorldSerializer` con `SaveWriter` (little endian, nessuna reflection). +- `SaveFile`: intestazione `RESV` leggibile senza decomprimere, corpo Brotli scritto da `WorldSerializer` con `SaveWriter` (little endian, nessuna reflection). - Definizioni salvate per id testuale e rimappate al caricamento; terreno salvato per intero. - `StateHasher` = XxHash64 di `WorldSerializer.WriteDynamic` (stato senza terreno, impostazioni ed eventi; il terreno entra con il suo hash). Dettagli: ADR 0006. - Corpo versione 2 (F4): `MaintenanceSerializer` aggiunge in coda allo stato dinamico manutenzione di veicoli e treni, officine, politiche, convenzioni e motivi dei posti scoperti; i salvataggi della versione 1 si migrano (ADR 0010). @@ -105,17 +105,17 @@ Requisito: stesso seme + stessi comandi agli stessi tick ⇒ stesso hash di stat ## 8. Server -- `ServerProgram`: Kestrel minimale, log JSON su stdout, configurazione da ambiente (`ServerConfig`: `VF_PORT`, `VF_TOKEN`, `VF_DATA_DIR`, `VF_TICK_MS`, `VF_AUTOSAVE_MIN`, `VF_SEED`, `VF_MAP_SIZE`, `VF_DIFFICULTY`, `VF_LOG_LEVEL`) e argomenti `--local` (127.0.0.1 su porta casuale, stampa `LISTENING porta`), `--healthcheck`, `--token`, `--port`, `--data`. -- `GameHost`: possiede il mondo su un thread dedicato. Ogni giro drena la coda delle azioni (messaggi delle sessioni, richieste HTTP), esegue i tick dovuti con un accumulatore (velocità 0/1/2/4/8, budget `VF_TICK_MS`), adegua la velocità effettiva se i tick costano troppo (`slow`), pubblica e fa l'autosave a rotazione. +- `ServerProgram`: Kestrel minimale, log JSON su stdout, configurazione da ambiente (`ServerConfig`: `RE_PORT`, `RE_TOKEN`, `RE_DATA_DIR`, `RE_TICK_MS`, `RE_AUTOSAVE_MIN`, `RE_SEED`, `RE_MAP_SIZE`, `RE_DIFFICULTY`, `RE_LOG_LEVEL`) e argomenti `--local` (127.0.0.1 su porta casuale, stampa `LISTENING porta`), `--healthcheck`, `--token`, `--port`, `--data`. +- `GameHost`: possiede il mondo su un thread dedicato. Ogni giro drena la coda delle azioni (messaggi delle sessioni, richieste HTTP), esegue i tick dovuti con un accumulatore (velocità 0/1/2/4/8, budget `RE_TICK_MS`), adegua la velocità effettiva se i tick costano troppo (`slow`), pubblica e fa l'autosave a rotazione. - `Session` / `SessionEndpoint`: WebSocket su `/ws`, primo frame `Hello`, coda d'invio a due classi (affidabili e moti scartabili), ripresa con `sessionId` entro 120 s. - `Projection`: mondo → record del protocollo (entità, archi, chunk, moto dei treni, resoconti, cartelle di manutenzione, registri officina, Registro degli impieghi); i delta per sessione si calcolano con gli hash dei record; i dettagli F4 si mandano su `RequestDetail`, gli avvisi di manutenzione (`World.Alerts`) come `MaintenanceAlert`. -- `SaveStore`: salvataggi `.vfsave` in `$VF_DATA_DIR/saves`, ultimi cinque automatici; all'avvio si riprende il più recente. +- `SaveStore`: salvataggi `.vfsave` in `$RE_DATA_DIR/saves`, ultimi cinque automatici; all'avvio si riprende il più recente. - HTTP: `/health`, `/metrics` (Prometheus), `GET/POST /api/saves`, `GET /api/saves/{id}`. - Docker: `docker/Dockerfile` (build in due stadi, utente non root, healthcheck), `docker-compose.yml`, `unraid-template.xml`; `scripts/publish-image.sh` per il registry Gitea. ## 9. Client -- Progetto Godot 4.7 .NET in `client/ViaFerrea.Client` (fuori dalla soluzione), compilato con `Godot.NET.Sdk`; referenzia Core e Protocol (net8.0). I file dati e gli schemi si copiano in `res://data` a ogni build. +- Progetto Godot 4.7 .NET in `client/RailEnterprise.Client` (fuori dalla soluzione), compilato con `Godot.NET.Sdk`; referenzia Core e Protocol (net8.0). I file dati e gli schemi si copiano in `res://data` a ogni build. - `Main` → `MenuScreen` / `ConnectScreen` / `GameScreen`. `LocalServerLauncher` avvia il server come processo figlio per la partita locale. - `GameSession` applica i messaggi a `ClientWorld` (Protocol) sul thread principale; i comandi sono l'unico modo di cambiare il mondo; le anteprime del tracciato usano `TrackPreview` di Core. - `MapView` (Node2D + Camera2D): `TerrainLayer` (texture per chunk con fasce, ombreggiatura, sponde e curve di livello; shader per le rive), `EntityLayer` (case, industrie, stazioni, depositi, alberi in MultiMesh), `TrackLayer` (massicciata, traversine, rotaie, opere, cantieri, segnali), `TrainLayer` (veicoli interpolati, fumo, avvisi), `ToolOverlay`; `LabelLayer` disegna le etichette in coordinate schermo. diff --git a/docs/GDD.md b/docs/GDD.md index 04574a8..ca5e037 100644 --- a/docs/GDD.md +++ b/docs/GDD.md @@ -1,10 +1,10 @@ -# Via Ferrea — Game Design Document +# Rail Enterprise — Game Design Document Documento di design vivo. Le regole numeriche vincolanti sono in `docs/GUIDA.md` e i valori in `data/*.json`; qui si descrive *che gioco è* e *perché* le regole sono fatte così. ## 1. Visione -«Via Ferrea» è un gestionale ferroviario visto rigorosamente dall'alto, ambientato in una regione europea immaginaria a partire dal 1850. Il giocatore guida una compagnia che costruisce binari veri (pendenze, trincee, ponti, gallerie), compra e mantiene treni, porta merci alle industrie e lavoratori ai posti di lavoro, compete con compagnie controllate dall'IA e, se vuole, le compra in borsa. Il mondo non finisce mai: regioni nuove, ere tecnologiche, decadenza delle opere e concorrenti rinnovati mantengono sempre qualcosa da fare. +«Rail Enterprise» è un gestionale ferroviario visto rigorosamente dall'alto, ambientato in una regione europea immaginaria a partire dal 1850. Il giocatore guida una compagnia che costruisce binari veri (pendenze, trincee, ponti, gallerie), compra e mantiene treni, porta merci alle industrie e lavoratori ai posti di lavoro, compete con compagnie controllate dall'IA e, se vuole, le compra in borsa. Il mondo non finisce mai: regioni nuove, ere tecnologiche, decadenza delle opere e concorrenti rinnovati mantengono sempre qualcosa da fare. Pilastri: diff --git a/docs/GUIDA.md b/docs/GUIDA.md index 1b74fc3..d51854e 100644 --- a/docs/GUIDA.md +++ b/docs/GUIDA.md @@ -1,6 +1,6 @@ -# VIA FERREA — Guida operativa per Claude Code (v2) +# RAIL ENTERPRISE — Guida operativa per Claude Code (v2) -Sei lo sviluppatore principale di «Via Ferrea», gestionale ferroviario dall'alto per desktop, con motore di gioco headless eseguibile anche su un server Linux in Docker. Questo documento sostituisce la v1 e ti dice esattamente cosa costruire, con quale linguaggio, in quale ordine e come verificarlo. Le nove immagini in `reference/` (01–09) sono il riferimento visivo vincolante. Non chiedere conferme: se manca un dettaglio, decidi, scrivi un ADR in `docs/adr/` e vai avanti. Salva questo file come `docs/GUIDA.md` nella prima sessione. +Sei lo sviluppatore principale di «Rail Enterprise», gestionale ferroviario dall'alto per desktop, con motore di gioco headless eseguibile anche su un server Linux in Docker. Questo documento sostituisce la v1 e ti dice esattamente cosa costruire, con quale linguaggio, in quale ordine e come verificarlo. Le nove immagini in `reference/` (01–09) sono il riferimento visivo vincolante. Non chiedere conferme: se manca un dettaglio, decidi, scrivi un ADR in `docs/adr/` e vai avanti. Salva questo file come `docs/GUIDA.md` nella prima sessione. --- @@ -12,7 +12,7 @@ Sei lo sviluppatore principale di «Via Ferrea», gestionale ferroviario dall'al - Identificatori in inglese; commenti, documentazione e testi UI in italiano (localizzazione it/en in `client/assets/i18n/`). - Nessun numero magico: ogni parametro sta in `data/*.json`. Le costanti citate qui sono i valori iniziali di quei file. - Ogni decisione non coperta qui → `docs/adr/NNNN-titolo.md` (contesto, decisione, conseguenze). -- Il client non contiene logica di gioco: calcola solo anteprime usando le stesse classi di `ViaFerrea.Core`; il server è sempre autorevole. +- Il client non contiene logica di gioco: calcola solo anteprime usando le stesse classi di `RailEnterprise.Core`; il server è sempre autorevole. ## 1. Piattaforma e linguaggio (decisioni fisse) @@ -33,32 +33,32 @@ Sei lo sviluppatore principale di «Via Ferrea», gestionale ferroviario dall'al ## 3. Creazione della soluzione (esegui esattamente questi comandi) ``` -dotnet new sln -n ViaFerrea -dotnet new classlib -n ViaFerrea.Core -o src/ViaFerrea.Core -f net10.0 -dotnet new classlib -n ViaFerrea.Protocol -o src/ViaFerrea.Protocol -f net10.0 -dotnet new web -n ViaFerrea.Server -o src/ViaFerrea.Server -f net10.0 -dotnet new console -n ViaFerrea.Tools -o src/ViaFerrea.Tools -f net10.0 -dotnet new console -n ViaFerrea.Tests -o tests/ViaFerrea.Tests -f net10.0 -dotnet sln add src/ViaFerrea.Core src/ViaFerrea.Protocol src/ViaFerrea.Server src/ViaFerrea.Tools tests/ViaFerrea.Tests -dotnet add src/ViaFerrea.Protocol reference src/ViaFerrea.Core -dotnet add src/ViaFerrea.Server reference src/ViaFerrea.Core src/ViaFerrea.Protocol -dotnet add src/ViaFerrea.Tools reference src/ViaFerrea.Core src/ViaFerrea.Protocol -dotnet add tests/ViaFerrea.Tests reference src/ViaFerrea.Core src/ViaFerrea.Protocol src/ViaFerrea.Server +dotnet new sln -n RailEnterprise +dotnet new classlib -n RailEnterprise.Core -o src/RailEnterprise.Core -f net10.0 +dotnet new classlib -n RailEnterprise.Protocol -o src/RailEnterprise.Protocol -f net10.0 +dotnet new web -n RailEnterprise.Server -o src/RailEnterprise.Server -f net10.0 +dotnet new console -n RailEnterprise.Tools -o src/RailEnterprise.Tools -f net10.0 +dotnet new console -n RailEnterprise.Tests -o tests/RailEnterprise.Tests -f net10.0 +dotnet sln add src/RailEnterprise.Core src/RailEnterprise.Protocol src/RailEnterprise.Server src/RailEnterprise.Tools tests/RailEnterprise.Tests +dotnet add src/RailEnterprise.Protocol reference src/RailEnterprise.Core +dotnet add src/RailEnterprise.Server reference src/RailEnterprise.Core src/RailEnterprise.Protocol +dotnet add src/RailEnterprise.Tools reference src/RailEnterprise.Core src/RailEnterprise.Protocol +dotnet add tests/RailEnterprise.Tests reference src/RailEnterprise.Core src/RailEnterprise.Protocol src/RailEnterprise.Server ``` - `Directory.Build.props` alla radice: `Nullable=enable`, `ImplicitUsings=enable`, `LangVersion=latest`, `TreatWarningsAsErrors=true`, `InvariantGlobalization=true`, `Deterministic=true`, `Version` (unica fonte della versione). - Core e Protocol: `net10.0;net8.0` (il progetto Godot può richiedere net8.0 o net9.0: verifica il TargetFramework generato da Godot e allinea). -- Client (Fase 3): `client/ViaFerrea.Client` con `project.godot`; il csproj lo genera Godot (Project › Tools › C# › Create C# solution) oppure scrivilo a mano con ``, `EnableDynamicLoading=true` e `ProjectReference` a Core e Protocol. Il client non entra nella sln principale. +- Client (Fase 3): `client/RailEnterprise.Client` con `project.godot`; il csproj lo genera Godot (Project › Tools › C# › Create C# solution) oppure scrivilo a mano con ``, `EnableDynamicLoading=true` e `ProjectReference` a Core e Protocol. Il client non entra nella sln principale. - Struttura finale: ``` -CLAUDE.md README.md Directory.Build.props ViaFerrea.sln +CLAUDE.md README.md Directory.Build.props RailEnterprise.sln docs/ GDD.md ARCHITECTURE.md PROTOCOL.md GUIDA.md STATE.md adr/ data/ goods.json industries.json vehicles.json eras.json tiers.json balance.json difficulty.json construction.json maintenance.json ai.json contracts.json regions.json schema/ -src/ ViaFerrea.Core ViaFerrea.Protocol ViaFerrea.Server ViaFerrea.Tools -client/ ViaFerrea.Client (scenes/ scripts/ assets/fonts/ assets/i18n/ assets/theme/) -tests/ ViaFerrea.Tests (scenarios/) +src/ RailEnterprise.Core RailEnterprise.Protocol RailEnterprise.Server RailEnterprise.Tools +client/ RailEnterprise.Client (scenes/ scripts/ assets/fonts/ assets/i18n/ assets/theme/) +tests/ RailEnterprise.Tests (scenarios/) docker/ Dockerfile docker-compose.yml unraid-template.xml scripts/ build.sh build.ps1 test.sh check-nuget.sh publish-image.sh reference/ 01..09 .jpg @@ -76,7 +76,7 @@ reference/ 01..09 .jpg ## 5. File dati e schemi -Tutti i file hanno uno schema in `data/schema/` e sono validati all'avvio del server e da `viaferrea-tools validate-data` (id univoci, riferimenti risolti, limiti). +Tutti i file hanno uno schema in `data/schema/` e sono validati all'avvio del server e da `railenterprise-tools validate-data` (id univoci, riferimenti risolti, limiti). - `goods.json`: `{ "id":"coal", "name_it":"Carbone", "category":"bulk|general|liquid|perishable", "unit":"t", "wagon":"hopper", "basePrice":3800, "elasticity":0.6, "decayDaysAtStation":20, "era":1850 }`. Includi i beni di servizio `spare_parts` (ricambi, prodotti dalla fabbrica di macchinari) e `machinery` (macchinari): la manutenzione li consuma e arrivano solo in treno. - `industries.json`: `{ "id":"steel_mill", "name_it":"Acciaieria", "kind":"primary|processing|manufacturing", "recipe":{ "inputs":[{"good":"iron_ore","perCycle":2},{"good":"coal","perCycle":1}], "outputs":[{"good":"steel","perCycle":1}] }, "cycleDays":1, "capacityPerLevel":[120,240,400,600,900], "workersPerLevel":[40,80,160,240,320], "staffPerLevel":[2,6,12,20,30], "storageDays":30, "wearIntensity":1.2, "footprint":"large", "placement":{ "needs":"ore_deposit|forest|plain|coast|any", "minTownDistanceKm":2 }, "depletable":true, "era":1850 }`. @@ -257,22 +257,22 @@ Ordine di implementazione consigliato: 3 → 5 → 4 → 1 → 2 → 6 → 7 → ## 14. Protocollo, server, client, deploy, test -### 14.1 Protocollo (`src/ViaFerrea.Protocol`) +### 14.1 Protocollo (`src/RailEnterprise.Protocol`) - Frame `[u32 length][u16 messageId][payload]`, little endian, massimo 4 MB. Handshake `Hello { protocolVersion, clientVersion, token }` → `Welcome { sessionId, worldSummary, dataHash, difficulty }` o `Reject`. - Client → Server: Hello, Ping, Subscribe { viewport }, Command { seq, type, payload }, SetSpeed, ListSaves, Save, Load, NewGame { seed, size, startYear, difficultyPreset, overrides, endlessFlags }. - Comandi: BuildTrack { polyline, heightOffset, allowBridges, allowTunnels, trackClass, doubleTrack, electrified }, RenewTrack, UpgradeTrack, Demolish, BuildStation, BuildDepot { size }, PlaceSignal, BuyVehicle, SellVehicle, ComposeTrain, CreateLine, EditLine, AssignTrain, SendToDepot, SetReserve, SetMaintenancePolicy { scope, level }, ScheduleService { trainId, kind }, OrderParts { depotId, qty }, TakeLoan, RepayLoan, AcceptAgreement, RejectAgreement, BuyGoods, SellGoods, BuyIndustry, SetIndustryPolicy, OverhaulIndustry, UpgradeIndustry, Ipo, BuyShares, SellShares, PayDividend, LaunchBid, RespondBid, BuyConcession, AcceptContract, FundResearch, DelegateRegion. - Server → Client: Welcome, Reject, Pong, MapChunk, EntitySnapshot, EntityDelta, TrackWorks (opere per arco: tipo, altezze, stato cantiere), TrainMotion { trainId, segments[], state, condition }, DailyDigest { date, cash, netWorth, rating, prices[], events[], stateHash, slow }, MaintenanceAlert, EmploymentReport (mensile), MarketTape (giornaliero: prezzi azioni, offerte in corso), CommandResult, Notification, Newspaper (mensile: la «Cronaca»). - Serializzazione a mano con `Write(ref SpanWriter)` / `Read(ref SpanReader)`; id stabili, nuovi campi in coda dopo un `byte flags`. Interest management: TrainMotion solo nel viewport (margine un chunk), massimo 10 aggiornamenti/s per treno. -### 14.2 Server (`src/ViaFerrea.Server`) -- Config da ambiente: `VF_PORT` (7400), `VF_TOKEN`, `VF_DATA_DIR` (/data), `VF_TICK_MS` (50), `VF_AUTOSAVE_MIN` (10), `VF_SEED`, `VF_MAP_SIZE`, `VF_DIFFICULTY`, `VF_LOG_LEVEL`; argomenti `--local` (porta 0 casuale, stampa `LISTENING `) e `--healthcheck` (GET su /health, exit 0/1). +### 14.2 Server (`src/RailEnterprise.Server`) +- Config da ambiente: `RE_PORT` (7400), `RE_TOKEN`, `RE_DATA_DIR` (/data), `RE_TICK_MS` (50), `RE_AUTOSAVE_MIN` (10), `RE_SEED`, `RE_MAP_SIZE`, `RE_DIFFICULTY`, `RE_LOG_LEVEL`; argomenti `--local` (porta 0 casuale, stampa `LISTENING `) e `--healthcheck` (GET su /health, exit 0/1). - `GameLoop` su thread dedicato con accumulatore (Stopwatch); se un tick supera il budget riduce la velocità effettiva e segnala `slow`. Comandi da `ConcurrentQueue` drenata a inizio tick. - `SessionManager`: WebSocket su `/ws`, token nell'Hello, coda di invio per sessione con backpressure, riconnessione con `sessionId`. -- HTTP: `GET /health`, `GET /api/saves`, `GET /api/saves/{id}`, `POST /api/saves`, `GET /metrics` (formato Prometheus: tick_ms, trains, packets, contracts, sessions). Autosave in `$VF_DATA_DIR/saves/` con rotazione degli ultimi 5. Log JSON su stdout. +- HTTP: `GET /health`, `GET /api/saves`, `GET /api/saves/{id}`, `POST /api/saves`, `GET /metrics` (formato Prometheus: tick_ms, trains, packets, contracts, sessions). Autosave in `$RE_DATA_DIR/saves/` con rotazione degli ultimi 5. Log JSON su stdout. -### 14.3 Client Godot (`client/ViaFerrea.Client`) +### 14.3 Client Godot (`client/RailEnterprise.Client`) - Scene: `Main` → `Menu`, `Connect` (immagine 09), `Game` = `MapView` (Node2D + Camera2D) + `Hud` (CanvasLayer) + `Panels/` (Market, Industry, Train, Maintenance, Fleet, Employment, Finance, Lines, Companies, Contracts, Regions, TrackProfile). -- `NetClient` con `ClientWebSocket`; `LocalServerLauncher` avvia `server/ViaFerrea.Server(.exe)` con `--local --token `, legge `LISTENING `, termina il processo alla chiusura. +- `NetClient` con `ClientWebSocket`; `LocalServerLauncher` avvia `server/RailEnterprise.Server(.exe)` con `--local --token `, legge `LISTENING `, termina il processo alla chiusura. - Rendering (immagini 01–04): `TerrainLayer` (ImageTexture per chunk: fasce altimetriche, hillshade verso sud-est, curve di livello ogni 20 m a zoom > 1, sponde); `TrackLayer` (massicciata #bfb79f, traversine #5b4a39 ogni 5,3 unità, rotaie #3b3f42 a ±2,4; rilevati come banda chiara con ombra, trincee come banda scura, ponti con pile ogni 30 m e spallette, gallerie con portali e binario tratteggiato; cantieri con tratteggio #8a7a52 e barriera ambra); `EntityLayer` (impronte dell'immagine 04, foreste con MultiMeshInstance2D, campi a strisce); `TrainLayer` (forme dell'immagine 03, interpolazione dei segmenti, fumo con GPUParticles2D, sfumatura di colore sui veicoli con condizione < 40 e icona di avviso); LOD a zoom < 0,4 e < 0,15. - Strumento binari: tracciamento con snap a 45°, cursore di altezza, interruttori ponti/gallerie, classe; pannello `TrackProfile` con grafico altimetrico e riepilogo opere, costo, giorni; conferma → `BuildTrack`. - UI: Theme con palette dell'immagine 05; font Big Shoulders Display e IBM Plex Sans (OFL in `assets/fonts/`); barra superiore, toolbar sinistra, pannello destro, ticker, minimappa (immagine 01); pannelli 06, 07, 08 a tutto schermo; tooltip «perché» su ogni valore. @@ -282,26 +282,26 @@ Ordine di implementazione consigliato: 3 → 5 → 4 → 1 → 2 → 6 → 7 → FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build WORKDIR /src COPY . . -RUN dotnet publish src/ViaFerrea.Server -c Release -o /app +RUN dotnet publish src/RailEnterprise.Server -c Release -o /app FROM mcr.microsoft.com/dotnet/aspnet:10.0 WORKDIR /app COPY --from=build /app . -RUN adduser --disabled-password --gecos "" vf && mkdir -p /data && chown vf /data -USER vf -ENV VF_PORT=7400 VF_DATA_DIR=/data ASPNETCORE_URLS=http://0.0.0.0:7400 +RUN adduser --disabled-password --gecos "" rail && mkdir -p /data && chown rail /data +USER rail +ENV RE_PORT=7400 RE_DATA_DIR=/data ASPNETCORE_URLS=http://0.0.0.0:7400 EXPOSE 7400 VOLUME /data -HEALTHCHECK --interval=30s --timeout=5s CMD ["dotnet","ViaFerrea.Server.dll","--healthcheck"] -ENTRYPOINT ["dotnet","ViaFerrea.Server.dll"] +HEALTHCHECK --interval=30s --timeout=5s CMD ["dotnet","RailEnterprise.Server.dll","--healthcheck"] +ENTRYPOINT ["dotnet","RailEnterprise.Server.dll"] ``` -- `docker/docker-compose.yml`: servizio via-ferrea, porta 7400:7400, volume ./data:/data, env VF_TOKEN e VF_DIFFICULTY, restart unless-stopped. -- `docker/unraid-template.xml`: Repository `/via-ferrea-server:latest`, rete bridge, porta 7400, volume /mnt/user/appdata/via-ferrea → /data, variabili VF_TOKEN e VF_DIFFICULTY, WebUI http://[IP]:[PORT:7400]/health. +- `docker/docker-compose.yml`: servizio rail-enterprise, porta 7400:7400, volume ./data:/data, env RE_TOKEN e RE_DIFFICULTY, restart unless-stopped. +- `docker/unraid-template.xml`: Repository `/rail-enterprise-server:latest`, rete bridge, porta 7400, volume /mnt/user/appdata/rail-enterprise → /data, variabili RE_TOKEN e RE_DIFFICULTY, WebUI http://[IP]:[PORT:7400]/health. - `scripts/publish-image.sh`: build con tag versione (da Directory.Build.props) e latest, push sul registry Gitea. TLS a carico del reverse proxy o della rete privata (README). ### 14.5 Test e strumenti -- `tests/ViaFerrea.Tests`: harness interno (`[Test]` via reflection, `Assert` Equal/True/Throws/Approx, exit code); unico comando `dotnet run --project tests/ViaFerrea.Tests`. +- `tests/RailEnterprise.Tests`: harness interno (`[Test]` via reflection, `Assert` Equal/True/Throws/Approx, exit code); unico comando `dotnet run --project tests/RailEnterprise.Tests`. - Test obbligatori: determinismo (stesso seed + stessi comandi, IA comprese → stesso hash dopo 5 anni); invarianti di merci e denaro; round-trip salvataggio e di ogni messaggio; validazione dati; profilo altimetrico (le due passate rispettano `gMax`, classificazione opere, costo, ponte obbligatorio sull'acqua, campata massima per era); usura e rischio monotoni nella condizione; tagliando e revisione riportano la condizione attesa; pianificatore predittivo non lascia scendere un treno sotto 30 con politica Standard e ricambi disponibili; pendolarismo (un'industria con città raggiungibile e capacità sufficiente raggiunge copertura > 0.9 in 60 giorni); IA (non emette comandi rifiutati più del 5 % delle volte; con capitale ×2 supera il giocatore passivo in 10 anni); borsa (scalata ostile completata quando il flottante lo consente); scenario di riferimento `tests/scenarios/valdoria.json`. -- `src/ViaFerrea.Tools`: `validate-data`, `genmap --seed --size --out mappa.bmp`, `profile --seed --polyline --out profilo.csv`, `simulate --seed --years --difficulty --scenario --out kpi.csv` (CSV con separatore `;`: anno; compagnia; bene; prezzo medio; produzione; consumo; popolazione; efficienza media; condizione media flotta; condizione media impianti; cassa; patrimonio; quota di mercato; nota), `bench --trains 2000`, `replay --save --commands`. +- `src/RailEnterprise.Tools`: `validate-data`, `genmap --seed --size --out mappa.bmp`, `profile --seed --polyline --out profilo.csv`, `simulate --seed --years --difficulty --scenario --out kpi.csv` (CSV con separatore `;`: anno; compagnia; bene; prezzo medio; produzione; consumo; popolazione; efficienza media; condizione media flotta; condizione media impianti; cassa; patrimonio; quota di mercato; nota), `bench --trains 2000`, `replay --save --commands`. ## 15. Obiettivi di prestazione (mappa 256 km, una regione) diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md index 7f5c3a6..a475c64 100644 --- a/docs/PROTOCOL.md +++ b/docs/PROTOCOL.md @@ -1,13 +1,13 @@ -# Via Ferrea — Protocollo di rete +# Rail Enterprise — Protocollo di rete Stato: **normativo da F3**. Ogni messaggio e ogni comando ha un test di round-trip -(`tests/ViaFerrea.Tests/Protocol/ProtocolTests.cs`); decisioni in ADR 0009. +(`tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs`); decisioni in ADR 0009. ## 1. Trasporto - WebSocket su `ws://:/ws` (TLS a carico del reverse proxy: `wss://`). - Solo messaggi binari. Un messaggio WebSocket contiene esattamente un frame. -- Porta predefinita 7400 (`VF_PORT`). Il primo messaggio del client dev'essere `Hello` entro 10 s. +- Porta predefinita 7400 (`RE_PORT`). Il primo messaggio del client dev'essere `Hello` entro 10 s. ## 2. Frame diff --git a/docs/STATE.md b/docs/STATE.md index 9e99a63..0c02000 100644 --- a/docs/STATE.md +++ b/docs/STATE.md @@ -1,4 +1,4 @@ -# Via Ferrea — Stato dei lavori +# Rail Enterprise — Stato dei lavori Aggiornato alla fine di ogni fase (guida, sezione 18). @@ -6,7 +6,7 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). | Strumento | Versione | Note | |---|---|---| -| .NET SDK | 10.0.112 | da apt (Ubuntu 24.04, `dotnet-sdk-10.0`) | +| .NET SDK | 10.0.112 (cloud), 10.0.403 (Windows) | da apt (Ubuntu 24.04, `dotnet-sdk-10.0`); su Windows dall'installer | | Runtime .NET / ASP.NET Core | 10.0.12 | | | Targeting pack net8.0 | 8.0.31 | `dotnet-targeting-pack-8.0`, per Core e Protocol | | Godot .NET | 4.7.2.stable.mono | scaricato dal mirror SourceForge (github.com non raggiungibile); client compilato con `Godot.NET.Sdk` 4.7.2 da NuGet | @@ -17,7 +17,7 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). ## Fatto ### F0 — Fondamenta -- Soluzione `ViaFerrea.sln` con Core, Protocol (net10.0 + net8.0), Server (Web SDK), Tools (`viaferrea-tools`), Tests. +- Soluzione `RailEnterprise.sln` con Core, Protocol (net10.0 + net8.0), Server (Web SDK), Tools (`railenterprise-tools`), Tests. - `Directory.Build.props` con Nullable, ImplicitUsings, LangVersion latest, warning come errori, globalizzazione invariante, build deterministica, versione unica (0.1.0). - Script: `build.sh`, `build.ps1`, `test.sh`, `check-nuget.sh`, `publish-image.sh`. - Documenti: GUIDA, GDD, ARCHITECTURE, PROTOCOL (bozza), STATE, ADR 0001. @@ -25,33 +25,33 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). ### F1 — Economia headless - Base: `Rng` (xoshiro256** con `Fork`), `Money` (centesimi, formati italiani), 20 identità tipizzate, `DMath` deterministica (ADR 0003), `XxHash64`, `Vec2`, `Calendar`/`GameClock`/`GameDate`. -- Dati: 12 file `data/*.json` (16 beni con ricambi e macchinari, 14 industrie, 13 veicoli, 4 ere, 5 livelli, 4 difficoltà; costruzione, manutenzione, IA, contratti, regioni) con 12 schemi in `data/schema/`; caricamento con source generator, validatore di schema interno, deserializzazione rigorosa, validazione semantica, hash dei dati (ADR 0002). `viaferrea-tools validate-data`. -- Mappa: generatore deterministico (rilievo con domain warping, mare, priority-flood, fiumi larghi 1–4 celle, laghi, copertura, giacimenti con riserva, città, porto e valico, 14 tipi di industria) e `viaferrea-tools genmap` con BMP di controllo (ADR 0005). +- Dati: 12 file `data/*.json` (16 beni con ricambi e macchinari, 14 industrie, 13 veicoli, 4 ere, 5 livelli, 4 difficoltà; costruzione, manutenzione, IA, contratti, regioni) con 12 schemi in `data/schema/`; caricamento con source generator, validatore di schema interno, deserializzazione rigorosa, validazione semantica, hash dei dati (ADR 0002). `railenterprise-tools validate-data`. +- Mappa: generatore deterministico (rilievo con domain warping, mare, priority-flood, fiumi larghi 1–4 celle, laghi, copertura, giacimenti con riserva, città, porto e valico, 14 tipi di industria) e `railenterprise-tools genmap` con BMP di controllo (ADR 0005). - Economia: città (domanda con elasticità, soddisfazione per categoria, servizi, crescita, migrazione, espansione), industrie (efficienza dalle coperture, fattore di profitto, condizione, esaurimento giacimenti, salari, crescita trimestrale delle industrie servite, chiusure, nascita per capacità mancante), hub, mercato con componente mondiale e shock, prezzi locali, tariffe, lavoratori in sede e a piedi, trasporto locale su strada, registro a partita doppia, prestiti e rating, difficoltà applicata (ADR 0004). - Comandi: `TakeLoan`, `RepayLoan`, `SetIndustryPolicy`; gli altri tipi esistono e rispondono `NotImplemented`. - Persistenza: `SaveFile` (intestazione + Brotli), `WorldSerializer` con rimappatura per id, `StateHasher` giornaliero (ADR 0006). -- `viaferrea-tools simulate` con KPI annuali in CSV (separatore `;`). +- `railenterprise-tools simulate` con KPI annuali in CSV (separatore `;`). - 45 test: dati, determinismo, round-trip dei salvataggi, invarianti di merci e denaro, limiti dei prezzi, crescita e chiusura delle industrie, città, prestiti, collocazione e distanze della mappa, tempi di generazione. ### F2 — Rete ferroviaria realistica headless -- Tracciato: `TrackGeometry` (raccordi al raggio minimo della classe), `TrackPlanner` (profilo a 25 m, inviluppi di pendenza in avanti e all'indietro, smussatura, rilevati, trincee, ponti e gallerie, ponte obbligatorio su acqua, palude e binari altrui, campate per classe di fiume, limiti per era, costi, giorni di cantiere, esproprio), `viaferrea-tools profile` con CSV. +- Tracciato: `TrackGeometry` (raccordi al raggio minimo della classe), `TrackPlanner` (profilo a 25 m, inviluppi di pendenza in avanti e all'indietro, smussatura, rilevati, trincee, ponti e gallerie, ponte obbligatorio su acqua, palude e binari altrui, campate per classe di fiume, limiti per era, costi, giorni di cantiere, esproprio), `railenterprise-tools profile` con CSV. - Rete: `RailNetwork` con agganci e scambi, stazioni con bacino, depositi, segnali, cantieri con squadre per livello, rinnovi e ammodernamenti, usura e manutenzione del binario, ispezioni e invecchiamento di ponti e gallerie (ADR 0007). - Treni: acquisto e vendita di veicoli, composizioni, linee con ordini (carica, scarica, attendi il pieno con tempo massimo), A* con vincolo di svolta, blocchi e versi fino al punto sicuro, fisica con aderenza e `Stalled`, soste proporzionali alle unità movimentate. - Pacchetti e linee: `LineGraph` per compagnia con maschere dei carichi, capacità e durata dei giri; ritiro della produzione verso la destinazione migliore, trasbordi, consegna in attesa del consumatore, tariffe merci e passeggeri, costi di esercizio (ADR 0008). - Pendolarismo su rotaia: abbinamento mensile entro 60/90 minuti con i tratti a piedi, quote proporzionali ai lavoratori liberi, capacità residua delle linee, pacchetti giornalieri di andata e ritorno, coperture, scioglimento dei contratti e insoddisfazione «lavoro». - Salvataggi: tutto lo stato ferroviario (rete, cantieri, veicoli, treni in movimento, linee, pacchetti, contratti) entra nel salvataggio e nell'hash. -- Scenario `tests/ViaFerrea.Tests/scenarios/valdoria.json` e test di accettazione: tracciato diretto rifiutato per `gMax`; valico con trincea e ponte accettato a 2,5 volte il costo in piano e 180 giorni di cantiere; con tre linee (merci, lavoratori, personale) l'acciaieria passa dal 20 % a oltre l'80 % di media mensile in tre mesi, senza stalli. -- `viaferrea-tools bench --trains 2000`: rete di 300 linee a doppio binario costruita con i comandi. +- Scenario `tests/RailEnterprise.Tests/scenarios/valdoria.json` e test di accettazione: tracciato diretto rifiutato per `gMax`; valico con trincea e ponte accettato a 2,5 volte il costo in piano e 180 giorni di cantiere; con tre linee (merci, lavoratori, personale) l'acciaieria passa dal 20 % a oltre l'80 % di media mensile in tre mesi, senza stalli. +- `railenterprise-tools bench --trains 2000`: rete di 300 linee a doppio binario costruita con i comandi. - 75 test (dati, mappa, economia, persistenza, pianificatore, rete, treni, incroci senza stallo, `Stalled`, salvataggio con treni in moto, pendolarismo, scenario Valdoria). ### F3 — Server e client minimo -- Protocollo (`ViaFerrea.Protocol`, normativo in `docs/PROTOCOL.md`): `SpanWriter`/`SpanReader`, frame, tutti i messaggi dei due versi e i 38 comandi (record definitivi in Core anche per le fasi future), byte di estensione, test di round-trip, troncamento e corruzione (ADR 0009). +- Protocollo (`RailEnterprise.Protocol`, normativo in `docs/PROTOCOL.md`): `SpanWriter`/`SpanReader`, frame, tutti i messaggi dei due versi e i 38 comandi (record definitivi in Core anche per le fasi future), byte di estensione, test di round-trip, troncamento e corruzione (ADR 0009). - `ClientWorld` e `ProtocolClient` condivisi da client, test e strumenti; `TrackPreview` in Core: anteprima del client e piano del server con lo stesso codice (`PreviewMismatch` se differiscono). - Server: `GameHost` con ciclo su thread dedicato, velocità e `slow`, sessioni WebSocket con backpressure e ripresa, snapshot e delta per hash, `TrackWorks` a lotti, chunk del viewport, moto dei treni, resoconti giornalieri e mensili, `/health`, `/metrics`, `/api/saves`, autosave a rotazione, log JSON, `--local`, `--healthcheck`. - Docker: `docker/Dockerfile`, `docker-compose.yml`, `unraid-template.xml`; immagine costruita e provata (health, metriche, healthcheck interno, utente non root). -- Registro dei comandi (`--record` / `VF_RECORD`, con salvataggio di partenza) e `viaferrea-tools replay` con confronto dell'hash; `viaferrea-tools smoke` per collaudare un server in esecuzione. +- Registro dei comandi (`--record` / `RE_RECORD`, con salvataggio di partenza) e `railenterprise-tools replay` con confronto dell'hash; `railenterprise-tools smoke` per collaudare un server in esecuzione. - Client Godot 4.7 .NET: menu, collegamento, partita locale con server figlio, mappa con terreno (fasce, ombreggiatura, sponde, curve di livello), opere, entità, alberi, treni interpolati con fumo; strumenti binari (scatto a 45°, quota, ponti e gallerie, classe, profilo con opere, costo e giorni), stazione, deposito, segnali, demolizione; pannelli treni, linee, mercato, finanze, schede; barra superiore con velocità, minimappa, notiziario; italiano e inglese. -- Accettazione F3 verificata senza intervento umano: test in processo (linea con ponte via WebSocket, anteprima identica al server, scarto client/server sotto 1 cm), `viaferrea-tools smoke` contro il container Docker (ponte di 275 m, scarto 0,00 m) e pilota automatico del client Godot con schermate (`docs/screenshots/`). +- Accettazione F3 verificata senza intervento umano: test in processo (linea con ponte via WebSocket, anteprima identica al server, scarto client/server sotto 1 cm), `railenterprise-tools smoke` contro il container Docker (ponte di 275 m, scarto 0,00 m) e pilota automatico del client Godot con schermate (`docs/screenshots/`). - 85 test. ### F4 — Pendolarismo e manutenzione dei treni @@ -73,7 +73,7 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - Industrie possedute: `BuyIndustry` dal livello 3 con prezzo chiesto (attivi, condizione, utile, cassa), cassa di riserva, surplus e perdite al proprietario (voce «Industrie»), `SetIndustryPolicy`, `OverhaulIndustry`, `UpgradeIndustry` e `OrderParts` per l'industria. - Livelli (`Tiers`): patrimonio netto, città collegate sopra una soglia di abitanti e rating, soglie ritarate in `tiers.json`; ritaratura economica di costi di costruzione, manutenzione e tariffe misurata con le IA (ADR 0011 §7). - Borsa e società (sezione 12.2–12.3, ADR 0012): libro dei soci, prezzo da patrimonio e utili con sentiment ciclico, ordini con spread e limite, quotazione dal livello 4, aumento di capitale, riacquisto, dividendi ordinari e straordinari, controllo oltre il 50 % con quota dell'utile al controllante, fusione (`MergeCompany`, comando 39), offerte pubbliche condizionate con adesione del flottante, risposte delle compagnie azioniste e tre difese, esiti per difficoltà (amministrazione controllata, fine partita), aste degli attivi delle IA fallite, nuovi concorrenti quando una compagnia domina i ricavi, `GameOver` con osservatore e Cronaca finale con prestigio. -- Agenti IA (sezione 12.1, ADR 0013): pianificazione mensile con candidati (merci e pendolari), regioni collegabili, Dijkstra a 8 direzioni con pendenze, fiumi e ostacoli, semplificazione che non taglia ostacoli, `TrackPreview`, ROI con soglia della personalità; esecuzione con gli stessi comandi del giocatore (stazioni, binario, deposito, linea, treni), treni aggiuntivi, linee dei ricambi, rimedio agli stalli di capacità, liquidità, rimborso dei prestiti, borsa (partecipazioni, offerte, adesioni, difese, fusioni); tre personalità (Espansiva, Prudente, Predatoria). `viaferrea-tools simulate --trace-ai` con riepilogo per compagnia. +- Agenti IA (sezione 12.1, ADR 0013): pianificazione mensile con candidati (merci e pendolari), regioni collegabili, Dijkstra a 8 direzioni con pendenze, fiumi e ostacoli, semplificazione che non taglia ostacoli, `TrackPreview`, ROI con soglia della personalità; esecuzione con gli stessi comandi del giocatore (stazioni, binario, deposito, linea, treni), treni aggiuntivi, linee dei ricambi, rimedio agli stalli di capacità, liquidità, rimborso dei prestiti, borsa (partecipazioni, offerte, adesioni, difese, fusioni); tre personalità (Espansiva, Prudente, Predatoria). `railenterprise-tools simulate --trace-ai` con riepilogo per compagnia. - Salvataggio: corpo versione 3 con sezione societaria (libro dei soci, storici, offerte, aste, stato degli agenti, fine partita) nell'hash; migrazione dei salvataggi F4. - Protocollo: prezzi e offerte nei record (blocco 1), `CompanyCard` (126), `IndustryCard` (127), `Chronicle` (128), `RequestDetail` per compagnia, industria e cronaca, `MergeCompany` e campi nuovi di `OrderParts` e `RespondBid` (blocco 1 dei comandi). - Server: listino quotidiano, schede di compagnia e industria su richiesta, Cronaca una volta per sessione a fine partita. @@ -82,6 +82,12 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - Accettazione F5 (`OnMagnateAnAiReachesTierThreeIn15Years`, seme 7, 128 km, «Magnate», giocatore passivo): la Società Ferroviaria Adriatica arriva al livello 3 nel 1863 (13 anni) con ₤ 2,7 milioni di patrimonio, rating BBB e 3 città sopra 1.000 abitanti collegate. - 120 test. +### Infrastruttura — nome, CI e rilasci (novembre 2026) +- Nuovo nome «Rail Enterprise» ovunque: namespace e progetti `RailEnterprise.*`, `RailEnterprise.sln`, `railenterprise-tools`, variabili `RE_*`, intestazioni dei file `RESV`/`RECL`, immagine `rail-enterprise-server` (ADR 0014). +- Gitea Actions: `ci.yml` (PR e `main`: zero NuGet, build, dati, test, server Windows, client, immagine con healthcheck), `release.yml` (tag `v*`: gioco desktop Windows con server in `server/`, server Windows e Linux, `SHA256SUMS`, immagine `:` e `:latest`), `nightly.yml` (`:nightly`). +- Modelli di PR e issue in `.gitea/`; issue, milestone F0–F7 e progetto «Roadmap» su Gitea con tutto il lavoro svolto; Wiki con guida e schermate. +- Immagini di riferimento 06–09 aggiunte in `reference/`. + ## In corso - Nessun lavoro a metà: F5 chiusa. @@ -92,11 +98,10 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). ## Limiti noti -- Le immagini di riferimento 06–09 (pannelli a tutto schermo e schermata di connessione) non sono state fornite: i pannelli seguiranno palette e componenti dell'immagine 05 finché non arrivano. - Godot non è eseguibile nell'ambiente cloud: il client potrà essere compilato con `Godot.NET.Sdk` ma non avviato né esportato qui. - Senza vettori il mondo è in lento declino: le città perdono circa l'1 % di abitanti l'anno e le industrie lavorano a circa il 15–30 % (voluto, ADR 0004). -- Il client non è stato provato su Windows né esportato (servono i template di esportazione di Godot); la partita locale usa il server compilato dal repository o `VF_SERVER_PATH`. -- Nella vista d'insieme i fiumi larghi una cella mostrano ancora gradini; i pannelli 06–08 e la schermata di connessione 09 seguono la palette dell'immagine 05 finché non arrivano i riferimenti. +- Il client non è stato provato su Windows né esportato (servono i template di esportazione di Godot); la partita locale usa il server compilato dal repository o `RE_SERVER_PATH`. +- Nella vista d'insieme i fiumi larghi una cella mostrano ancora gradini. Le immagini di riferimento 06–09 sono arrivate (novembre 2026): i pannelli Mercato, Industria e Scalata e la schermata di connessione vanno allineati in F6. - In F3 tutte le sessioni guidano la compagnia del giocatore (ADR 0009). - Il bilanciamento economico è provvisorio (F6): nello scenario l'acciaieria cresce di livello ogni due trimestri finché la linea operai non satura; il prezzo del minerale sale oltre 1,5 volte il base e il margine dei trasformatori diventa negativo quando la domanda supera l'offerta delle miniere. - La lunghezza dei marciapiedi non è modellata; i segnali sono solo a blocco fisso (niente segnali di percorso). diff --git a/docs/adr/0001-stack.md b/docs/adr/0001-stack.md index 837e126..790f86f 100644 --- a/docs/adr/0001-stack.md +++ b/docs/adr/0001-stack.md @@ -9,12 +9,12 @@ La guida (sezioni 1 e 3) fissa C# 14 su .NET 10, ASP.NET Core come shared framew ## Decisione 1. **SDK**: .NET SDK 10.0.1xx. Nell'ambiente di sviluppo cloud è installato dai repository Ubuntu 24.04 (`dotnet-sdk-10.0`, più `dotnet-targeting-pack-8.0` per compilare Core e Protocol anche per net8.0 senza scaricare pacchetti di riferimento). -2. **Formato della soluzione**: `ViaFerrea.sln` classico (non `.slnx`, che .NET 10 crea per default) per compatibilità con Godot e con gli strumenti più vecchi; si crea con `dotnet new sln -n ViaFerrea --format sln`. +2. **Formato della soluzione**: `RailEnterprise.sln` classico (non `.slnx`, che .NET 10 crea per default) per compatibilità con Godot e con gli strumenti più vecchi; si crea con `dotnet new sln -n RailEnterprise --format sln`. 3. **Target**: Core e Protocol `net10.0;net8.0` perché il client Godot 4.x compila per net8.0; Server, Tools e Tests solo `net10.0`. In Core e Protocol non si usano API successive a .NET 8. 4. **Godot**: versione stabile più recente pubblicata, 4.7.2. Il client usa `Godot.NET.Sdk/4.7.2`; è l'unica dipendenza esterna ammessa e sta fuori dalla soluzione principale, quindi `check-nuget.sh` esclude `client/`. 5. **Punti d'ingresso espliciti**: i progetti eseguibili usano classi `static Main` con nome proprio (`ServerProgram`, `ToolsProgram`, `TestProgram`) invece delle istruzioni di primo livello, perché il progetto di test referenzia il server e due tipi `Program` globali entrerebbero in conflitto (CS0436 trattato come errore). -6. **Harness di test**: interno, in `tests/ViaFerrea.Tests/Harness`, con esecuzione parallela dei test indipendenti; i test marcati `Isolated` girano da soli, quelli `Slow` si possono escludere con `--skip-slow`. -7. **Strumenti**: l'eseguibile dei Tools si chiama `viaferrea-tools` (`AssemblyName`), come nei comandi della guida. +6. **Harness di test**: interno, in `tests/RailEnterprise.Tests/Harness`, con esecuzione parallela dei test indipendenti; i test marcati `Isolated` girano da soli, quelli `Slow` si possono escludere con `--skip-slow`. +7. **Strumenti**: l'eseguibile dei Tools si chiama `railenterprise-tools` (`AssemblyName`), come nei comandi della guida. ## Conseguenze diff --git a/docs/adr/0002-dati-e-validazione.md b/docs/adr/0002-dati-e-validazione.md index b48017c..ff82bd2 100644 --- a/docs/adr/0002-dati-e-validazione.md +++ b/docs/adr/0002-dati-e-validazione.md @@ -4,7 +4,7 @@ Stato: accettato (F1). ## Contesto -La guida chiede che ogni parametro stia in `data/*.json`, con uno schema in `data/schema/`, validato all'avvio del server e da `viaferrea-tools validate-data`. Non si possono usare librerie NuGet (niente validatori JSON Schema esterni) e il caricamento deve usare System.Text.Json con source generator. +La guida chiede che ogni parametro stia in `data/*.json`, con uno schema in `data/schema/`, validato all'avvio del server e da `railenterprise-tools validate-data`. Non si possono usare librerie NuGet (niente validatori JSON Schema esterni) e il caricamento deve usare System.Text.Json con source generator. ## Decisione diff --git a/docs/adr/0006-salvataggi.md b/docs/adr/0006-salvataggi.md index 6dddcdd..14a26f0 100644 --- a/docs/adr/0006-salvataggi.md +++ b/docs/adr/0006-salvataggi.md @@ -8,7 +8,7 @@ La guida chiede snapshot binari compressi con Brotli, portabili tra Windows e Li ## Decisione -1. **File**: `VFSV`, versione del formato (u16), intestazione leggibile senza decomprimere (versione del gioco, hash dei dati, hash di stato, tick, data, nome della compagnia, seme, dimensione, difficoltà, lunghezza del corpo), poi il corpo compresso con Brotli. Scrittura atomica (file temporaneo e rinomina). +1. **File**: `RESV`, versione del formato (u16), intestazione leggibile senza decomprimere (versione del gioco, hash dei dati, hash di stato, tick, data, nome della compagnia, seme, dimensione, difficoltà, lunghezza del corpo), poi il corpo compresso con Brotli. Scrittura atomica (file temporaneo e rinomina). 2. **Corpo** scritto a mano con `SaveWriter` (little endian, lunghezze esplicite): versione del corpo, dizionario dei beni, impostazioni (difficoltà effettiva completa), terreno intero, stato dinamico, ultimo hash, eventi recenti. 3. **Riferimenti per id**: tipi di industria e beni sono salvati per id testuale e rimappati al caricamento; giacenze per ricetta come coppie (bene, quantità). Aggiungere o riordinare definizioni non rompe i salvataggi; rimuovere un tipo di industria usato sì (errore esplicito). 4. **Hash di stato** = XxHash64 dello stato dinamico (tutto tranne terreno, impostazioni ed eventi; il terreno entra con il proprio hash, ricalcolato solo quando cambia un'impronta). Calcolato dal sistema Hash nel primo tick di ogni giorno. diff --git a/docs/adr/0007-rete-e-circolazione.md b/docs/adr/0007-rete-e-circolazione.md index c050fe7..c4a7441 100644 --- a/docs/adr/0007-rete-e-circolazione.md +++ b/docs/adr/0007-rete-e-circolazione.md @@ -52,4 +52,4 @@ si liberano le risorse e cosa succede a un gestore in bancarotta. - Le linee a binario semplice funzionano senza segnali intermedi purché le stazioni abbiano un binario libero per l'incrocio; i segnali servono solo ad aumentare la capacità. -- `viaferrea-tools bench` misura la circolazione con 2.000 treni su 300 linee a doppio binario. +- `railenterprise-tools bench` misura la circolazione con 2.000 treni su 300 linee a doppio binario. diff --git a/docs/adr/0009-server-client-protocollo.md b/docs/adr/0009-server-client-protocollo.md index 37e18f4..2799df7 100644 --- a/docs/adr/0009-server-client-protocollo.md +++ b/docs/adr/0009-server-client-protocollo.md @@ -32,8 +32,8 @@ del server e come collaudare client e immagine in un ambiente senza grafica. 256 KB (backpressure), mentre i messaggi affidabili chiudono la sessione oltre 64 MB. 6. **Una compagnia per tutte le sessioni.** In F3 ogni sessione guida la compagnia del giocatore: più client sono più finestre sulla stessa partita. Le compagnie per giocatore arrivano con le IA. -7. **Copia del mondo nel client.** `ClientWorld` e `ProtocolClient` stanno in `ViaFerrea.Protocol` - (namespace `Client`): li usano il client Godot, i test di integrazione e `viaferrea-tools smoke`. +7. **Copia del mondo nel client.** `ClientWorld` e `ProtocolClient` stanno in `RailEnterprise.Protocol` + (namespace `Client`): li usano il client Godot, i test di integrazione e `railenterprise-tools smoke`. `ClientWorld` ricostruisce un `RailNetwork` con gli stessi id del server; `TrackPreview` (Core) è lo stesso codice del comando `BuildTrack`, quindi l'anteprima coincide: il client manda il costo atteso e il server rifiuta con `PreviewMismatch` se differisce. @@ -44,7 +44,7 @@ del server e come collaudare client e immagine in un ambiente senza grafica. (`tick_ms`, `trains`, `packets`, `contracts`, `sessions`). 9. **Docker.** L'immagine .NET 10 è Ubuntu 24.04: l'utente si crea con `useradd` invece di `adduser` (assente). Core e Protocol si compilano solo per net10.0 nell'immagine - (`-p:VfServerOnly=true`): la build non scarica il targeting pack net8.0 e non ha bisogno di rete + (`-p:ReServerOnly=true`): la build non scarica il targeting pack net8.0 e non ha bisogno di rete oltre alle immagini di base. `IsTrimmable` è stato tolto per lo stesso motivo (pacchetto ILLink). 10. **Client.** Scena principale minima e nodi costruiti in codice (niente editor nel flusso di lavoro); tema dalla palette dell'immagine 05 con i font OFL in `assets/fonts/`; testi con @@ -53,15 +53,15 @@ del server e come collaudare client e immagine in un ambiente senza grafica. 5,5·zoom^−0,56 (1 unità = 1 m da vicino). Rive curve: l'alfa della texture del terreno è il campo dell'acqua interpolato tra i centri delle celle e uno shader lo taglia a 0,5. Fumo con `GpuParticles2D`, alberi con `MultiMeshInstance2D`. -11. **Collaudi senza grafica.** `viaferrea-tools smoke` gioca contro un server vero (locale o in +11. **Collaudi senza grafica.** `railenterprise-tools smoke` gioca contro un server vero (locale o in Docker): trova un fiume, costruisce con l'anteprima, compra un treno e confronta la posizione estrapolata con quella del moto successivo. Il client ha un pilota automatico (`-- --autopilot cartella`, `scripts/client-autopilot.sh`) che fa lo stesso con la grafica vera (Godot sotto Xvfb con Mesa) e salva schermate. -12. **Replay.** Con `--record` (o `VF_RECORD`) il server salva lo stato di partenza accanto al +12. **Replay.** Con `--record` (o `RE_RECORD`) il server salva lo stato di partenza accanto al registro e vi accoda ogni comando eseguito con tick, emittente e payload del protocollo; - `viaferrea-tools replay` li riapplica ai loro tick e confronta l'hash di stato. + `railenterprise-tools replay` li riapplica ai loro tick e confronta l'hash di stato. ## Conseguenze diff --git a/docs/adr/0014-nome-ci-e-rilasci.md b/docs/adr/0014-nome-ci-e-rilasci.md new file mode 100644 index 0000000..935c0c9 --- /dev/null +++ b/docs/adr/0014-nome-ci-e-rilasci.md @@ -0,0 +1,68 @@ +# ADR 0014 — Nuovo nome «Rail Enterprise», CI e rilasci su Gitea + +## Contesto + +Il progetto è nato come «Via Ferrea» (guida v2). Il repository su Gitea si chiama già `BalboSoft/Rail_Enterprise` e il +proprietario ha deciso di adottare «Rail Enterprise» ovunque. Mancavano inoltre una CI sulle PR e una pipeline di +pubblicazione delle versioni: gioco desktop per Windows (.exe) e server in Docker. Le altre repository BalboSoft +(in particolare Chronos) usano Gitea Actions con act_runner in modalità Docker sullo stesso server di Gitea. + +## Decisione + +### Nome + +- Testi, documenti e UI: «Via Ferrea» → «Rail Enterprise» (anche nella guida `docs/GUIDA.md`, che resta la specifica + vincolante: cambia solo il nome). +- Codice: namespace, progetti, cartelle e assembly `ViaFerrea.*` → `RailEnterprise.*`; soluzione `RailEnterprise.sln`; + strumenti `railenterprise-tools`; immagine `rail-enterprise-server`. +- Variabili d'ambiente: prefisso `VF_` → `RE_` (`RE_PORT`, `RE_TOKEN`, `RE_DATA_DIR`, `RE_DIFFICULTY`, …, + `RE_SERVER_PATH`, `RE_GAME_DATA`); proprietà MSBuild `VfServerOnly` → `ReServerOnly`. +- Formati binari: intestazioni `VFSV` → `RESV` (salvataggi) e `VFCL` → `RECL` (registro dei comandi). Il gioco non è + ancora stato rilasciato: i salvataggi di sviluppo precedenti non si leggono più e non è prevista migrazione. +- Utente del container: `vf` → `rail`. +- Il vettore di prova di XxHash64 sulla stringa del nome è stato ricalcolato; gli altri vettori di riferimento + (vuoto, «a», «abc», con seme) restano quelli pubblici e garantiscono la correttezza dell'implementazione. + +### CI (`.gitea/workflows/ci.yml`) + +Su ogni PR e su ogni push su `main`: controllo zero NuGet, build Release con warning come errori, validazione dei dati, +test (sulle PR senza i test lunghi, su `main` la suite completa), compilazione incrociata del server per Windows, +compilazione C# del client Godot, build dell'immagine Docker con prova dell'healthcheck. Checkout con git (l'immagine +dell'SDK non ha Node.js, quindi niente azioni JavaScript), nessuna cache né artefatto. + +### Rilasci (`.gitea/workflows/release.yml`) + +Un tag `vMAJOR.MINOR.PATCH[-PRERELEASE]` produce: + +| File sulla release Gitea | Contenuto | +|---|---| +| `RailEnterprise--windows-x64.zip` | client Godot esportato (`RailEnterprise.exe`) con il server autonomo in `server/` | +| `RailEnterprise-Server--windows-x64.zip` | server autonomo per Windows | +| `RailEnterprise-Server--linux-x64.tar.gz` | server autonomo per Linux | +| `docker-compose.yml`, `unraid-template.xml` | installazione del server | +| `SHA256SUMS` | somme di controllo | + +e l'immagine `gitea.encke-hake.ts.net/balbosoft/rail-enterprise-server:` (più `:latest` per le versioni stabili) +nel registro container di Gitea. La versione viene dal tag e sovrascrive `Directory.Build.props` (passata a MSBuild e +al Dockerfile con `RE_VERSION`). Il client si esporta con Godot .NET senza interfaccia scaricato dalla release ufficiale +(variabile `GODOT_MIRROR` per un mirror) nella versione di `Godot.NET.Sdk` del client. + +`nightly.yml` pubblica ogni notte `:nightly` da `main`. + +### Segreti e variabili + +- `REGISTRY_TOKEN` (segreto di organizzazione, già presente): token di un utente con permesso di scrittura sui + pacchetti; il token del workflow non può scrivere i pacchetti di un'organizzazione. +- Facoltative: `PUBLIC_URL`, `REGISTRY`, `REGISTRY_USER`, `GODOT_MIRROR`. + +### Flusso di lavoro + +Rami `claude/` o `feature/`, PR verso `main` con il modello `.gitea/PULL_REQUEST_TEMPLATE.md`, +merge solo con la CI verde. Ogni lavoro ha una issue nel milestone della sua fase e nel progetto «Roadmap». + +## Conseguenze + +- I comandi e le variabili cambiano nome: chi aveva un container con `VF_TOKEN` deve passare a `RE_TOKEN`. +- L'esportazione del client richiede che il runner raggiunga il sito di download di Godot (circa 1 GB fra editor e + modelli a ogni rilascio, nessuna cache). +- Il client esportato non è firmato: Windows SmartScreen può chiedere conferma al primo avvio. diff --git a/reference/06_mercato_globale.jpg b/reference/06_mercato_globale.jpg new file mode 100644 index 0000000..450e1f7 Binary files /dev/null and b/reference/06_mercato_globale.jpg differ diff --git a/reference/07_scheda_industria.jpg b/reference/07_scheda_industria.jpg new file mode 100644 index 0000000..b8db6d3 Binary files /dev/null and b/reference/07_scheda_industria.jpg differ diff --git a/reference/08_scalata_patrimonio.jpg b/reference/08_scalata_patrimonio.jpg new file mode 100644 index 0000000..6a3fafd Binary files /dev/null and b/reference/08_scalata_patrimonio.jpg differ diff --git a/reference/09_connessione_server.jpg b/reference/09_connessione_server.jpg new file mode 100644 index 0000000..482873c Binary files /dev/null and b/reference/09_connessione_server.jpg differ diff --git a/scripts/build.ps1 b/scripts/build.ps1 index c8e9354..d9aa955 100644 --- a/scripts/build.ps1 +++ b/scripts/build.ps1 @@ -16,19 +16,19 @@ $bad = Get-ChildItem -Recurse -Include *.csproj,*.props,*.targets | Where-Object { Select-String -Path $_.FullName -Pattern '/dev/null 2>&1 || true +dotnet build src/RailEnterprise.Server -c Release -v quiet -nologo +dotnet build client/RailEnterprise.Client/RailEnterprise.Client.csproj -c Debug -v quiet -nologo +"$godot" --headless --path client/RailEnterprise.Client --import >/dev/null 2>&1 || true -run=("$godot" --path client/ViaFerrea.Client --rendering-driver opengl3 --resolution 1600x900 --windowed -- --autopilot "$out") +run=("$godot" --path client/RailEnterprise.Client --rendering-driver opengl3 --resolution 1600x900 --windowed -- --autopilot "$out") if [ -z "${DISPLAY:-}" ] && command -v xvfb-run >/dev/null 2>&1; then xvfb-run -a -s "-screen 0 1600x900x24" "${run[@]}" 2>&1 | grep -E "autopilot|ERROR" || true else diff --git a/scripts/publish-image.sh b/scripts/publish-image.sh index 8630a5b..ca6131c 100755 --- a/scripts/publish-image.sh +++ b/scripts/publish-image.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash # Costruisce l'immagine Docker del server con il tag della versione (da Directory.Build.props) # e "latest", poi la pubblica sul registry Gitea. -# Uso: VF_REGISTRY=gitea.lan:3000/utente scripts/publish-image.sh [--no-push] +# Uso: RE_REGISTRY=gitea.lan:3000/utente scripts/publish-image.sh [--no-push] set -euo pipefail cd "$(dirname "$0")/.." @@ -10,8 +10,8 @@ if [ -z "$version" ]; then echo "ERRORE: versione non trovata in Directory.Build.props" >&2 exit 1 fi -registry="${VF_REGISTRY:-}" -name="via-ferrea-server" +registry="${RE_REGISTRY:-}" +name="rail-enterprise-server" image="${registry:+$registry/}$name" docker build -f docker/Dockerfile -t "$image:$version" -t "$image:latest" . @@ -21,7 +21,7 @@ if [ "${1:-}" = "--no-push" ]; then exit 0 fi if [ -z "$registry" ]; then - echo "VF_REGISTRY non impostato: immagine solo locale (usa --no-push per non vedere questo avviso)" >&2 + echo "RE_REGISTRY non impostato: immagine solo locale (usa --no-push per non vedere questo avviso)" >&2 exit 0 fi docker push "$image:$version" diff --git a/scripts/test.sh b/scripts/test.sh index 9f7d5c9..b4f1b74 100755 --- a/scripts/test.sh +++ b/scripts/test.sh @@ -6,8 +6,8 @@ cd "$(dirname "$0")/.." export DOTNET_CLI_TELEMETRY_OPTOUT=1 DOTNET_NOLOGO=1 scripts/check-nuget.sh -dotnet build ViaFerrea.sln -c Release -nologo -v quiet -if [ -f src/ViaFerrea.Tools/Commands/ValidateDataCommand.cs ]; then - dotnet run --project src/ViaFerrea.Tools -c Release --no-build -- validate-data --data data +dotnet build RailEnterprise.sln -c Release -nologo -v quiet +if [ -f src/RailEnterprise.Tools/Commands/ValidateDataCommand.cs ]; then + dotnet run --project src/RailEnterprise.Tools -c Release --no-build -- validate-data --data data fi -dotnet run --project tests/ViaFerrea.Tests -c Release --no-build -- "$@" +dotnet run --project tests/RailEnterprise.Tests -c Release --no-build -- "$@" diff --git a/src/ViaFerrea.Core/Commands/GameCommand.cs b/src/RailEnterprise.Core/Commands/GameCommand.cs similarity index 97% rename from src/ViaFerrea.Core/Commands/GameCommand.cs rename to src/RailEnterprise.Core/Commands/GameCommand.cs index 102b58f..d0dee29 100644 --- a/src/ViaFerrea.Core/Commands/GameCommand.cs +++ b/src/RailEnterprise.Core/Commands/GameCommand.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Commands; +namespace RailEnterprise.Core.Commands; /// /// Tipi di comando con codici stabili: coincidono con Command.type del protocollo e non diff --git a/src/ViaFerrea.Core/Commands/LaterCommands.cs b/src/RailEnterprise.Core/Commands/LaterCommands.cs similarity index 98% rename from src/ViaFerrea.Core/Commands/LaterCommands.cs rename to src/RailEnterprise.Core/Commands/LaterCommands.cs index 0c4e941..4a99b87 100644 --- a/src/ViaFerrea.Core/Commands/LaterCommands.cs +++ b/src/RailEnterprise.Core/Commands/LaterCommands.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Commands; +namespace RailEnterprise.Core.Commands; // Comandi delle fasi F4–F7: il formato è già definitivo (protocollo stabile), l'esecuzione // risponde NotImplemented finché il sistema corrispondente non esiste. diff --git a/src/ViaFerrea.Core/Commands/RailCommands.cs b/src/RailEnterprise.Core/Commands/RailCommands.cs similarity index 97% rename from src/ViaFerrea.Core/Commands/RailCommands.cs rename to src/RailEnterprise.Core/Commands/RailCommands.cs index 2fa2768..26ae7d0 100644 --- a/src/ViaFerrea.Core/Commands/RailCommands.cs +++ b/src/RailEnterprise.Core/Commands/RailCommands.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Commands; +namespace RailEnterprise.Core.Commands; /// Costruisce un binario lungo la polilinea (metri). ExpectedCostCents ≠ 0 confronta l'anteprima del client. public sealed record BuildTrackCommand(IReadOnlyList Polyline, double HeightOffsetM = 0, bool AllowBridges = true, bool AllowTunnels = true, diff --git a/src/ViaFerrea.Core/Common/DMath.cs b/src/RailEnterprise.Core/Common/DMath.cs similarity index 99% rename from src/ViaFerrea.Core/Common/DMath.cs rename to src/RailEnterprise.Core/Common/DMath.cs index 91df8d5..ecade19 100644 --- a/src/ViaFerrea.Core/Common/DMath.cs +++ b/src/RailEnterprise.Core/Common/DMath.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Common; +namespace RailEnterprise.Core.Common; /// /// Funzioni matematiche deterministiche per la simulazione (ADR 0003). diff --git a/src/ViaFerrea.Core/Common/Ids.cs b/src/RailEnterprise.Core/Common/Ids.cs similarity index 99% rename from src/ViaFerrea.Core/Common/Ids.cs rename to src/RailEnterprise.Core/Common/Ids.cs index f69d834..7e5720c 100644 --- a/src/ViaFerrea.Core/Common/Ids.cs +++ b/src/RailEnterprise.Core/Common/Ids.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Common; +namespace RailEnterprise.Core.Common; // Identità tipizzate: impediscono di confondere gli id di entità diverse. // Il valore −1 (None) indica l'assenza di riferimento. Generato da uno script: tutte le identità hanno la stessa forma. diff --git a/src/ViaFerrea.Core/Common/Money.cs b/src/RailEnterprise.Core/Common/Money.cs similarity index 99% rename from src/ViaFerrea.Core/Common/Money.cs rename to src/RailEnterprise.Core/Common/Money.cs index 6d902cb..ac361cf 100644 --- a/src/ViaFerrea.Core/Common/Money.cs +++ b/src/RailEnterprise.Core/Common/Money.cs @@ -1,7 +1,7 @@ using System.Globalization; using System.Text; -namespace ViaFerrea.Core.Common; +namespace RailEnterprise.Core.Common; /// /// Importo in centesimi di lira (₤). Tutta la contabilità della simulazione usa interi per diff --git a/src/ViaFerrea.Core/Common/Rng.cs b/src/RailEnterprise.Core/Common/Rng.cs similarity index 99% rename from src/ViaFerrea.Core/Common/Rng.cs rename to src/RailEnterprise.Core/Common/Rng.cs index 6fbe33e..4efcccd 100644 --- a/src/ViaFerrea.Core/Common/Rng.cs +++ b/src/RailEnterprise.Core/Common/Rng.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Common; +namespace RailEnterprise.Core.Common; /// /// Generatore pseudo-casuale xoshiro256** (Blackman e Vigna), unico ammesso nella simulazione. diff --git a/src/ViaFerrea.Core/Common/StableHash.cs b/src/RailEnterprise.Core/Common/StableHash.cs similarity index 97% rename from src/ViaFerrea.Core/Common/StableHash.cs rename to src/RailEnterprise.Core/Common/StableHash.cs index 9692216..1255936 100644 --- a/src/ViaFerrea.Core/Common/StableHash.cs +++ b/src/RailEnterprise.Core/Common/StableHash.cs @@ -1,6 +1,6 @@ using System.Text; -namespace ViaFerrea.Core.Common; +namespace RailEnterprise.Core.Common; /// /// Hash stabili tra processi e piattaforme (string.GetHashCode è randomizzato per processo e diff --git a/src/ViaFerrea.Core/Common/Vec2.cs b/src/RailEnterprise.Core/Common/Vec2.cs similarity index 97% rename from src/ViaFerrea.Core/Common/Vec2.cs rename to src/RailEnterprise.Core/Common/Vec2.cs index 14075d4..269e539 100644 --- a/src/ViaFerrea.Core/Common/Vec2.cs +++ b/src/RailEnterprise.Core/Common/Vec2.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Common; +namespace RailEnterprise.Core.Common; /// Vettore 2D in metri (x verso est, y verso sud, come le righe della mappa). public readonly record struct Vec2(double X, double Y) diff --git a/src/ViaFerrea.Core/Common/XxHash64.cs b/src/RailEnterprise.Core/Common/XxHash64.cs similarity index 98% rename from src/ViaFerrea.Core/Common/XxHash64.cs rename to src/RailEnterprise.Core/Common/XxHash64.cs index 70ed616..687cf1b 100644 --- a/src/ViaFerrea.Core/Common/XxHash64.cs +++ b/src/RailEnterprise.Core/Common/XxHash64.cs @@ -1,6 +1,6 @@ using System.Buffers.Binary; -namespace ViaFerrea.Core.Common; +namespace RailEnterprise.Core.Common; /// /// XXH64 (Yann Collet), implementato in Core perché System.IO.Hashing è un pacchetto NuGet. diff --git a/src/ViaFerrea.Core/Data/AiDefs.cs b/src/RailEnterprise.Core/Data/AiDefs.cs similarity index 99% rename from src/ViaFerrea.Core/Data/AiDefs.cs rename to src/RailEnterprise.Core/Data/AiDefs.cs index 0d5dec3..0e7764b 100644 --- a/src/ViaFerrea.Core/Data/AiDefs.cs +++ b/src/RailEnterprise.Core/Data/AiDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; // Contenuto di ai.json (guida, sezione 12.1). diff --git a/src/ViaFerrea.Core/Data/BalanceDefs.cs b/src/RailEnterprise.Core/Data/BalanceDefs.cs similarity index 99% rename from src/ViaFerrea.Core/Data/BalanceDefs.cs rename to src/RailEnterprise.Core/Data/BalanceDefs.cs index 6555588..1069b8f 100644 --- a/src/ViaFerrea.Core/Data/BalanceDefs.cs +++ b/src/RailEnterprise.Core/Data/BalanceDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; // Contenuto di balance.json: costanti delle formule (guida, sezioni 6–11). // Ogni proprietà è obbligatoria: un valore mancante o un nome sbagliato blocca il caricamento. diff --git a/src/ViaFerrea.Core/Data/ConstructionDefs.cs b/src/RailEnterprise.Core/Data/ConstructionDefs.cs similarity index 99% rename from src/ViaFerrea.Core/Data/ConstructionDefs.cs rename to src/RailEnterprise.Core/Data/ConstructionDefs.cs index 68ec48e..e5cdc73 100644 --- a/src/ViaFerrea.Core/Data/ConstructionDefs.cs +++ b/src/RailEnterprise.Core/Data/ConstructionDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; // Contenuto di construction.json (guida, sezione 8). diff --git a/src/ViaFerrea.Core/Data/ContractsDefs.cs b/src/RailEnterprise.Core/Data/ContractsDefs.cs similarity index 97% rename from src/ViaFerrea.Core/Data/ContractsDefs.cs rename to src/RailEnterprise.Core/Data/ContractsDefs.cs index 07d5b49..7ff30af 100644 --- a/src/ViaFerrea.Core/Data/ContractsDefs.cs +++ b/src/RailEnterprise.Core/Data/ContractsDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; // Contenuto di contracts.json (guida, sezione 13.5). diff --git a/src/ViaFerrea.Core/Data/DataJsonContext.cs b/src/RailEnterprise.Core/Data/DataJsonContext.cs similarity index 97% rename from src/ViaFerrea.Core/Data/DataJsonContext.cs rename to src/RailEnterprise.Core/Data/DataJsonContext.cs index 0b49325..429d602 100644 --- a/src/ViaFerrea.Core/Data/DataJsonContext.cs +++ b/src/RailEnterprise.Core/Data/DataJsonContext.cs @@ -1,7 +1,7 @@ using System.Text.Json; using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// /// Contesto System.Text.Json generato a compile time per i file dati: niente reflection, diff --git a/src/ViaFerrea.Core/Data/DataSource.cs b/src/RailEnterprise.Core/Data/DataSource.cs similarity index 93% rename from src/ViaFerrea.Core/Data/DataSource.cs rename to src/RailEnterprise.Core/Data/DataSource.cs index aa56337..cf54ca0 100644 --- a/src/ViaFerrea.Core/Data/DataSource.cs +++ b/src/RailEnterprise.Core/Data/DataSource.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// Sorgente dei file dati: cartella su disco, risorse del client Godot, memoria nei test. public interface IDataSource @@ -23,12 +23,12 @@ public sealed class DirectoryDataSource(string root) : IDataSource public string ReadText(string relativePath) => File.ReadAllText(Path.Combine(Root, relativePath)); /// - /// Trova la cartella dati: variabile VF_GAME_DATA, poi «data» accanto all'eseguibile, + /// Trova la cartella dati: variabile RE_GAME_DATA, poi «data» accanto all'eseguibile, /// poi risalendo dalla cartella corrente (utile in sviluppo). /// public static DirectoryDataSource FindDefault() { - string? env = Environment.GetEnvironmentVariable("VF_GAME_DATA"); + string? env = Environment.GetEnvironmentVariable("RE_GAME_DATA"); if (!string.IsNullOrWhiteSpace(env) && File.Exists(Path.Combine(env, "goods.json"))) return new DirectoryDataSource(env); @@ -42,7 +42,7 @@ public sealed class DirectoryDataSource(string root) : IDataSource if (File.Exists(Path.Combine(candidate, "goods.json"))) return new DirectoryDataSource(candidate); dir = dir.Parent; } - throw new DirectoryNotFoundException("Cartella dei dati di gioco non trovata (imposta VF_GAME_DATA)"); + throw new DirectoryNotFoundException("Cartella dei dati di gioco non trovata (imposta RE_GAME_DATA)"); } } diff --git a/src/ViaFerrea.Core/Data/DataValidator.cs b/src/RailEnterprise.Core/Data/DataValidator.cs similarity index 99% rename from src/ViaFerrea.Core/Data/DataValidator.cs rename to src/RailEnterprise.Core/Data/DataValidator.cs index ec2532f..9d5bf6a 100644 --- a/src/ViaFerrea.Core/Data/DataValidator.cs +++ b/src/RailEnterprise.Core/Data/DataValidator.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// /// Validazione semantica dei dati, dopo lo schema: id univoci, riferimenti risolti, diff --git a/src/ViaFerrea.Core/Data/DifficultyDefs.cs b/src/RailEnterprise.Core/Data/DifficultyDefs.cs similarity index 98% rename from src/ViaFerrea.Core/Data/DifficultyDefs.cs rename to src/RailEnterprise.Core/Data/DifficultyDefs.cs index 6207a53..d5eb01b 100644 --- a/src/ViaFerrea.Core/Data/DifficultyDefs.cs +++ b/src/RailEnterprise.Core/Data/DifficultyDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// Contenuto di difficulty.json. public sealed class DifficultyFile diff --git a/src/ViaFerrea.Core/Data/DifficultyOverrides.cs b/src/RailEnterprise.Core/Data/DifficultyOverrides.cs similarity index 98% rename from src/ViaFerrea.Core/Data/DifficultyOverrides.cs rename to src/RailEnterprise.Core/Data/DifficultyOverrides.cs index e847361..a165537 100644 --- a/src/ViaFerrea.Core/Data/DifficultyOverrides.cs +++ b/src/RailEnterprise.Core/Data/DifficultyOverrides.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// /// Difficoltà «Personalizzata»: ritocchi di un preset per nome di campo (camelCase, come in diff --git a/src/ViaFerrea.Core/Data/Enums.cs b/src/RailEnterprise.Core/Data/Enums.cs similarity index 97% rename from src/ViaFerrea.Core/Data/Enums.cs rename to src/RailEnterprise.Core/Data/Enums.cs index 4e24a3e..4612e11 100644 --- a/src/ViaFerrea.Core/Data/Enums.cs +++ b/src/RailEnterprise.Core/Data/Enums.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; // Enumerazioni dei file dati. Nel JSON compaiono in minuscolo; la lettura è insensibile alle maiuscole. diff --git a/src/ViaFerrea.Core/Data/ErasDefs.cs b/src/RailEnterprise.Core/Data/ErasDefs.cs similarity index 98% rename from src/ViaFerrea.Core/Data/ErasDefs.cs rename to src/RailEnterprise.Core/Data/ErasDefs.cs index 51b9141..bb48dae 100644 --- a/src/ViaFerrea.Core/Data/ErasDefs.cs +++ b/src/RailEnterprise.Core/Data/ErasDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// Contenuto di eras.json: introduzione di trazioni, ponti, gallerie, binari e segnali. public sealed class ErasFile diff --git a/src/ViaFerrea.Core/Data/GameData.cs b/src/RailEnterprise.Core/Data/GameData.cs similarity index 99% rename from src/ViaFerrea.Core/Data/GameData.cs rename to src/RailEnterprise.Core/Data/GameData.cs index 33658b0..ef2f976 100644 --- a/src/ViaFerrea.Core/Data/GameData.cs +++ b/src/RailEnterprise.Core/Data/GameData.cs @@ -2,9 +2,9 @@ using System.Buffers; using System.Text; using System.Text.Json; using System.Text.Json.Serialization.Metadata; -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// /// Tutte le definizioni immutabili del gioco, caricate e validate da data/*.json. diff --git a/src/ViaFerrea.Core/Data/GoodsDefs.cs b/src/RailEnterprise.Core/Data/GoodsDefs.cs similarity index 98% rename from src/ViaFerrea.Core/Data/GoodsDefs.cs rename to src/RailEnterprise.Core/Data/GoodsDefs.cs index 358f34c..fb20684 100644 --- a/src/ViaFerrea.Core/Data/GoodsDefs.cs +++ b/src/RailEnterprise.Core/Data/GoodsDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// Contenuto di goods.json. public sealed class GoodsFile diff --git a/src/ViaFerrea.Core/Data/IndustryDefs.cs b/src/RailEnterprise.Core/Data/IndustryDefs.cs similarity index 98% rename from src/ViaFerrea.Core/Data/IndustryDefs.cs rename to src/RailEnterprise.Core/Data/IndustryDefs.cs index 0b778ed..26ac821 100644 --- a/src/ViaFerrea.Core/Data/IndustryDefs.cs +++ b/src/RailEnterprise.Core/Data/IndustryDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// Contenuto di industries.json. public sealed class IndustriesFile diff --git a/src/ViaFerrea.Core/Data/JsonSchemaValidator.cs b/src/RailEnterprise.Core/Data/JsonSchemaValidator.cs similarity index 99% rename from src/ViaFerrea.Core/Data/JsonSchemaValidator.cs rename to src/RailEnterprise.Core/Data/JsonSchemaValidator.cs index 5e87481..1592c72 100644 --- a/src/ViaFerrea.Core/Data/JsonSchemaValidator.cs +++ b/src/RailEnterprise.Core/Data/JsonSchemaValidator.cs @@ -2,7 +2,7 @@ using System.Globalization; using System.Text.Json; using System.Text.RegularExpressions; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// /// Validatore di un sottoinsieme di JSON Schema (draft 2020-12), sufficiente per gli schemi diff --git a/src/ViaFerrea.Core/Data/MaintenanceDefs.cs b/src/RailEnterprise.Core/Data/MaintenanceDefs.cs similarity index 99% rename from src/ViaFerrea.Core/Data/MaintenanceDefs.cs rename to src/RailEnterprise.Core/Data/MaintenanceDefs.cs index f0e2daa..f952aec 100644 --- a/src/ViaFerrea.Core/Data/MaintenanceDefs.cs +++ b/src/RailEnterprise.Core/Data/MaintenanceDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; // Contenuto di maintenance.json (guida, sezione 10). diff --git a/src/ViaFerrea.Core/Data/RegionsDefs.cs b/src/RailEnterprise.Core/Data/RegionsDefs.cs similarity index 98% rename from src/ViaFerrea.Core/Data/RegionsDefs.cs rename to src/RailEnterprise.Core/Data/RegionsDefs.cs index d72ee1a..1fa3825 100644 --- a/src/ViaFerrea.Core/Data/RegionsDefs.cs +++ b/src/RailEnterprise.Core/Data/RegionsDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; // Contenuto di regions.json (guida, sezione 13.1) e serbatoi di nomi. diff --git a/src/ViaFerrea.Core/Data/TiersDefs.cs b/src/RailEnterprise.Core/Data/TiersDefs.cs similarity index 97% rename from src/ViaFerrea.Core/Data/TiersDefs.cs rename to src/RailEnterprise.Core/Data/TiersDefs.cs index 1dccc2d..a8f9ab9 100644 --- a/src/ViaFerrea.Core/Data/TiersDefs.cs +++ b/src/RailEnterprise.Core/Data/TiersDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// Contenuto di tiers.json: livelli della compagnia e sblocchi. public sealed class TiersFile diff --git a/src/ViaFerrea.Core/Data/VehicleDefs.cs b/src/RailEnterprise.Core/Data/VehicleDefs.cs similarity index 98% rename from src/ViaFerrea.Core/Data/VehicleDefs.cs rename to src/RailEnterprise.Core/Data/VehicleDefs.cs index 2d633de..40422d1 100644 --- a/src/ViaFerrea.Core/Data/VehicleDefs.cs +++ b/src/RailEnterprise.Core/Data/VehicleDefs.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Data; +namespace RailEnterprise.Core.Data; /// Contenuto di vehicles.json. public sealed class VehiclesFile diff --git a/src/ViaFerrea.Core/Economy/Company.cs b/src/RailEnterprise.Core/Economy/Company.cs similarity index 98% rename from src/ViaFerrea.Core/Economy/Company.cs rename to src/RailEnterprise.Core/Economy/Company.cs index d8a372c..d96f745 100644 --- a/src/ViaFerrea.Core/Economy/Company.cs +++ b/src/RailEnterprise.Core/Economy/Company.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// Voci del conto economico di una compagnia. public enum LedgerEntry : byte diff --git a/src/ViaFerrea.Core/Economy/Employment.cs b/src/RailEnterprise.Core/Economy/Employment.cs similarity index 97% rename from src/ViaFerrea.Core/Economy/Employment.cs rename to src/RailEnterprise.Core/Economy/Employment.cs index 844bffc..b513f10 100644 --- a/src/ViaFerrea.Core/Economy/Employment.cs +++ b/src/RailEnterprise.Core/Economy/Employment.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// Tipo di posto di lavoro. public enum WorkplaceKind : byte { Industry = 0, Depot = 1 } diff --git a/src/ViaFerrea.Core/Economy/Hub.cs b/src/RailEnterprise.Core/Economy/Hub.cs similarity index 92% rename from src/ViaFerrea.Core/Economy/Hub.cs rename to src/RailEnterprise.Core/Economy/Hub.cs index 423ffe8..5863e73 100644 --- a/src/ViaFerrea.Core/Economy/Hub.cs +++ b/src/RailEnterprise.Core/Economy/Hub.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// /// Hub verso il mercato mondiale (porto o valico): importa ed esporta qualsiasi bene al prezzo diff --git a/src/ViaFerrea.Core/Economy/Industry.cs b/src/RailEnterprise.Core/Economy/Industry.cs similarity index 98% rename from src/ViaFerrea.Core/Economy/Industry.cs rename to src/RailEnterprise.Core/Economy/Industry.cs index 80e4b7d..8e69933 100644 --- a/src/ViaFerrea.Core/Economy/Industry.cs +++ b/src/RailEnterprise.Core/Economy/Industry.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// Budget di manutenzione degli impianti scelto dal proprietario (guida, sezione 11). public enum IndustryBudget : byte { None = 0, Base = 1, High = 2 } diff --git a/src/ViaFerrea.Core/Economy/Ledger.cs b/src/RailEnterprise.Core/Economy/Ledger.cs similarity index 97% rename from src/ViaFerrea.Core/Economy/Ledger.cs rename to src/RailEnterprise.Core/Economy/Ledger.cs index b7f9e51..2b1348d 100644 --- a/src/ViaFerrea.Core/Economy/Ledger.cs +++ b/src/RailEnterprise.Core/Economy/Ledger.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// Titolare di un conto nel registro a partita doppia. public enum AccountKind : byte { External = 0, Company = 1, Industry = 2 } diff --git a/src/ViaFerrea.Core/Economy/Market.cs b/src/RailEnterprise.Core/Economy/Market.cs similarity index 98% rename from src/ViaFerrea.Core/Economy/Market.cs rename to src/RailEnterprise.Core/Economy/Market.cs index 8fd5280..691dd73 100644 --- a/src/ViaFerrea.Core/Economy/Market.cs +++ b/src/RailEnterprise.Core/Economy/Market.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// /// Mercato dei beni: prezzo globale per bene aggiornato ogni giorno dal rapporto tra domanda e diff --git a/src/ViaFerrea.Core/Economy/ResourceSite.cs b/src/RailEnterprise.Core/Economy/ResourceSite.cs similarity index 88% rename from src/ViaFerrea.Core/Economy/ResourceSite.cs rename to src/RailEnterprise.Core/Economy/ResourceSite.cs index 973f238..d07edd4 100644 --- a/src/ViaFerrea.Core/Economy/ResourceSite.cs +++ b/src/RailEnterprise.Core/Economy/ResourceSite.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// Giacimento con riserva finita (carbone, ferro, pietra, petrolio). public sealed class ResourceSite diff --git a/src/ViaFerrea.Core/Economy/RollingWindow.cs b/src/RailEnterprise.Core/Economy/RollingWindow.cs similarity index 98% rename from src/ViaFerrea.Core/Economy/RollingWindow.cs rename to src/RailEnterprise.Core/Economy/RollingWindow.cs index c5eb009..5bd6d0c 100644 --- a/src/ViaFerrea.Core/Economy/RollingWindow.cs +++ b/src/RailEnterprise.Core/Economy/RollingWindow.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// /// Somma mobile su una finestra fissa di N campioni giornalieri (per esempio domanda e offerta diff --git a/src/ViaFerrea.Core/Economy/Shares.cs b/src/RailEnterprise.Core/Economy/Shares.cs similarity index 98% rename from src/ViaFerrea.Core/Economy/Shares.cs rename to src/RailEnterprise.Core/Economy/Shares.cs index 80752c0..6f76bc7 100644 --- a/src/ViaFerrea.Core/Economy/Shares.cs +++ b/src/RailEnterprise.Core/Economy/Shares.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// /// Libro dei soci di una compagnia (12.2): fondatore (il giocatore o il proprietario privato diff --git a/src/ViaFerrea.Core/Economy/Town.cs b/src/RailEnterprise.Core/Economy/Town.cs similarity index 96% rename from src/ViaFerrea.Core/Economy/Town.cs rename to src/RailEnterprise.Core/Economy/Town.cs index 4d55799..7f9211a 100644 --- a/src/ViaFerrea.Core/Economy/Town.cs +++ b/src/RailEnterprise.Core/Economy/Town.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Economy; +namespace RailEnterprise.Core.Economy; /// Città: popolazione, domanda di beni, soddisfazione per categoria e forza lavoro. public sealed class Town diff --git a/src/ViaFerrea.Core/Map/GeneratedMap.cs b/src/RailEnterprise.Core/Map/GeneratedMap.cs similarity index 96% rename from src/ViaFerrea.Core/Map/GeneratedMap.cs rename to src/RailEnterprise.Core/Map/GeneratedMap.cs index 029ee30..50a9948 100644 --- a/src/ViaFerrea.Core/Map/GeneratedMap.cs +++ b/src/RailEnterprise.Core/Map/GeneratedMap.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Map; +namespace RailEnterprise.Core.Map; /// Parametri di generazione di una mappa. public sealed record MapSpec(ulong Seed, int SizeKm, int StartYear, string RegionId = "valdoria"); diff --git a/src/ViaFerrea.Core/Map/MapGenerator.Placement.cs b/src/RailEnterprise.Core/Map/MapGenerator.Placement.cs similarity index 99% rename from src/ViaFerrea.Core/Map/MapGenerator.Placement.cs rename to src/RailEnterprise.Core/Map/MapGenerator.Placement.cs index c48a02a..9dfe7c8 100644 --- a/src/ViaFerrea.Core/Map/MapGenerator.Placement.cs +++ b/src/RailEnterprise.Core/Map/MapGenerator.Placement.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Map; +namespace RailEnterprise.Core.Map; // Copertura del suolo e collocazione di giacimenti, città, hub e industrie. public sealed partial class MapGenerator diff --git a/src/ViaFerrea.Core/Map/MapGenerator.cs b/src/RailEnterprise.Core/Map/MapGenerator.cs similarity index 99% rename from src/ViaFerrea.Core/Map/MapGenerator.cs rename to src/RailEnterprise.Core/Map/MapGenerator.cs index 263ed30..d1c29ad 100644 --- a/src/ViaFerrea.Core/Map/MapGenerator.cs +++ b/src/RailEnterprise.Core/Map/MapGenerator.cs @@ -1,8 +1,8 @@ using System.Diagnostics; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Map; +namespace RailEnterprise.Core.Map; /// /// Generatore procedurale della regione (guida 6.2). Tutto dipende solo dal seme e dai dati: diff --git a/src/ViaFerrea.Core/Map/NameGenerator.cs b/src/RailEnterprise.Core/Map/NameGenerator.cs similarity index 95% rename from src/ViaFerrea.Core/Map/NameGenerator.cs rename to src/RailEnterprise.Core/Map/NameGenerator.cs index 2e3e519..29c96ff 100644 --- a/src/ViaFerrea.Core/Map/NameGenerator.cs +++ b/src/RailEnterprise.Core/Map/NameGenerator.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Map; +namespace RailEnterprise.Core.Map; /// Nomi di città all'italiana composti da prefissi, radici e suffissi del serbatoio della regione. public sealed class NameGenerator(NamePoolDef pool, Rng rng) diff --git a/src/ViaFerrea.Core/Map/Terrain.cs b/src/RailEnterprise.Core/Map/Terrain.cs similarity index 97% rename from src/ViaFerrea.Core/Map/Terrain.cs rename to src/RailEnterprise.Core/Map/Terrain.cs index 6aaf828..7bb485e 100644 --- a/src/ViaFerrea.Core/Map/Terrain.cs +++ b/src/RailEnterprise.Core/Map/Terrain.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Map; +namespace RailEnterprise.Core.Map; /// Tipo di cella (un byte nella mappa). public enum CellType : byte diff --git a/src/ViaFerrea.Core/Map/TerrainSampler.cs b/src/RailEnterprise.Core/Map/TerrainSampler.cs similarity index 97% rename from src/ViaFerrea.Core/Map/TerrainSampler.cs rename to src/RailEnterprise.Core/Map/TerrainSampler.cs index 88c4e14..990e52e 100644 --- a/src/ViaFerrea.Core/Map/TerrainSampler.cs +++ b/src/RailEnterprise.Core/Map/TerrainSampler.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Map; +namespace RailEnterprise.Core.Map; /// /// Campionamento continuo del terreno: altezza bilineare in un punto qualsiasi (metri), diff --git a/src/ViaFerrea.Core/Map/ValueNoise.cs b/src/RailEnterprise.Core/Map/ValueNoise.cs similarity index 98% rename from src/ViaFerrea.Core/Map/ValueNoise.cs rename to src/RailEnterprise.Core/Map/ValueNoise.cs index 8769014..5ff4ea9 100644 --- a/src/ViaFerrea.Core/Map/ValueNoise.cs +++ b/src/RailEnterprise.Core/Map/ValueNoise.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Map; +namespace RailEnterprise.Core.Map; /// /// Rumore di valore 2D deterministico: valori pseudo-casuali sui nodi di un reticolo intero, diff --git a/src/ViaFerrea.Core/Persistence/CorporateSerializer.cs b/src/RailEnterprise.Core/Persistence/CorporateSerializer.cs similarity index 98% rename from src/ViaFerrea.Core/Persistence/CorporateSerializer.cs rename to src/RailEnterprise.Core/Persistence/CorporateSerializer.cs index d3b1b75..1c611b8 100644 --- a/src/ViaFerrea.Core/Persistence/CorporateSerializer.cs +++ b/src/RailEnterprise.Core/Persistence/CorporateSerializer.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Ai; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Ai; -namespace ViaFerrea.Core.Persistence; +namespace RailEnterprise.Core.Persistence; /// /// Stato della fase F5 (corpo del salvataggio dalla versione 3): manutenzione e proprietà delle diff --git a/src/ViaFerrea.Core/Persistence/MaintenanceSerializer.cs b/src/RailEnterprise.Core/Persistence/MaintenanceSerializer.cs similarity index 97% rename from src/ViaFerrea.Core/Persistence/MaintenanceSerializer.cs rename to src/RailEnterprise.Core/Persistence/MaintenanceSerializer.cs index d46d48b..01c4b42 100644 --- a/src/ViaFerrea.Core/Persistence/MaintenanceSerializer.cs +++ b/src/RailEnterprise.Core/Persistence/MaintenanceSerializer.cs @@ -1,11 +1,11 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Persistence; +namespace RailEnterprise.Core.Persistence; /// /// Stato della fase F4 (corpo del salvataggio dalla versione 2): manutenzione di veicoli e treni, diff --git a/src/ViaFerrea.Core/Persistence/RailSerializer.cs b/src/RailEnterprise.Core/Persistence/RailSerializer.cs similarity index 99% rename from src/ViaFerrea.Core/Persistence/RailSerializer.cs rename to src/RailEnterprise.Core/Persistence/RailSerializer.cs index 9223e84..72c18ad 100644 --- a/src/ViaFerrea.Core/Persistence/RailSerializer.cs +++ b/src/RailEnterprise.Core/Persistence/RailSerializer.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; -namespace ViaFerrea.Core.Persistence; +namespace RailEnterprise.Core.Persistence; /// Serializzazione dello stato ferroviario: rete, cantieri, veicoli, treni, linee, pacchetti. public static class RailSerializer diff --git a/src/ViaFerrea.Core/Persistence/SaveFile.cs b/src/RailEnterprise.Core/Persistence/SaveFile.cs similarity index 94% rename from src/ViaFerrea.Core/Persistence/SaveFile.cs rename to src/RailEnterprise.Core/Persistence/SaveFile.cs index 9d4e083..a23a320 100644 --- a/src/ViaFerrea.Core/Persistence/SaveFile.cs +++ b/src/RailEnterprise.Core/Persistence/SaveFile.cs @@ -1,21 +1,21 @@ using System.IO.Compression; using System.Text; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Simulation; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Simulation; -namespace ViaFerrea.Core.Persistence; +namespace RailEnterprise.Core.Persistence; /// Informazioni leggibili dall'intestazione senza decomprimere il salvataggio. public sealed record SaveInfo(int FormatVersion, string GameVersion, ulong DataHash, ulong StateHash, long Tick, string Date, string CompanyName, ulong Seed, int SizeKm, string Difficulty); /// -/// File di salvataggio: intestazione «VFSV» in chiaro + corpo binario compresso con Brotli. +/// File di salvataggio: intestazione «RESV» in chiaro + corpo binario compresso con Brotli. /// Portabile tra Windows e Linux (little endian esplicito, nessuna dipendenza dalla piattaforma). /// public static class SaveFile { - private static readonly byte[] Magic = "VFSV"u8.ToArray(); + private static readonly byte[] Magic = "RESV"u8.ToArray(); public const ushort FormatVersion = 1; /// Serializza e comprime il mondo. @@ -78,7 +78,7 @@ public static class SaveFile private static SaveInfo ReadHeader(byte[] file, out int bodyOffset, out int bodyLength) { if (file.Length < 8 || !file.AsSpan(0, 4).SequenceEqual(Magic)) - throw new InvalidDataException("Non è un salvataggio di Via Ferrea"); + throw new InvalidDataException("Non è un salvataggio di Rail Enterprise"); var r = new SaveReader(file, 4); ushort version = r.ReadUInt16(); if (version > FormatVersion) throw new InvalidDataException($"Formato di salvataggio più recente del gioco ({version})"); diff --git a/src/ViaFerrea.Core/Persistence/SaveWriter.cs b/src/RailEnterprise.Core/Persistence/SaveWriter.cs similarity index 99% rename from src/ViaFerrea.Core/Persistence/SaveWriter.cs rename to src/RailEnterprise.Core/Persistence/SaveWriter.cs index 56e90a0..0028ac4 100644 --- a/src/ViaFerrea.Core/Persistence/SaveWriter.cs +++ b/src/RailEnterprise.Core/Persistence/SaveWriter.cs @@ -1,7 +1,7 @@ using System.Buffers.Binary; using System.Text; -namespace ViaFerrea.Core.Persistence; +namespace RailEnterprise.Core.Persistence; /// /// Scrittore binario little endian su buffer crescente e riutilizzabile (nessuna reflection). diff --git a/src/ViaFerrea.Core/Persistence/StateHasher.cs b/src/RailEnterprise.Core/Persistence/StateHasher.cs similarity index 83% rename from src/ViaFerrea.Core/Persistence/StateHasher.cs rename to src/RailEnterprise.Core/Persistence/StateHasher.cs index c781278..0a0cbc2 100644 --- a/src/ViaFerrea.Core/Persistence/StateHasher.cs +++ b/src/RailEnterprise.Core/Persistence/StateHasher.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Simulation; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Simulation; -namespace ViaFerrea.Core.Persistence; +namespace RailEnterprise.Core.Persistence; /// /// Hash dello stato dinamico: XxHash64 della serializzazione di . diff --git a/src/ViaFerrea.Core/Persistence/WorldSerializer.cs b/src/RailEnterprise.Core/Persistence/WorldSerializer.cs similarity index 99% rename from src/ViaFerrea.Core/Persistence/WorldSerializer.cs rename to src/RailEnterprise.Core/Persistence/WorldSerializer.cs index 23619f1..884dfdf 100644 --- a/src/ViaFerrea.Core/Persistence/WorldSerializer.cs +++ b/src/RailEnterprise.Core/Persistence/WorldSerializer.cs @@ -1,10 +1,10 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Simulation; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Simulation; -namespace ViaFerrea.Core.Persistence; +namespace RailEnterprise.Core.Persistence; /// /// Serializzazione completa del mondo. I riferimenti alle definizioni sono salvati per id diff --git a/src/ViaFerrea.Core/Rail/LineGraph.cs b/src/RailEnterprise.Core/Rail/LineGraph.cs similarity index 99% rename from src/ViaFerrea.Core/Rail/LineGraph.cs rename to src/RailEnterprise.Core/Rail/LineGraph.cs index eef4ea7..d456115 100644 --- a/src/ViaFerrea.Core/Rail/LineGraph.cs +++ b/src/RailEnterprise.Core/Rail/LineGraph.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Rail; +namespace RailEnterprise.Core.Rail; /// Tratto continuo su una linea: si sale in From e si scende in To. public readonly record struct Hop(LineId Line, StationId From, StationId To, double Minutes); diff --git a/src/ViaFerrea.Core/Rail/Network.cs b/src/RailEnterprise.Core/Rail/Network.cs similarity index 99% rename from src/ViaFerrea.Core/Rail/Network.cs rename to src/RailEnterprise.Core/Rail/Network.cs index 723f465..ebaf555 100644 --- a/src/ViaFerrea.Core/Rail/Network.cs +++ b/src/RailEnterprise.Core/Rail/Network.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Rail; +namespace RailEnterprise.Core.Rail; /// Stato di un arco di binario. public enum EdgeState : byte diff --git a/src/ViaFerrea.Core/Rail/Pathfinder.cs b/src/RailEnterprise.Core/Rail/Pathfinder.cs similarity index 98% rename from src/ViaFerrea.Core/Rail/Pathfinder.cs rename to src/RailEnterprise.Core/Rail/Pathfinder.cs index d090074..f73710a 100644 --- a/src/ViaFerrea.Core/Rail/Pathfinder.cs +++ b/src/RailEnterprise.Core/Rail/Pathfinder.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Rail; +namespace RailEnterprise.Core.Rail; /// /// Ricerca del percorso più rapido (A*) sul grafo dei binari di una compagnia. Gli stati sono diff --git a/src/ViaFerrea.Core/Rail/RailNetwork.cs b/src/RailEnterprise.Core/Rail/RailNetwork.cs similarity index 99% rename from src/ViaFerrea.Core/Rail/RailNetwork.cs rename to src/RailEnterprise.Core/Rail/RailNetwork.cs index e1f77c4..9dfa0a9 100644 --- a/src/ViaFerrea.Core/Rail/RailNetwork.cs +++ b/src/RailEnterprise.Core/Rail/RailNetwork.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Rail; +namespace RailEnterprise.Core.Rail; /// Punto di aggancio di un'estremità di binario. public readonly record struct AttachPoint(NodeId Node, EdgeId SplitEdge, int SplitIndex, Vec2 Position, double HeightM) diff --git a/src/ViaFerrea.Core/Rail/TrackGeometry.cs b/src/RailEnterprise.Core/Rail/TrackGeometry.cs similarity index 99% rename from src/ViaFerrea.Core/Rail/TrackGeometry.cs rename to src/RailEnterprise.Core/Rail/TrackGeometry.cs index ec8a9f2..8758002 100644 --- a/src/ViaFerrea.Core/Rail/TrackGeometry.cs +++ b/src/RailEnterprise.Core/Rail/TrackGeometry.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Rail; +namespace RailEnterprise.Core.Rail; /// Tratto elementare della linea d'asse: rettilineo o arco di cerchio. public readonly record struct TrackPiece(Vec2 Start, Vec2 End, double Length, bool IsArc, Vec2 Center, double Radius, double StartAngle, double Sweep) diff --git a/src/ViaFerrea.Core/Rail/TrackPlan.cs b/src/RailEnterprise.Core/Rail/TrackPlan.cs similarity index 96% rename from src/ViaFerrea.Core/Rail/TrackPlan.cs rename to src/RailEnterprise.Core/Rail/TrackPlan.cs index 178238f..2d93f2a 100644 --- a/src/ViaFerrea.Core/Rail/TrackPlan.cs +++ b/src/RailEnterprise.Core/Rail/TrackPlan.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Map; -namespace ViaFerrea.Core.Rail; +namespace RailEnterprise.Core.Rail; /// Tipo di opera lungo il tracciato (guida 8.1). public enum WorkKind : byte { Natural = 0, Embankment = 1, Cutting = 2, Bridge = 3, Tunnel = 4 } diff --git a/src/ViaFerrea.Core/Rail/TrackPlanner.cs b/src/RailEnterprise.Core/Rail/TrackPlanner.cs similarity index 99% rename from src/ViaFerrea.Core/Rail/TrackPlanner.cs rename to src/RailEnterprise.Core/Rail/TrackPlanner.cs index ad5a85d..19bf676 100644 --- a/src/ViaFerrea.Core/Rail/TrackPlanner.cs +++ b/src/RailEnterprise.Core/Rail/TrackPlanner.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Map; -namespace ViaFerrea.Core.Rail; +namespace RailEnterprise.Core.Rail; /// Attraversamento di un binario esistente lungo un segmento (T = frazione 0–1). public readonly record struct TrackCrossing(double T, double OtherHeightM, bool Foreign); diff --git a/src/ViaFerrea.Core/Rail/TrackPreview.cs b/src/RailEnterprise.Core/Rail/TrackPreview.cs similarity index 93% rename from src/ViaFerrea.Core/Rail/TrackPreview.cs rename to src/RailEnterprise.Core/Rail/TrackPreview.cs index 9b433fd..4f82284 100644 --- a/src/ViaFerrea.Core/Rail/TrackPreview.cs +++ b/src/RailEnterprise.Core/Rail/TrackPreview.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Map; -namespace ViaFerrea.Core.Rail; +namespace RailEnterprise.Core.Rail; /// /// Ciò che serve al pianificatore oltre al comando: dati, terreno, rete, anno e costi. Il server diff --git a/src/ViaFerrea.Core/Rail/Trains.cs b/src/RailEnterprise.Core/Rail/Trains.cs similarity index 99% rename from src/ViaFerrea.Core/Rail/Trains.cs rename to src/RailEnterprise.Core/Rail/Trains.cs index ad4fd31..9efce1d 100644 --- a/src/ViaFerrea.Core/Rail/Trains.cs +++ b/src/RailEnterprise.Core/Rail/Trains.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Rail; +namespace RailEnterprise.Core.Rail; /// Veicolo posseduto: locomotiva, carro o carrozza. public sealed class Vehicle diff --git a/src/ViaFerrea.Core/ViaFerrea.Core.csproj b/src/RailEnterprise.Core/RailEnterprise.Core.csproj similarity index 75% rename from src/ViaFerrea.Core/ViaFerrea.Core.csproj rename to src/RailEnterprise.Core/RailEnterprise.Core.csproj index fd2dfc7..7c43f59 100644 --- a/src/ViaFerrea.Core/ViaFerrea.Core.csproj +++ b/src/RailEnterprise.Core/RailEnterprise.Core.csproj @@ -4,8 +4,8 @@ net10.0;net8.0 - net10.0 - ViaFerrea.Core + net10.0 + RailEnterprise.Core diff --git a/src/ViaFerrea.Core/Simulation/Ai/AiAgent.cs b/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs similarity index 99% rename from src/ViaFerrea.Core/Simulation/Ai/AiAgent.cs rename to src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs index 389a6e7..c1bf956 100644 --- a/src/ViaFerrea.Core/Simulation/Ai/AiAgent.cs +++ b/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs @@ -1,11 +1,11 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Simulation.Ai; +namespace RailEnterprise.Core.Simulation.Ai; /// /// Agente di una compagnia IA (12.1). Legge solo informazioni pubbliche del mondo e agisce diff --git a/src/ViaFerrea.Core/Simulation/Ai/AiState.cs b/src/RailEnterprise.Core/Simulation/Ai/AiState.cs similarity index 96% rename from src/ViaFerrea.Core/Simulation/Ai/AiState.cs rename to src/RailEnterprise.Core/Simulation/Ai/AiState.cs index 785441c..a09a03e 100644 --- a/src/ViaFerrea.Core/Simulation/Ai/AiState.cs +++ b/src/RailEnterprise.Core/Simulation/Ai/AiState.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Simulation.Ai; +namespace RailEnterprise.Core.Simulation.Ai; /// Tipo di progetto di un'IA: merci da un produttore a un consumatore o pendolari da una città. public enum AiProjectKind : byte { Freight = 0, Commuter = 1 } diff --git a/src/ViaFerrea.Core/Simulation/Ai/AiSystem.cs b/src/RailEnterprise.Core/Simulation/Ai/AiSystem.cs similarity index 97% rename from src/ViaFerrea.Core/Simulation/Ai/AiSystem.cs rename to src/RailEnterprise.Core/Simulation/Ai/AiSystem.cs index 415710a..ed4f51a 100644 --- a/src/ViaFerrea.Core/Simulation/Ai/AiSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Ai/AiSystem.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Simulation.Ai; +namespace RailEnterprise.Core.Simulation.Ai; /// /// Agenti delle compagnie IA (12.1), dopo la borsa: ogni giorno seguono progetti e offerte, una diff --git a/src/ViaFerrea.Core/Simulation/Ai/GridPath.cs b/src/RailEnterprise.Core/Simulation/Ai/GridPath.cs similarity index 99% rename from src/ViaFerrea.Core/Simulation/Ai/GridPath.cs rename to src/RailEnterprise.Core/Simulation/Ai/GridPath.cs index 40465ce..6e78d3d 100644 --- a/src/ViaFerrea.Core/Simulation/Ai/GridPath.cs +++ b/src/RailEnterprise.Core/Simulation/Ai/GridPath.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Map; -namespace ViaFerrea.Core.Simulation.Ai; +namespace RailEnterprise.Core.Simulation.Ai; /// /// Percorso di un nuovo binario per le IA (12.1): Dijkstra sulla griglia delle celle in un diff --git a/src/ViaFerrea.Core/Simulation/ChronicleReport.cs b/src/RailEnterprise.Core/Simulation/ChronicleReport.cs similarity index 95% rename from src/ViaFerrea.Core/Simulation/ChronicleReport.cs rename to src/RailEnterprise.Core/Simulation/ChronicleReport.cs index 8c20ba7..96a2cb9 100644 --- a/src/ViaFerrea.Core/Simulation/ChronicleReport.cs +++ b/src/RailEnterprise.Core/Simulation/ChronicleReport.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Primato della Cronaca finale. public readonly record struct ChronicleRecord(string Title, string Value, int Year); diff --git a/src/ViaFerrea.Core/Simulation/CommandProcessor.cs b/src/RailEnterprise.Core/Simulation/CommandProcessor.cs similarity index 97% rename from src/ViaFerrea.Core/Simulation/CommandProcessor.cs rename to src/RailEnterprise.Core/Simulation/CommandProcessor.cs index 4f58c0b..4a044e5 100644 --- a/src/ViaFerrea.Core/Simulation/CommandProcessor.cs +++ b/src/RailEnterprise.Core/Simulation/CommandProcessor.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Esecuzione dei comandi di gioco con validazione completa: un comando non valido non cambia nulla. public static class CommandProcessor diff --git a/src/ViaFerrea.Core/Simulation/Corporate.cs b/src/RailEnterprise.Core/Simulation/Corporate.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Corporate.cs rename to src/RailEnterprise.Core/Simulation/Corporate.cs index 77a8880..630bd98 100644 --- a/src/ViaFerrea.Core/Simulation/Corporate.cs +++ b/src/RailEnterprise.Core/Simulation/Corporate.cs @@ -1,10 +1,10 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// /// Operazioni societarie (12.2–12.3): prezzo delle azioni, controllo, fusioni, liquidazioni, diff --git a/src/ViaFerrea.Core/Simulation/CorporateCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/CorporateCommandHandlers.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/CorporateCommandHandlers.cs rename to src/RailEnterprise.Core/Simulation/CorporateCommandHandlers.cs index 8057c37..9f279bc 100644 --- a/src/ViaFerrea.Core/Simulation/CorporateCommandHandlers.cs +++ b/src/RailEnterprise.Core/Simulation/CorporateCommandHandlers.cs @@ -1,10 +1,10 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// /// Comandi di borsa (12.2): quotazione, compravendita di azioni, dividendi, offerte pubbliche con le diff --git a/src/ViaFerrea.Core/Simulation/Estimators.cs b/src/RailEnterprise.Core/Simulation/Estimators.cs similarity index 96% rename from src/ViaFerrea.Core/Simulation/Estimators.cs rename to src/RailEnterprise.Core/Simulation/Estimators.cs index 2f26bfa..762773c 100644 --- a/src/ViaFerrea.Core/Simulation/Estimators.cs +++ b/src/RailEnterprise.Core/Simulation/Estimators.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// /// Stimatori economici condivisi da IA e tooltip «perché» (12.1): ricavi per unità e per viaggio, diff --git a/src/ViaFerrea.Core/Simulation/GameEvents.cs b/src/RailEnterprise.Core/Simulation/GameEvents.cs similarity index 96% rename from src/ViaFerrea.Core/Simulation/GameEvents.cs rename to src/RailEnterprise.Core/Simulation/GameEvents.cs index 7762c5d..a5c31da 100644 --- a/src/ViaFerrea.Core/Simulation/GameEvents.cs +++ b/src/RailEnterprise.Core/Simulation/GameEvents.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Gravità di un evento mostrato al giocatore. public enum EventSeverity : byte { Info = 0, Opportunity = 1, Warning = 2, Critical = 3 } diff --git a/src/ViaFerrea.Core/Simulation/ISimSystem.cs b/src/RailEnterprise.Core/Simulation/ISimSystem.cs similarity index 96% rename from src/ViaFerrea.Core/Simulation/ISimSystem.cs rename to src/RailEnterprise.Core/Simulation/ISimSystem.cs index ab9f823..355108d 100644 --- a/src/ViaFerrea.Core/Simulation/ISimSystem.cs +++ b/src/RailEnterprise.Core/Simulation/ISimSystem.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Un sistema della simulazione: chiamato una volta per tick in ordine fisso. public interface ISimSystem diff --git a/src/ViaFerrea.Core/Simulation/IndustryCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/IndustryCommandHandlers.cs similarity index 97% rename from src/ViaFerrea.Core/Simulation/IndustryCommandHandlers.cs rename to src/RailEnterprise.Core/Simulation/IndustryCommandHandlers.cs index 885a86e..bfd5b5f 100644 --- a/src/ViaFerrea.Core/Simulation/IndustryCommandHandlers.cs +++ b/src/RailEnterprise.Core/Simulation/IndustryCommandHandlers.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Comandi delle industrie possedute (sezione 11): acquisto, budget, revisione, ammodernamento, ricambi. public static class IndustryCommandHandlers diff --git a/src/ViaFerrea.Core/Simulation/IndustryPlacer.cs b/src/RailEnterprise.Core/Simulation/IndustryPlacer.cs similarity index 97% rename from src/ViaFerrea.Core/Simulation/IndustryPlacer.cs rename to src/RailEnterprise.Core/Simulation/IndustryPlacer.cs index 29530ac..10ce362 100644 --- a/src/ViaFerrea.Core/Simulation/IndustryPlacer.cs +++ b/src/RailEnterprise.Core/Simulation/IndustryPlacer.cs @@ -1,11 +1,11 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Map; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Creazione e collocazione delle industrie durante la partita (nascita per domanda insoddisfatta). public static class IndustryPlacer diff --git a/src/ViaFerrea.Core/Simulation/MaintenanceCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs similarity index 96% rename from src/ViaFerrea.Core/Simulation/MaintenanceCommandHandlers.cs rename to src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs index 0f8cef7..74944bc 100644 --- a/src/ViaFerrea.Core/Simulation/MaintenanceCommandHandlers.cs +++ b/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs @@ -1,11 +1,11 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Comandi della manutenzione della flotta (10.2–10.3) e delle convenzioni di pendolarismo (9). public static class MaintenanceCommandHandlers diff --git a/src/ViaFerrea.Core/Simulation/RailCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs similarity index 99% rename from src/ViaFerrea.Core/Simulation/RailCommandHandlers.cs rename to src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs index 268a462..93361e9 100644 --- a/src/ViaFerrea.Core/Simulation/RailCommandHandlers.cs +++ b/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Esecuzione dei comandi ferroviari. Ogni gestore valida tutto prima di modificare il mondo. public static class RailCommandHandlers diff --git a/src/ViaFerrea.Core/Simulation/Scenarios/ScenarioFile.cs b/src/RailEnterprise.Core/Simulation/Scenarios/ScenarioFile.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Scenarios/ScenarioFile.cs rename to src/RailEnterprise.Core/Simulation/Scenarios/ScenarioFile.cs index 70102ab..4e71b15 100644 --- a/src/ViaFerrea.Core/Simulation/Scenarios/ScenarioFile.cs +++ b/src/RailEnterprise.Core/Simulation/Scenarios/ScenarioFile.cs @@ -1,6 +1,6 @@ using System.Text.Json.Serialization; -namespace ViaFerrea.Core.Simulation.Scenarios; +namespace RailEnterprise.Core.Simulation.Scenarios; /// /// Scenario costruito a mano (tests/scenarios/*.json): terreno da elementi geometrici, città, diff --git a/src/ViaFerrea.Core/Simulation/Scenarios/ScenarioLoader.cs b/src/RailEnterprise.Core/Simulation/Scenarios/ScenarioLoader.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Scenarios/ScenarioLoader.cs rename to src/RailEnterprise.Core/Simulation/Scenarios/ScenarioLoader.cs index 76e516f..7c0268d 100644 --- a/src/ViaFerrea.Core/Simulation/Scenarios/ScenarioLoader.cs +++ b/src/RailEnterprise.Core/Simulation/Scenarios/ScenarioLoader.cs @@ -1,11 +1,11 @@ using System.Text.Json; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Simulation.Scenarios; +namespace RailEnterprise.Core.Simulation.Scenarios; /// Scenario caricato: mondo pronto e definizioni originali (per i tracciati nominati). public sealed record LoadedScenario(World World, ScenarioFile File) diff --git a/src/ViaFerrea.Core/Simulation/SystemPipeline.cs b/src/RailEnterprise.Core/Simulation/SystemPipeline.cs similarity index 94% rename from src/ViaFerrea.Core/Simulation/SystemPipeline.cs rename to src/RailEnterprise.Core/Simulation/SystemPipeline.cs index cbc4061..193e36e 100644 --- a/src/ViaFerrea.Core/Simulation/SystemPipeline.cs +++ b/src/RailEnterprise.Core/Simulation/SystemPipeline.cs @@ -1,8 +1,8 @@ using System.Diagnostics; -using ViaFerrea.Core.Simulation.Ai; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Simulation.Ai; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// /// Sistemi nell'ordine fisso della guida (sezione 4). I sistemi delle fasi successive si diff --git a/src/ViaFerrea.Core/Simulation/Systems/ClockSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/ClockSystem.cs similarity index 91% rename from src/ViaFerrea.Core/Simulation/Systems/ClockSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/ClockSystem.cs index 4294636..24ca516 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/ClockSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/ClockSystem.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// Primo sistema del tick: calcola una volta gli indicatori di calendario. public sealed class ClockSystem : ISimSystem diff --git a/src/ViaFerrea.Core/Simulation/Systems/CommandSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/CommandSystem.cs similarity index 85% rename from src/ViaFerrea.Core/Simulation/Systems/CommandSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/CommandSystem.cs index a7be557..dc8ffa8 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/CommandSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/CommandSystem.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Commands; +using RailEnterprise.Core.Commands; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// Drena la coda dei comandi a inizio tick e ne registra gli esiti. public sealed class CommandSystem : ISimSystem diff --git a/src/ViaFerrea.Core/Simulation/Systems/ConstructionSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/ConstructionSystem.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Systems/ConstructionSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/ConstructionSystem.cs index ec25783..1bf89d1 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/ConstructionSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/ConstructionSystem.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Cantieri (guida 8.2) e usura dei binari (8.3). Ogni giorno le squadre libere di ogni compagnia diff --git a/src/ViaFerrea.Core/Simulation/Systems/DemandSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/DemandSystem.cs similarity index 95% rename from src/ViaFerrea.Core/Simulation/Systems/DemandSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/DemandSystem.cs index 7e6990a..7174dae 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/DemandSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/DemandSystem.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Domanda giornaliera: consumo desiderato delle città (con elasticità al prezzo), input diff --git a/src/ViaFerrea.Core/Simulation/Systems/EmploymentSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/EmploymentSystem.cs similarity index 99% rename from src/ViaFerrea.Core/Simulation/Systems/EmploymentSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/EmploymentSystem.cs index cc929ab..dfaa2c8 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/EmploymentSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/EmploymentSystem.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Pendolarismo (guida, sezione 9): servizi cittadini, lavoratori in sede, contratti a piedi entro diff --git a/src/ViaFerrea.Core/Simulation/Systems/FinanceSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Systems/FinanceSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs index 3f76ea4..1ccf0ba 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/FinanceSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Finanza delle compagnie: giorni di cassa negativa e bancarotta, rate mensili dei prestiti, diff --git a/src/ViaFerrea.Core/Simulation/Systems/Fleet.cs b/src/RailEnterprise.Core/Simulation/Systems/Fleet.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Systems/Fleet.cs rename to src/RailEnterprise.Core/Simulation/Systems/Fleet.cs index 60cf018..dbb58ac 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/Fleet.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/Fleet.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// Scadenze di un treno in giorni (negative se già scadute). public readonly record struct FleetDues(double Inspection, double Service, double Overhaul, double Condition, bool ConditionIsBrakes); diff --git a/src/ViaFerrea.Core/Simulation/Systems/FleetMaintenanceSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs similarity index 99% rename from src/ViaFerrea.Core/Simulation/Systems/FleetMaintenanceSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs index ec9315f..72f17f2 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/FleetMaintenanceSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Manutenzione della flotta (guida, sezione 10), una volta al giorno: diff --git a/src/ViaFerrea.Core/Simulation/Systems/HashSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/HashSystem.cs similarity index 82% rename from src/ViaFerrea.Core/Simulation/Systems/HashSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/HashSystem.cs index 878d4c2..21a5c31 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/HashSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/HashSystem.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Persistence; +using RailEnterprise.Core.Persistence; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// Ultimo sistema: una volta al giorno calcola l'hash dello stato (resoconto giornaliero e test di determinismo). public sealed class HashSystem : ISimSystem diff --git a/src/ViaFerrea.Core/Simulation/Systems/IndustryMaintenanceSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/IndustryMaintenanceSystem.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Systems/IndustryMaintenanceSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/IndustryMaintenanceSystem.cs index 5d7dd9a..b9b0d2a 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/IndustryMaintenanceSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/IndustryMaintenanceSystem.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Manutenzione degli impianti (guida, sezione 11): usura giornaliera con l'utilizzo, recupero e diff --git a/src/ViaFerrea.Core/Simulation/Systems/IndustryMath.cs b/src/RailEnterprise.Core/Simulation/Systems/IndustryMath.cs similarity index 97% rename from src/ViaFerrea.Core/Simulation/Systems/IndustryMath.cs rename to src/RailEnterprise.Core/Simulation/Systems/IndustryMath.cs index f798797..b279d0a 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/IndustryMath.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/IndustryMath.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// Formule dell'industria condivise da più sistemi (guida 6.3 e 11). public static class IndustryMath diff --git a/src/ViaFerrea.Core/Simulation/Systems/IndustrySystem.cs b/src/RailEnterprise.Core/Simulation/Systems/IndustrySystem.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Systems/IndustrySystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/IndustrySystem.cs index 9a3f576..8f001b4 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/IndustrySystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/IndustrySystem.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Produzione giornaliera delle industrie (guida 6.3), esaurimento dei giacimenti, salari, diff --git a/src/ViaFerrea.Core/Simulation/Systems/LocalTransportSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/LocalTransportSystem.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Systems/LocalTransportSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/LocalTransportSystem.cs index f8595eb..8da860a 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/LocalTransportSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/LocalTransportSystem.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Trasporto locale su strada (carrettieri, ADR 0004): piccole quantità tra produttori, consumatori diff --git a/src/ViaFerrea.Core/Simulation/Systems/MarketSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/MarketSystem.cs similarity index 96% rename from src/ViaFerrea.Core/Simulation/Systems/MarketSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/MarketSystem.cs index cbca298..11b4f76 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/MarketSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/MarketSystem.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Prezzi globali giornalieri (guida 6.3, ADR 0004): diff --git a/src/ViaFerrea.Core/Simulation/Systems/StationSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/StationSystem.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Systems/StationSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/StationSystem.cs index fa6d5a5..4b664e7 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/StationSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/StationSystem.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Stazioni (guida 7): bacini di utenza, industrie servite, merci che passano dalle industrie diff --git a/src/ViaFerrea.Core/Simulation/Systems/StationWork.cs b/src/RailEnterprise.Core/Simulation/Systems/StationWork.cs similarity index 98% rename from src/ViaFerrea.Core/Simulation/Systems/StationWork.cs rename to src/RailEnterprise.Core/Simulation/Systems/StationWork.cs index b5c9400..191055a 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/StationWork.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/StationWork.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Operazioni dei treni in stazione: scarico (consegna con tariffa o trasbordo), carico dei diff --git a/src/ViaFerrea.Core/Simulation/Systems/StockMarketSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/StockMarketSystem.cs similarity index 99% rename from src/ViaFerrea.Core/Simulation/Systems/StockMarketSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/StockMarketSystem.cs index 8df9cc3..6ed76bc 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/StockMarketSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/StockMarketSystem.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Borsa e vita societaria (12.1–12.3), una volta al giorno: prezzi e sentiment, valore delle diff --git a/src/ViaFerrea.Core/Simulation/Systems/Tiers.cs b/src/RailEnterprise.Core/Simulation/Systems/Tiers.cs similarity index 95% rename from src/ViaFerrea.Core/Simulation/Systems/Tiers.cs rename to src/RailEnterprise.Core/Simulation/Systems/Tiers.cs index f6dbd6b..aa79acc 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/Tiers.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/Tiers.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Livelli della compagnia (tiers.json): ogni mese, dopo il rating, una compagnia che soddisfa i diff --git a/src/ViaFerrea.Core/Simulation/Systems/TownSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/TownSystem.cs similarity index 97% rename from src/ViaFerrea.Core/Simulation/Systems/TownSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/TownSystem.cs index 82c1745..05b2ca5 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/TownSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/TownSystem.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Map; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Città: consumo giornaliero e soddisfazione per categoria, crescita mensile, espansione diff --git a/src/ViaFerrea.Core/Simulation/Systems/TrainSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/TrainSystem.cs similarity index 99% rename from src/ViaFerrea.Core/Simulation/Systems/TrainSystem.cs rename to src/RailEnterprise.Core/Simulation/Systems/TrainSystem.cs index 1248f87..b9c249d 100644 --- a/src/ViaFerrea.Core/Simulation/Systems/TrainSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/TrainSystem.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Core.Simulation.Systems; +namespace RailEnterprise.Core.Simulation.Systems; /// /// Marcia dei treni (guida 8.4) con il segnalamento a blocchi: diff --git a/src/ViaFerrea.Core/Simulation/World.cs b/src/RailEnterprise.Core/Simulation/World.cs similarity index 97% rename from src/ViaFerrea.Core/Simulation/World.cs rename to src/RailEnterprise.Core/Simulation/World.cs index 5010a11..093c944 100644 --- a/src/ViaFerrea.Core/Simulation/World.cs +++ b/src/RailEnterprise.Core/Simulation/World.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Time; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Time; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// /// Il mondo di gioco: tutto lo stato della simulazione e il ciclo dei sistemi. diff --git a/src/ViaFerrea.Core/Simulation/WorldFactory.cs b/src/RailEnterprise.Core/Simulation/WorldFactory.cs similarity index 97% rename from src/ViaFerrea.Core/Simulation/WorldFactory.cs rename to src/RailEnterprise.Core/Simulation/WorldFactory.cs index e6b65f4..0ed8897 100644 --- a/src/ViaFerrea.Core/Simulation/WorldFactory.cs +++ b/src/RailEnterprise.Core/Simulation/WorldFactory.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Map; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Creazione di una partita nuova: mappa, entità iniziali, compagnie e contabilità di apertura. public static class WorldFactory diff --git a/src/ViaFerrea.Core/Simulation/WorldSettings.cs b/src/RailEnterprise.Core/Simulation/WorldSettings.cs similarity index 95% rename from src/ViaFerrea.Core/Simulation/WorldSettings.cs rename to src/RailEnterprise.Core/Simulation/WorldSettings.cs index 3663708..d830cf8 100644 --- a/src/ViaFerrea.Core/Simulation/WorldSettings.cs +++ b/src/RailEnterprise.Core/Simulation/WorldSettings.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Simulation; +namespace RailEnterprise.Core.Simulation; /// Sistemi del gioco infinito attivabili alla creazione della partita (guida, sezione 13). [Flags] diff --git a/src/ViaFerrea.Core/Time/Calendar.cs b/src/RailEnterprise.Core/Time/Calendar.cs similarity index 97% rename from src/ViaFerrea.Core/Time/Calendar.cs rename to src/RailEnterprise.Core/Time/Calendar.cs index f511dc1..6dbab26 100644 --- a/src/ViaFerrea.Core/Time/Calendar.cs +++ b/src/RailEnterprise.Core/Time/Calendar.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Core.Time; +namespace RailEnterprise.Core.Time; /// /// Costanti del calendario lette da balance.json (time): tick per giorno, giorni per mese, diff --git a/src/ViaFerrea.Core/Time/GameClock.cs b/src/RailEnterprise.Core/Time/GameClock.cs similarity index 97% rename from src/ViaFerrea.Core/Time/GameClock.cs rename to src/RailEnterprise.Core/Time/GameClock.cs index 3eea42b..940825c 100644 --- a/src/ViaFerrea.Core/Time/GameClock.cs +++ b/src/RailEnterprise.Core/Time/GameClock.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Core.Time; +namespace RailEnterprise.Core.Time; /// /// Orologio della simulazione: conta i tick e segnala i cambi di giorno, mese, trimestre e anno. diff --git a/src/ViaFerrea.Protocol/Client/BridgeSiteFinder.cs b/src/RailEnterprise.Protocol/Client/BridgeSiteFinder.cs similarity index 86% rename from src/ViaFerrea.Protocol/Client/BridgeSiteFinder.cs rename to src/RailEnterprise.Protocol/Client/BridgeSiteFinder.cs index 5ec7674..521b087 100644 --- a/src/ViaFerrea.Protocol/Client/BridgeSiteFinder.cs +++ b/src/RailEnterprise.Protocol/Client/BridgeSiteFinder.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Protocol.Client; +namespace RailEnterprise.Protocol.Client; /// -/// Collaudi (viaferrea-tools smoke, pilota automatico del client): cerca sulla copia locale del +/// Collaudi (railenterprise-tools smoke, pilota automatico del client): cerca sulla copia locale del /// terreno un attraversamento di fiume rettilineo di 1,5–2,5 km con estremità e deposito su /// terreno libero e un'anteprima valida con ponte. /// diff --git a/src/ViaFerrea.Protocol/Client/ClientWorld.cs b/src/RailEnterprise.Protocol/Client/ClientWorld.cs similarity index 98% rename from src/ViaFerrea.Protocol/Client/ClientWorld.cs rename to src/RailEnterprise.Protocol/Client/ClientWorld.cs index 6c25648..007204c 100644 --- a/src/ViaFerrea.Protocol/Client/ClientWorld.cs +++ b/src/RailEnterprise.Protocol/Client/ClientWorld.cs @@ -1,11 +1,11 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Time; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Time; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Protocol.Client; +namespace RailEnterprise.Protocol.Client; /// /// Copia locale del mondo costruita dai messaggi del server: terreno a chunk, entità, rete dei diff --git a/src/ViaFerrea.Protocol/Client/ProtocolClient.cs b/src/RailEnterprise.Protocol/Client/ProtocolClient.cs similarity index 97% rename from src/ViaFerrea.Protocol/Client/ProtocolClient.cs rename to src/RailEnterprise.Protocol/Client/ProtocolClient.cs index 1e8b6b5..39c528e 100644 --- a/src/ViaFerrea.Protocol/Client/ProtocolClient.cs +++ b/src/RailEnterprise.Protocol/Client/ProtocolClient.cs @@ -1,9 +1,9 @@ using System.Net.WebSockets; using System.Threading.Channels; -using ViaFerrea.Core.Commands; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Core.Commands; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Protocol.Client; +namespace RailEnterprise.Protocol.Client; /// Il server ha rifiutato la sessione. public sealed class SessionRejectedException(Reject reject) : Exception($"{reject.Code}: {reject.Reason}") diff --git a/src/ViaFerrea.Protocol/CommandCodec.cs b/src/RailEnterprise.Protocol/CommandCodec.cs similarity index 98% rename from src/ViaFerrea.Protocol/CommandCodec.cs rename to src/RailEnterprise.Protocol/CommandCodec.cs index 7ac0a87..d597370 100644 --- a/src/ViaFerrea.Protocol/CommandCodec.cs +++ b/src/RailEnterprise.Protocol/CommandCodec.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Protocol; +namespace RailEnterprise.Protocol; /// /// Codifica del payload dei comandi (Command.type = ). I campi seguono diff --git a/src/ViaFerrea.Protocol/CommandLogFile.cs b/src/RailEnterprise.Protocol/CommandLogFile.cs similarity index 87% rename from src/ViaFerrea.Protocol/CommandLogFile.cs rename to src/RailEnterprise.Protocol/CommandLogFile.cs index 287293e..26c5fb2 100644 --- a/src/ViaFerrea.Protocol/CommandLogFile.cs +++ b/src/RailEnterprise.Protocol/CommandLogFile.cs @@ -1,17 +1,17 @@ using System.Buffers.Binary; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Protocol; +namespace RailEnterprise.Protocol; /// -/// Registro dei comandi per il replay: intestazione «VFCL» + versione, poi record +/// Registro dei comandi per il replay: intestazione «RECL» + versione, poi record /// [u32 lunghezza][i64 tick][i32 emittente][u32 seq][u16 tipo][payload] con il payload -/// del protocollo. Il server lo scrive con --record, viaferrea-tools replay lo rilegge. +/// del protocollo. Il server lo scrive con --record, railenterprise-tools replay lo rilegge. /// public static class CommandLogFile { - private static ReadOnlySpan Magic => "VFCL"u8; + private static ReadOnlySpan Magic => "RECL"u8; public const ushort Version = 1; public static void WriteHeader(Stream s) @@ -37,7 +37,7 @@ public static class CommandLogFile public static List<(long Tick, GameCommand Command)> ReadAll(byte[] file) { - if (file.Length < 6 || !file.AsSpan(0, 4).SequenceEqual(Magic)) throw new ProtocolException("non è un registro di comandi di Via Ferrea"); + if (file.Length < 6 || !file.AsSpan(0, 4).SequenceEqual(Magic)) throw new ProtocolException("non è un registro di comandi di Rail Enterprise"); ushort version = BinaryPrimitives.ReadUInt16LittleEndian(file.AsSpan(4)); if (version > Version) throw new ProtocolException($"registro di versione più recente ({version})"); var list = new List<(long, GameCommand)>(); diff --git a/src/ViaFerrea.Protocol/Frame.cs b/src/RailEnterprise.Protocol/Frame.cs similarity index 96% rename from src/ViaFerrea.Protocol/Frame.cs rename to src/RailEnterprise.Protocol/Frame.cs index 0dbb320..a58342c 100644 --- a/src/ViaFerrea.Protocol/Frame.cs +++ b/src/RailEnterprise.Protocol/Frame.cs @@ -1,7 +1,7 @@ using System.Buffers.Binary; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Protocol; +namespace RailEnterprise.Protocol; /// /// Frame [u32 length][u16 messageId][payload], little endian; length conta messageId e diff --git a/src/ViaFerrea.Protocol/Message.cs b/src/RailEnterprise.Protocol/Message.cs similarity index 97% rename from src/ViaFerrea.Protocol/Message.cs rename to src/RailEnterprise.Protocol/Message.cs index 47e758a..db52e1d 100644 --- a/src/ViaFerrea.Protocol/Message.cs +++ b/src/RailEnterprise.Protocol/Message.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Protocol; +namespace RailEnterprise.Protocol; /// Identificativi stabili dei messaggi (PROTOCOL.md): 1–99 dal client, 101–199 dal server. public enum MessageId : ushort diff --git a/src/ViaFerrea.Protocol/Messages/ClientMessages.cs b/src/RailEnterprise.Protocol/Messages/ClientMessages.cs similarity index 98% rename from src/ViaFerrea.Protocol/Messages/ClientMessages.cs rename to src/RailEnterprise.Protocol/Messages/ClientMessages.cs index dda34c8..a19879c 100644 --- a/src/ViaFerrea.Protocol/Messages/ClientMessages.cs +++ b/src/RailEnterprise.Protocol/Messages/ClientMessages.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Commands; +using RailEnterprise.Core.Commands; -namespace ViaFerrea.Protocol.Messages; +namespace RailEnterprise.Protocol.Messages; /// Apertura della sessione: versione, token, sessione da riprendere (0 = nuova) e hash dei dati del client. public sealed class Hello : IMessage diff --git a/src/ViaFerrea.Protocol/Messages/CorporateMessages.cs b/src/RailEnterprise.Protocol/Messages/CorporateMessages.cs similarity index 99% rename from src/ViaFerrea.Protocol/Messages/CorporateMessages.cs rename to src/RailEnterprise.Protocol/Messages/CorporateMessages.cs index e36aec9..597b51b 100644 --- a/src/ViaFerrea.Protocol/Messages/CorporateMessages.cs +++ b/src/RailEnterprise.Protocol/Messages/CorporateMessages.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Protocol.Messages; +namespace RailEnterprise.Protocol.Messages; // Messaggi della fase F5: scheda di una compagnia (soci e storico), scheda del proprietario di // un'industria, Cronaca finale. Arrivano solo su richiesta (RequestDetail) o, la Cronaca, alla fine diff --git a/src/ViaFerrea.Protocol/Messages/MessageCodec.cs b/src/RailEnterprise.Protocol/Messages/MessageCodec.cs similarity index 97% rename from src/ViaFerrea.Protocol/Messages/MessageCodec.cs rename to src/RailEnterprise.Protocol/Messages/MessageCodec.cs index 3f4f9b7..3fdd6b3 100644 --- a/src/ViaFerrea.Protocol/Messages/MessageCodec.cs +++ b/src/RailEnterprise.Protocol/Messages/MessageCodec.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Protocol.Messages; +namespace RailEnterprise.Protocol.Messages; /// Decodifica per id: l'unico punto in cui un id diventa un tipo. public static class MessageCodec diff --git a/src/ViaFerrea.Protocol/Messages/Records.cs b/src/RailEnterprise.Protocol/Messages/Records.cs similarity index 99% rename from src/ViaFerrea.Protocol/Messages/Records.cs rename to src/RailEnterprise.Protocol/Messages/Records.cs index 24e41a3..a1dfa3d 100644 --- a/src/ViaFerrea.Protocol/Messages/Records.cs +++ b/src/RailEnterprise.Protocol/Messages/Records.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; -namespace ViaFerrea.Protocol.Messages; +namespace RailEnterprise.Protocol.Messages; // Record delle entità inviati al client. Ogni record ha Write/Read e un byte di estensione finale. diff --git a/src/ViaFerrea.Protocol/Messages/ServerMessages.cs b/src/RailEnterprise.Protocol/Messages/ServerMessages.cs similarity index 99% rename from src/ViaFerrea.Protocol/Messages/ServerMessages.cs rename to src/RailEnterprise.Protocol/Messages/ServerMessages.cs index 578e037..cb25e90 100644 --- a/src/ViaFerrea.Protocol/Messages/ServerMessages.cs +++ b/src/RailEnterprise.Protocol/Messages/ServerMessages.cs @@ -1,7 +1,7 @@ using System.IO.Compression; -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Protocol.Messages; +namespace RailEnterprise.Protocol.Messages; /// Codici di . public enum RejectCode : ushort { ProtocolVersion = 1, BadToken = 2, DataMismatch = 3, ServerFull = 4, NoGame = 5 } diff --git a/src/ViaFerrea.Protocol/ViaFerrea.Protocol.csproj b/src/RailEnterprise.Protocol/RailEnterprise.Protocol.csproj similarity index 65% rename from src/ViaFerrea.Protocol/ViaFerrea.Protocol.csproj rename to src/RailEnterprise.Protocol/RailEnterprise.Protocol.csproj index dade18a..83bec6f 100644 --- a/src/ViaFerrea.Protocol/ViaFerrea.Protocol.csproj +++ b/src/RailEnterprise.Protocol/RailEnterprise.Protocol.csproj @@ -4,12 +4,12 @@ net10.0;net8.0 - net10.0 - ViaFerrea.Protocol + net10.0 + RailEnterprise.Protocol - + diff --git a/src/ViaFerrea.Protocol/SpanReader.cs b/src/RailEnterprise.Protocol/SpanReader.cs similarity index 97% rename from src/ViaFerrea.Protocol/SpanReader.cs rename to src/RailEnterprise.Protocol/SpanReader.cs index 448af26..d40b30c 100644 --- a/src/ViaFerrea.Protocol/SpanReader.cs +++ b/src/RailEnterprise.Protocol/SpanReader.cs @@ -1,8 +1,8 @@ using System.Buffers.Binary; using System.Text; -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Protocol; +namespace RailEnterprise.Protocol; /// Errore di decodifica: frame troncato, valore fuori dai limiti o messaggio sconosciuto. public sealed class ProtocolException(string message) : Exception(message); diff --git a/src/ViaFerrea.Protocol/SpanWriter.cs b/src/RailEnterprise.Protocol/SpanWriter.cs similarity index 97% rename from src/ViaFerrea.Protocol/SpanWriter.cs rename to src/RailEnterprise.Protocol/SpanWriter.cs index 1133a0c..fb908c5 100644 --- a/src/ViaFerrea.Protocol/SpanWriter.cs +++ b/src/RailEnterprise.Protocol/SpanWriter.cs @@ -1,8 +1,8 @@ using System.Buffers.Binary; using System.Text; -using ViaFerrea.Core.Common; +using RailEnterprise.Core.Common; -namespace ViaFerrea.Protocol; +namespace RailEnterprise.Protocol; /// /// Scrittore binario little endian su un buffer che cresce. Le lunghezze e i conteggi sono diff --git a/src/ViaFerrea.Server/GameHost.cs b/src/RailEnterprise.Server/GameHost.cs similarity index 99% rename from src/ViaFerrea.Server/GameHost.cs rename to src/RailEnterprise.Server/GameHost.cs index ce5a76f..422fb65 100644 --- a/src/ViaFerrea.Server/GameHost.cs +++ b/src/RailEnterprise.Server/GameHost.cs @@ -3,14 +3,14 @@ using System.Diagnostics; using System.Globalization; using System.Security.Cryptography; using System.Text; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Protocol; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Server; +namespace RailEnterprise.Server; /// /// Ospita la partita: il mondo appartiene al thread del ciclo di gioco, che esegue i tick con un diff --git a/src/ViaFerrea.Server/Program.cs b/src/RailEnterprise.Server/Program.cs similarity index 94% rename from src/ViaFerrea.Server/Program.cs rename to src/RailEnterprise.Server/Program.cs index 2409575..899e5f1 100644 --- a/src/ViaFerrea.Server/Program.cs +++ b/src/RailEnterprise.Server/Program.cs @@ -2,14 +2,14 @@ using System.Net.Http; using System.Text.Json.Serialization; using Microsoft.AspNetCore.Hosting.Server; using Microsoft.AspNetCore.Hosting.Server.Features; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Simulation; -using ProtocolSaveInfo = ViaFerrea.Protocol.Messages.SaveInfo; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Simulation; +using ProtocolSaveInfo = RailEnterprise.Protocol.Messages.SaveInfo; -namespace ViaFerrea.Server; +namespace RailEnterprise.Server; /// -/// Server autorevole di Via Ferrea: Kestrel con WebSocket su /ws, API HTTP (/health, /metrics, +/// Server autorevole di Rail Enterprise: Kestrel con WebSocket su /ws, API HTTP (/health, /metrics, /// /api/saves), ciclo di gioco su un thread dedicato, log JSON su stdout. /// public static class ServerProgram @@ -53,7 +53,7 @@ public static class ServerProgram }); var app = builder.Build(); - var log = app.Services.GetRequiredService().CreateLogger("ViaFerrea.Server"); + var log = app.Services.GetRequiredService().CreateLogger("RailEnterprise.Server"); data ??= GameData.LoadDefault(); log.LogInformation("Dati caricati: hash {Hash:x16}", data.Hash); var host = new GameHost(config, data, log, world); diff --git a/src/ViaFerrea.Server/Projection.cs b/src/RailEnterprise.Server/Projection.cs similarity index 98% rename from src/ViaFerrea.Server/Projection.cs rename to src/RailEnterprise.Server/Projection.cs index b5c2a50..f190b56 100644 --- a/src/ViaFerrea.Server/Projection.cs +++ b/src/RailEnterprise.Server/Projection.cs @@ -1,13 +1,13 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; -using ViaFerrea.Protocol; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Server; +namespace RailEnterprise.Server; /// /// Proiezione del mondo autorevole nei record del protocollo. Gira sul thread del ciclo di gioco: diff --git a/src/ViaFerrea.Server/ViaFerrea.Server.csproj b/src/RailEnterprise.Server/RailEnterprise.Server.csproj similarity index 66% rename from src/ViaFerrea.Server/ViaFerrea.Server.csproj rename to src/RailEnterprise.Server/RailEnterprise.Server.csproj index 346d8eb..d0c0727 100644 --- a/src/ViaFerrea.Server/ViaFerrea.Server.csproj +++ b/src/RailEnterprise.Server/RailEnterprise.Server.csproj @@ -3,12 +3,12 @@ net10.0 - ViaFerrea.Server + RailEnterprise.Server - - + + diff --git a/src/ViaFerrea.Server/SaveStore.cs b/src/RailEnterprise.Server/SaveStore.cs similarity index 92% rename from src/ViaFerrea.Server/SaveStore.cs rename to src/RailEnterprise.Server/SaveStore.cs index 237877b..a334577 100644 --- a/src/ViaFerrea.Server/SaveStore.cs +++ b/src/RailEnterprise.Server/SaveStore.cs @@ -1,13 +1,13 @@ using System.Globalization; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Persistence; -using ViaFerrea.Core.Simulation; -using ProtocolSaveInfo = ViaFerrea.Protocol.Messages.SaveInfo; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Core.Simulation; +using ProtocolSaveInfo = RailEnterprise.Protocol.Messages.SaveInfo; -namespace ViaFerrea.Server; +namespace RailEnterprise.Server; /// -/// Salvataggi in $VF_DATA_DIR/saves: file .vfsave; i salvataggi automatici ruotano +/// Salvataggi in $RE_DATA_DIR/saves: file .vfsave; i salvataggi automatici ruotano /// sugli ultimi cinque. L'id di un salvataggio è il nome del file senza estensione. /// public sealed class SaveStore(string directory, string gameVersion) diff --git a/src/ViaFerrea.Server/ServerConfig.cs b/src/RailEnterprise.Server/ServerConfig.cs similarity index 71% rename from src/ViaFerrea.Server/ServerConfig.cs rename to src/RailEnterprise.Server/ServerConfig.cs index 3d99110..1006d93 100644 --- a/src/ViaFerrea.Server/ServerConfig.cs +++ b/src/RailEnterprise.Server/ServerConfig.cs @@ -1,6 +1,6 @@ using System.Collections; -namespace ViaFerrea.Server; +namespace RailEnterprise.Server; /// /// Configurazione del server dalle variabili d'ambiente (sezione 14.2) e dagli argomenti @@ -20,7 +20,7 @@ public sealed class ServerConfig /// Processo locale figlio del client: porta casuale su 127.0.0.1, stampa «LISTENING porta». public bool Local { get; init; } public bool HealthCheck { get; init; } - /// File in cui registrare i comandi eseguiti (per viaferrea-tools replay). + /// File in cui registrare i comandi eseguiti (per railenterprise-tools replay). public string? RecordPath { get; init; } /// Numero massimo di sessioni contemporanee. public int MaxSessions { get; init; } = 16; @@ -39,22 +39,22 @@ public sealed class ServerConfig return null; } bool local = args.Contains("--local"); - string dataDir = Arg("--data") ?? Env("VF_DATA_DIR") - ?? (local ? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "ViaFerrea") : "/data"); + string dataDir = Arg("--data") ?? Env("RE_DATA_DIR") + ?? (local ? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "RailEnterprise") : "/data"); return new ServerConfig { Local = local, HealthCheck = args.Contains("--healthcheck"), - RecordPath = Arg("--record") ?? Env("VF_RECORD"), - Port = int.TryParse(Arg("--port") ?? Env("VF_PORT"), out int port) ? port : 7400, - Token = Arg("--token") ?? Env("VF_TOKEN") ?? "", + RecordPath = Arg("--record") ?? Env("RE_RECORD"), + Port = int.TryParse(Arg("--port") ?? Env("RE_PORT"), out int port) ? port : 7400, + Token = Arg("--token") ?? Env("RE_TOKEN") ?? "", DataDir = dataDir, - TickMs = int.TryParse(Env("VF_TICK_MS"), out int tick) && tick > 0 ? tick : 50, - AutosaveMinutes = int.TryParse(Env("VF_AUTOSAVE_MIN"), out int auto) ? auto : 10, - Seed = ulong.TryParse(Env("VF_SEED"), out ulong seed) ? seed : 1, - MapSizeKm = int.TryParse(Env("VF_MAP_SIZE"), out int size) ? size : 128, - Difficulty = Env("VF_DIFFICULTY") ?? "imprenditore", - LogLevel = Env("VF_LOG_LEVEL") ?? "Information", + TickMs = int.TryParse(Env("RE_TICK_MS"), out int tick) && tick > 0 ? tick : 50, + AutosaveMinutes = int.TryParse(Env("RE_AUTOSAVE_MIN"), out int auto) ? auto : 10, + Seed = ulong.TryParse(Env("RE_SEED"), out ulong seed) ? seed : 1, + MapSizeKm = int.TryParse(Env("RE_MAP_SIZE"), out int size) ? size : 128, + Difficulty = Env("RE_DIFFICULTY") ?? "imprenditore", + LogLevel = Env("RE_LOG_LEVEL") ?? "Information", }; } } diff --git a/src/ViaFerrea.Server/Session.cs b/src/RailEnterprise.Server/Session.cs similarity index 96% rename from src/ViaFerrea.Server/Session.cs rename to src/RailEnterprise.Server/Session.cs index da011d2..b686db7 100644 --- a/src/ViaFerrea.Server/Session.cs +++ b/src/RailEnterprise.Server/Session.cs @@ -1,10 +1,10 @@ using System.Net.WebSockets; using System.Threading.Channels; -using ViaFerrea.Core.Common; -using ViaFerrea.Protocol; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Core.Common; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Server; +namespace RailEnterprise.Server; /// /// Sessione di un client. La coda d'invio ha due classi: i messaggi affidabili (chunk, entità, diff --git a/src/ViaFerrea.Server/SessionEndpoint.cs b/src/RailEnterprise.Server/SessionEndpoint.cs similarity index 97% rename from src/ViaFerrea.Server/SessionEndpoint.cs rename to src/RailEnterprise.Server/SessionEndpoint.cs index d946b6c..1527f1a 100644 --- a/src/ViaFerrea.Server/SessionEndpoint.cs +++ b/src/RailEnterprise.Server/SessionEndpoint.cs @@ -1,8 +1,8 @@ using System.Net.WebSockets; -using ViaFerrea.Protocol; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Server; +namespace RailEnterprise.Server; /// /// Endpoint WebSocket /ws: il primo frame dev'essere un Hello (entro 10 s); poi un task diff --git a/src/ViaFerrea.Server/appsettings.json b/src/RailEnterprise.Server/appsettings.json similarity index 100% rename from src/ViaFerrea.Server/appsettings.json rename to src/RailEnterprise.Server/appsettings.json diff --git a/src/ViaFerrea.Tools/BmpWriter.cs b/src/RailEnterprise.Tools/BmpWriter.cs similarity index 97% rename from src/ViaFerrea.Tools/BmpWriter.cs rename to src/RailEnterprise.Tools/BmpWriter.cs index f68a6f4..cc9ea72 100644 --- a/src/ViaFerrea.Tools/BmpWriter.cs +++ b/src/RailEnterprise.Tools/BmpWriter.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Tools; +namespace RailEnterprise.Tools; /// Scrittura di bitmap BMP a 24 bit senza dipendenze. public static class BmpWriter diff --git a/src/ViaFerrea.Tools/CommandLine.cs b/src/RailEnterprise.Tools/CommandLine.cs similarity index 96% rename from src/ViaFerrea.Tools/CommandLine.cs rename to src/RailEnterprise.Tools/CommandLine.cs index 691a312..f9ea6cf 100644 --- a/src/ViaFerrea.Tools/CommandLine.cs +++ b/src/RailEnterprise.Tools/CommandLine.cs @@ -1,6 +1,6 @@ using System.Globalization; -namespace ViaFerrea.Tools; +namespace RailEnterprise.Tools; /// Analisi minima degli argomenti: «--chiave valore» e opzioni booleane «--flag». public sealed class CommandLine @@ -73,7 +73,7 @@ public sealed class CommandLine } } -/// Un comando di viaferrea-tools. +/// Un comando di railenterprise-tools. public interface IToolCommand { string Name { get; } diff --git a/src/ViaFerrea.Tools/Commands/BenchCommand.cs b/src/RailEnterprise.Tools/Commands/BenchCommand.cs similarity index 97% rename from src/ViaFerrea.Tools/Commands/BenchCommand.cs rename to src/RailEnterprise.Tools/Commands/BenchCommand.cs index a807790..9da3feb 100644 --- a/src/ViaFerrea.Tools/Commands/BenchCommand.cs +++ b/src/RailEnterprise.Tools/Commands/BenchCommand.cs @@ -1,13 +1,13 @@ using System.Diagnostics; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Tools.Commands; +namespace RailEnterprise.Tools.Commands; /// /// bench: costruisce con i comandi del protocollo una rete di linee a doppio binario con segnali, diff --git a/src/ViaFerrea.Tools/Commands/GenMapCommand.cs b/src/RailEnterprise.Tools/Commands/GenMapCommand.cs similarity index 95% rename from src/ViaFerrea.Tools/Commands/GenMapCommand.cs rename to src/RailEnterprise.Tools/Commands/GenMapCommand.cs index 55afe55..38c8116 100644 --- a/src/ViaFerrea.Tools/Commands/GenMapCommand.cs +++ b/src/RailEnterprise.Tools/Commands/GenMapCommand.cs @@ -1,8 +1,8 @@ using System.Diagnostics; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Map; -namespace ViaFerrea.Tools.Commands; +namespace RailEnterprise.Tools.Commands; /// genmap --seed --size --out mappa.bmp: genera una mappa e ne scrive un'immagine di controllo. public sealed class GenMapCommand : IToolCommand diff --git a/src/ViaFerrea.Tools/Commands/ProfileCommand.cs b/src/RailEnterprise.Tools/Commands/ProfileCommand.cs similarity index 95% rename from src/ViaFerrea.Tools/Commands/ProfileCommand.cs rename to src/RailEnterprise.Tools/Commands/ProfileCommand.cs index 3c37054..681f3fe 100644 --- a/src/ViaFerrea.Tools/Commands/ProfileCommand.cs +++ b/src/RailEnterprise.Tools/Commands/ProfileCommand.cs @@ -1,13 +1,13 @@ using System.Globalization; using System.Text; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Scenarios; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Scenarios; -namespace ViaFerrea.Tools.Commands; +namespace RailEnterprise.Tools.Commands; /// /// profile: pianifica un tracciato e scrive il profilo campionato ogni 25 m in CSV (separatore «;»), diff --git a/src/ViaFerrea.Tools/Commands/ReplayCommand.cs b/src/RailEnterprise.Tools/Commands/ReplayCommand.cs similarity index 93% rename from src/ViaFerrea.Tools/Commands/ReplayCommand.cs rename to src/RailEnterprise.Tools/Commands/ReplayCommand.cs index b36c3ea..d5881c7 100644 --- a/src/ViaFerrea.Tools/Commands/ReplayCommand.cs +++ b/src/RailEnterprise.Tools/Commands/ReplayCommand.cs @@ -1,9 +1,9 @@ using System.Diagnostics; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Persistence; -using ViaFerrea.Protocol; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Protocol; -namespace ViaFerrea.Tools.Commands; +namespace RailEnterprise.Tools.Commands; /// /// replay: carica un salvataggio, riapplica i comandi registrati dal server (--record) ai diff --git a/src/ViaFerrea.Tools/Commands/SimulateCommand.cs b/src/RailEnterprise.Tools/Commands/SimulateCommand.cs similarity index 96% rename from src/ViaFerrea.Tools/Commands/SimulateCommand.cs rename to src/RailEnterprise.Tools/Commands/SimulateCommand.cs index 15cfe8e..0bc16b4 100644 --- a/src/ViaFerrea.Tools/Commands/SimulateCommand.cs +++ b/src/RailEnterprise.Tools/Commands/SimulateCommand.cs @@ -1,13 +1,13 @@ using System.Diagnostics; using System.Globalization; using System.Text; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Persistence; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; -namespace ViaFerrea.Tools.Commands; +namespace RailEnterprise.Tools.Commands; /// /// simulate: fa girare il mondo per N anni senza client e scrive i KPI annuali in CSV diff --git a/src/ViaFerrea.Tools/Commands/SmokeCommand.cs b/src/RailEnterprise.Tools/Commands/SmokeCommand.cs similarity index 96% rename from src/ViaFerrea.Tools/Commands/SmokeCommand.cs rename to src/RailEnterprise.Tools/Commands/SmokeCommand.cs index e1fa16a..a105da0 100644 --- a/src/ViaFerrea.Tools/Commands/SmokeCommand.cs +++ b/src/RailEnterprise.Tools/Commands/SmokeCommand.cs @@ -1,14 +1,14 @@ using System.Diagnostics; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Rail; -using ViaFerrea.Protocol; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; -namespace ViaFerrea.Tools.Commands; +namespace RailEnterprise.Tools.Commands; /// /// smoke: collaudo di un server in esecuzione (locale o in Docker) con un client vero. Trova un diff --git a/src/ViaFerrea.Tools/Commands/ValidateDataCommand.cs b/src/RailEnterprise.Tools/Commands/ValidateDataCommand.cs similarity index 94% rename from src/ViaFerrea.Tools/Commands/ValidateDataCommand.cs rename to src/RailEnterprise.Tools/Commands/ValidateDataCommand.cs index 92dbf99..a988245 100644 --- a/src/ViaFerrea.Tools/Commands/ValidateDataCommand.cs +++ b/src/RailEnterprise.Tools/Commands/ValidateDataCommand.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Tools.Commands; +namespace RailEnterprise.Tools.Commands; /// validate-data [--data cartella]: valida schema e semantica di tutti i file dati. public sealed class ValidateDataCommand : IToolCommand diff --git a/src/ViaFerrea.Tools/MapRenderer.cs b/src/RailEnterprise.Tools/MapRenderer.cs similarity index 98% rename from src/ViaFerrea.Tools/MapRenderer.cs rename to src/RailEnterprise.Tools/MapRenderer.cs index a968a44..7a15985 100644 --- a/src/ViaFerrea.Tools/MapRenderer.cs +++ b/src/RailEnterprise.Tools/MapRenderer.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Map; -namespace ViaFerrea.Tools; +namespace RailEnterprise.Tools; /// /// Rendering di controllo della mappa con la palette dell'immagine di riferimento 05: diff --git a/src/ViaFerrea.Tools/Program.cs b/src/RailEnterprise.Tools/Program.cs similarity index 79% rename from src/ViaFerrea.Tools/Program.cs rename to src/RailEnterprise.Tools/Program.cs index 7a1b1f9..f701433 100644 --- a/src/ViaFerrea.Tools/Program.cs +++ b/src/RailEnterprise.Tools/Program.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Tools.Commands; +using RailEnterprise.Tools.Commands; -namespace ViaFerrea.Tools; +namespace RailEnterprise.Tools; -/// Strumenti da riga di comando di Via Ferrea. +/// Strumenti da riga di comando di Rail Enterprise. public static class ToolsProgram { private static readonly IToolCommand[] Commands = @@ -37,14 +37,14 @@ public static class ToolsProgram catch (ArgumentException ex) { Console.Error.WriteLine($"{command.Name}: {ex.Message}"); - Console.Error.WriteLine($"uso: viaferrea-tools {command.Usage}"); + Console.Error.WriteLine($"uso: railenterprise-tools {command.Usage}"); return 2; } } private static void PrintHelp() { - Console.WriteLine("viaferrea-tools [opzioni]"); + Console.WriteLine("railenterprise-tools [opzioni]"); foreach (var c in Commands) Console.WriteLine($" {c.Usage}"); } } diff --git a/src/ViaFerrea.Tools/ViaFerrea.Tools.csproj b/src/RailEnterprise.Tools/RailEnterprise.Tools.csproj similarity index 59% rename from src/ViaFerrea.Tools/ViaFerrea.Tools.csproj rename to src/RailEnterprise.Tools/RailEnterprise.Tools.csproj index 6aaa774..de78243 100644 --- a/src/ViaFerrea.Tools/ViaFerrea.Tools.csproj +++ b/src/RailEnterprise.Tools/RailEnterprise.Tools.csproj @@ -4,13 +4,13 @@ Exe net10.0 - viaferrea-tools - ViaFerrea.Tools + railenterprise-tools + RailEnterprise.Tools - - + + diff --git a/src/ViaFerrea.Tools/Scenarios/ScenarioLoader.cs b/src/RailEnterprise.Tools/Scenarios/ScenarioLoader.cs similarity index 87% rename from src/ViaFerrea.Tools/Scenarios/ScenarioLoader.cs rename to src/RailEnterprise.Tools/Scenarios/ScenarioLoader.cs index b0f4fd8..47102a8 100644 --- a/src/ViaFerrea.Tools/Scenarios/ScenarioLoader.cs +++ b/src/RailEnterprise.Tools/Scenarios/ScenarioLoader.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Tools.Scenarios; +namespace RailEnterprise.Tools.Scenarios; /// Accesso agli scenari di Core dagli strumenti. public static class ScenarioLoader diff --git a/tests/ViaFerrea.Tests/Core/CommonTests.cs b/tests/RailEnterprise.Tests/Core/CommonTests.cs similarity index 95% rename from tests/ViaFerrea.Tests/Core/CommonTests.cs rename to tests/RailEnterprise.Tests/Core/CommonTests.cs index 4a99cf4..08160ec 100644 --- a/tests/ViaFerrea.Tests/Core/CommonTests.cs +++ b/tests/RailEnterprise.Tests/Core/CommonTests.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Common; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Basics; +namespace RailEnterprise.Tests.Basics; public static class CommonTests { @@ -36,7 +36,7 @@ public static class CommonTests Assert.Equal(0xef46db3751d8e999UL, XxHash64.Hash([])); Assert.Equal(0xd24ec4f1a98c6e5bUL, XxHash64.Hash("a"u8)); Assert.Equal(0x44bc2cf5ad770999UL, XxHash64.Hash("abc"u8)); - Assert.Equal(0x7e13e2793f7d6198UL, XxHash64.Hash("Via Ferrea"u8)); + Assert.Equal(0x81cf4b9562ee9c31UL, XxHash64.Hash("Rail Enterprise"u8)); Assert.Equal(0x95584af7701f808dUL, XxHash64.Hash([], 12345)); var hundred = new byte[100]; for (int i = 0; i < hundred.Length; i++) hundred[i] = (byte)i; diff --git a/tests/ViaFerrea.Tests/Core/RngTests.cs b/tests/RailEnterprise.Tests/Core/RngTests.cs similarity index 94% rename from tests/ViaFerrea.Tests/Core/RngTests.cs rename to tests/RailEnterprise.Tests/Core/RngTests.cs index 2bc1bd5..2aeb168 100644 --- a/tests/ViaFerrea.Tests/Core/RngTests.cs +++ b/tests/RailEnterprise.Tests/Core/RngTests.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Common; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Basics; +namespace RailEnterprise.Tests.Basics; public static class RngTests { diff --git a/tests/ViaFerrea.Tests/Core/TimeTests.cs b/tests/RailEnterprise.Tests/Core/TimeTests.cs similarity index 92% rename from tests/ViaFerrea.Tests/Core/TimeTests.cs rename to tests/RailEnterprise.Tests/Core/TimeTests.cs index e73b84b..6803e0d 100644 --- a/tests/ViaFerrea.Tests/Core/TimeTests.cs +++ b/tests/RailEnterprise.Tests/Core/TimeTests.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Time; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Time; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Basics; +namespace RailEnterprise.Tests.Basics; public static class TimeTests { diff --git a/tests/ViaFerrea.Tests/Data/DataTests.cs b/tests/RailEnterprise.Tests/Data/DataTests.cs similarity index 98% rename from tests/ViaFerrea.Tests/Data/DataTests.cs rename to tests/RailEnterprise.Tests/Data/DataTests.cs index 20c6ae4..f10b527 100644 --- a/tests/ViaFerrea.Tests/Data/DataTests.cs +++ b/tests/RailEnterprise.Tests/Data/DataTests.cs @@ -1,8 +1,8 @@ using System.Text.Json.Nodes; -using ViaFerrea.Core.Data; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Data; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Data; +namespace RailEnterprise.Tests.Data; public static class DataTests { diff --git a/tests/ViaFerrea.Tests/Economy/AiTests.cs b/tests/RailEnterprise.Tests/Economy/AiTests.cs similarity index 93% rename from tests/ViaFerrea.Tests/Economy/AiTests.cs rename to tests/RailEnterprise.Tests/Economy/AiTests.cs index a505308..13ff80b 100644 --- a/tests/ViaFerrea.Tests/Economy/AiTests.cs +++ b/tests/RailEnterprise.Tests/Economy/AiTests.cs @@ -1,11 +1,11 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Persistence; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Ai; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Ai; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Economy; +namespace RailEnterprise.Tests.Economy; /// Concorrenti IA (guida 12.1, test di 14.5): comandi validi, crescita, determinismo. public static class AiTests diff --git a/tests/ViaFerrea.Tests/Economy/EconomyTests.cs b/tests/RailEnterprise.Tests/Economy/EconomyTests.cs similarity index 95% rename from tests/ViaFerrea.Tests/Economy/EconomyTests.cs rename to tests/RailEnterprise.Tests/Economy/EconomyTests.cs index aea21d3..4b7a97d 100644 --- a/tests/ViaFerrea.Tests/Economy/EconomyTests.cs +++ b/tests/RailEnterprise.Tests/Economy/EconomyTests.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Economy; +namespace RailEnterprise.Tests.Economy; public static class EconomyTests { @@ -181,14 +181,14 @@ public static class EconomyTests public static void UnimplementedCommandsAreRejectedWithoutSideEffects() { var w = TestWorlds.Small(108); - ulong before = ViaFerrea.Core.Persistence.StateHasher.Compute(w); + ulong before = RailEnterprise.Core.Persistence.StateHasher.Compute(w); w.Enqueue(new BuyConcessionCommand(new RegionId(0)) { Issuer = w.Player.Id, Seq = 9 }); w.Enqueue(new TakeLoanCommand(Money.FromLire(1)) { Issuer = new CompanyId(99), Seq = 10 }); w.Pipeline.Get().Step(w.Context); var results = w.DrainResults(); Assert.Equal(CommandError.NotImplemented, results[0].Error); Assert.Equal(CommandError.UnknownCompany, results[1].Error); - Assert.Equal(before, ViaFerrea.Core.Persistence.StateHasher.Compute(w)); + Assert.Equal(before, RailEnterprise.Core.Persistence.StateHasher.Compute(w)); } [Test] diff --git a/tests/ViaFerrea.Tests/Economy/IndustryMaintenanceTests.cs b/tests/RailEnterprise.Tests/Economy/IndustryMaintenanceTests.cs similarity index 97% rename from tests/ViaFerrea.Tests/Economy/IndustryMaintenanceTests.cs rename to tests/RailEnterprise.Tests/Economy/IndustryMaintenanceTests.cs index 2399738..39ff710 100644 --- a/tests/ViaFerrea.Tests/Economy/IndustryMaintenanceTests.cs +++ b/tests/RailEnterprise.Tests/Economy/IndustryMaintenanceTests.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Economy; +namespace RailEnterprise.Tests.Economy; /// Manutenzione degli impianti (guida, sezione 11) e industrie possedute dal giocatore. public static class IndustryMaintenanceTests diff --git a/tests/ViaFerrea.Tests/Economy/StockMarketTests.cs b/tests/RailEnterprise.Tests/Economy/StockMarketTests.cs similarity index 97% rename from tests/ViaFerrea.Tests/Economy/StockMarketTests.cs rename to tests/RailEnterprise.Tests/Economy/StockMarketTests.cs index a36440e..84c6ece 100644 --- a/tests/ViaFerrea.Tests/Economy/StockMarketTests.cs +++ b/tests/RailEnterprise.Tests/Economy/StockMarketTests.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Persistence; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Economy; +namespace RailEnterprise.Tests.Economy; /// Borsa, quotazione, dividendi, scalate e loro esiti (guida 12.2–12.3, test di 14.5). public static class StockMarketTests diff --git a/tests/ViaFerrea.Tests/Harness/Assert.cs b/tests/RailEnterprise.Tests/Harness/Assert.cs similarity index 99% rename from tests/ViaFerrea.Tests/Harness/Assert.cs rename to tests/RailEnterprise.Tests/Harness/Assert.cs index 240f884..c9fd5ea 100644 --- a/tests/ViaFerrea.Tests/Harness/Assert.cs +++ b/tests/RailEnterprise.Tests/Harness/Assert.cs @@ -1,6 +1,6 @@ using System.Runtime.CompilerServices; -namespace ViaFerrea.Tests.Harness; +namespace RailEnterprise.Tests.Harness; /// Fallimento di un'asserzione, con posizione nel sorgente. public sealed class AssertionException(string message) : Exception(message); diff --git a/tests/ViaFerrea.Tests/Harness/TestAttribute.cs b/tests/RailEnterprise.Tests/Harness/TestAttribute.cs similarity index 94% rename from tests/ViaFerrea.Tests/Harness/TestAttribute.cs rename to tests/RailEnterprise.Tests/Harness/TestAttribute.cs index 63a2374..ba9b602 100644 --- a/tests/ViaFerrea.Tests/Harness/TestAttribute.cs +++ b/tests/RailEnterprise.Tests/Harness/TestAttribute.cs @@ -1,4 +1,4 @@ -namespace ViaFerrea.Tests.Harness; +namespace RailEnterprise.Tests.Harness; /// /// Marca un metodo come test. Il metodo può essere statico o d'istanza (classe con costruttore diff --git a/tests/ViaFerrea.Tests/Harness/TestRunner.cs b/tests/RailEnterprise.Tests/Harness/TestRunner.cs similarity index 97% rename from tests/ViaFerrea.Tests/Harness/TestRunner.cs rename to tests/RailEnterprise.Tests/Harness/TestRunner.cs index d3f5a46..10b65d5 100644 --- a/tests/ViaFerrea.Tests/Harness/TestRunner.cs +++ b/tests/RailEnterprise.Tests/Harness/TestRunner.cs @@ -2,7 +2,7 @@ using System.Collections.Concurrent; using System.Diagnostics; using System.Reflection; -namespace ViaFerrea.Tests.Harness; +namespace RailEnterprise.Tests.Harness; /// /// Scopre i metodi [Test] per reflection e li esegue. Opzioni: @@ -35,7 +35,7 @@ public static class TestRunner return 0; } - Console.WriteLine($"Via Ferrea — {tests.Count} test selezionati"); + Console.WriteLine($"Rail Enterprise — {tests.Count} test selezionati"); var total = Stopwatch.StartNew(); var outcomes = new ConcurrentBag(); diff --git a/tests/ViaFerrea.Tests/Map/MapTests.cs b/tests/RailEnterprise.Tests/Map/MapTests.cs similarity index 97% rename from tests/ViaFerrea.Tests/Map/MapTests.cs rename to tests/RailEnterprise.Tests/Map/MapTests.cs index a18ca57..c76d37b 100644 --- a/tests/ViaFerrea.Tests/Map/MapTests.cs +++ b/tests/RailEnterprise.Tests/Map/MapTests.cs @@ -1,10 +1,10 @@ using System.Diagnostics; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Map; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Map; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Map; +namespace RailEnterprise.Tests.Map; public static class MapTests { diff --git a/tests/ViaFerrea.Tests/Persistence/PersistenceTests.cs b/tests/RailEnterprise.Tests/Persistence/PersistenceTests.cs similarity index 94% rename from tests/ViaFerrea.Tests/Persistence/PersistenceTests.cs rename to tests/RailEnterprise.Tests/Persistence/PersistenceTests.cs index 8d92f5f..2396ad2 100644 --- a/tests/ViaFerrea.Tests/Persistence/PersistenceTests.cs +++ b/tests/RailEnterprise.Tests/Persistence/PersistenceTests.cs @@ -1,10 +1,10 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Persistence; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Persistence; +namespace RailEnterprise.Tests.Persistence; public static class PersistenceTests { diff --git a/tests/RailEnterprise.Tests/Program.cs b/tests/RailEnterprise.Tests/Program.cs new file mode 100644 index 0000000..caa7290 --- /dev/null +++ b/tests/RailEnterprise.Tests/Program.cs @@ -0,0 +1,11 @@ +using RailEnterprise.Tests.Harness; + +namespace RailEnterprise.Tests; + +/// +/// Punto d'ingresso unico: dotnet run --project tests/RailEnterprise.Tests [-- filtri] [--list] [--serial] [--skip-slow]. +/// +public static class TestProgram +{ + public static int Main(string[] args) => TestRunner.Run(args, typeof(TestProgram).Assembly); +} diff --git a/tests/ViaFerrea.Tests/Protocol/ProtocolTests.cs b/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs similarity index 96% rename from tests/ViaFerrea.Tests/Protocol/ProtocolTests.cs rename to tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs index 2cb0218..3c664d2 100644 --- a/tests/ViaFerrea.Tests/Protocol/ProtocolTests.cs +++ b/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; -using ViaFerrea.Protocol; -using ViaFerrea.Protocol.Messages; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Messages; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Protocol; +namespace RailEnterprise.Tests.Protocol; public static class ProtocolTests { @@ -362,9 +362,9 @@ public static class CommandLogTests [Test(Description = "Registro dei comandi: salvataggio di partenza + comandi riapplicati ai loro tick = stesso hash")] public static void RecordedCommandsReplayToTheSameState() { - var f = ViaFerrea.Tests.Rail.RailFixture.Valdoria(); + var f = RailEnterprise.Tests.Rail.RailFixture.Valdoria(); var w = f.W; - byte[] start = ViaFerrea.Core.Persistence.SaveFile.Save(w, "test"); + byte[] start = RailEnterprise.Core.Persistence.SaveFile.Save(w, "test"); w.CommandLog = []; var (mine, mill, depot) = f.BuildFreightNetwork(waitForConstruction: false); f.Ok(new TakeLoanCommand(Money.FromLire(10_000))); @@ -373,11 +373,11 @@ public static class CommandLogTests CommandLogFile.WriteHeader(file); foreach (var (tick, command) in w.CommandLog) CommandLogFile.Append(file, tick, command); long endTick = w.Clock.Tick; - ulong expected = ViaFerrea.Core.Persistence.StateHasher.Compute(w); + ulong expected = RailEnterprise.Core.Persistence.StateHasher.Compute(w); var commands = CommandLogFile.ReadAll(file.ToArray()); Assert.Equal(w.CommandLog.Count, commands.Count); - var replay = ViaFerrea.Core.Persistence.SaveFile.Load(TestData.Data, start); + var replay = RailEnterprise.Core.Persistence.SaveFile.Load(TestData.Data, start); int next = 0; while (replay.Clock.Tick < endTick) { @@ -385,7 +385,7 @@ public static class CommandLogTests replay.Tick(); } Assert.Equal(commands.Count, next); - Assert.Equal(expected, ViaFerrea.Core.Persistence.StateHasher.Compute(replay)); + Assert.Equal(expected, RailEnterprise.Core.Persistence.StateHasher.Compute(replay)); Assert.True(mine >= 0 && mill >= 0 && depot >= 0); } } diff --git a/tests/ViaFerrea.Tests/Rail/CommutingTests.cs b/tests/RailEnterprise.Tests/Rail/CommutingTests.cs similarity index 96% rename from tests/ViaFerrea.Tests/Rail/CommutingTests.cs rename to tests/RailEnterprise.Tests/Rail/CommutingTests.cs index cf708c9..1f0740a 100644 --- a/tests/ViaFerrea.Tests/Rail/CommutingTests.cs +++ b/tests/RailEnterprise.Tests/Rail/CommutingTests.cs @@ -1,14 +1,14 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; -using ViaFerrea.Tests.Harness; -using static ViaFerrea.Tests.Rail.RailFixture; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Tests.Harness; +using static RailEnterprise.Tests.Rail.RailFixture; -namespace ViaFerrea.Tests.Rail; +namespace RailEnterprise.Tests.Rail; public static class CommutingTests { diff --git a/tests/ViaFerrea.Tests/Rail/MaintenanceTests.cs b/tests/RailEnterprise.Tests/Rail/MaintenanceTests.cs similarity index 97% rename from tests/ViaFerrea.Tests/Rail/MaintenanceTests.cs rename to tests/RailEnterprise.Tests/Rail/MaintenanceTests.cs index 587adbc..d9e6f94 100644 --- a/tests/ViaFerrea.Tests/Rail/MaintenanceTests.cs +++ b/tests/RailEnterprise.Tests/Rail/MaintenanceTests.cs @@ -1,15 +1,15 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Persistence; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; -using ViaFerrea.Tests.Harness; -using static ViaFerrea.Tests.Rail.RailFixture; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Tests.Harness; +using static RailEnterprise.Tests.Rail.RailFixture; -namespace ViaFerrea.Tests.Rail; +namespace RailEnterprise.Tests.Rail; public static class MaintenanceTests { diff --git a/tests/ViaFerrea.Tests/Rail/RailFixture.cs b/tests/RailEnterprise.Tests/Rail/RailFixture.cs similarity index 96% rename from tests/ViaFerrea.Tests/Rail/RailFixture.cs rename to tests/RailEnterprise.Tests/Rail/RailFixture.cs index eae7b12..1f0c601 100644 --- a/tests/ViaFerrea.Tests/Rail/RailFixture.cs +++ b/tests/RailEnterprise.Tests/Rail/RailFixture.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Scenarios; -using ViaFerrea.Tests.Harness; -using ViaFerrea.Tests.Scenarios; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Scenarios; +using RailEnterprise.Tests.Harness; +using RailEnterprise.Tests.Scenarios; -namespace ViaFerrea.Tests.Rail; +namespace RailEnterprise.Tests.Rail; /// Mondo con comandi di comodo per i test ferroviari. public sealed class RailFixture diff --git a/tests/ViaFerrea.Tests/Rail/RailNetworkTests.cs b/tests/RailEnterprise.Tests/Rail/RailNetworkTests.cs similarity index 92% rename from tests/ViaFerrea.Tests/Rail/RailNetworkTests.cs rename to tests/RailEnterprise.Tests/Rail/RailNetworkTests.cs index 1239b5b..f9eb7a8 100644 --- a/tests/ViaFerrea.Tests/Rail/RailNetworkTests.cs +++ b/tests/RailEnterprise.Tests/Rail/RailNetworkTests.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Systems; -using ViaFerrea.Tests.Harness; -using static ViaFerrea.Tests.Rail.RailFixture; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Tests.Harness; +using static RailEnterprise.Tests.Rail.RailFixture; -namespace ViaFerrea.Tests.Rail; +namespace RailEnterprise.Tests.Rail; public static class RailNetworkTests { @@ -89,7 +89,7 @@ public static class RailNetworkTests Assert.Equal(CommandError.NotFound, f.Do(new BuyVehicleCommand("loco_steam_1850", new DepotId(3))).Error); Assert.Equal(cash, f.W.Player.Cash); Assert.Equal(0, f.W.Network.Edges.Count); - f.W.Money.Transfer(ViaFerrea.Core.Economy.Account.Of(f.Me), ViaFerrea.Core.Economy.Account.External, f.W.Player.Cash, ViaFerrea.Core.Economy.LedgerEntry.Other); + f.W.Money.Transfer(RailEnterprise.Core.Economy.Account.Of(f.Me), RailEnterprise.Core.Economy.Account.External, f.W.Player.Cash, RailEnterprise.Core.Economy.LedgerEntry.Other); Assert.Equal(CommandError.InsufficientFunds, f.Do(new BuildTrackCommand(new[] { K(11.0, 9.5), K(14.0, 9.5) })).Error); } diff --git a/tests/ViaFerrea.Tests/Rail/SyntheticTerrain.cs b/tests/RailEnterprise.Tests/Rail/SyntheticTerrain.cs similarity index 96% rename from tests/ViaFerrea.Tests/Rail/SyntheticTerrain.cs rename to tests/RailEnterprise.Tests/Rail/SyntheticTerrain.cs index b25c627..2ab4b5e 100644 --- a/tests/ViaFerrea.Tests/Rail/SyntheticTerrain.cs +++ b/tests/RailEnterprise.Tests/Rail/SyntheticTerrain.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Map; +using RailEnterprise.Core.Map; -namespace ViaFerrea.Tests.Rail; +namespace RailEnterprise.Tests.Rail; /// Terreni costruiti a mano per i test del pianificatore (celle da 100 m). public static class SyntheticTerrain diff --git a/tests/ViaFerrea.Tests/Rail/TrackPlannerTests.cs b/tests/RailEnterprise.Tests/Rail/TrackPlannerTests.cs similarity index 98% rename from tests/ViaFerrea.Tests/Rail/TrackPlannerTests.cs rename to tests/RailEnterprise.Tests/Rail/TrackPlannerTests.cs index d14c141..6df57e8 100644 --- a/tests/ViaFerrea.Tests/Rail/TrackPlannerTests.cs +++ b/tests/RailEnterprise.Tests/Rail/TrackPlannerTests.cs @@ -1,9 +1,9 @@ -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Rail; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Rail; +namespace RailEnterprise.Tests.Rail; public static class TrackPlannerTests { diff --git a/tests/ViaFerrea.Tests/Rail/TrainTests.cs b/tests/RailEnterprise.Tests/Rail/TrainTests.cs similarity index 94% rename from tests/ViaFerrea.Tests/Rail/TrainTests.cs rename to tests/RailEnterprise.Tests/Rail/TrainTests.cs index b38f05b..aebef2b 100644 --- a/tests/ViaFerrea.Tests/Rail/TrainTests.cs +++ b/tests/RailEnterprise.Tests/Rail/TrainTests.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Economy; -using ViaFerrea.Core.Persistence; -using ViaFerrea.Core.Rail; -using ViaFerrea.Tests.Harness; -using static ViaFerrea.Tests.Rail.RailFixture; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Core.Rail; +using RailEnterprise.Tests.Harness; +using static RailEnterprise.Tests.Rail.RailFixture; -namespace ViaFerrea.Tests.Rail; +namespace RailEnterprise.Tests.Rail; public static class TrainTests { diff --git a/tests/ViaFerrea.Tests/ViaFerrea.Tests.csproj b/tests/RailEnterprise.Tests/RailEnterprise.Tests.csproj similarity index 59% rename from tests/ViaFerrea.Tests/ViaFerrea.Tests.csproj rename to tests/RailEnterprise.Tests/RailEnterprise.Tests.csproj index 25f6b77..9113633 100644 --- a/tests/ViaFerrea.Tests/ViaFerrea.Tests.csproj +++ b/tests/RailEnterprise.Tests/RailEnterprise.Tests.csproj @@ -4,13 +4,13 @@ Exe net10.0 - ViaFerrea.Tests + RailEnterprise.Tests - - - + + + diff --git a/tests/ViaFerrea.Tests/Scenarios/CommutingAcceptanceTests.cs b/tests/RailEnterprise.Tests/Scenarios/CommutingAcceptanceTests.cs similarity index 93% rename from tests/ViaFerrea.Tests/Scenarios/CommutingAcceptanceTests.cs rename to tests/RailEnterprise.Tests/Scenarios/CommutingAcceptanceTests.cs index 51a1ebe..87fde0f 100644 --- a/tests/ViaFerrea.Tests/Scenarios/CommutingAcceptanceTests.cs +++ b/tests/RailEnterprise.Tests/Scenarios/CommutingAcceptanceTests.cs @@ -1,12 +1,12 @@ -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Data; -using ViaFerrea.Core.Rail; -using ViaFerrea.Tests.Harness; -using ViaFerrea.Tests.Rail; -using static ViaFerrea.Tests.Rail.RailFixture; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Rail; +using RailEnterprise.Tests.Harness; +using RailEnterprise.Tests.Rail; +using static RailEnterprise.Tests.Rail.RailFixture; -namespace ViaFerrea.Tests.Scenarios; +namespace RailEnterprise.Tests.Scenarios; public static class CommutingAcceptanceTests { diff --git a/tests/ViaFerrea.Tests/Scenarios/MaintenanceAcceptanceTests.cs b/tests/RailEnterprise.Tests/Scenarios/MaintenanceAcceptanceTests.cs similarity index 92% rename from tests/ViaFerrea.Tests/Scenarios/MaintenanceAcceptanceTests.cs rename to tests/RailEnterprise.Tests/Scenarios/MaintenanceAcceptanceTests.cs index 4fbdae2..2bb97fb 100644 --- a/tests/ViaFerrea.Tests/Scenarios/MaintenanceAcceptanceTests.cs +++ b/tests/RailEnterprise.Tests/Scenarios/MaintenanceAcceptanceTests.cs @@ -1,10 +1,10 @@ -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation.Systems; -using ViaFerrea.Tests.Harness; -using ViaFerrea.Tests.Rail; -using static ViaFerrea.Tests.Rail.RailFixture; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Tests.Harness; +using RailEnterprise.Tests.Rail; +using static RailEnterprise.Tests.Rail.RailFixture; -namespace ViaFerrea.Tests.Scenarios; +namespace RailEnterprise.Tests.Scenarios; public static class MaintenanceAcceptanceTests { diff --git a/tests/ViaFerrea.Tests/Scenarios/ScenarioHelper.cs b/tests/RailEnterprise.Tests/Scenarios/ScenarioHelper.cs similarity index 83% rename from tests/ViaFerrea.Tests/Scenarios/ScenarioHelper.cs rename to tests/RailEnterprise.Tests/Scenarios/ScenarioHelper.cs index 6f67631..ff7a502 100644 --- a/tests/ViaFerrea.Tests/Scenarios/ScenarioHelper.cs +++ b/tests/RailEnterprise.Tests/Scenarios/ScenarioHelper.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Core.Simulation.Scenarios; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Scenarios; -namespace ViaFerrea.Tests.Scenarios; +namespace RailEnterprise.Tests.Scenarios; /// Accesso agli scenari di riferimento copiati accanto ai test. public static class ScenarioHelper @@ -14,7 +14,7 @@ public static class ScenarioHelper var dir = new DirectoryInfo(Directory.GetCurrentDirectory()); while (dir is not null) { - string candidate = Path.Combine(dir.FullName, "tests", "ViaFerrea.Tests", "scenarios", name + ".json"); + string candidate = Path.Combine(dir.FullName, "tests", "RailEnterprise.Tests", "scenarios", name + ".json"); if (File.Exists(candidate)) return candidate; dir = dir.Parent; } diff --git a/tests/ViaFerrea.Tests/Scenarios/ValdoriaTests.cs b/tests/RailEnterprise.Tests/Scenarios/ValdoriaTests.cs similarity index 95% rename from tests/ViaFerrea.Tests/Scenarios/ValdoriaTests.cs rename to tests/RailEnterprise.Tests/Scenarios/ValdoriaTests.cs index 27f33fc..ed11066 100644 --- a/tests/ViaFerrea.Tests/Scenarios/ValdoriaTests.cs +++ b/tests/RailEnterprise.Tests/Scenarios/ValdoriaTests.cs @@ -1,8 +1,8 @@ -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Rail; -using ViaFerrea.Tests.Harness; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; +using RailEnterprise.Tests.Harness; -namespace ViaFerrea.Tests.Scenarios; +namespace RailEnterprise.Tests.Scenarios; public static class ValdoriaTests { diff --git a/tests/ViaFerrea.Tests/Server/ServerTests.cs b/tests/RailEnterprise.Tests/Server/ServerTests.cs similarity index 96% rename from tests/ViaFerrea.Tests/Server/ServerTests.cs rename to tests/RailEnterprise.Tests/Server/ServerTests.cs index ac045ae..9f1882c 100644 --- a/tests/ViaFerrea.Tests/Server/ServerTests.cs +++ b/tests/RailEnterprise.Tests/Server/ServerTests.cs @@ -3,18 +3,18 @@ using Microsoft.AspNetCore.Hosting.Server; using Microsoft.AspNetCore.Hosting.Server.Features; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; -using ViaFerrea.Core.Commands; -using ViaFerrea.Core.Common; -using ViaFerrea.Core.Rail; -using ViaFerrea.Core.Simulation; -using ViaFerrea.Protocol; -using ViaFerrea.Protocol.Client; -using ViaFerrea.Protocol.Messages; -using ViaFerrea.Server; -using ViaFerrea.Tests.Harness; -using ViaFerrea.Tests.Scenarios; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Client; +using RailEnterprise.Protocol.Messages; +using RailEnterprise.Server; +using RailEnterprise.Tests.Harness; +using RailEnterprise.Tests.Scenarios; -namespace ViaFerrea.Tests.Server; +namespace RailEnterprise.Tests.Server; /// Server in processo su una porta casuale, con un client WebSocket vero. public sealed class ServerFixture : IAsyncDisposable @@ -36,7 +36,7 @@ public sealed class ServerFixture : IAsyncDisposable public static ServerFixture Start(World world, int tickMs = 1) { - string dir = Path.Combine(Path.GetTempPath(), "viaferrea-test-" + Path.GetRandomFileName()); + string dir = Path.Combine(Path.GetTempPath(), "railenterprise-test-" + Path.GetRandomFileName()); var config = new ServerConfig { Local = true, Token = Token, TickMs = tickMs, AutosaveMinutes = 0, DataDir = dir, LogLevel = "Error" }; var app = ServerProgram.Build(config, [], world, TestData.Data); app.Start(); @@ -317,6 +317,6 @@ public static class ServerTests Assert.True(saves.Contains("da-http", StringComparison.Ordinal), saves); string id = saves.Split("\"id\":\"")[1].Split('"')[0]; var file = await http.GetByteArrayAsync($"/api/saves/{id}"); - Assert.True(file.AsSpan(0, 4).SequenceEqual("VFSV"u8)); + Assert.True(file.AsSpan(0, 4).SequenceEqual("RESV"u8)); } } diff --git a/tests/ViaFerrea.Tests/TestData.cs b/tests/RailEnterprise.Tests/TestData.cs similarity index 86% rename from tests/ViaFerrea.Tests/TestData.cs rename to tests/RailEnterprise.Tests/TestData.cs index 7c33203..e0cb6bc 100644 --- a/tests/ViaFerrea.Tests/TestData.cs +++ b/tests/RailEnterprise.Tests/TestData.cs @@ -1,6 +1,6 @@ -using ViaFerrea.Core.Data; +using RailEnterprise.Core.Data; -namespace ViaFerrea.Tests; +namespace RailEnterprise.Tests; /// Dati di gioco caricati una volta sola e condivisi dai test (sono immutabili). public static class TestData diff --git a/tests/ViaFerrea.Tests/TestWorlds.cs b/tests/RailEnterprise.Tests/TestWorlds.cs similarity index 92% rename from tests/ViaFerrea.Tests/TestWorlds.cs rename to tests/RailEnterprise.Tests/TestWorlds.cs index 4163000..064cf0a 100644 --- a/tests/ViaFerrea.Tests/TestWorlds.cs +++ b/tests/RailEnterprise.Tests/TestWorlds.cs @@ -1,7 +1,7 @@ -using ViaFerrea.Core.Map; -using ViaFerrea.Core.Simulation; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Simulation; -namespace ViaFerrea.Tests; +namespace RailEnterprise.Tests; /// Mondi di prova generati dal seme (64 km: veloci da creare). public static class TestWorlds diff --git a/tests/ViaFerrea.Tests/scenarios/valdoria.json b/tests/RailEnterprise.Tests/scenarios/valdoria.json similarity index 100% rename from tests/ViaFerrea.Tests/scenarios/valdoria.json rename to tests/RailEnterprise.Tests/scenarios/valdoria.json diff --git a/tests/ViaFerrea.Tests/Program.cs b/tests/ViaFerrea.Tests/Program.cs deleted file mode 100644 index 3586be1..0000000 --- a/tests/ViaFerrea.Tests/Program.cs +++ /dev/null @@ -1,11 +0,0 @@ -using ViaFerrea.Tests.Harness; - -namespace ViaFerrea.Tests; - -/// -/// Punto d'ingresso unico: dotnet run --project tests/ViaFerrea.Tests [-- filtri] [--list] [--serial] [--skip-slow]. -/// -public static class TestProgram -{ - public static int Main(string[] args) => TestRunner.Run(args, typeof(TestProgram).Assembly); -}