286 lines
12 KiB
C#
286 lines
12 KiB
C#
using ProjectM.Simulation;
|
||
using Unity.Entities;
|
||
using Unity.NetCode;
|
||
using UnityEngine;
|
||
|
||
namespace ProjectM.Client
|
||
{
|
||
/// <summary>
|
||
/// Client-only PROCEDURAL MUSIC — four synchronized loop layers (bass / chord pad / arpeggio / percussion
|
||
/// pulse), all generated over the SAME 4-bar buffer (100 BPM, Am–F–C–G) so they stay phase-locked forever:
|
||
/// every AudioSource starts the same frame with loop=true and identical clip length, and per-bar amplitude
|
||
/// envelopes reach ~zero at each bar boundary so both the chord changes and the loop point are click-free
|
||
/// (the <c>AmbientAudioSystem.Snap</c> trick generalized to enveloped segments). The MIX is the state
|
||
/// machine: layer volumes ease toward targets chosen from replicated state only — <see cref="RunInfo"/>
|
||
/// lifecycle (staging / combat / boss / reward lull), <see cref="CycleState"/> siege, and the terminal
|
||
/// <see cref="RunOutcome"/> (one-shot victory/defeat sting + aftermath bed). Observe-only presentation
|
||
/// system: no sim writes, no determinism surface; asset-free per the project convention. Sits under SFX at
|
||
/// <see cref="MasterVolume"/> × <see cref="GameVolume.Music"/>; the low <c>AmbientAudioSystem</c> drone
|
||
/// (vol 0.10) remains as texture beneath it.
|
||
/// </summary>
|
||
[WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
|
||
[UpdateInGroup(typeof(PresentationSystemGroup))]
|
||
public partial class MusicSystem : SystemBase
|
||
{
|
||
const float MasterVolume = 0.45f;
|
||
const float FadePerSecond = 0.30f;
|
||
|
||
// ---- shared musical grid: 100 BPM, 4/4, one chord per bar, 4 bars ----
|
||
const int SampleRate = 44100;
|
||
const float BarSeconds = 2.4f; // 4 beats @ 0.6 s
|
||
const int Bars = 4;
|
||
const float LoopSeconds = BarSeconds * Bars; // 9.6 s
|
||
|
||
// Am – F – C – G (natural-minor loop; index = bar): root/third/fifth per chord.
|
||
static readonly float[][] ChordHz =
|
||
{
|
||
new[] { 110.00f, 130.81f, 164.81f }, // Am: A2 C3 E3
|
||
new[] { 87.31f, 110.00f, 130.81f }, // F: F2 A2 C3
|
||
new[] { 130.81f, 164.81f, 196.00f }, // C: C3 E3 G3
|
||
new[] { 98.00f, 123.47f, 146.83f }, // G: G2 B2 D3
|
||
};
|
||
|
||
GameObject _root;
|
||
AudioSource _bass, _pad, _arp, _pulse;
|
||
float _vBass, _vPad, _vArp, _vPulse; // current smoothed volumes (pre-master)
|
||
byte _outcomePlayed; // which terminal outcome's sting has fired (0 = none)
|
||
|
||
protected override void OnStartRunning()
|
||
{
|
||
if (_root != null) return;
|
||
_root = new GameObject("~Music");
|
||
_bass = MakeSource(BuildBassLoop());
|
||
_pad = MakeSource(BuildPadLoop());
|
||
_arp = MakeSource(BuildArpLoop());
|
||
_pulse = MakeSource(BuildPulseLoop());
|
||
// Same frame, same length, loop=true -> phase-locked for the whole session.
|
||
_bass.Play(); _pad.Play(); _arp.Play(); _pulse.Play();
|
||
}
|
||
|
||
protected override void OnDestroy()
|
||
{
|
||
if (_root != null) Object.Destroy(_root);
|
||
}
|
||
|
||
AudioSource MakeSource(AudioClip clip)
|
||
{
|
||
var src = _root.AddComponent<AudioSource>();
|
||
src.clip = clip;
|
||
src.loop = true;
|
||
src.playOnAwake = false;
|
||
src.spatialBlend = 0f;
|
||
src.volume = 0f;
|
||
return src;
|
||
}
|
||
|
||
protected override void OnUpdate()
|
||
{
|
||
if (_bass == null) return;
|
||
|
||
// ---- pick the mix from replicated state (defaults = quiet staging bed) ----
|
||
float tBass = 0.50f, tPad = 0.55f, tArp = 0.12f, tPulse = 0f;
|
||
|
||
bool haveRun = SystemAPI.TryGetSingleton<RunInfo>(out var run);
|
||
SystemAPI.TryGetSingleton<CycleState>(out var cyc);
|
||
bool siege = cyc.Phase == CyclePhase.Siege;
|
||
bool finalSiege = siege && SystemAPI.TryGetSingleton<GoalProgress>(out var goal)
|
||
&& goal.Target > 0 && goal.Charge >= goal.Target;
|
||
|
||
byte outcome = SystemAPI.TryGetSingleton<RunOutcome>(out var oc) ? oc.Value : RunOutcomeId.InProgress;
|
||
if (outcome != RunOutcomeId.InProgress)
|
||
{
|
||
if (_outcomePlayed != outcome)
|
||
{
|
||
_outcomePlayed = outcome;
|
||
PlayOutcomeSting(outcome == RunOutcomeId.Victory);
|
||
}
|
||
tBass = 0.20f; tPad = 0.45f; tArp = 0f; tPulse = 0f; // aftermath bed under the banner
|
||
}
|
||
else if (siege)
|
||
{
|
||
tBass = 0.70f; tPad = 0.40f; tArp = 0.60f; tPulse = finalSiege ? 0.90f : 0.65f;
|
||
}
|
||
else if (haveRun)
|
||
{
|
||
switch (run.Lifecycle)
|
||
{
|
||
case RunLifecycle.Launching:
|
||
tBass = 0.55f; tPad = 0.50f; tArp = 0.35f; tPulse = 0.20f; // anticipation swell
|
||
break;
|
||
case RunLifecycle.InRoom:
|
||
bool boss = run.CurrentRoomType == RoomTypeId.Boss;
|
||
tBass = boss ? 0.75f : 0.65f;
|
||
tPad = 0.40f;
|
||
tArp = boss ? 0.80f : 0.65f;
|
||
tPulse = boss ? 0.75f : 0.35f;
|
||
break;
|
||
case RunLifecycle.RoomReward:
|
||
case RunLifecycle.RouteSelect:
|
||
tBass = 0.45f; tPad = 0.55f; tArp = 0.25f; tPulse = 0.08f; // between-rooms lull
|
||
break;
|
||
case RunLifecycle.Returning:
|
||
tBass = 0.45f; tPad = 0.60f; tArp = 0.15f; tPulse = 0f; // resolution
|
||
break;
|
||
// Staging keeps the defaults.
|
||
}
|
||
}
|
||
|
||
float dt = SystemAPI.Time.DeltaTime * FadePerSecond;
|
||
_vBass = Mathf.MoveTowards(_vBass, tBass, dt);
|
||
_vPad = Mathf.MoveTowards(_vPad, tPad, dt);
|
||
_vArp = Mathf.MoveTowards(_vArp, tArp, dt);
|
||
_vPulse = Mathf.MoveTowards(_vPulse, tPulse, dt);
|
||
|
||
float master = MasterVolume * GameVolume.Music;
|
||
_bass.volume = _vBass * master;
|
||
_pad.volume = _vPad * master;
|
||
_arp.volume = _vArp * master;
|
||
_pulse.volume = _vPulse * master;
|
||
}
|
||
|
||
void PlayOutcomeSting(bool victory)
|
||
{
|
||
// Victory: rising A-minor->major-feel arpeggio; defeat: falling minor third crawl.
|
||
float[] notes = victory
|
||
? new[] { 220f, 277.18f, 329.63f, 440f } // A3 C#4 E4 A4 (picardy lift)
|
||
: new[] { 220f, 207.65f, 174.61f, 146.83f }; // A3 Ab3 F3 D3
|
||
var clip = BuildStingClip(notes, victory ? 0.16f : 0.28f, victory ? 0.45f : 0.40f);
|
||
if (_pad != null) _pad.PlayOneShot(clip, 0.9f * GameVolume.Music);
|
||
}
|
||
|
||
// ================= clip builders (deterministic, asset-free) =================
|
||
|
||
static AudioClip NewLoopClip(string name, out float[] data)
|
||
{
|
||
int len = (int)(LoopSeconds * SampleRate);
|
||
data = new float[len];
|
||
return AudioClip.Create(name, len, 1, SampleRate, false);
|
||
}
|
||
|
||
/// <summary>Bar-local envelope that is ~0 at both bar edges (click-free chord changes + loop point).</summary>
|
||
static float BarEnv(float tInBar, float attack, float release)
|
||
{
|
||
float up = Mathf.Clamp01(tInBar / attack);
|
||
float down = Mathf.Clamp01((BarSeconds - tInBar) / release);
|
||
return up * up * down;
|
||
}
|
||
|
||
static AudioClip BuildBassLoop()
|
||
{
|
||
var clip = NewLoopClip("music_bass", out var data);
|
||
for (int i = 0; i < data.Length; i++)
|
||
{
|
||
float t = i / (float)SampleRate;
|
||
int bar = Mathf.Min(Bars - 1, (int)(t / BarSeconds));
|
||
float tb = t - bar * BarSeconds;
|
||
float f = ChordHz[bar][0] * 0.5f; // root, an octave down
|
||
float s = Mathf.Sin(2f * Mathf.PI * f * t) * 0.8f
|
||
+ Mathf.Sin(2f * Mathf.PI * f * 2f * t) * 0.2f;
|
||
data[i] = s * BarEnv(tb, 0.03f, 0.12f) * 0.50f;
|
||
}
|
||
clip.SetData(data, 0);
|
||
return clip;
|
||
}
|
||
|
||
static AudioClip BuildPadLoop()
|
||
{
|
||
var clip = NewLoopClip("music_pad", out var data);
|
||
for (int i = 0; i < data.Length; i++)
|
||
{
|
||
float t = i / (float)SampleRate;
|
||
int bar = Mathf.Min(Bars - 1, (int)(t / BarSeconds));
|
||
float tb = t - bar * BarSeconds;
|
||
var chord = ChordHz[bar];
|
||
float s = 0f;
|
||
for (int n = 0; n < chord.Length; n++)
|
||
s += Mathf.Sin(2f * Mathf.PI * chord[n] * t + n * 1.7f);
|
||
float trem = 0.85f + 0.15f * Mathf.Sin(2f * Mathf.PI * 0.8f * t);
|
||
data[i] = s / 3f * BarEnv(tb, 0.45f, 0.50f) * trem * 0.34f;
|
||
}
|
||
clip.SetData(data, 0);
|
||
return clip;
|
||
}
|
||
|
||
static AudioClip BuildArpLoop()
|
||
{
|
||
var clip = NewLoopClip("music_arp", out var data);
|
||
const float noteLen = BarSeconds / 8f; // 8th notes
|
||
for (int i = 0; i < data.Length; i++)
|
||
{
|
||
float t = i / (float)SampleRate;
|
||
int bar = Mathf.Min(Bars - 1, (int)(t / BarSeconds));
|
||
float tb = t - bar * BarSeconds;
|
||
int step = Mathf.Min(7, (int)(tb / noteLen));
|
||
float tn = tb - step * noteLen;
|
||
var chord = ChordHz[bar];
|
||
// up-and-over pattern: root, fifth, octave, tenth, back down
|
||
float f = step switch
|
||
{
|
||
0 => chord[0] * 2f,
|
||
1 => chord[2] * 2f,
|
||
2 => chord[0] * 4f,
|
||
3 => chord[1] * 4f,
|
||
4 => chord[2] * 4f,
|
||
5 => chord[0] * 4f,
|
||
6 => chord[2] * 2f,
|
||
_ => chord[1] * 2f,
|
||
};
|
||
float env = Mathf.Exp(-9f * tn);
|
||
data[i] = Mathf.Sin(2f * Mathf.PI * f * tn) * env * 0.32f;
|
||
}
|
||
clip.SetData(data, 0);
|
||
return clip;
|
||
}
|
||
|
||
static AudioClip BuildPulseLoop()
|
||
{
|
||
var clip = NewLoopClip("music_pulse", out var data);
|
||
const float beat = BarSeconds / 4f;
|
||
uint rng = 0x5EED5EEDu; // deterministic hat noise
|
||
for (int i = 0; i < data.Length; i++)
|
||
{
|
||
float t = i / (float)SampleRate;
|
||
float tBeat = t % beat;
|
||
// Low thump on every beat: 55->38 Hz sweep, tight decay.
|
||
float thump = 0f;
|
||
if (tBeat < 0.14f)
|
||
{
|
||
float f = Mathf.Lerp(55f, 38f, tBeat / 0.14f);
|
||
thump = Mathf.Sin(2f * Mathf.PI * f * tBeat) * Mathf.Exp(-22f * tBeat) * 0.85f;
|
||
}
|
||
// Off-beat hat: a 30 ms noise tick halfway through each beat.
|
||
float tHat = (t + beat * 0.5f) % beat;
|
||
float hat = 0f;
|
||
if (tHat < 0.03f)
|
||
{
|
||
rng ^= rng << 13; rng ^= rng >> 17; rng ^= rng << 5; // xorshift
|
||
float n = (rng & 0xFFFF) / 32768f - 1f;
|
||
hat = n * Mathf.Exp(-120f * tHat) * 0.22f;
|
||
}
|
||
data[i] = thump + hat;
|
||
}
|
||
clip.SetData(data, 0);
|
||
return clip;
|
||
}
|
||
|
||
static AudioClip BuildStingClip(float[] notes, float noteLen, float vol)
|
||
{
|
||
int len = (int)(notes.Length * noteLen * SampleRate) + SampleRate / 2; // + half-second tail
|
||
var clip = AudioClip.Create("music_sting", len, 1, SampleRate, false);
|
||
var data = new float[len];
|
||
for (int n = 0; n < notes.Length; n++)
|
||
{
|
||
int start = (int)(n * noteLen * SampleRate);
|
||
int dur = (int)(SampleRate * (noteLen + (n == notes.Length - 1 ? 0.5f : 0.05f)));
|
||
for (int i = 0; i < dur && start + i < len; i++)
|
||
{
|
||
float tn = i / (float)SampleRate;
|
||
data[start + i] += Mathf.Sin(2f * Mathf.PI * notes[n] * tn) * Mathf.Exp(-4.5f * tn) * vol;
|
||
}
|
||
}
|
||
clip.SetData(data, 0);
|
||
return clip;
|
||
}
|
||
}
|
||
}
|