Files
Alby96andClaude Opus 5.5 e75c8e1586
CI / Build e test (pull_request) Successful in 1m32s
CI / Immagine Docker (pull_request) Successful in 31s
F6: audio, correzioni della revisione
I treni suonano solo se si sentono davvero e solo mentre il server li dà in
marcia; il fischio all'arrivo, che non poteva mai suonare, è tolto.

- Il client non riceve mai un moto Loading (all'arrivo il percorso si svuota e
  Projection.Motion non manda nulla): via fischio e tromba all'arrivo da
  AudioManager e documenti; tornerà con una modifica del protocollo decisa a
  parte. Synth.SteamWhistle e Synth.Horn restano pronti.
- Un treno suona solo con un moto ricevuto da meno di 500 ms
  (GameSession.MotionReceivedMs): fermo in stazione o fuori dalla zona
  sottoscritta tace invece di restare sull'ultimo moto Moving.
- I candidati oltre metà diagonale non prendono un canale: niente Play e Stop
  a ogni fotogramma.
- Clic dei pulsanti collegato una volta sola (IsConnected con un Callable
  preparato): MarketPanel riattacca il TradeBox a ogni resoconto.
- Volumi e muto si salvano all'uscita del pannello e di AudioManager se
  cambiati, anche chiudendo la finestra con il pannello aperto; lo sfondo
  chiude solo con il clic sinistro, non con rotella o tasto destro.
- Sbuffi da 1,2 a 10 al secondo fino a 30 m/s, in modo lineare: seguono la
  velocità su tutto l'esercizio; ADR corretto (non è il passo della ruota).
- Tabelle d'onda dei temi limitate alle armoniche sotto il 45 % della
  frequenza di campionamento per nota: niente ripiegamento oltre Nyquist.

Refs #46.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 14:05:24 +01:00

151 lines
6.9 KiB
C#
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
namespace RailEnterprise.Client.Audio;
/// <summary>Frazioni del terreno sotto la telecamera (somma 1 sui campioni letti).</summary>
public struct TerrainMix
{
public float River;
public float Lake;
public float Sea;
public float Town;
public float Forest;
public float Open;
}
/// <summary>Guadagni lineari (0–1) dei quattro anelli d'ambiente e probabilità relativa degli uccelli.</summary>
public readonly record struct AmbienceGains(float Wind, float Water, float Sea, float City, float Birds);
/// <summary>
/// Miscelazione dell'audio senza dipendenze da Godot: guadagni dell'ambiente dal terreno e dallo
/// zoom, volume e intonazione dei treni dalla distanza sullo schermo e dalla velocità, scelta dei
/// treni più vicini senza allocazioni, ere dall'anno, dissolvenze e conversione in PCM. Le costanti
/// sono di resa sonora del client, non della simulazione.
/// </summary>
public static class AudioMix
{
/// <summary>Zoom (pixel per metro) sotto il quale si sente quasi solo il vento della vista d'insieme.</summary>
public const float FarZoom = 0.02f;
/// <summary>Zoom da cui ambiente e treni sono al massimo.</summary>
public const float NearZoom = 0.5f;
/// <summary>Canali dei treni: al più tanti treni suonano insieme.</summary>
public const int TrainChannels = 3;
/// <summary>Velocità (m/s) a cui il rotolamento è al massimo.</summary>
public const float FullSpeedMs = 25f;
/// <summary>Sbuffi al secondo da fermo (al passo) e alla velocità <see cref="ChuffFullSpeedMs"/>.</summary>
public const float ChuffMinRate = 1.2f, ChuffMaxRate = 10f;
/// <summary>Velocità (m/s, circa 110 km/h) a cui gli sbuffi sono più fitti.</summary>
public const float ChuffFullSpeedMs = 30f;
public static float Clamp01(float x) => x < 0 ? 0 : x > 1 ? 1 : x;
public static float SmoothStep(float x)
{
x = Clamp01(x);
return x * x * (3 - 2 * x);
}
/// <summary>Vicinanza della telecamera (0 = vista d'insieme, 1 = da vicino) su scala logaritmica dello zoom.</summary>
public static float Closeness(float zoom)
{
if (zoom <= 0) return 0;
return SmoothStep((MathF.Log(zoom) - MathF.Log(FarZoom)) / (MathF.Log(NearZoom) - MathF.Log(FarZoom)));
}
/// <summary>
/// Ambiente: il vento c'è sempre (più forte da lontano), acqua, mare e città seguono la
/// frazione del terreno visibile e si attenuano allontanandosi; gli uccelli solo da vicino in
/// campagna e nei boschi.
/// </summary>
public static AmbienceGains Ambience(float zoom, in TerrainMix t)
{
float close = Closeness(zoom);
float wind = 0.35f + 0.35f * (1 - close) + 0.15f * t.Open;
float water = Clamp01((t.River * 3 + t.Lake * 1.5f) * (0.25f + 0.75f * close));
float sea = Clamp01(t.Sea * 1.6f * (0.45f + 0.55f * close));
float city = Clamp01(t.Town * 4 * (0.15f + 0.85f * close));
float birds = Clamp01((t.Forest + t.Open * 0.6f) * close * close * (1 - t.Town * 2));
// l'acqua e la città coprono un po' il vento
wind *= 1 - 0.4f * MathF.Max(sea, city);
return new AmbienceGains(Clamp01(wind), water, sea, city, birds);
}
/// <summary>Volume di un treno: vicinanza al centro dello schermo, velocità e zoom.</summary>
/// <param name="distancePx">Distanza in pixel dal centro dello schermo.</param>
/// <param name="radiusPx">Raggio oltre il quale non si sente (di solito metà della diagonale).</param>
public static float TrainGain(float distancePx, float radiusPx, float speedMs, float zoom)
{
if (radiusPx <= 0) return 0;
float near = 1 - Clamp01(distancePx / radiusPx);
float speed = Clamp01(speedMs / FullSpeedMs);
return near * near * (0.25f + 0.75f * speed) * (0.15f + 0.85f * Closeness(zoom));
}
/// <summary>Intonazione del rotolamento: più rapido e acuto con la velocità.</summary>
public static float RumblePitch(float speedMs) => 0.55f + 1.0f * Clamp01(speedMs / FullSpeedMs);
/// <summary>Intonazione del motore (diesel o elettrico) con la velocità.</summary>
public static float EnginePitch(float speedMs) => 0.8f + 0.5f * Clamp01(speedMs / FullSpeedMs);
/// <summary>
/// Secondi tra due sbuffi della vaporiera alla velocità data: la frequenza cresce in modo lineare
/// da <see cref="ChuffMinRate"/> a <see cref="ChuffMaxRate"/> fino a <see cref="ChuffFullSpeedMs"/>,
/// così segue la velocità su tutto l'esercizio normale. È una resa sonora, non il passo reale della
/// ruota: sullo schermo il tempo dei treni corre decine di volte più veloce e gli sbuffi reali
/// sarebbero un ronzio continuo.
/// </summary>
public static float ChuffInterval(float speedMs) => 1f / (ChuffMinRate + (ChuffMaxRate - ChuffMinRate) * Clamp01(speedMs / ChuffFullSpeedMs));
/// <summary>
/// Inserisce un candidato nell'elenco ordinato dei più vicini (al più ids.Length): nessuna
/// allocazione, gli elenchi sono preparati una volta sola. Restituisce il nuovo conteggio.
/// </summary>
public static int InsertNearest(int[] ids, float[] distances, int count, int id, float distance)
{
int capacity = ids.Length;
if (count == capacity && distance >= distances[capacity - 1]) return count;
int i = Math.Min(count, capacity - 1);
while (i > 0 && distances[i - 1] > distance)
{
ids[i] = ids[i - 1];
distances[i] = distances[i - 1];
i--;
}
ids[i] = id;
distances[i] = distance;
return Math.Min(count + 1, capacity);
}
/// <summary>Era dell'anno: l'ultima il cui inizio («from» di eras.json, crescente) non è dopo l'anno.</summary>
public static int EraIndex(int year, IReadOnlyList<int> froms)
{
int index = 0;
for (int i = 0; i < froms.Count; i++)
{
if (froms[i] <= year) index = i;
}
return index;
}
/// <summary>Avvicina un valore al bersaglio con velocità costante (unità al secondo).</summary>
public static float Approach(float current, float target, float ratePerSecond, float dt)
{
float step = ratePerSecond * dt;
return current < target ? MathF.Min(target, current + step) : MathF.Max(target, current - step);
}
/// <summary>Lineare → decibel, con −80 dB come silenzio.</summary>
public static float LinearToDb(float linear) => linear <= 0.0001f ? -80f : 20f * MathF.Log10(linear);
/// <summary>Campioni in [−1, 1] → PCM a 16 bit little-endian (formato di AudioStreamWAV).</summary>
public static byte[] ToPcm16(float[] samples)
{
var bytes = new byte[samples.Length * 2];
for (int i = 0; i < samples.Length; i++)
{
short s = (short)Math.Clamp((int)MathF.Round(samples[i] * 32767f), short.MinValue, short.MaxValue);
bytes[2 * i] = (byte)s;
bytes[2 * i + 1] = (byte)(s >> 8);
}
return bytes;
}
}