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>
151 lines
6.9 KiB
C#
151 lines
6.9 KiB
C#
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;
|
||
}
|
||
}
|