Search the source of every open source package.
348 results
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Sandbox;
namespace SFXR;
[Title( "SFXR Component" )]
[Category( "SFXR" )]
[Icon( "volume_up" )]
public sealed class SFXRComponent : Component
{
/// <summary>
/// The base Waveform
/// (Default: Square)
/// </summary>
[Property, Group( "Sound" )]
public Waveform Waveform { get; set; } = Waveform.Square;
/// <summary>
/// The sample rate of the sound
/// </summary>
[Property, Group( "Sound" )]
public SampleRate SampleRate { get; set; } = SampleRate.Hz44100;
/// <summary>
/// The bit depth of the sound
/// </summary>
// [Property, Group( "Sound" )]
public BitDepth BitDepth { get; set; } = BitDepth.Bit16;
/// <summary>
/// The length of the sound in seconds
/// </summary>
[Property, Group( "Sound" ), Range( 0f, 20f, 0.01f )]
public float Length { get; set; } = 0.5f;
/// <summary>
/// The volume of the sound
/// (Default: 0.5)
/// </summary>
[Property, Group( "Sound" ), Range( 0f, 1f, 0.01f )]
public float MasterVolume { get; set; } = 0.5f;
[Property, Group( "Frequency" ), Range( 0, 3000f, 1f )]
float StartFrequency
{
get => Frequency.Start;
set => Frequency.Start = value;
}
[Property, Group( "Frequency" ), Range( -3000f, 3000f, 1f )]
float Slide
{
get => Frequency.Slide;
set => Frequency.Slide = value;
}
[Property, Group( "Frequency" ), Range( -3000f, 3000f, 1f )]
float SlideDelta
{
get => Frequency.DeltaSlide;
set => Frequency.DeltaSlide = value;
}
/// <summary>
/// The random seed
/// </summary>
[Property, Group( "Controls" )]
public long Seed { get; set; } = 0;
[Property, Group( "Controls" )]
public SFXRControls Controls { get; set; } = new SFXRControls();
public SFXRFrequency Frequency { get; set; } = new SFXRFrequency();
Random _random = new Random();
List<SFXRNote> NotesPlaying = new();
/// <summary>
/// Plays the sound defined by the component
/// </summary>
/// <returns>The sound handle of the sound. This can be used to change position, pitch, ect</returns>
public SoundHandle PlaySound()
{
var sfx = Generate( (int)(Length * (int)SampleRate) );
var handle = sfx.Play();
// DestroyStream(sfx, Length);
return handle;
}
/// <summary>
/// Plays the sound defined by the component (Via a frequency trigger. This will play indefinitely until released)
/// </summary>
/// <param name="frequency">The frequency of the sound</param>
/// <param name="volume">The volume of the trigger </param>
public void TriggerNotePress( float frequency, float volume = 1f )
{
foreach ( var note in NotesPlaying.Where( x => x.Frequency == frequency ) )
{
note.Release();
}
var newNote = new SFXRNote( this, frequency, volume );
newNote.Trigger();
NotesPlaying.Add( newNote );
}
/// <summary>
/// Releases a note playing at the given frequency
/// </summary>
/// <param name="frequency">The frequency of the sound</param>
public void TriggerNoteRelease( float frequency )
{
foreach ( var note in NotesPlaying.Where( x => x.Frequency == frequency ) )
{
note.Release();
}
}
/// <summary>
/// Releases all notes playing
/// </summary>
public void TriggerReleaseAll()
{
foreach ( var note in NotesPlaying )
{
note.Release();
}
}
/// <summary>
/// Generates a sound stream from the component
/// </summary>
/// <param name="sampleCount">How many samples the stream should be filled with</param>
/// <returns></returns>
public SoundStream Generate( int sampleCount )
{
List<SFXREffect> effects = new();
foreach ( var component in GameObject.Components.GetAll() )
{
if ( component is not SFXREffect effect || !effect.Enabled ) continue;
effects.Add( effect );
}
return Generate( sampleCount, effects );
}
/// <summary>
/// Generates a sound stream from the component with the given effects
/// </summary>
/// <param name="sampleCount">The number of samples</param>
/// <param name="effects">A list of the effects to apply</param>
/// <returns></returns>
public SoundStream Generate( int sampleCount, List<SFXREffect> effects )
{
short[] samples = new short[sampleCount];
float t = 0;
for ( int i = 0; i < sampleCount; i++ )
{
t += 1f / (int)SampleRate;
short sampleValue = SFXR.GetWaveformSample( Waveform, t, Frequency.GetFrequency( t ) );
sampleValue = (short)((float)sampleValue * MasterVolume);
samples[i] = sampleValue;
}
foreach ( var effect in effects )
{
if ( !effect.Enabled ) continue;
samples = effect.Apply( samples, this );
}
var stream = new SoundStream( (int)SampleRate );
stream.WriteData( samples );
return stream;
}
/// <summary>
/// Randomizes the component's parameters
/// </summary>
public void Randomize()
{
if ( Seed != 0 ) _random = new Random( (int)Seed );
var waveform = Waveform;
ResetParameters();
Waveform = waveform;
Frequency.Start = _random.Next( 10, 3000 );
if ( _random.Next( 2 ) == 0 ) Frequency.Slide = _random.Next( -3000, 3000 );
if ( Frequency.Start > 2000 && Frequency.Slide > 200 ) Frequency.Slide = -Frequency.Slide;
else if ( Frequency.Start < 400 && Frequency.Slide < -50 ) Frequency.Slide = -Frequency.Slide;
if ( _random.Next( 2 ) == 0 ) Frequency.DeltaSlide = _random.Next( -3000, 3000 );
SanitizeParameters();
}
/// <summary>
/// Mutates the component's parameters slightly
/// </summary>
public void Mutate( float mutation = 0.05f )
{
if ( Seed != 0 ) _random = new Random( (int)Seed );
Frequency.Start += _random.Float( -mutation, mutation ) * 1000;
if ( Frequency.Start > 2000 && Frequency.Slide > 200 ) Frequency.Slide = -Frequency.Slide;
else if ( Frequency.Start < 400 && Frequency.Slide < -50 ) Frequency.Slide = -Frequency.Slide;
Frequency.Slide += _random.Float( -mutation, mutation ) * 1000;
Frequency.DeltaSlide += _random.Float( -mutation, mutation ) * 1000;
if ( Frequency.Slide < -3000 ) Frequency.Slide = -3000;
if ( Frequency.Slide > 3000 ) Frequency.Slide = 3000;
SanitizeParameters();
}
public void RandomizePickup()
{
if ( Seed != 0 ) _random = new Random( (int)Seed );
ResetParameters();
foreach ( var component in GameObject.Components.GetAll() )
{
if ( component is not SFXREffect effect ) continue;
effect.Enabled = false;
}
var envelope = Components.GetOrCreate<SFXREnvelope>();
Waveform = (Waveform)_random.Int( 0, 2 );
Frequency.Start = _random.Float( 0.4f, 0.9f ) * 3000;
envelope.Enabled = true;
envelope.Attack = 0;
envelope.Decay = _random.Float( 0.1f, 0.3f );
envelope.Sustain = _random.Float( 0f, 0.1f );
envelope.Release = _random.Float( 0.1f, 0.3f );
Length = envelope.Attack + envelope.Sustain + envelope.Decay + envelope.Release;
}
public void RandomizeLaser()
{
if ( Seed != 0 ) _random = new Random( (int)Seed );
ResetParameters();
foreach ( var component in GameObject.Components.GetAll() )
{
if ( component is not SFXREffect effect ) continue;
effect.Enabled = false;
}
var envelope = Components.GetOrCreate<SFXREnvelope>();
var highpass = Components.GetOrCreate<SFXRHighPass>();
Waveform = (Waveform)_random.Int( 0, 2 );
if ( Waveform == Waveform.Sine && _random.Next( 2 ) == 0 ) Waveform = (Waveform)_random.Int( 0, 1 );
Frequency.Start = _random.Float( 0.6f, 0.75f ) * 3000;
Frequency.Slide = _random.Float( -0.25f, -0.15f ) * 3000;
envelope.Enabled = true;
envelope.Attack = 0;
envelope.Decay = _random.Float( 0f, 0.4f );
envelope.Sustain = _random.Float( 0.1f, 0.3f );
envelope.Release = _random.Float( 0.25f, 0.3f );
Length = envelope.Attack + envelope.Sustain + envelope.Decay + envelope.Release;
if ( _random.Next( 2 ) == 0 )
{
highpass.Enabled = true;
highpass.Cutoff = _random.Float( 0f, 0.3f );
}
}
public void RandomizeExplosion()
{
if ( Seed != 0 ) _random = new Random( (int)Seed );
ResetParameters();
foreach ( var component in GameObject.Components.GetAll() )
{
if ( component is not SFXREffect effect ) continue;
effect.Enabled = false;
}
var envelope = Components.GetOrCreate<SFXREnvelope>();
var vibrato = Components.GetOrCreate<SFXRVibrato>();
Waveform = Waveform.Noise;
if ( _random.Next( 2 ) == 0 )
{
Frequency.Start = _random.Float( 0.025f, 0.15f ) * 3000;
Frequency.Slide = _random.Float( -0.1f, -0.01f ) * 3000;
}
else
{
Frequency.Start = _random.Float( 0.1f, 0.2f ) * 3000;
Frequency.Slide = _random.Float( -0.6f, 0.6f ) * 3000;
}
if ( _random.Next( 4 ) == 0 ) Frequency.Slide = 0;
envelope.Enabled = true;
envelope.Attack = 0;
envelope.Sustain = _random.Float( 0.1f, 0.4f );
envelope.Release = _random.Float( 0.1f, 0.3f );
Length = envelope.Attack + envelope.Sustain + envelope.Decay + envelope.Release;
if ( _random.Next( 2 ) == 0 )
{
vibrato.Enabled = true;
vibrato.Depth = _random.Float( 0f, 0.7f );
vibrato.Speed = _random.Float( 0f, 60f );
}
else
{
vibrato.Enabled = false;
}
if ( -Frequency.Slide > Frequency.Start )
{
Frequency.Slide = -Frequency.Start;
}
}
public void RandomizePowerup()
{
if ( Seed != 0 ) _random = new Random( (int)Seed );
ResetParameters();
foreach ( var component in GameObject.Components.GetAll() )
{
if ( component is not SFXREffect effect ) continue;
effect.Enabled = false;
}
var envelope = Components.GetOrCreate<SFXREnvelope>();
var vibrato = Components.GetOrCreate<SFXRVibrato>();
if ( _random.Next( 2 ) == 0 )
{
Waveform = Waveform.Sawtooth;
}
if ( _random.Next( 2 ) == 0 )
{
Frequency.Start = _random.Float( 0.2f, 0.5f ) * 3000;
Frequency.Slide = _random.Float( 0.1f, 0.5f ) * 3000;
}
else
{
Frequency.Start = _random.Float( 0.25f, 0.5f ) * 3000;
Frequency.Slide = _random.Float( 0.05f, 0.25f ) * 3000;
if ( _random.Next( 2 ) == 0 )
{
vibrato.Enabled = true;
vibrato.Depth = _random.Float( 0, 0.7f );
vibrato.Speed = _random.Float( 0, 60f );
}
else
{
vibrato.Enabled = false;
}
}
if ( -Frequency.Slide > Frequency.Start )
{
Frequency.Slide = -Frequency.Start;
}
envelope.Enabled = true;
envelope.Attack = 0;
envelope.Sustain = _random.Float( 0f, 0.4f );
envelope.Release = _random.Float( 0.1f, 0.5f );
Length = envelope.Attack + envelope.Sustain + envelope.Decay + envelope.Release;
}
public void RandomizeHit()
{
if ( Seed != 0 ) _random = new Random( (int)Seed );
ResetParameters();
foreach ( var component in GameObject.Components.GetAll() )
{
if ( component is not SFXREffect effect ) continue;
effect.Enabled = false;
}
var envelope = Components.GetOrCreate<SFXREnvelope>();
var highpass = Components.GetOrCreate<SFXRHighPass>();
Waveform = (Waveform)_random.Int( 0, 3 );
if ( Waveform == Waveform.Sine )
{
Waveform = Waveform.Noise;
}
Frequency.Start = _random.Float( 0.1f, 0.5f ) * 3000;
Frequency.Slide = _random.Float( -0.7f, -0.3f ) * 3000;
if ( -Frequency.Slide > Frequency.Start )
{
Frequency.Slide = -Frequency.Start;
}
envelope.Enabled = true;
envelope.Attack = 0;
envelope.Decay = 0;
envelope.Sustain = _random.Float( 0.025f, 0.1f );
envelope.Release = _random.Float( 0.1f, 0.3f );
Length = envelope.Attack + envelope.Sustain + envelope.Decay + envelope.Release;
if ( _random.Next( 2 ) == 0 )
{
highpass.Enabled = true;
highpass.Cutoff = _random.Float( 0f, 0.3f );
}
else
{
highpass.Enabled = false;
}
}
public void RandomizeJump()
{
if ( Seed != 0 ) _random = new Random( (int)Seed );
ResetParameters();
foreach ( var component in GameObject.Components.GetAll() )
{
if ( component is not SFXREffect effect ) continue;
effect.Enabled = false;
}
var envelope = Components.GetOrCreate<SFXREnvelope>();
Waveform = Waveform.Square;
Frequency.Start = _random.Float( 0.3f, 0.6f ) * 3000;
Frequency.Slide = _random.Float( 0.1f, 0.3f ) * 3000;
if ( -Frequency.Slide > Frequency.Start )
{
Frequency.Slide = -Frequency.Start;
}
envelope.Enabled = true;
envelope.Attack = 0;
envelope.Sustain = _random.Float( 0.1f, 0.4f );
envelope.Release = _random.Float( 0.1f, 0.3f );
Length = envelope.Attack + envelope.Sustain + envelope.Decay + envelope.Release;
}
public void RandomizeBlip()
{
if ( Seed != 0 ) _random = new Random( (int)Seed );
ResetParameters();
foreach ( var component in GameObject.Components.GetAll() )
{
if ( component is not SFXREffect effect ) continue;
effect.Enabled = false;
}
var envelope = Components.GetOrCreate<SFXREnvelope>();
Waveform = Waveform.Square;
Frequency.Start = _random.Float( 0.2f, 0.6f ) * 3000;
envelope.Enabled = true;
envelope.Attack = 0;
envelope.Decay = _random.Float( 0.1f, 0.2f );
envelope.Sustain = _random.Float( 0.025f, 0.1f );
envelope.Release = _random.Float( 0.1f, 0.3f );
Length = envelope.Attack + envelope.Sustain + envelope.Decay + envelope.Release;
}
public void ResetParameters()
{
Waveform = Waveform.Square;
SampleRate = SampleRate.Hz44100;
BitDepth = BitDepth.Bit16;
Length = 0.5f;
MasterVolume = 0.5f;
Frequency = new SFXRFrequency();
Controls = new SFXRControls();
}
void SanitizeParameters()
{
}
protected override void OnUpdate()
{
foreach ( var note in NotesPlaying )
{
note.Update();
// if (!note.IsPlaying)
// {
// note.DestroyStreams();
// }
}
NotesPlaying.RemoveAll( x => !x.IsPlaying );
}
}
using System;
using System.Collections.Generic;
using Sandbox;
namespace SFXR;
[Title( "ADSR Envelope" )]
[Category( "SFXR Effects" )]
[Icon( "mail_outline" )]
public class SFXREnvelope : SFXREffect
{
/// <summary>
/// Time the sound takes to reach its peak amplitude
/// (Default: 0)
/// </summary>
[Property, Range( 0, 10 )]
public float Attack { get; set; } = 0;
/// <summary>
/// The time taken for the sound to fade to the sustain level
/// </summary>
[Property, Range( 0, 10 )]
public float Decay { get; set; } = 0;
/// <summary>
/// The level maintained until release is triggered
/// (Default: 1)
/// </summary>
[Property, Range( 0, 1 )]
public float Sustain { get; set; } = 1f;
/// <summary>
/// The time taken for the sound to fade to zero after the sustain
/// (Default: 0.3)
/// </summary>
[Property, Range( 0, 10 )]
public float SustainTime { get; set; } = 0.3f;
/// <summary>
/// The time taken for the sound to fade to zero after the release
/// (Default: 0.4)
/// </summary>
[Property, Range( 0, 10 )]
public float Release { get; set; } = 0.4f;
/// <summary>
/// Returns the amplitude of the envelope at a given time
/// </summary>
/// <param name="time">Time in seconds</param>
/// <returns>Amplitude of the envelope at the given time</returns>
public float GetAmplitude( float time )
{
return GetCurve().Evaluate( time / GetLength() );
}
public override short[] Apply( short[] samples, SFXRComponent sound )
{
// Calculate the envelope amplitude for each sample
for ( int i = 0; i < samples.Length; i++ )
{
float t = i / (float)sound.SampleRate;
float amplitude = GetAmplitude( t );
samples[i] = (short)(samples[i] * amplitude);
}
return samples;
}
public float GetLength()
{
return Attack + Decay + SustainTime + Release;
}
public Curve GetCurve()
{
Curve curve = new();
List<Vector2> points = new();
// Add the attack curve
points.Add( new Vector2( 0, 0 ) );
points.Add( new Vector2( Attack, 1 ) );
// Add the decay curve
points.Add( new Vector2( Attack + Decay, Sustain ) );
// Add the sustain curve
points.Add( new Vector2( Attack + Decay + SustainTime, Sustain ) );
// Add the release curve
points.Add( new Vector2( Attack + Decay + SustainTime + Release, 0 ) );
// Normalize the curve to 0-1 in the x
for ( int i = 0; i < points.Count; i++ )
{
points[i] = new Vector2( points[i].x / (Attack + Decay + SustainTime + Release), points[i].y );
}
// Add the points to the curve
foreach ( var point in points )
{
curve.AddPoint( point.x, point.y );
}
return curve;
}
}using Sandbox;
public sealed class SceneTrigger : Component, Component.ITriggerListener
{
[Property] public SceneFile SceneFile { get; set; }
protected override void OnUpdate()
{
}
void ITriggerListener.OnTriggerEnter(Sandbox.Collider other)
{
if (other.GameObject.Parent.Tags.Has("player") || other.GameObject.Tags.Has("boat"))
{
Game.ActiveScene.Load(SceneFile);
}
}
void ITriggerListener.OnTriggerExit(Sandbox.Collider other)
{
}
}
using System.Collections.Generic;
namespace Sandbox;
/// <summary>
/// How to use the system:
/// <code>
/// public sealed class ExampleComponent : Component
/// {
/// // Reference to the system.
/// private FixedUpdateInputSystem _fixedInput;
///
/// protected override void Start()
/// {
/// // Get the reference like this:
/// _fixedInput = Scene.GetSystem<FixedUpdateInputSystem>();
///
/// base.OnStart();
/// }
///
/// protected override void OnFixedUpdate()
/// {
/// // Query for input like usual.
/// if( _fixedInput.Pressed("jump") )
/// {
/// Log.Info("Jumped");
/// }
///
/// base.OnFixedUpdate();
/// }
/// }
/// </code>
/// </summary>
public sealed class FixedUpdateInputSystem : GameObjectSystem
{
private struct FixedUpdateInputBuffer
{
private class State
{
public bool Held;
public bool Pressed;
public bool Released;
}
private Dictionary<string, State> _actionStates;
public FixedUpdateInputBuffer()
{
_actionStates = new Dictionary<string, State>();
foreach ( var b in Input.GetActions() )
{
_actionStates[b.Name.ToLowerInvariant()] = new State();
}
}
/// <summary>
/// Call from a <see cref="Component.OnUpdate"/> method
/// to update the states of the actions.
/// </summary>
public void OnUpdate()
{
foreach ( var (name, state) in _actionStates )
{
if ( Input.Down( name ) )
_actionStates[name].Held = true;
if ( Input.Pressed( name ) )
_actionStates[name].Pressed = true;
if ( Input.Released( name ) )
_actionStates[name].Released = true;
}
}
/// <summary>
/// Call from a <see cref="Component.OnFixedUpdate"/>
/// method to get the <see cref="State.Held"/> state of this action.
/// </summary>
/// <param name="action">The action name (case insensitive).</param>
/// <returns></returns>
///
public bool Held( string action )
{
return _actionStates[action.ToLowerInvariant()].Held;
}
/// <summary>
/// Call from a <see cref="Component.OnFixedUpdate"/>
/// method to get the <see cref="State.Pressed"/> state of this action.
/// </summary>
/// <param name="action">The action name (case insensitive).</param>
/// <returns></returns>
public bool Pressed( string action )
{
return _actionStates[action.ToLowerInvariant()].Pressed;
}
/// <summary>
/// Call from a <see cref="Component.OnFixedUpdate"/>
/// method to get the <see cref="State.Pressed"/> state of this action.
/// </summary>
/// <param name="action">The action name (case insensitive).</param>
/// <returns></returns>
public bool Released( string action )
{
return _actionStates[action.ToLowerInvariant()].Released;
}
/// <summary>
/// Call at the end of your <see cref="Component.OnFixedUpdate"/> method
/// to clear the state of the struct and reset.
/// </summary>
public void Clear()
{
foreach ( var actionName in _actionStates.Keys )
{
_actionStates[actionName].Held = false;
_actionStates[actionName].Pressed = false;
}
}
}
private FixedUpdateInputBuffer _buffer;
public FixedUpdateInputSystem( Scene scene ) : base( scene )
{
_buffer = new();
Listen( Stage.StartUpdate, int.MinValue, OnStartUpdate, "FUIB.OnStartUpdate" );
Listen( Stage.FinishFixedUpdate, int.MaxValue, OnFinishFixedUpdate, "FUIB.OnFinishFixedUpdate" );
}
private void OnStartUpdate()
{
_buffer.OnUpdate();
}
private void OnFinishFixedUpdate()
{
_buffer.Clear();
}
/// <summary>
/// Is the action currently held down?
/// </summary>
/// <param name="action">The action name (case insensitive).</param>
/// <returns></returns>
///
public bool Held( string action ) => _buffer.Held( action );
/// <summary>
/// Was the action pressed?
/// </summary>
/// <param name="action">The action name (case insensitive).</param>
/// <returns></returns>
public bool Pressed( string action ) => _buffer.Pressed( action );
/// <summary>
/// Was the action released?
/// </summary>
/// <param name="action">The action name (case insensitive).</param>
/// <returns></returns>
public bool Released( string action ) => _buffer.Released( action );
}
using System;
namespace Sandbox.Events;
/// <summary>
/// Only valid on <see cref="IGameEventHandler{T}.OnGameEvent"/> implementations. Forces this
/// event handler to be invoked before any handlers not marked as early, except if more specific
/// constraints are given (i.e., <see cref="BeforeAttribute{T}"/>, <see cref="AfterAttribute{T}"/>).
/// </summary>
[AttributeUsage( AttributeTargets.Method )]
public sealed class EarlyAttribute : Attribute
{
}
/// <summary>
/// Only valid on <see cref="IGameEventHandler{T}.OnGameEvent"/> implementations. Forces this
/// event handler to be invoked after any handlers not marked as late, except if more specific
/// constraints are given (i.e., <see cref="BeforeAttribute{T}"/>, <see cref="AfterAttribute{T}"/>).
/// </summary>
[AttributeUsage( AttributeTargets.Method )]
public sealed class LateAttribute : Attribute
{
}
internal interface IBeforeAttribute
{
Type Type { get; }
}
internal interface IAfterAttribute
{
Type Type { get; }
}
/// <summary>
/// Only valid on <see cref="IGameEventHandler{T}.OnGameEvent"/> implementations. Forces this
/// event handler to be invoked before any handlers in the specified type.
/// </summary>
[AttributeUsage( AttributeTargets.Method, AllowMultiple = true )]
public sealed class BeforeAttribute<T> : Attribute, IBeforeAttribute
{
Type IBeforeAttribute.Type => typeof(T);
}
/// <summary>
/// Only valid on <see cref="IGameEventHandler{T}.OnGameEvent"/> implementations. Forces this
/// event handler to be invoked after any handlers in the specified type.
/// </summary>
[AttributeUsage( AttributeTargets.Method, AllowMultiple = true )]
public sealed class AfterAttribute<T> : Attribute, IAfterAttribute
{
Type IAfterAttribute.Type => typeof( T );
}
using System.Collections.Generic;
using System.Linq;
namespace Sandbox.Events;
/// <summary>
/// Generate an ordering based on a set of first-most and last-most items, and
/// individual constraints between pairs of items. All first-most items will be
/// ordered before all last-most items, and any other items will be put in the
/// middle unless forced to be elsewhere by a constraint.
/// </summary>
internal class SortingHelper
{
public record struct SortConstraint( int EarlierIndex, int LaterIndex )
{
public SortConstraint Complement => new ( LaterIndex, EarlierIndex );
}
private readonly int _itemCount;
private readonly HashSet<SortConstraint> _initialConstraints = new HashSet<SortConstraint>();
private readonly HashSet<int> _first = new HashSet<int>();
private readonly HashSet<int> _last = new HashSet<int>();
public SortingHelper( int itemCount )
{
_itemCount = itemCount;
}
public void AddConstraint( int earlierIndex, int laterIndex )
{
_initialConstraints.Add( new SortConstraint( earlierIndex, laterIndex ) );
}
public void AddFirst( int earlierIndex )
{
_first.Add( earlierIndex );
}
public void AddLast( int laterIndex )
{
_last.Add( laterIndex );
}
public bool Sort( List<int> result, out SortConstraint invalidConstraint )
{
var middle = new HashSet<int>();
for ( var index = 0; index < _itemCount; ++index )
{
if ( !_first.Contains( index ) && !_last.Contains( index ) )
middle.Add( index );
}
var allConstraints = new HashSet<SortConstraint>();
var newConstraints = new Queue<SortConstraint>();
var beforeDict = new Dictionary<int, HashSet<int>>();
var afterDict = new Dictionary<int, HashSet<int>>();
bool AddWorkingConstraint( int earlierIndex, int laterIndex, out SortConstraint constraint )
{
constraint = new SortConstraint( earlierIndex, laterIndex );
if ( allConstraints.Contains( constraint.Complement ) )
return false;
if ( !allConstraints.Add( constraint ) )
return true;
newConstraints.Enqueue( constraint );
if ( !beforeDict.TryGetValue( earlierIndex, out var before ) )
beforeDict.Add( earlierIndex, before = new HashSet<int>() );
if ( !afterDict.TryGetValue( laterIndex, out var after ) )
afterDict.Add( laterIndex, after = new HashSet<int>() );
before.Add( laterIndex );
after.Add( earlierIndex );
return true;
}
// Add initial constraints
foreach ( var initialConstraint in _initialConstraints )
{
if ( !AddWorkingConstraint( initialConstraint.EarlierIndex, initialConstraint.LaterIndex, out invalidConstraint ) )
return false;
}
// Everything in _first should be before everything in _last
foreach ( var earlierIndex in _first )
{
foreach ( var laterIndex in _last )
{
if ( !AddWorkingConstraint( earlierIndex, laterIndex, out invalidConstraint ) )
return false;
}
}
// Keep propagating constraints until nothing changes
while ( newConstraints.TryDequeue( out var nextConstraint ) )
{
// if a < b, and b < c, then a < c etc
if ( beforeDict.TryGetValue( nextConstraint.LaterIndex, out var before ) )
{
foreach ( var laterIndex in before )
{
if ( !AddWorkingConstraint( nextConstraint.EarlierIndex, laterIndex, out invalidConstraint ) )
return false;
}
}
if ( afterDict.TryGetValue( nextConstraint.EarlierIndex, out var after ) )
{
foreach ( var earlierIndex in after )
{
if ( !AddWorkingConstraint( earlierIndex, nextConstraint.LaterIndex, out invalidConstraint ) )
{
return false;
}
}
}
}
// Now if we have any items that aren't using GroupOrder.First, and haven't
// determined that they are ordered before another item with GroupOrder.First,
// we can safely order them after all GroupOrder.First items. And vice versa.
foreach ( var middleIndex in middle )
{
var isBeforeAnyFirst = beforeDict.TryGetValue( middleIndex, out var before )
&& before.Any( x => _first.Contains( x ) );
var isAfterAnyLast = afterDict.TryGetValue( middleIndex, out var after )
&& after.Any( x => _last.Contains( x ) );
if ( !isBeforeAnyFirst )
{
foreach ( var earlierIndex in _first )
AddWorkingConstraint( earlierIndex, middleIndex, out invalidConstraint );
}
if ( !isAfterAnyLast )
{
foreach ( var laterIndex in _last )
AddWorkingConstraint( middleIndex, laterIndex, out invalidConstraint );
}
}
// Now lets add items to the final ordering if all items that should be sorted
// before them are already added to that ordering. We'll implement this by choosing
// items that have an empty list / don't appear in afterDict, and update that
// dictionary as we go.
var earliestRemaining = new Queue<int>();
// First, seed the queue with everything that's already not ordered after anything
for ( var index = 0; index < _itemCount; ++index )
{
if ( !afterDict.ContainsKey( index ) )
{
earliestRemaining.Enqueue( index );
}
}
result.Clear();
while ( earliestRemaining.TryDequeue( out var nextIndex ) )
{
result.Add( nextIndex );
foreach ( var laterIndex in beforeDict.TryGetValue( nextIndex, out var laterIndices )
? laterIndices : Enumerable.Empty<int>() )
{
var beforeLater = afterDict[laterIndex];
beforeLater.Remove( nextIndex );
if ( beforeLater.Count == 0 )
earliestRemaining.Enqueue( laterIndex );
}
}
invalidConstraint = default;
return result.Count == _itemCount;
}
}
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
namespace Sandbox.Events;
/// <summary>
/// Interface for event payloads that can be listened for by <see cref="IGameEventHandler{T}"/>s.
/// </summary>
public interface IGameEvent { }
/// <summary>
/// Interface for components that handle game events with a payload of type <see cref="T"/>.
/// </summary>
/// <typeparam name="T">Event payload type.</typeparam>
public interface IGameEventHandler<in T>
where T : IGameEvent
{
/// <summary>
/// Called when an event with payload of type <see cref="T"/> is dispatched on a <see cref="GameObject"/>
/// that contains this component, including on a descendant.
/// </summary>
/// <param name="eventArgs">Event payload.</param>
void OnGameEvent( T eventArgs );
}
/// <summary>
/// Helper for dispatching game events in a scene.
/// </summary>
public static class GameEvent
{
private static Dictionary<Type, IReadOnlyDictionary<Type, int>> HandlerOrderingCache { get; } = new();
/// <summary>
/// Notifies all <see cref="IGameEventHandler{T}"/> components that are within <paramref name="root"/>,
/// with a payload of type <typeparamref name="T"/>.
/// </summary>
public static void Dispatch<T>( this GameObject root, T eventArgs )
where T : IGameEvent
{
var handlers = (root is Scene scene
? scene.GetAllComponents<IGameEventHandler<T>>() // I think this is more efficient?
: root.Components.GetAll<IGameEventHandler<T>>())
.ToArray();
if ( !HandlerOrderingCache.TryGetValue( typeof(T), out var ordering ) || handlers.Any( x => !ordering.ContainsKey( x.GetType() ) ) )
{
ordering = HandlerOrderingCache[typeof(T)] = GetHandlerOrdering<T>();
}
List<Exception>? exceptions = null;
foreach ( var handler in handlers.OrderBy( x => ordering[x.GetType()] ) )
{
try
{
handler.OnGameEvent( eventArgs );
}
catch ( Exception e )
{
exceptions ??= new();
exceptions.Add( e );
}
}
switch ( exceptions?.Count )
{
case 1:
Log.Error( exceptions[0] );
break;
case > 1:
Log.Error( new AggregateException( exceptions ) );
break;
}
}
private static bool IsImplementingMethodName( string methodName )
{
if ( methodName == nameof(IGameEventHandler<IGameEvent>.OnGameEvent) )
{
return true;
}
return methodName.StartsWith( "Sandbox.Events.IGameEventHandler<" ) && methodName.EndsWith( ">.OnGameEvent" );
}
private static MethodDescription? GetImplementation<T>( TypeDescription type )
{
foreach ( var method in type.Methods )
{
if ( method.IsStatic ) continue;
if ( method.Parameters.Length != 1 ) continue;
if ( method.Parameters[0].ParameterType != typeof( T ) ) continue;
if ( !IsImplementingMethodName( method.Name ) ) continue;
return method;
}
return null;
}
private static IReadOnlyDictionary<Type, int> GetHandlerOrdering<T>()
where T : IGameEvent
{
var types = TypeLibrary.GetTypes<IGameEventHandler<T>>().ToArray();
var helper = new SortingHelper( types.Length );
for ( var i = 0; i < types.Length; ++i )
{
var type = types[i];
var method = GetImplementation<T>( type );
if ( method is null )
{
Log.Warning( $"Can't find {nameof( IGameEventHandler<T> )}<{typeof( T ).Name}> implementation in {type.Name}!" );
continue;
}
foreach ( var attrib in method.Attributes )
{
switch ( attrib )
{
case EarlyAttribute:
helper.AddFirst( i );
break;
case LateAttribute:
helper.AddLast( i );
break;
case IBeforeAttribute before:
for ( var j = 0; j < types.Length; ++j )
{
if ( i == j ) continue;
var other = types[j];
if ( before.Type.IsAssignableFrom( other.TargetType ) )
{
helper.AddConstraint( i, j );
}
}
break;
case IAfterAttribute after:
for ( var j = 0; j < types.Length; ++j )
{
if ( i == j ) continue;
var other = types[j];
if ( after.Type.IsAssignableFrom( other.TargetType ) )
{
helper.AddConstraint( j, i );
}
}
break;
}
}
}
var ordering = new List<int>();
if ( !helper.Sort( ordering, out var invalid ) )
{
Log.Error( $"Invalid event ordering constraint between {types[invalid.EarlierIndex].Name} and {types[invalid.LaterIndex].Name}!" );
return ImmutableDictionary<Type, int>.Empty;
}
return Enumerable.Range( 0, ordering.Count )
.ToImmutableDictionary( i => types[ordering[i]].TargetType, i => i );
}
}
public delegate void GameEventAction<in T>( T eventArgs )
where T : IGameEvent;
/// <summary>
/// Base class for components that expose game events to Action Graph.
/// </summary>
public abstract class GameEventComponent<T> : Component, IGameEventHandler<T>
where T : IGameEvent
{
/// <summary>
/// Action invoked when the <typeparamref name="T"/> event is dispatched.
/// </summary>
[Property]
public GameEventAction<T>? OnEvent { get; set; }
/// <summary>
/// If this component is within a state machine, optional state to transition
/// to when this event is dispatched.
/// </summary>
[Property]
public StateComponent? NextState { get; set; }
void IGameEventHandler<T>.OnGameEvent( T eventArgs )
{
OnEvent?.Invoke( eventArgs );
if ( NextState is not null )
{
Components.GetInAncestorsOrSelf<StateMachineComponent>()?.Transition( NextState );
}
}
}
using System.Collections.Generic;
using System.Linq;
namespace Sandbox.Events;
/// <summary>
/// Generate an ordering based on a set of first-most and last-most items, and
/// individual constraints between pairs of items. All first-most items will be
/// ordered before all last-most items, and any other items will be put in the
/// middle unless forced to be elsewhere by a constraint.
/// </summary>
internal class SortingHelper
{
public record struct SortConstraint( int EarlierIndex, int LaterIndex )
{
public SortConstraint Complement => new ( LaterIndex, EarlierIndex );
}
private readonly int _itemCount;
private readonly HashSet<SortConstraint> _initialConstraints = new HashSet<SortConstraint>();
private readonly HashSet<int> _first = new HashSet<int>();
private readonly HashSet<int> _last = new HashSet<int>();
public SortingHelper( int itemCount )
{
_itemCount = itemCount;
}
public void AddConstraint( int earlierIndex, int laterIndex )
{
_initialConstraints.Add( new SortConstraint( earlierIndex, laterIndex ) );
}
public void AddFirst( int earlierIndex )
{
_first.Add( earlierIndex );
}
public void AddLast( int laterIndex )
{
_last.Add( laterIndex );
}
public bool Sort( List<int> result, out SortConstraint invalidConstraint )
{
var middle = new HashSet<int>();
for ( var index = 0; index < _itemCount; ++index )
{
if ( !_first.Contains( index ) && !_last.Contains( index ) )
middle.Add( index );
}
var allConstraints = new HashSet<SortConstraint>();
var newConstraints = new Queue<SortConstraint>();
var beforeDict = new Dictionary<int, HashSet<int>>();
var afterDict = new Dictionary<int, HashSet<int>>();
bool AddWorkingConstraint( int earlierIndex, int laterIndex, out SortConstraint constraint )
{
constraint = new SortConstraint( earlierIndex, laterIndex );
if ( allConstraints.Contains( constraint.Complement ) )
return false;
if ( !allConstraints.Add( constraint ) )
return true;
newConstraints.Enqueue( constraint );
if ( !beforeDict.TryGetValue( earlierIndex, out var before ) )
beforeDict.Add( earlierIndex, before = new HashSet<int>() );
if ( !afterDict.TryGetValue( laterIndex, out var after ) )
afterDict.Add( laterIndex, after = new HashSet<int>() );
before.Add( laterIndex );
after.Add( earlierIndex );
return true;
}
// Add initial constraints
foreach ( var initialConstraint in _initialConstraints )
{
if ( !AddWorkingConstraint( initialConstraint.EarlierIndex, initialConstraint.LaterIndex, out invalidConstraint ) )
return false;
}
// Everything in _first should be before everything in _last
foreach ( var earlierIndex in _first )
{
foreach ( var laterIndex in _last )
{
if ( !AddWorkingConstraint( earlierIndex, laterIndex, out invalidConstraint ) )
return false;
}
}
// Keep propagating constraints until nothing changes
while ( newConstraints.TryDequeue( out var nextConstraint ) )
{
// if a < b, and b < c, then a < c etc
if ( beforeDict.TryGetValue( nextConstraint.LaterIndex, out var before ) )
{
foreach ( var laterIndex in before )
{
if ( !AddWorkingConstraint( nextConstraint.EarlierIndex, laterIndex, out invalidConstraint ) )
return false;
}
}
if ( afterDict.TryGetValue( nextConstraint.EarlierIndex, out var after ) )
{
foreach ( var earlierIndex in after )
{
if ( !AddWorkingConstraint( earlierIndex, nextConstraint.LaterIndex, out invalidConstraint ) )
{
return false;
}
}
}
}
// Now if we have any items that aren't using GroupOrder.First, and haven't
// determined that they are ordered before another item with GroupOrder.First,
// we can safely order them after all GroupOrder.First items. And vice versa.
foreach ( var middleIndex in middle )
{
var isBeforeAnyFirst = beforeDict.TryGetValue( middleIndex, out var before )
&& before.Any( x => _first.Contains( x ) );
var isAfterAnyLast = afterDict.TryGetValue( middleIndex, out var after )
&& after.Any( x => _last.Contains( x ) );
if ( !isBeforeAnyFirst )
{
foreach ( var earlierIndex in _first )
AddWorkingConstraint( earlierIndex, middleIndex, out invalidConstraint );
}
if ( !isAfterAnyLast )
{
foreach ( var laterIndex in _last )
AddWorkingConstraint( middleIndex, laterIndex, out invalidConstraint );
}
}
// Now lets add items to the final ordering if all items that should be sorted
// before them are already added to that ordering. We'll implement this by choosing
// items that have an empty list / don't appear in afterDict, and update that
// dictionary as we go.
var earliestRemaining = new Queue<int>();
// First, seed the queue with everything that's already not ordered after anything
for ( var index = 0; index < _itemCount; ++index )
{
if ( !afterDict.ContainsKey( index ) )
{
earliestRemaining.Enqueue( index );
}
}
result.Clear();
while ( earliestRemaining.TryDequeue( out var nextIndex ) )
{
result.Add( nextIndex );
foreach ( var laterIndex in beforeDict.TryGetValue( nextIndex, out var laterIndices )
? laterIndices : Enumerable.Empty<int>() )
{
var beforeLater = afterDict[laterIndex];
beforeLater.Remove( nextIndex );
if ( beforeLater.Count == 0 )
earliestRemaining.Enqueue( laterIndex );
}
}
invalidConstraint = default;
return result.Count == _itemCount;
}
}
using Sandbox;
using System.Collections.Generic;
namespace EZCameraShake
{
public class CameraShaker : Component
{
/// <summary>
/// The single instance of the CameraShaker in the current scene. Do not use if you have multiple instances.
/// </summary>
public static CameraShaker Instance;
static Dictionary<string, CameraShaker> instanceList = new Dictionary<string, CameraShaker>();
/// <summary>
/// The default position influcence of all shakes created by this shaker.
/// </summary>
[Property] public Vector3 DefaultPosInfluence = new Vector3(0.15f, 0.15f, 0.15f);
/// <summary>
/// The default rotation influcence of all shakes created by this shaker.
/// </summary>
[Property] public Vector3 DefaultRotInfluence = new Vector3(1, 1, 1);
/// <summary>
/// Offset that will be applied to the camera's default (0,0,0) rest position
/// </summary>
[Property] public Vector3 RestPositionOffset = new Vector3(0, 0, 0);
/// <summary>
/// Offset that will be applied to the camera's default (0,0,0) rest rotation
/// </summary>
[Property] public Vector3 RestRotationOffset = new Vector3(0, 0, 0);
Vector3 posAddShake, rotAddShake;
List<CameraShakeInstance> cameraShakeInstances = new List<CameraShakeInstance>();
protected override void OnAwake()
{
Instance = this;
instanceList.Add(GameObject.Name, this);
}
protected override void OnUpdate()
{
posAddShake = Vector3.Zero;
rotAddShake = Vector3.Zero;
for (int i = 0; i < cameraShakeInstances.Count; i++)
{
if (i >= cameraShakeInstances.Count)
break;
CameraShakeInstance c = cameraShakeInstances[i];
if (c.CurrentState == CameraShakeState.Inactive && c.DeleteOnInactive)
{
cameraShakeInstances.RemoveAt(i);
i--;
}
else if (c.CurrentState != CameraShakeState.Inactive)
{
posAddShake += CameraUtilities.MultiplyVectors(c.UpdateShake(), c.PositionInfluence);
rotAddShake += CameraUtilities.MultiplyVectors(c.UpdateShake(), c.RotationInfluence);
}
}
Transform.LocalPosition = (posAddShake) + RestPositionOffset;
Vector3 thing = (rotAddShake / 100) + RestRotationOffset;
Transform.LocalRotation = new Angles(thing.x, thing.y, thing.z);
}
/// <summary>
/// Gets the CameraShaker with the given name, if it exists.
/// </summary>
/// <param name="name">The name of the camera shaker instance.</param>
/// <returns></returns>
public static CameraShaker GetInstance(string name)
{
CameraShaker c;
if (instanceList.TryGetValue(name, out c))
return c;
Log.Error("CameraShake " + name + " not found!");
return null;
}
/// <summary>
/// Starts a shake using the given preset.
/// </summary>
/// <param name="shake">The preset to use.</param>
/// <returns>A CameraShakeInstance that can be used to alter the shake's properties.</returns>
public CameraShakeInstance Shake(CameraShakeInstance shake)
{
cameraShakeInstances.Add(shake);
return shake;
}
/// <summary>
/// Shake the camera once, fading in and out over a specified durations.
/// </summary>
/// <param name="magnitude">The intensity of the shake.</param>
/// <param name="roughness">Roughness of the shake. Lower values are smoother, higher values are more jarring.</param>
/// <param name="fadeInTime">How long to fade in the shake, in seconds.</param>
/// <param name="fadeOutTime">How long to fade out the shake, in seconds.</param>
/// <returns>A CameraShakeInstance that can be used to alter the shake's properties.</returns>
public CameraShakeInstance ShakeOnce(float magnitude, float roughness, float fadeInTime, float fadeOutTime)
{
CameraShakeInstance shake = new CameraShakeInstance(magnitude, roughness, fadeInTime, fadeOutTime);
shake.PositionInfluence = DefaultPosInfluence;
shake.RotationInfluence = DefaultRotInfluence;
cameraShakeInstances.Add(shake);
return shake;
}
/// <summary>
/// Shake the camera once, fading in and out over a specified durations.
/// </summary>
/// <param name="magnitude">The intensity of the shake.</param>
/// <param name="roughness">Roughness of the shake. Lower values are smoother, higher values are more jarring.</param>
/// <param name="fadeInTime">How long to fade in the shake, in seconds.</param>
/// <param name="fadeOutTime">How long to fade out the shake, in seconds.</param>
/// <param name="posInfluence">How much this shake influences position.</param>
/// <param name="rotInfluence">How much this shake influences rotation.</param>
/// <returns>A CameraShakeInstance that can be used to alter the shake's properties.</returns>
public CameraShakeInstance ShakeOnce(float magnitude, float roughness, float fadeInTime, float fadeOutTime, Vector3 posInfluence, Vector3 rotInfluence)
{
CameraShakeInstance shake = new CameraShakeInstance(magnitude, roughness, fadeInTime, fadeOutTime);
shake.PositionInfluence = posInfluence;
shake.RotationInfluence = rotInfluence;
cameraShakeInstances.Add(shake);
return shake;
}
/// <summary>
/// Start shaking the camera.
/// </summary>
/// <param name="magnitude">The intensity of the shake.</param>
/// <param name="roughness">Roughness of the shake. Lower values are smoother, higher values are more jarring.</param>
/// <param name="fadeInTime">How long to fade in the shake, in seconds.</param>
/// <returns>A CameraShakeInstance that can be used to alter the shake's properties.</returns>
public CameraShakeInstance StartShake(float magnitude, float roughness, float fadeInTime)
{
CameraShakeInstance shake = new CameraShakeInstance(magnitude, roughness);
shake.PositionInfluence = DefaultPosInfluence;
shake.RotationInfluence = DefaultRotInfluence;
shake.StartFadeIn(fadeInTime);
cameraShakeInstances.Add(shake);
return shake;
}
/// <summary>
/// Start shaking the camera.
/// </summary>
/// <param name="magnitude">The intensity of the shake.</param>
/// <param name="roughness">Roughness of the shake. Lower values are smoother, higher values are more jarring.</param>
/// <param name="fadeInTime">How long to fade in the shake, in seconds.</param>
/// <param name="posInfluence">How much this shake influences position.</param>
/// <param name="rotInfluence">How much this shake influences rotation.</param>
/// <returns>A CameraShakeInstance that can be used to alter the shake's properties.</returns>
public CameraShakeInstance StartShake(float magnitude, float roughness, float fadeInTime, Vector3 posInfluence, Vector3 rotInfluence)
{
CameraShakeInstance shake = new CameraShakeInstance(magnitude, roughness);
shake.PositionInfluence = posInfluence;
shake.RotationInfluence = rotInfluence;
shake.StartFadeIn(fadeInTime);
cameraShakeInstances.Add(shake);
return shake;
}
/// <summary>
/// Gets a copy of the list of current camera shake instances.
/// </summary>
public List<CameraShakeInstance> ShakeInstances
{ get { return new List<CameraShakeInstance>(cameraShakeInstances); } }
protected override void OnDestroy()
{
instanceList.Remove(GameObject.Name);
}
}
}
public sealed class PlayerPusher : Component
{
[Property] public float Radius { get; set; } = 100;
protected override void DrawGizmos()
{
base.DrawGizmos();
Gizmo.Draw.LineSphere( Vector3.Zero, Radius );
}
public static Vector3 GetPushVector( in Vector3 position, Scene scene, GameObject ignore )
{
Vector3 vec = default;
foreach ( var pusher in scene.GetAllComponents<PlayerPusher>() )
{
if ( pusher.GameObject.IsAncestor( ignore ) )
continue;
pusher.Collect( position, ref vec );
}
return vec;
}
private void Collect( Vector3 position, ref Vector3 output )
{
var delta = (position - Transform.Position);
if ( delta.Length > Radius ) return;
delta.z = 0; // ignore z
var distanceDelta = (delta.Length / Radius);
output += delta.Normal * (1.0f - distanceDelta);
}
}
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using Sandbox;
using System.Threading.Tasks;
public sealed class WebSocketUtility : Component
{
[Property] public List<WebsocketTools> websocketToolsList { get; set; }
protected override void OnAwake()
{
foreach ( var websocketTools in websocketToolsList )
{
if ( websocketTools.url is null )
{
Log.Error( "WebsocketTools URL is null" );
return;
}
websocketTools.webSocket = new WebSocket();
ConnectToSocket( websocketTools.webSocket, websocketTools.url );
websocketTools.isConnected = true;
websocketTools.webSocket.OnMessageReceived += websocketTools.OnMessageReceivedMethod;
websocketTools.isSubscribed = true;
}
}
protected override void OnUpdate()
{
SendMessageFromList( WebsocketTools.Fetch.OnUpdate );
}
protected override void OnFixedUpdate()
{
SendMessageFromList( WebsocketTools.Fetch.OnFixedUpdate );
}
protected override void OnStart()
{
SendMessageFromList( WebsocketTools.Fetch.OnStart );
}
private async void SendMessageFromList( WebsocketTools.Fetch fetch )
{
foreach ( var websocketTools in websocketToolsList )
{
if ( websocketTools.fetch == fetch )
{
if ( websocketTools.message.UseJsonTags )
{
var jsonStrings = websocketTools.message.jsonTags.Select( tag => Json.Serialize( tag.ToString() ) );
var bigString = string.Join( "", jsonStrings );
var finalJsonString = Json.Serialize( bigString );
await websocketTools.webSocket.Send( finalJsonString );
}
else
{
var messageBytes = Encoding.UTF8.GetBytes( websocketTools.message.message );
await websocketTools.webSocket.Send( messageBytes );
}
}
}
}
[Description( "Sends a message over a websocket connection" )]
public static async Task SendAsync( WebsocketTools websocketTools )
{
if ( websocketTools.webSocket is null )
{
websocketTools.webSocket = new WebSocket();
}
if ( !websocketTools.isConnected )
{
await websocketTools.webSocket.Connect( websocketTools.url );
websocketTools.isConnected = true;
}
if ( websocketTools.message.UseJsonTags )
await websocketTools.webSocket.Send( Json.Serialize( websocketTools.message.jsonTags ) );
else
await websocketTools.webSocket.Send( websocketTools.message.message );
if ( !websocketTools.isSubscribed )
{
websocketTools.webSocket.OnMessageReceived += websocketTools.OnMessageReceivedMethod;
websocketTools.isSubscribed = true;
}
}
public static async Task SendStringAsync( string url, string message )
{
var webSocket = new WebSocket();
await webSocket.Connect( url );
await webSocket.Send( message );
}
public static void ChangeJsonTagValue( WebsocketMessage message, string tag, string value )
{
if ( message is null )
message = new WebsocketMessage();
if ( message.jsonTags is null )
message.jsonTags = new List<JsonTags>();
var jsonTag = message.jsonTags.Find( x => x.tag == tag );
if ( jsonTag is null )
{
Log.Warning( $"Tag {tag} not found in message" );
}
else
{
jsonTag.value = value;
}
}
public static void AddJsonTag( WebsocketMessage message, string tag, string value )
{
if ( message is null )
message = new WebsocketMessage();
if ( message.jsonTags is null )
message.jsonTags = new List<JsonTags>();
var jsonTag = new JsonTags
{
tag = tag,
value = value
};
message.jsonTags.Add( jsonTag );
}
private async void ConnectToSocket( WebSocket webSocket, string url )
{
await webSocket.Connect( url );
}
[ActionGraphNode( "new websocket tools" ), Pure]
public static WebsocketTools NewWebsocketTools()
{
return new WebsocketTools();
}
}
public class WebsocketTools
{
public delegate void OnMessageReceived( string message );
public OnMessageReceived onMessageReceived { get; set; }
public WebSocket webSocket { get; set; }
public string url { get; set; }
public WebsocketMessage message { get; set; } = new();
public bool isConnected { get; set; }
public bool isSubscribed { get; set; }
public string returnMessage { get; set; }
public enum Fetch
{
OnUpdate,
OnFixedUpdate,
OnStart,
}
public Fetch fetch { get; set; }
public void OnMessageReceivedMethod( string message )
{
onMessageReceived?.Invoke( message );
returnMessage = message;
}
public WebsocketTools()
{
url = "ws://localhost:8080";
fetch = Fetch.OnUpdate;
onMessageReceived = null;
message = null;
}
public WebsocketTools( string url, OnMessageReceived onMessageReceived, WebsocketMessage message, Fetch fetch = Fetch.OnUpdate )
{
this.url = url;
this.fetch = fetch;
this.onMessageReceived = onMessageReceived;
this.message = message;
}
}
[GameResource( "Message", "message", "A message to be sent over a websocket connection", Icon = "chat_bubble" )]
public class WebsocketMessage : GameResource
{
public bool UseJsonTags { get; set; }
[ShowIf( "UseJsonTags", false )] public string message { get; set; } = "";
[ShowIf( "UseJsonTags", true )] public List<JsonTags> jsonTags { get; set; } = new();
}
public class JsonTags
{
public string tag { get; set; }
public string value { get; set; }
}
public sealed class JiggleBone : TransformProxyComponent
{
JiggleBoneState state = new JiggleBoneState();
[Property]
public Vector3 StartPoint = new Vector3( 0, 0, 0 );
[Property]
public Vector3 EndPoint = new Vector3( 32, 0, 0 );
[Property, Range( 0, 2 )]
public float Speed { get; set; } = 1.0f;
[Property, Range( 0, 2 )]
public float Stiffness { get; set; } = 1.0f;
[Property, Range( 0, 2 )]
public float Damping { get; set; } = 1.0f;
[Property, Range( 0, 100 )]
public float Radius { get; set; } = 40.0f;
[Property, Range( 0, 100 )]
public float Mass { get; set; } = 1.0f;
Transform LocalJigglePosition;
protected override void OnEnabled()
{
LocalJigglePosition = Transform.Local;
base.OnEnabled();
state = new JiggleBoneState();
}
protected override void OnUpdate()
{
var oldPos = LocalJigglePosition;
using ( Transform.DisableProxy() )
{
var worldTx = Transform.World;
var startPoint = worldTx.PointToWorld( StartPoint );
var endPoint = worldTx.PointToWorld( EndPoint );
//Gizmo.Draw.LineSphere( startPoint, 1 );
//Gizmo.Draw.LineSphere( endPoint, 1 );
state.Extent = (endPoint - startPoint);
state.Stiffness = Stiffness;
state.Damping = Damping;
state.Radius = Radius;
state.Mass = Mass;
state.Update( startPoint, Time.Delta * Speed * 16.0f );
var tx = worldTx.RotateAround( startPoint, state.Rotation );
LocalJigglePosition = GameObject.Parent.Transform.World.ToLocal( tx );
}
if ( oldPos != LocalJigglePosition )
{
MarkTransformChanged();
}
}
protected override void DrawGizmos()
{
base.DrawGizmos();
if ( !Gizmo.IsSelected )
return;
using ( Transform.DisableProxy() )
{
Gizmo.Transform = Transform.World;
Gizmo.Draw.IgnoreDepth = false;
Gizmo.Draw.Color = Gizmo.Colors.Yaw.WithAlpha( 0.5f );
Gizmo.Draw.Line( StartPoint, EndPoint );
Gizmo.Draw.LineBBox( BBox.FromPositionAndSize( StartPoint, 5 ) );
Gizmo.Draw.LineBBox( BBox.FromPositionAndSize( EndPoint, 5 ) );
Gizmo.Draw.LineSphere( EndPoint, Radius * 2.0f, 4 );
}
}
public override Transform GetLocalTransform()
{
return LocalJigglePosition;
}
}
class JiggleBoneState
{
public Vector3 Extent = new Vector3( 32, 0, 0 );
public Vector3 Position { get; set; }
public Rotation Rotation { get; set; }
public float Stiffness { get; set; } = 1.0f;
public float Damping { get; set; } = 1.0f;
public float Radius { get; set; } = 10.0f;
public float Gravity { get; set; } = 1.0f;
public float Mass { get; set; } = 1.0f;
Vector3 basePosition;
Vector3 velocity;
public JiggleBoneState()
{
}
internal void Update( Vector3 position, float timeDelta )
{
basePosition = position + Extent;
// initialization
if ( Position == default )
{
Position = basePosition;
}
// Calculate spring force based on displacement from the cube
Vector3 displacement = Position - basePosition;
Vector3 springForce = -Stiffness * displacement;
// Calculate acceleration (Newton's second law)
Vector3 acceleration = springForce / Mass;
// Update velocity (integrate acceleration)
velocity += acceleration * timeDelta;
// Apply exponential damping
velocity *= (float)Math.Exp( -Damping * timeDelta );
// Update position (integrate velocity)
Position += velocity * timeDelta;
{
var diff = Position - basePosition;
var diffLen = diff.Length;
if ( diffLen > Radius )
{
Position = basePosition + diff.Normal * Radius;
//velocity = velocity.AddClamped( -diff * 2.0f, diff.Length );
}
}
// Store the rotation offset result
Rotation = Rotation.FromToRotation( basePosition - position, Position - position );
//Gizmo.Draw.IgnoreDepth = true;
//Gizmo.Draw.Line( position, Position );
//Gizmo.Draw.Line( basePosition, Position );
}
}
using Sandbox;
/// <summary>
/// This is a component - in your library!
/// </summary>
[Title( "LibraryImporter - My Component" )]
public class MyLibraryComponent : Component
{
}
using Sandbox;
public sealed class CameraMovement : Component
{
[Property] public CharacterController1 Player { get; set; }
[Property] public GameObject Body { get; set; }
[Property] public GameObject Head { get; set; }
[Property] public float Distance { get; set; } = 0f;
[Property] public float Sensitivity { get; set; } = 0.1f;
public bool IsFirstPerson => Distance == 0f;
private CameraComponent Camera;
private ModelRenderer BodyRenderer;
private Vector3 CurrentOffset = Vector3.Zero;
protected override void OnAwake()
{
base.OnAwake();
Camera = Components.Get<CameraComponent>();
BodyRenderer = Body.Components.Get<ModelRenderer>();
}
protected override void OnUpdate()
{
var eyeAngles = Head.Transform.Rotation.Angles();
eyeAngles.pitch += Input.MouseDelta.y * Sensitivity;
eyeAngles.yaw -= Input.MouseDelta.x * Sensitivity;
eyeAngles.roll = 0f;
eyeAngles.pitch = eyeAngles.pitch.Clamp( -89.9f, 89.9f );
Head.Transform.Rotation = eyeAngles.ToRotation();
var targetOffset = Vector3.Zero;
if ( Player.IsCrouching ) targetOffset += Vector3.Down * 35f;
CurrentOffset = Vector3.Lerp( CurrentOffset, targetOffset, Time.Delta * 10f );
if ( Camera is not null )
{
var camPos = Head.Transform.Position + CurrentOffset;
if ( !IsFirstPerson )
{
var camForward = eyeAngles.ToRotation().Forward;
var camTrace = Scene.Trace.Ray( camPos, camPos - (camForward * Distance) )
.WithoutTags( "player", "trigger" )
.Run();
if ( camTrace.Hit )
{
camPos = camTrace.HitPosition + camTrace.Normal;
}
else
{
camPos = camTrace.EndPosition;
}
BodyRenderer.RenderType = ModelRenderer.ShadowRenderType.On;
}
else
{
BodyRenderer.RenderType = ModelRenderer.ShadowRenderType.ShadowsOnly;
}
Log.Info( CurrentOffset );
Camera.Transform.Position = camPos;
Camera.Transform.Rotation = eyeAngles.ToRotation();
}
}
}
global using Microsoft.AspNetCore.Components;
global using Microsoft.AspNetCore.Components.Rendering;
using System.Collections.Generic;
using Sandbox.Diagnostics;
namespace NPBehave
{
public class Parallel : Composite
{
public enum Policy
{
One,
All,
}
// public enum Wait
// {
// NEVER,
// ON_FAILURE,
// ON_SUCCESS,
// BOTH
// }
// private Wait waitForPendingChildrenRule;
private Policy _failurePolicy;
private Policy _successPolicy;
private int _childrenCount = 0;
private int _runningCount = 0;
private int _succeededCount = 0;
private int _failedCount = 0;
private Dictionary<Node, bool> _childrenResults;
private bool _successState;
private bool _childrenAborted;
public Parallel(Policy successPolicy, Policy failurePolicy, /*Wait waitForPendingChildrenRule,*/ params Node[] children) : base("Parallel", children)
{
_successPolicy = successPolicy;
_failurePolicy = failurePolicy;
// this.waitForPendingChildrenRule = waitForPendingChildrenRule;
_childrenCount = children.Length;
_childrenResults = new Dictionary<Node, bool>();
}
protected override void DoStart()
{
foreach (Node child in Children)
{
Assert.AreEqual(child.CurrentState, State.Inactive);
}
_childrenAborted = false;
_runningCount = 0;
_succeededCount = 0;
_failedCount = 0;
foreach (Node child in Children)
{
_runningCount++;
child.Start();
}
}
protected override void DoStop()
{
Assert.True(_runningCount + _succeededCount + _failedCount == _childrenCount);
foreach (Node child in Children)
{
if (child.IsActive)
{
child.Stop();
}
}
}
protected override void DoChildStopped(Node child, bool result)
{
_runningCount--;
if (result)
{
_succeededCount++;
}
else
{
_failedCount++;
}
_childrenResults[child] = result;
bool allChildrenStarted = _runningCount + _succeededCount + _failedCount == _childrenCount;
if (allChildrenStarted)
{
if (_runningCount == 0)
{
if (!_childrenAborted) // if children got aborted because rule was evaluated previously, we don't want to override the successState
{
if (_failurePolicy == Policy.One && _failedCount > 0)
{
_successState = false;
}
else if (_successPolicy == Policy.One && _succeededCount > 0)
{
_successState = true;
}
else if (_successPolicy == Policy.All && _succeededCount == _childrenCount)
{
_successState = true;
}
else
{
_successState = false;
}
}
Stopped(_successState);
}
else if (!_childrenAborted)
{
Assert.False(_succeededCount == _childrenCount);
Assert.False(_failedCount == _childrenCount);
if (_failurePolicy == Policy.One && _failedCount > 0/* && waitForPendingChildrenRule != Wait.ON_FAILURE && waitForPendingChildrenRule != Wait.BOTH*/)
{
_successState = false;
_childrenAborted = true;
}
else if (_successPolicy == Policy.One && _succeededCount > 0/* && waitForPendingChildrenRule != Wait.ON_SUCCESS && waitForPendingChildrenRule != Wait.BOTH*/)
{
_successState = true;
_childrenAborted = true;
}
if (_childrenAborted)
{
foreach (Node currentChild in Children)
{
if (currentChild.IsActive)
{
currentChild.Stop();
}
}
}
}
}
}
public override void StopLowerPriorityChildrenForChild(Node abortForChild, bool immediateRestart)
{
if (immediateRestart)
{
Assert.False(abortForChild.IsActive);
if (_childrenResults[abortForChild])
{
_succeededCount--;
}
else
{
_failedCount--;
}
_runningCount++;
abortForChild.Start();
}
else
{
throw new Exception("On Parallel Nodes all children have the same priority, thus the method does nothing if you pass false to 'immediateRestart'!");
}
}
}
}
using System.Collections;
using Sandbox.Diagnostics;
namespace NPBehave
{
public class RandomSequence : Composite
{
static System.Random _rng = new System.Random();
#if DEBUG
static public void DebugSetSeed( int seed )
{
_rng = new System.Random( seed );
}
#endif
private int _currentIndex = -1;
private int[] _randomizedOrder;
public RandomSequence(params Node[] children) : base("Random Sequence", children)
{
_randomizedOrder = new int[children.Length];
for (int i = 0; i < Children.Length; i++)
{
_randomizedOrder[i] = i;
}
}
protected override void DoStart()
{
foreach (Node child in Children)
{
Assert.AreEqual(child.CurrentState, State.Inactive);
}
_currentIndex = -1;
// Shuffling
int n = _randomizedOrder.Length;
while (n > 1)
{
int k = _rng.Next(n--);
(_randomizedOrder[n], _randomizedOrder[k]) = (_randomizedOrder[k], _randomizedOrder[n]);
}
ProcessChildren();
}
protected override void DoStop()
{
Children[_randomizedOrder[_currentIndex]].Stop();
}
protected override void DoChildStopped(Node child, bool result)
{
if (result)
{
ProcessChildren();
}
else
{
Stopped(false);
}
}
private void ProcessChildren()
{
if (++_currentIndex < Children.Length)
{
if (IsStopRequested)
{
Stopped(false);
}
else
{
Children[_randomizedOrder[_currentIndex]].Start();
}
}
else
{
Stopped(true);
}
}
public override void StopLowerPriorityChildrenForChild(Node abortForChild, bool immediateRestart)
{
int indexForChild = 0;
bool found = false;
foreach (Node currentChild in Children)
{
if (currentChild == abortForChild)
{
found = true;
}
else if (!found)
{
indexForChild++;
}
else if (found && currentChild.IsActive)
{
if (immediateRestart)
{
_currentIndex = indexForChild - 1;
}
else
{
_currentIndex = Children.Length;
}
currentChild.Stop();
break;
}
}
}
public override string ToString()
{
return $"{base.ToString()}[{_currentIndex}]";
}
}
}
namespace NPBehave
{
public class Succeeder : Decorator
{
public Succeeder(Node decoratee) : base("Succeeder", decoratee)
{
}
protected override void DoStart()
{
Decoratee.Start();
}
protected override void DoStop()
{
Decoratee.Stop();
}
protected override void DoChildStopped(Node child, bool result)
{
Stopped(true);
}
}
}using System;
namespace NPBehave
{
public class Exception : System.Exception
{
public Exception(string message) : base(message)
{
}
}
}namespace NPBehave
{
public class Repeater : Decorator
{
private int _loopCount = -1;
private int _currentLoop;
/// <param name="loopCount">number of times to execute the decoratee. Set to -1 to repeat forever, be careful with endless loops!</param>
/// <param name="decoratee">Decorated Node</param>
public Repeater(int loopCount, Node decoratee) : base("Repeater", decoratee)
{
_loopCount = loopCount;
}
/// <param name="decoratee">Decorated Node, repeated forever</param>
public Repeater(Node decoratee) : base("Repeater", decoratee)
{
}
protected override void DoStart()
{
if (_loopCount != 0)
{
_currentLoop = 0;
Decoratee.Start();
}
else
{
Stopped(true);
}
}
protected override void DoStop()
{
Clock.RemoveTimer(RestartDecoratee);
if (Decoratee.IsActive)
{
Decoratee.Stop();
}
else
{
Stopped(false);
}
}
protected override void DoChildStopped(Node child, bool result)
{
if (result)
{
if (IsStopRequested || (_loopCount > 0 && ++_currentLoop >= _loopCount))
{
Stopped(true);
}
else
{
Clock.AddTimer(0, 0, RestartDecoratee);
}
}
else
{
Stopped(false);
}
}
protected void RestartDecoratee()
{
Decoratee.Start();
}
}
}global using Sandbox;
global using System.Collections.Generic;
global using System.Linq;
global using Microsoft.AspNetCore.Components;
global using Microsoft.AspNetCore.Components.Rendering;
global using Sandbox;
global using System.Collections.Generic;
global using System.Linq;
using System.Threading.Tasks;
using System.Threading;
using System;
namespace Duccsoft;
/// <summary>
/// Provides a handy asynchronous wrapper for loading a VideoPlayer and waiting
/// until its video and audio are both loaded.
/// </summary>
public class AsyncVideoLoader
{
public AsyncVideoLoader()
{
_videoPlayer = new VideoPlayer();
}
public AsyncVideoLoader( VideoPlayer player )
{
_videoPlayer = player ?? new VideoPlayer();
}
public bool IsLoading { get; private set; }
private VideoPlayer _videoPlayer;
private Action _onLoaded;
private Action _onAudioReady;
public async Task<VideoPlayer> LoadFromUrl( string url, CancellationToken cancelToken = default )
{
void Play( VideoPlayer player ) => player.Play( url );
await Load( Play, cancelToken );
return _videoPlayer;
}
public async Task<VideoPlayer> LoadFromFile( BaseFileSystem fileSystem, string path, CancellationToken cancelToken )
{
void Play( VideoPlayer player ) => player.Play( fileSystem, path );
await Load( Play, cancelToken );
return _videoPlayer;
}
private async Task Load( Action<VideoPlayer> playAction, CancellationToken cancelToken = default )
{
// Attempting to play a video from a thread would throw an exception.
await GameTask.MainThread( cancelToken );
if ( IsLoading )
{
throw new InvalidOperationException( "Another video was already being loaded. Check IsLoading or create a new instance of AsyncVideoLoader." );
}
IsLoading = true;
bool videoLoaded = false;
bool audioLoaded = false;
// Assign private members instead of named methods to the invocation lists of the
// VideoPlayer delegates to break reference equality between runs.
_onLoaded = () => videoLoaded = true;
_onAudioReady = () => audioLoaded = true;
_videoPlayer.OnLoaded = _onLoaded;
_videoPlayer.OnAudioReady = _onAudioReady;
playAction?.Invoke( _videoPlayer );
// Non-blocking spin until video and audio are loaded.
while ( !videoLoaded || !audioLoaded )
{
// If OnLoaded or OnAudioReady are changed externally before we're finished
// loading, the video will likely never load. Abort to avoid spinning forever.
var callbacksChanged = _onLoaded != _videoPlayer.OnLoaded || _onAudioReady != _videoPlayer.OnAudioReady;
if ( callbacksChanged || cancelToken.IsCancellationRequested )
{
IsLoading = false;
return;
}
await GameTask.Yield();
}
IsLoading = false;
}
}
global using Microsoft.AspNetCore.Components;
global using Microsoft.AspNetCore.Components.Rendering;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Sandbox;
namespace TikTokTTS;
/// <summary>
/// A static class that allows you to use the TikTokTTS API.
/// </summary>
public static class TikTokTTS
{
/// <summary>
/// The API endpoint that the library uses.
/// </summary>
public static string ENDPOINT = "https://tiktok-tts.weilnet.workers.dev";
static int currentId = 0;
/// <summary>
/// Use TikTok's TTS to speak via a MusicPlayer. This MusicPlayer will automatically dispose itself when it finishes playing.
/// </summary>
/// <param name="text">The text to be said by the TTS</param>
/// <param name="voice">The name of the voice</param>
/// <returns></returns>
public static async Task<MusicPlayer> Say( string text, string voice = "en_us_007" )
{
string fileName = $"tts-{currentId}.mp3";
currentId++;
if ( !FileSystem.Data.FileExists( fileName ) )
{
await Download( text, voice, fileName, FileSystem.Data );
}
var musicPlayer = MusicPlayer.Play( FileSystem.Data, fileName );
musicPlayer.ListenLocal = true;
return musicPlayer;
}
/// <summary>
/// Use TikTok's TTS to speak and download/save the mp3 file.
/// </summary>
/// <param name="text">The text to be said by the TTS</param>
/// <param name="voice">The name of the voice</param>
/// <param name="fileName">The file name/path it should download to (defaults to "tts-##########.mp3"</param>
/// <param name="fileSystem">The filesystem to use (defaults to FileSystem.Data)</param>
/// <returns>The file path</returns>
public static async Task<string> Download( string text, string voice = "en_us_007", string fileName = null, BaseFileSystem fileSystem = null )
{
if ( fileSystem == null ) fileSystem = FileSystem.Data;
if ( string.IsNullOrEmpty( fileName ) ) fileName = $"tts-{new Guid()}.mp3";
var content = new Dictionary<string, string> {
{ "text", text },
{ "voice", voice }
};
var headers = new Dictionary<string, string> {
{ "Content-Type", "application/json" }
};
text = text.RemoveBadCharacters();
text = text.Substring( 0, Math.Min( text.Length, 300 ) );
if ( !text.Any( x => char.IsLetterOrDigit( x ) ) ) return null;
if ( string.IsNullOrEmpty( text ) ) return null;
// Make sure folders exist
var folders = fileName.Split( '/' );
if ( folders.Length == 1 ) folders = fileName.Split( '\\' );
if ( folders.Length > 1 )
{
string path = "";
for ( int i = 0; i < folders.Length - 1; i++ )
{
path += folders[i] + "/";
if ( !fileSystem.DirectoryExists( path ) )
fileSystem.CreateDirectory( path );
}
}
try
{
if ( fileSystem.FileExists( fileName ) )
fileSystem.DeleteFile( fileName );
var response = await Http.RequestJsonAsync<TikTokTTSResponse>( "https://tiktok-tts.weilnet.workers.dev/api/generation", "POST", Http.CreateJsonContent( content ), headers );
string base64 = response.data;
byte[] mp3 = Convert.FromBase64String( base64 );
var stream = fileSystem.OpenWrite( fileName );
stream.Write( mp3, 0, mp3.Length );
stream.Close();
return fileName;
}
catch ( Exception e )
{
Log.Error( e.Message );
return null;
}
}
class TikTokTTSResponse
{
public bool success { get; set; }
public string data { get; set; }
public string error { get; set; }
}
}
using System;
using System.Collections.Generic;
namespace Sandbox.Polygons;
public class PolygonModelRenderer : ModelRenderer
{
private Mesh _mesh;
private string _svg;
private bool _meshDirty;
/// <summary>
/// Scalable Vector Graphics source string for this model.
/// </summary>
[Property]
public string Svg
{
get => _svg;
set
{
_svg = value;
_meshDirty = true;
}
}
private int _lastHash = 0;
protected override void OnEnabled()
{
base.OnEnabled();
UpdateModel();
}
protected override void OnValidate()
{
base.OnValidate();
_meshDirty = true;
}
private void UpdateModel()
{
if ( !_meshDirty )
{
return;
}
var hash = Svg?.FastHash() ?? 0;
if ( _lastHash == hash )
{
return;
}
if ( Model?.IsProcedural is not true )
{
Model = null;
}
_lastHash = hash;
if ( !string.IsNullOrEmpty( Svg ) )
{
using var builder = PolygonMeshBuilder.Rent();
builder.MaxSmoothAngle = 33f.DegreeToRadian();
builder.AddSvg( _svg, new AddSvgOptions
{
ThrowIfNotSupported = true
}, new Rect( -128f, -128f, 256f, 256f ) );
builder.Extrude( 8f );
builder.Arc( 2f, 2 );
builder.Fill();
builder.Mirror();
_mesh ??= new Mesh( Material.Load( "materials/default/white.vmat" ) );
_mesh.UpdateMesh( PolygonMeshBuilder.Vertex.Layout, builder.Vertices, builder.Indices );
Model ??= new ModelBuilder()
.AddMesh( _mesh )
.Create();
}
else
{
_mesh?.SetIndexRange( 0, 0 );
}
}
protected override void OnUpdate()
{
UpdateModel();
base.OnUpdate();
}
}
using System;
namespace Duccsoft;
public partial class Freecam
{
/// <summary>
/// Invoked whenever a freecam is enabled. The argument is the freecam that was enabled.
/// </summary>
public static event Action<Freecam> OnFreecamStart;
/// <summary>
/// Invoked whenever a freecam is disabled. The argument is the freecam that was disabled.
/// </summary>
public static event Action<Freecam> OnFreecamEnd;
/// <summary>
/// Removes all listeners from the static events of this class. Used by
/// <see cref="CameraEventCleanupSystem"/> to tidy things up between play sessions.
/// </summary>
public static void ClearInvocationLists()
{
OnFreecamStart = null;
OnFreecamEnd = null;
}
}
global using Sandbox;
global using System.Collections.Generic;
global using System.Linq;
using System.Collections.Generic;
using System.Linq;
using Sandbox;
namespace SFXR;
[Title( "SFXR Sequencer" )]
[Category( "SFXR" )]
[Icon( "view_comfy" )]
public class SFXRSequencer : Component
{
[Property, Group( "Settings" )]
public float BPM { get; set; } = 120;
[Property, Group( "Settings" )]
public int BeatsPerBar { get; set; } = 4;
[Property, Group( "Notes" )]
public List<Note> Notes { get; set; } = new();
[Property, Group( "Controls" )]
public SFXRSequencerControls Controls { get; set; } = new();
public bool IsPlaying { get; private set; } = false;
public float CurrentTime { get; private set; } = 0f;
SFXRComponent Sfxr;
List<Note> NotesToPlay = new();
List<Note> NotesToStop = new();
protected override void OnDisabled()
{
Sfxr.TriggerReleaseAll();
StopSequence();
}
protected override void OnUpdate()
{
if ( !IsPlaying ) return;
Sfxr ??= GameObject.Components.Get<SFXRComponent>();
if ( Sfxr is null )
{
Log.Error( "SFXRSequencer requires an SFXRComponent to be attached to the same GameObject" );
return;
}
CurrentTime += Time.Delta;
for ( int i = 0; i < NotesToStop.Count; i++ )
{
var note = NotesToStop[i];
var time = BeatsToSeconds( note.Time + note.Length );
if ( CurrentTime >= time )
{
Sfxr.TriggerNoteRelease( note.Frequency );
NotesToStop.RemoveAt( i );
i--;
}
}
for ( int i = 0; i < NotesToPlay.Count; i++ )
{
var note = NotesToPlay[i];
var time = BeatsToSeconds( note.Time );
if ( CurrentTime >= time )
{
// Sfxr.Frequency.Start = note.Frequency;
// Sfxr.Length = BeatsToSeconds( note.Length );
// Sfxr.MasterVolume = note.Volume;
Sfxr.TriggerNotePress( note.Frequency, note.Volume );
NotesToStop.Add( note );
NotesToPlay.RemoveAt( i );
i--;
}
}
if ( NotesToPlay.Count == 0 && NotesToStop.Count == 0 )
{
IsPlaying = false;
}
}
public void PlaySequence()
{
if ( Sfxr is null )
{
Sfxr = GameObject.Components.Get<SFXRComponent>();
}
if ( !Sfxr.Enabled ) return;
IsPlaying = true;
CurrentTime = 0f;
NotesToPlay.Clear();
NotesToPlay.AddRange( Notes );
}
public void StopSequence()
{
IsPlaying = false;
CurrentTime = 0f;
}
public void PlayRange( float start, float end )
{
IsPlaying = true;
CurrentTime = BeatsToSeconds( start );
Sfxr.TriggerReleaseAll();
NotesToStop.Clear();
NotesToPlay.Clear();
NotesToPlay.AddRange( Notes.Where( x => x.Time >= start && x.Time <= end ) );
}
float BeatsToSeconds( float beats )
{
return beats * (60f / BPM / BeatsPerBar);
}
public class Note
{
[Property] public float Time { get; set; }
[Property] public float Frequency { get; set; }
[Property] public float Length { get; set; }
[Property] public float Volume { get; set; }
public Note()
{
Time = 0;
Frequency = 440;
Length = 1f;
Volume = 1f;
}
}
}using Sandbox;
using System;
using System.Text.Json.Serialization;
namespace SFXR;
public struct SFXRFloat
{
[JsonInclude] public float Value { get; set; }
[JsonInclude] public bool Locked { get; set; }
public SFXRFloat( float value )
{
Value = value;
Locked = false;
}
public static implicit operator float( SFXRFloat value ) => value.Value;
public static implicit operator SFXRFloat( float value ) => new SFXRFloat( value );
}using System.Collections.Generic;
using System.Linq;
namespace Sandbox.Volumes;
/// <summary>
/// A base GameObjectSystem for handling of VolumeComponents. The idea is that you're going to have
/// a custom VolumeComponent, and register your volumes in a VolumeGameObjectSystem derived GameObjectSystem.
/// This system's responsibility is primarily to store volumes and make them searchable.
/// </summary>
public abstract class VolumeSystem<T> : GameObjectSystem where T : VolumeComponent
{
public VolumeSystem( Scene scene ) : base( scene )
{
}
HashSet<T> volumes = new HashSet<T>();
public void Add( T volume )
{
volumes.Add( volume );
}
public void Remove( T volume )
{
volumes.Remove( volume );
}
public T FindVolume( Vector3 position )
{
return FindAll( position ).FirstOrDefault();
}
public IEnumerable<T> FindAll( Vector3 position )
{
foreach ( var volume in volumes )
{
if ( !volume.SceneVolume.Test( volume.Transform.World, position ) )
continue;
yield return volume;
}
}
}
namespace Sandbox.Volumes;
public class VolumeComponent : Component
{
[InlineEditor]
[Property] public SceneVolume SceneVolume { get; set; } = new SceneVolume();
protected override void DrawGizmos()
{
base.DrawGizmos();
if ( !Gizmo.IsSelected )
return;
var vol = SceneVolume;
vol.DrawGizmos( true );
SceneVolume = vol;
}
public virtual float GetPriority()
{
// higher number is better, smaller volume is better
return 1.0f - (SceneVolume.GetVolume() / 16000000000f);
}
}
using System.Collections.Generic;
using System.Linq;
namespace Sandbox.Events;
/// <summary>
/// Generate an ordering based on a set of first-most and last-most items, and
/// individual constraints between pairs of items. All first-most items will be
/// ordered before all last-most items, and any other items will be put in the
/// middle unless forced to be elsewhere by a constraint.
/// </summary>
internal class SortingHelper
{
public record struct SortConstraint( int EarlierIndex, int LaterIndex )
{
public SortConstraint Complement => new ( LaterIndex, EarlierIndex );
}
private readonly int _itemCount;
private readonly HashSet<SortConstraint> _initialConstraints = new HashSet<SortConstraint>();
private readonly HashSet<int> _first = new HashSet<int>();
private readonly HashSet<int> _last = new HashSet<int>();
public SortingHelper( int itemCount )
{
_itemCount = itemCount;
}
public void AddConstraint( int earlierIndex, int laterIndex )
{
_initialConstraints.Add( new SortConstraint( earlierIndex, laterIndex ) );
}
public void AddFirst( int earlierIndex )
{
_first.Add( earlierIndex );
}
public void AddLast( int laterIndex )
{
_last.Add( laterIndex );
}
public bool Sort( List<int> result, out SortConstraint invalidConstraint )
{
var middle = new HashSet<int>();
for ( var index = 0; index < _itemCount; ++index )
{
if ( !_first.Contains( index ) && !_last.Contains( index ) )
middle.Add( index );
}
var allConstraints = new HashSet<SortConstraint>();
var newConstraints = new Queue<SortConstraint>();
var beforeDict = new Dictionary<int, HashSet<int>>();
var afterDict = new Dictionary<int, HashSet<int>>();
bool AddWorkingConstraint( int earlierIndex, int laterIndex, out SortConstraint constraint )
{
constraint = new SortConstraint( earlierIndex, laterIndex );
if ( allConstraints.Contains( constraint.Complement ) )
return false;
if ( !allConstraints.Add( constraint ) )
return true;
newConstraints.Enqueue( constraint );
if ( !beforeDict.TryGetValue( earlierIndex, out var before ) )
beforeDict.Add( earlierIndex, before = new HashSet<int>() );
if ( !afterDict.TryGetValue( laterIndex, out var after ) )
afterDict.Add( laterIndex, after = new HashSet<int>() );
before.Add( laterIndex );
after.Add( earlierIndex );
return true;
}
// Add initial constraints
foreach ( var initialConstraint in _initialConstraints )
{
if ( !AddWorkingConstraint( initialConstraint.EarlierIndex, initialConstraint.LaterIndex, out invalidConstraint ) )
return false;
}
// Everything in _first should be before everything in _last
foreach ( var earlierIndex in _first )
{
foreach ( var laterIndex in _last )
{
if ( !AddWorkingConstraint( earlierIndex, laterIndex, out invalidConstraint ) )
return false;
}
}
// Keep propagating constraints until nothing changes
while ( newConstraints.TryDequeue( out var nextConstraint ) )
{
// if a < b, and b < c, then a < c etc
if ( beforeDict.TryGetValue( nextConstraint.LaterIndex, out var before ) )
{
foreach ( var laterIndex in before )
{
if ( !AddWorkingConstraint( nextConstraint.EarlierIndex, laterIndex, out invalidConstraint ) )
return false;
}
}
if ( afterDict.TryGetValue( nextConstraint.EarlierIndex, out var after ) )
{
foreach ( var earlierIndex in after )
{
if ( !AddWorkingConstraint( earlierIndex, nextConstraint.LaterIndex, out invalidConstraint ) )
{
return false;
}
}
}
}
// Now if we have any items that aren't using GroupOrder.First, and haven't
// determined that they are ordered before another item with GroupOrder.First,
// we can safely order them after all GroupOrder.First items. And vice versa.
foreach ( var middleIndex in middle )
{
var isBeforeAnyFirst = beforeDict.TryGetValue( middleIndex, out var before )
&& before.Any( x => _first.Contains( x ) );
var isAfterAnyLast = afterDict.TryGetValue( middleIndex, out var after )
&& after.Any( x => _last.Contains( x ) );
if ( !isBeforeAnyFirst )
{
foreach ( var earlierIndex in _first )
AddWorkingConstraint( earlierIndex, middleIndex, out invalidConstraint );
}
if ( !isAfterAnyLast )
{
foreach ( var laterIndex in _last )
AddWorkingConstraint( middleIndex, laterIndex, out invalidConstraint );
}
}
// Now lets add items to the final ordering if all items that should be sorted
// before them are already added to that ordering. We'll implement this by choosing
// items that have an empty list / don't appear in afterDict, and update that
// dictionary as we go.
var earliestRemaining = new Queue<int>();
// First, seed the queue with everything that's already not ordered after anything
for ( var index = 0; index < _itemCount; ++index )
{
if ( !afterDict.ContainsKey( index ) )
{
earliestRemaining.Enqueue( index );
}
}
result.Clear();
while ( earliestRemaining.TryDequeue( out var nextIndex ) )
{
result.Add( nextIndex );
foreach ( var laterIndex in beforeDict.TryGetValue( nextIndex, out var laterIndices )
? laterIndices : Enumerable.Empty<int>() )
{
var beforeLater = afterDict[laterIndex];
beforeLater.Remove( nextIndex );
if ( beforeLater.Count == 0 )
earliestRemaining.Enqueue( laterIndex );
}
}
invalidConstraint = default;
return result.Count == _itemCount;
}
}
using Sandbox.Citizen;
using System.Text.Json;
[Group( "Walker" )]
[Title( "Walker - Player Controller" )]
public sealed class PlayerController : Component
{
[Property] public CharacterController CharacterController { get; set; }
[Property] public float CrouchMoveSpeed { get; set; } = 64.0f;
[Property] public float WalkMoveSpeed { get; set; } = 190.0f;
[Property] public float RunMoveSpeed { get; set; } = 190.0f;
[Property] public float SprintMoveSpeed { get; set; } = 320.0f;
[Property] public CitizenAnimationHelper AnimationHelper { get; set; }
[Sync] public bool Crouching { get; set; }
[Sync] public Angles EyeAngles { get; set; }
[Sync] public Vector3 WishVelocity { get; set; }
public bool WishCrouch;
public float EyeHeight = 64;
protected override void OnAwake()
{
if ( !IsProxy ) Tags.Add( "player_local" );
if ( IsProxy ) Tags.Remove( "player_local" );
Log.Info( Tags );
Log.Info( JsonSerializer.Serialize( Tags ) );
}
protected override void OnUpdate()
{
if (!IsProxy)
{
MouseInput();
Transform.Rotation = new Angles( 0, EyeAngles.yaw, 0 );
}
UpdateAnimation();
}
protected override void OnFixedUpdate()
{
if ( IsProxy ) return;
CrouchingInput();
MovementInput();
}
private void MouseInput()
{
var e = EyeAngles;
e += Input.AnalogLook;
e.pitch = e.pitch.Clamp( -90, 90 );
e.roll = 0.0f;
EyeAngles = e;
}
float CurrentMoveSpeed
{
get
{
if ( Crouching ) return CrouchMoveSpeed;
if ( Input.Down( "run" ) ) return SprintMoveSpeed;
if ( Input.Down( "walk" ) ) return WalkMoveSpeed;
return RunMoveSpeed;
}
}
RealTimeSince lastGrounded;
RealTimeSince lastUngrounded;
RealTimeSince lastJump;
float GetFriction()
{
if ( CharacterController.IsOnGround ) return 6.0f;
// air friction
return 0.2f;
}
private void MovementInput()
{
if ( CharacterController is null )
return;
var cc = CharacterController;
Vector3 halfGravity = Scene.PhysicsWorld.Gravity * Time.Delta * 0.5f;
WishVelocity = Input.AnalogMove;
if ( lastGrounded < 0.2f && lastJump > 0.3f && Input.Pressed( "jump" ) )
{
lastJump = 0;
cc.Punch( Vector3.Up * 300 );
}
if ( !WishVelocity.IsNearlyZero() )
{
WishVelocity = new Angles( 0, EyeAngles.yaw, 0 ).ToRotation() * WishVelocity;
WishVelocity = WishVelocity.WithZ( 0 );
WishVelocity = WishVelocity.ClampLength( 1 );
WishVelocity *= CurrentMoveSpeed;
if ( !cc.IsOnGround )
{
WishVelocity = WishVelocity.ClampLength( 50 );
}
}
cc.ApplyFriction( GetFriction() );
if ( cc.IsOnGround )
{
cc.Accelerate( WishVelocity );
cc.Velocity = CharacterController.Velocity.WithZ( 0 );
}
else
{
cc.Velocity += halfGravity;
cc.Accelerate( WishVelocity );
}
//
// Don't walk through other players, let them push you out of the way
//
var pushVelocity = PlayerPusher.GetPushVector( Transform.Position + Vector3.Up * 40.0f, Scene, GameObject );
if ( !pushVelocity.IsNearlyZero() )
{
var travelDot = cc.Velocity.Dot( pushVelocity.Normal );
if ( travelDot < 0 )
{
cc.Velocity -= pushVelocity.Normal * travelDot * 0.6f;
}
cc.Velocity += pushVelocity * 128.0f;
}
cc.Move();
if ( !cc.IsOnGround )
{
cc.Velocity += halfGravity;
}
else
{
cc.Velocity = cc.Velocity.WithZ( 0 );
}
if ( cc.IsOnGround )
{
lastGrounded = 0;
}
else
{
lastUngrounded = 0;
}
}
float DuckHeight = (64 - 36);
bool CanUncrouch()
{
if ( !Crouching ) return true;
if ( lastUngrounded < 0.2f ) return false;
var tr = CharacterController.TraceDirection( Vector3.Up * DuckHeight );
return !tr.Hit; // hit nothing - we can!
}
public void CrouchingInput()
{
WishCrouch = Input.Down( "duck" );
if ( WishCrouch == Crouching )
return;
// crouch
if ( WishCrouch )
{
CharacterController.Height = 36;
Crouching = WishCrouch;
// if we're not on the ground, slide up our bbox so when we crouch
// the bottom shrinks, instead of the top, which will mean we can reach
// places by crouch jumping that we couldn't.
if ( !CharacterController.IsOnGround )
{
CharacterController.MoveTo( Transform.Position += Vector3.Up * DuckHeight, false );
Transform.ClearInterpolation();
EyeHeight -= DuckHeight;
}
return;
}
// uncrouch
if ( !WishCrouch )
{
if ( !CanUncrouch() ) return;
CharacterController.Height = 64;
Crouching = WishCrouch;
return;
}
}
private void UpdateCamera()
{
var camera = Scene.GetAllComponents<CameraComponent>().Where( x => x.IsMainCamera ).FirstOrDefault();
if ( camera is null ) return;
// Determine target eye height based on crouching state
var targetEyeHeight = Crouching ? -10f : 6.4f;
EyeHeight = EyeHeight.LerpTo( targetEyeHeight, RealTime.Delta * 10.0f );
// Get the camera's local position relative to the player's position
var targetLocalCameraPos = new Vector3( 0, 0, EyeHeight ); // Local offset for the camera (only affects z for height)
// Smooth transition when ungrounded (e.g. going up/down stairs or ducking)
if ( lastUngrounded > 0.2f )
{
// Interpolating z-axis (local space) smoothly
targetLocalCameraPos.z = camera.Transform.LocalPosition.z.LerpTo( targetLocalCameraPos.z, RealTime.Delta * 25.0f );
}
// Apply local position and rotation to the camera
camera.Transform.LocalPosition = targetLocalCameraPos;
// Set the camera's local rotation based on player's current view angles
camera.Transform.LocalRotation = new Angles( EyeAngles.pitch, 0, EyeAngles.roll );
// Set the camera's field of view from player preferences
camera.FieldOfView = Preferences.FieldOfView;
}
protected override void OnPreRender()
{
UpdateBodyVisibility();
if ( IsProxy )
return;
UpdateCamera();
}
private void UpdateAnimation()
{
if ( AnimationHelper is null ) return;
var wv = WishVelocity.Length;
AnimationHelper.WithWishVelocity( WishVelocity );
AnimationHelper.WithVelocity( CharacterController.Velocity );
AnimationHelper.IsGrounded = CharacterController.IsOnGround;
AnimationHelper.DuckLevel = Crouching ? 1.0f : 0.0f;
AnimationHelper.MoveStyle = wv < 160f ? CitizenAnimationHelper.MoveStyles.Walk : CitizenAnimationHelper.MoveStyles.Run;
var lookDir = EyeAngles.ToRotation().Forward * 1024;
AnimationHelper.WithLook( lookDir, 1, 0.5f, 0.25f );
}
private void UpdateBodyVisibility()
{
if ( AnimationHelper is null )
return;
var renderMode = ModelRenderer.ShadowRenderType.On;
if ( !IsProxy ) renderMode = ModelRenderer.ShadowRenderType.ShadowsOnly;
AnimationHelper.Target.RenderType = renderMode;
foreach ( var clothing in AnimationHelper.Target.Components.GetAll<ModelRenderer>( FindMode.InChildren ) )
{
if ( !clothing.Tags.Has( "clothing" ) )
continue;
clothing.RenderType = renderMode;
}
}
}
using Sandbox;
using System;
using System.Linq;
/// <summary>
/// Move an object around a path.
/// </summary>
[Title( "Motion Path" )]
public class MotionPath : Component, Component.ExecuteInEditor
{
/// <summary>
/// The object that moves around this path.
/// </summary>
[Property]
public GameObject Target { get; set; }
/// <summary>
/// Normalized time between 0 and 1 for how far the target is on this path.
/// </summary>
[Property, Range( 0.0f, 1.0f )]
[HostSync] public float Time { get; set; }
/// <summary>
/// Rotate the target using the rotation of points, otherwise use the curvature of the path.
/// </summary>
[Property]
public bool UsePointRotation { get; set; }
/// <summary>
/// Time is controlled manually.
/// </summary>
[Property]
public bool Manual { get; set; }
/// <summary>
/// How long the path takes to complete.
/// </summary>
[Property, ShowIf( nameof( Manual ), false )]
public float Duration { get; set; } = 10;
public enum SplineType
{
Tcb,
CatmullRom
};
[Title( "Mode" ), Group( "Spline" )]
[Property] public SplineType SplineMode { get; set; }
[Title( "Tension" ), Group( "Spline" ), ShowIf( nameof( SplineMode ), SplineType.Tcb )]
[Property, Range( -1, 1 )] public float SplineTension { get; set; }
[Title( "Continuity" ), Group( "Spline" ), ShowIf( nameof( SplineMode ), SplineType.Tcb )]
[Property, Range( -1, 1 )] public float SplineContinuity { get; set; }
[Title( "Bias" ), Group( "Spline" ), ShowIf( nameof( SplineMode ), SplineType.Tcb )]
[Property, Range( -1, 1 )] public float SplineBias { get; set; }
private Vector3[] _previewPoints;
protected override void OnStart()
{
base.OnStart();
if ( Scene.IsEditor )
{
if ( !GameObject.GetAllObjects( true )
.Select( x => x.Components.Get<MotionPathPoint>() )
.Where( x => x.IsValid() )
.Any() )
{
var go = new GameObject( true, "Point" );
go.SetParent( GameObject, false );
go.Components.Create<MotionPathPoint>( true );
}
}
}
protected override void DrawGizmos()
{
base.DrawGizmos();
if ( _previewPoints is null )
return;
using ( Gizmo.Hitbox.LineScope() )
{
for ( var i = 0; i < _previewPoints.Length - 1; i++ )
{
var pointA = Transform.World.PointToLocal( _previewPoints[i] );
var pointB = Transform.World.PointToLocal( _previewPoints[i + 1] );
Gizmo.Draw.Color = Gizmo.IsSelected ? Gizmo.Colors.Active : Gizmo.IsHovered ? Gizmo.Colors.Hovered : Color.White.WithAlpha( 0.5f );
Gizmo.Draw.LineThickness = Gizmo.IsHovered || Gizmo.IsSelected ? 2 : 1;
Gizmo.Draw.Line( pointA, pointB );
}
}
if ( Target.IsValid() )
{
Gizmo.Draw.Color = Gizmo.Colors.Forward;
var pointA = Transform.World.PointToLocal( Target.Transform.Position );
var pointB = Transform.World.NormalToLocal( Target.Transform.Rotation.Forward ) * 5;
Gizmo.Draw.SolidCone( pointA, pointB, 2 );
}
}
private Vector3 GetPointOnSpline( Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float delta )
{
if ( SplineMode == SplineType.Tcb )
return Vector3.TcbSpline( p0, p1, p2, p3, SplineTension, SplineContinuity, SplineBias, delta );
else if ( SplineMode == SplineType.CatmullRom )
return Vector3.CatmullRomSpline( p0, p1, p2, p3, delta );
return default;
}
protected override void OnUpdate()
{
base.OnUpdate();
var motionPoints = GameObject.GetAllObjects( true )
.Select( x => x.Components.Get<MotionPathPoint>() )
.Where( x => x.IsValid() )
.ToArray();
var points = motionPoints.Select( x => x.Transform.Position )
.ToArray();
if ( SplineMode == SplineType.Tcb )
_previewPoints = points.TcbSpline( 32, SplineTension, SplineContinuity, SplineBias ).ToArray();
else if ( SplineMode == SplineType.CatmullRom )
_previewPoints = points.CatmullRomSpline( 32 ).ToArray();
if ( points.Length < 2 )
return;
if ( points.Length == 2 )
_previewPoints = new Vector3[2] { points[0], points[1] };
if ( Target.IsValid() )
{
var pointCount = points.Length;
if ( !Manual && !Duration.AlmostEqual( 0.0f ) )
Time = Sandbox.Time.Now % Duration / Duration;
var time = Time.Clamp( 0.0f, 1.0f );
var segmentIndex = (int)((pointCount - 1) * time);
segmentIndex = Math.Min( segmentIndex, pointCount - 2 );
var delta = ((pointCount - 1) * time) - segmentIndex;
var p0 = segmentIndex > 0 ? points[segmentIndex - 1] : points[0];
var p1 = points[segmentIndex];
var p2 = segmentIndex < pointCount - 1 ? points[segmentIndex + 1] : points[pointCount - 1];
var p3 = segmentIndex < pointCount - 2 ? points[segmentIndex + 2] : points[pointCount - 1];
var offset = time.AlmostEqual( 1.0f ) ? -0.01f : 0.01f;
var positionA = GetPointOnSpline( p0, p1, p2, p3, delta );
if ( UsePointRotation )
{
var r1 = motionPoints[segmentIndex];
var r2 = segmentIndex < pointCount - 1 ? motionPoints[segmentIndex + 1] : motionPoints[pointCount - 1];
var rotationStart = r1.Transform.Rotation;
var rotationEnd = r2.Transform.Rotation;
if ( r1.LookAt.IsValid() )
rotationStart = Rotation.LookAt( (r1.LookAt.Transform.Position - r1.Transform.Position).Normal );
if ( r2.LookAt.IsValid() )
rotationEnd = Rotation.LookAt( (r2.LookAt.Transform.Position - r2.Transform.Position).Normal );
Target.Transform.Rotation = Rotation.Slerp( rotationStart, rotationEnd, delta );
}
else
{
var positionB = GetPointOnSpline( p0, p1, p2, p3, delta + offset );
var forward = (positionB - positionA).Normal * MathF.Sign( offset );
var right = forward.Cross( Vector3.Up ).Normal;
var up = right.Cross( forward ).Normal;
Target.Transform.Rotation = Rotation.LookAt( forward, up );
}
Target.Transform.Position = positionA;
}
}
}
public class MotionPathPoint : Component, Component.ExecuteInEditor
{
/// <summary>
/// Look at this object.
/// </summary>
[Property]
public GameObject LookAt { get; set; }
protected override void DrawGizmos()
{
base.DrawGizmos();
const float radius = 2.0f;
Gizmo.Hitbox.DepthBias = 0.1f;
Gizmo.Hitbox.Sphere( new Sphere( 0, radius ) );
Gizmo.Draw.Color = Gizmo.IsSelected ? Gizmo.Colors.Active : Gizmo.IsHovered ? Gizmo.Colors.Hovered : Color.White;
Gizmo.Draw.SolidSphere( 0, radius );
if ( Gizmo.IsSelected || Gizmo.IsHovered )
{
var end = LookAt.IsValid() ? Transform.World.PointToLocal( LookAt.Transform.Position ) : Vector3.Forward * 6;
Gizmo.Draw.Color = Gizmo.Colors.Forward;
Gizmo.Draw.Arrow( 0, end, 2, 1 );
}
}
}
using Sandbox;
namespace EZCameraShake
{
public static class CameraShakePresets
{
/// <summary>
/// [One-Shot] A high magnitude, short, yet smooth shake.
/// </summary>
public static CameraShakeInstance Bump
{
get
{
CameraShakeInstance c = new CameraShakeInstance(2.5f, 4, 0.1f, 0.75f);
c.PositionInfluence = Vector3.One * 0.15f;
c.RotationInfluence = Vector3.One;
return c;
}
}
/// <summary>
/// [One-Shot] An intense and rough shake.
/// </summary>
public static CameraShakeInstance Explosion
{
get
{
CameraShakeInstance c = new CameraShakeInstance(5f, 10, 0, 1.5f);
c.PositionInfluence = Vector3.One * 0.25f;
c.RotationInfluence = new Vector3(4, 1, 1);
return c;
}
}
/// <summary>
/// [Sustained] A continuous, rough shake.
/// </summary>
public static CameraShakeInstance Earthquake
{
get
{
CameraShakeInstance c = new CameraShakeInstance(0.6f, 3.5f, 2f, 10f);
c.PositionInfluence = Vector3.One * 0.25f;
c.RotationInfluence = new Vector3(1, 1, 4);
return c;
}
}
/// <summary>
/// [Sustained] A bizarre shake with a very high magnitude and low roughness.
/// </summary>
public static CameraShakeInstance BadTrip
{
get
{
CameraShakeInstance c = new CameraShakeInstance(10f, 0.15f, 5f, 10f);
c.PositionInfluence = new Vector3(0, 0, 0.15f);
c.RotationInfluence = new Vector3(2, 1, 4);
return c;
}
}
/// <summary>
/// [Sustained] A subtle, slow shake.
/// </summary>
public static CameraShakeInstance HandheldCamera
{
get
{
CameraShakeInstance c = new CameraShakeInstance(1f, 0.25f, 5f, 10f);
c.PositionInfluence = Vector3.Zero;
c.RotationInfluence = new Vector3(1, 0.5f, 0.5f);
return c;
}
}
/// <summary>
/// [Sustained] A very rough, yet low magnitude shake.
/// </summary>
public static CameraShakeInstance Vibration
{
get
{
CameraShakeInstance c = new CameraShakeInstance(0.4f, 20f, 2f, 2f);
c.PositionInfluence = new Vector3(0, 0.15f, 0);
c.RotationInfluence = new Vector3(1.25f, 0, 4);
return c;
}
}
/// <summary>
/// [Sustained] A slightly rough, medium magnitude shake.
/// </summary>
public static CameraShakeInstance RoughDriving
{
get
{
CameraShakeInstance c = new CameraShakeInstance(1, 2f, 1f, 1f);
c.PositionInfluence = Vector3.Zero;
c.RotationInfluence = Vector3.One;
return c;
}
}
}
}
public sealed class PlayerFootsteps : Component
{
[Property] SkinnedModelRenderer Source { get; set; }
protected override void OnEnabled()
{
if ( Source is null )
return;
Source.OnFootstepEvent += OnEvent;
}
protected override void OnDisabled()
{
if ( Source is null )
return;
Source.OnFootstepEvent -= OnEvent;
}
TimeSince timeSinceStep;
private void OnEvent( SceneModel.FootstepEvent e )
{
if ( timeSinceStep < 0.2f )
return;
var tr = Scene.Trace
.Ray( e.Transform.Position + Vector3.Up * 20, e.Transform.Position + Vector3.Up * -20 )
.Run();
if ( !tr.Hit )
return;
if ( tr.Surface is null )
return;
timeSinceStep = 0;
var sound = e.FootId == 0 ? tr.Surface.Sounds.FootLeft : tr.Surface.Sounds.FootRight;
if ( sound is null ) return;
var handle = Sound.Play( sound, tr.HitPosition + tr.Normal * 5 );
handle.Volume *= e.Volume;
handle.Update();
}
}
public sealed class BouncyBone : TransformProxyComponent
{
JiggleBoneState state = new JiggleBoneState();
[Property]
public Vector3 Influence { get; set; } = new Vector3( 1, 1, 1 );
[Property, Range( 0, 50.0f )]
public float Stiffness { get; set; } = 1;
[Property, Range( 0, 50.0f )]
public float Damping { get; set; } = 1;
Transform LocalJigglePosition;
TransformSpring springer;
protected override void OnEnabled()
{
springer = new TransformSpring();
springer.Transform = Transform.World;
LocalJigglePosition = springer.Transform;
base.OnEnabled();
}
protected override void OnUpdate()
{
var oldPos = LocalJigglePosition;
using ( Transform.DisableProxy() )
{
var worldTx = Transform.World;
springer.Stiffness = Stiffness;
springer.Damping = Damping;
springer.UpdateSpring( Transform.World, Time.Delta );
var tx = GameObject.Parent.Transform.World.ToLocal( springer.Transform );
LocalJigglePosition = tx;
}
if ( oldPos != LocalJigglePosition )
{
MarkTransformChanged();
}
}
public override Transform GetLocalTransform()
{
return LocalJigglePosition;
}
}
public struct TransformSpring
{
public Transform Transform;
private Vector3 velocityPosition;
private Vector3 velocityScale;
private Rotation velocityRotation = Rotation.Identity;
public float Stiffness = 1.5f; // Spring stiffness, higher is stiffer
public float Damping = 1.0f; // Damping, higher is less oscillation
public TransformSpring()
{
Transform = global::Transform.Zero;
}
public void UpdateSpring( Transform target, float deltaTime )
{
Transform.Position = SpringLerp( Transform.Position, target.Position, ref velocityPosition, deltaTime );
Transform.Scale = SpringLerp( Transform.Scale, target.Scale, ref velocityScale, deltaTime );
Transform.Rotation = target.Rotation;
}
private Vector3 SpringLerp( Vector3 current, Vector3 target, ref Vector3 velocity, float deltaTime )
{
float omega = 2f * MathF.PI * Stiffness;
float damper = MathF.Exp( -Damping * deltaTime * omega );
Vector3 displacement = current - target;
Vector3 springForce = -omega * omega * displacement;
Vector3 dampingForce = -2f * omega * Damping * velocity;
Vector3 acceleration = springForce + dampingForce;
velocity = (velocity + acceleration * deltaTime) * damper;
return target + displacement + velocity * deltaTime;
}
}
global using Microsoft.AspNetCore.Components;
global using Microsoft.AspNetCore.Components.Rendering;
global using Sandbox;
global using System;
global using System.Collections.Generic;
global using System.Linq;
internal static class CollectionExtensions
{
public static T Largest<T>(this IEnumerable<T> collection) where T : IComparable<T>
{
if ( collection == default || !collection.Any() ) return default;
T largest = collection.First();
foreach (T item in collection)
{
if(item.CompareTo(largest) > 0)
{
largest = item;
}
}
return largest;
}
public static T LargestBy<T, TKey>(this IEnumerable<T> collection, Func<T, TKey> keySelector ) where TKey : IComparable<TKey>
{
if ( collection == default || !collection.Any() ) return default;
T largestItem = collection.First();
TKey largestValue = keySelector(largestItem);
foreach ( T item in collection )
{
TKey value = keySelector( item );
if ( value.CompareTo( largestValue ) > 0 )
{
largestValue = value;
largestItem = item;
}
}
return largestItem;
}
public static T Smallest<T>( this IEnumerable<T> collection ) where T : IComparable<T>
{
if ( collection == default || !collection.Any() ) return default;
T largest = collection.First();
foreach ( T item in collection )
{
if ( item.CompareTo( largest ) < 0 )
{
largest = item;
}
}
return largest;
}
public static T SmallestBy<T, TKey>( this IEnumerable<T> collection, Func<T, TKey> keySelector ) where TKey : IComparable<TKey>
{
if ( collection == default || !collection.Any() ) return default;
T largestItem = collection.First();
TKey largestValue = keySelector(largestItem);
foreach ( T item in collection )
{
TKey value = keySelector( item );
if ( value.CompareTo( largestValue ) < 0 )
{
largestValue = value;
largestItem = item;
}
}
return largestItem;
}
public static TValue GetValueOrDefault<TKey, TValue>( this IDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue = default )
{
return dictionary.TryGetValue( key, out var value ) ? value : defaultValue;
}
}
using Sandbox;
/// <summary>
/// This is a component - in your library!
/// </summary>
[Title( "Viper's Citzen Controller - My Component" )]
public class MyLibraryComponent : Component
{
}
using System.Collections;
using Sandbox.Diagnostics;
namespace NPBehave
{
public class Selector : Composite
{
private int _currentIndex = -1;
public Selector(params Node[] children) : base("Selector", children)
{
}
#if DEBUG
public override string DebugIcon => "rule";
#endif
protected override void DoStart()
{
foreach (Node child in Children)
{
Assert.AreEqual(child.CurrentState, State.Inactive);
}
_currentIndex = -1;
ProcessChildren();
}
protected override void DoStop()
{
Children[_currentIndex].Stop();
}
protected override void DoChildStopped(Node child, bool result)
{
if (result)
{
Stopped(true);
}
else
{
ProcessChildren();
}
}
private void ProcessChildren()
{
if (++_currentIndex < Children.Length)
{
if (IsStopRequested)
{
Stopped(false);
}
else
{
Children[_currentIndex].Start();
}
}
else
{
Stopped(false);
}
}
public override void StopLowerPriorityChildrenForChild(Node abortForChild, bool immediateRestart)
{
int indexForChild = 0;
bool found = false;
foreach (Node currentChild in Children)
{
if (currentChild == abortForChild)
{
found = true;
}
else if (!found)
{
indexForChild++;
}
else if (found && currentChild.IsActive)
{
if (immediateRestart)
{
_currentIndex = indexForChild - 1;
}
else
{
_currentIndex = Children.Length;
}
currentChild.Stop();
break;
}
}
}
public override string ToString()
{
return $"{base.ToString()}[{_currentIndex}]";
}
}
}
namespace NPBehave
{
public class BlackboardCondition : ObservingDecorator
{
private string _key;
private object _value;
private Operator _op;
public string Key
{
get
{
return _key;
}
}
public object Value
{
get
{
return _value;
}
}
public Operator Operator
{
get
{
return _op;
}
}
#if DEBUG
public override string DebugIcon => "quiz";
public override string ComputedLabel
{
get
{
return $"{Key} {OperatorToString(Operator)} {Value}";
}
}
public string OperatorToString( Operator _op )
{
return _op switch
{
Operator.IsSet => "?=",
Operator.IsNotSet => "?!=",
Operator.IsEqual => "==",
Operator.IsNotEqual => "!=",
Operator.IsGreaterOrEqual => ">=",
Operator.IsGreater => ">",
Operator.IsSmallerOrEqual => "<=",
Operator.IsSmaller => "<",
Operator.AlwaysTrue => "ALWAYS_TRUE",
_ => $"<{_op}>"
};
}
#endif
public BlackboardCondition(string key, Operator op, object value, Stops stopsOnChange, Node decoratee) : base("BlackboardCondition", stopsOnChange, decoratee)
{
_op = op;
_key = key;
_value = value;
StopsOnChange = stopsOnChange;
}
public BlackboardCondition(string key, Operator op, Stops stopsOnChange, Node decoratee) : base("BlackboardCondition", stopsOnChange, decoratee)
{
_op = op;
_key = key;
StopsOnChange = stopsOnChange;
}
protected override void StartObserving()
{
RootNode.Blackboard.AddObserver(_key, OnValueChanged);
}
protected override void StopObserving()
{
RootNode.Blackboard.RemoveObserver(_key, OnValueChanged);
}
private void OnValueChanged(Blackboard.Type type, object newValue)
{
Evaluate();
}
protected override bool IsConditionMet()
{
if (_op == Operator.AlwaysTrue)
{
return true;
}
if (!RootNode.Blackboard.IsSet(_key))
{
return _op == Operator.IsNotSet;
}
object o = RootNode.Blackboard.Get(_key);
switch (_op)
{
case Operator.IsSet: return true;
case Operator.IsEqual: return Equals(o, _value);
case Operator.IsNotEqual: return !Equals(o, _value);
case Operator.IsGreaterOrEqual:
if (o is float)
{
return (float)o >= (float)_value;
}
else if (o is int)
{
return (int)o >= (int)_value;
}
else
{
Log.Error( $"Type not compareable: {o.GetType()}" );
return false;
}
case Operator.IsGreater:
if (o is float)
{
return (float)o > (float)_value;
}
else if (o is int)
{
return (int)o > (int)_value;
}
else
{
Log.Error( $"Type not compareable: {o.GetType()}" );
return false;
}
case Operator.IsSmallerOrEqual:
if (o is float)
{
return (float)o <= (float)_value;
}
else if (o is int)
{
return (int)o <= (int)_value;
}
else
{
Log.Error( $"Type not compareable: {o.GetType()}" );
return false;
}
case Operator.IsSmaller:
if (o is float)
{
return (float)o < (float)_value;
}
else if (o is int)
{
return (int)o < (int)_value;
}
else
{
Log.Error( $"Type not compareable: {o.GetType()}" );
return false;
}
default: return false;
}
}
public override string ToString()
{
return $"({_op}) {_key} ? {_value}";
}
}
}
using System;
namespace NPBehave
{
public class Condition : ObservingDecorator
{
private Func<bool> _condition;
private float _checkInterval;
private float _checkVariance;
public Condition(Func<bool> condition, Node decoratee) : base("Condition", Stops.None, decoratee)
{
_condition = condition;
_checkInterval = 0.0f;
_checkVariance = 0.0f;
}
public Condition(Func<bool> condition, Stops stopsOnChange, Node decoratee) : base("Condition", stopsOnChange, decoratee)
{
_condition = condition;
_checkInterval = 0.0f;
_checkVariance = 0.0f;
}
public Condition(Func<bool> condition, Stops stopsOnChange, float checkInterval, float randomVariance, Node decoratee) : base("Condition", stopsOnChange, decoratee)
{
_condition = condition;
_checkInterval = checkInterval;
_checkVariance = randomVariance;
}
protected override void StartObserving()
{
RootNode.Clock.AddTimer(_checkInterval, _checkVariance, -1, Evaluate);
}
protected override void StopObserving()
{
RootNode.Clock.RemoveTimer(Evaluate);
}
protected override bool IsConditionMet()
{
return _condition();
}
}
}namespace NPBehave
{
public abstract class Decorator : Container
{
protected Node Decoratee;
public Decorator(string name, Node decoratee) : base(name)
{
Decoratee = decoratee;
Decoratee.SetParent(this);
}
public override void SetRoot(Root rootNode)
{
base.SetRoot(rootNode);
Decoratee.SetRoot(rootNode);
}
#if DEBUG
public override string DebugIcon => "brush";
public override Node[] DebugChildren
{
get
{
return new Node[] { Decoratee };
}
}
#endif
public override void ParentCompositeStopped(Composite composite)
{
base.ParentCompositeStopped(composite);
Decoratee.ParentCompositeStopped(composite);
}
}
}
using System.Collections;
using Sandbox.Diagnostics;
namespace NPBehave
{
public abstract class ObservingDecorator : Decorator
{
protected Stops StopsOnChange;
private bool _isObserving;
public ObservingDecorator(string name, Stops stopsOnChange, Node decoratee) : base(name, decoratee)
{
StopsOnChange = stopsOnChange;
_isObserving = false;
}
protected override void DoStart()
{
if (StopsOnChange != Stops.None)
{
if (!_isObserving)
{
_isObserving = true;
StartObserving();
}
}
if (!IsConditionMet())
{
Stopped(false);
}
else
{
Decoratee.Start();
}
}
protected override void DoStop()
{
Decoratee.Stop();
}
protected override void DoChildStopped(Node child, bool result)
{
Assert.AreNotEqual(((Node)this).CurrentState, State.Inactive);
if (StopsOnChange is Stops.None or Stops.Self)
{
if (_isObserving)
{
_isObserving = false;
StopObserving();
}
}
Stopped(result);
}
protected override void DoParentCompositeStopped(Composite parentComposite)
{
if (_isObserving)
{
_isObserving = false;
StopObserving();
}
}
protected void Evaluate()
{
if (IsActive && !IsConditionMet())
{
if (StopsOnChange is Stops.Self or Stops.Both or Stops.ImmediateRestart)
{
// Debug.Log( this.key + " stopped self ");
Stop();
}
}
else if (!IsActive && IsConditionMet())
{
if (StopsOnChange == Stops.LowerPriority || StopsOnChange == Stops.Both || StopsOnChange == Stops.ImmediateRestart || StopsOnChange == Stops.LowerPriorityImmediateRestart)
{
// Debug.Log( this.key + " stopped other ");
Container parentNode = ParentNode;
Node childNode = this;
while (parentNode != null && !(parentNode is Composite))
{
childNode = parentNode;
parentNode = parentNode.ParentNode;
}
Assert.NotNull(parentNode, "NTBtrStops is only valid when attached to a parent composite");
Assert.NotNull(childNode);
if (parentNode is Parallel)
{
Assert.True(StopsOnChange == Stops.ImmediateRestart, "On Parallel Nodes all children have the same priority, thus Stops.LOWER_PRIORITY or Stops.BOTH are unsupported in this context!");
}
if (StopsOnChange == Stops.ImmediateRestart || StopsOnChange == Stops.LowerPriorityImmediateRestart)
{
if (_isObserving)
{
_isObserving = false;
StopObserving();
}
}
((Composite)parentNode)?.StopLowerPriorityChildrenForChild(childNode, StopsOnChange is Stops.ImmediateRestart or Stops.LowerPriorityImmediateRestart);
}
}
}
protected abstract void StartObserving();
protected abstract void StopObserving();
protected abstract bool IsConditionMet();
}
}
using Sandbox.Diagnostics;
namespace NPBehave
{
public class TimeMin : Decorator
{
private float _limit = 0.0f;
private float _randomVariation;
private bool _waitOnFailure = false;
private bool _isLimitReached = false;
private bool _isDecorateeDone = false;
private bool _isDecorateeSuccess = false;
public TimeMin(float limit, Node decoratee) : base("TimeMin", decoratee)
{
_limit = limit;
_randomVariation = _limit * 0.05f;
_waitOnFailure = false;
Assert.True(limit > 0f, "limit has to be set");
}
public TimeMin(float limit, bool waitOnFailure, Node decoratee) : base("TimeMin", decoratee)
{
_limit = limit;
_randomVariation = _limit * 0.05f;
_waitOnFailure = waitOnFailure;
Assert.True(limit > 0f, "limit has to be set");
}
public TimeMin(float limit, float randomVariation, bool waitOnFailure, Node decoratee) : base("TimeMin", decoratee)
{
_limit = limit;
_randomVariation = randomVariation;
_waitOnFailure = waitOnFailure;
Assert.True(limit > 0f, "limit has to be set");
}
protected override void DoStart()
{
_isDecorateeDone = false;
_isDecorateeSuccess = false;
_isLimitReached = false;
Clock.AddTimer(_limit, _randomVariation, 0, TimeoutReached);
Decoratee.Start();
}
protected override void DoStop()
{
if (Decoratee.IsActive)
{
Clock.RemoveTimer(TimeoutReached);
_isLimitReached = true;
Decoratee.Stop();
}
else
{
Clock.RemoveTimer(TimeoutReached);
Stopped(false);
}
}
protected override void DoChildStopped(Node child, bool result)
{
_isDecorateeDone = true;
_isDecorateeSuccess = result;
if (_isLimitReached || (!result && !_waitOnFailure))
{
Clock.RemoveTimer(TimeoutReached);
Stopped(_isDecorateeSuccess);
}
else
{
Assert.True(Clock.HasTimer(TimeoutReached));
}
}
private void TimeoutReached()
{
_isLimitReached = true;
if (_isDecorateeDone)
{
Stopped(_isDecorateeSuccess);
}
else
{
Assert.True(Decoratee.IsActive);
}
}
}
}
using System;
using System.Threading;
using System.Threading.Tasks;
using Sandbox;
namespace TwitchAPI.Examples;
public class CustomSubscriberBadges
{
[ImageAssetPath, Title( "Default/1 Month Badge" )] public string DefaultBadge { get; set; }
[ImageAssetPath, Title( "2 Month Badge" )] public string MonthBadge2 { get; set; }
[ImageAssetPath, Title( "3 Month Badge" )] public string MonthBadge3 { get; set; }
[ImageAssetPath, Title( "6 Month Badge" )] public string MonthBadge6 { get; set; }
[ImageAssetPath, Title( "9 Month Badge" )] public string MonthBadge9 { get; set; }
[ImageAssetPath, Title( "1 Year Badge" )] public string YearBadge1 { get; set; }
[ImageAssetPath, Title( "1.5 Year Badge" )] public string YearBadge1_5 { get; set; }
[ImageAssetPath, Title( "2 Year Badge" )] public string YearBadge2 { get; set; }
[ImageAssetPath, Title( "2.5 Year Badge" )] public string YearBadge2_5 { get; set; }
[ImageAssetPath, Title( "3 Year Badge" )] public string YearBadge3 { get; set; }
[ImageAssetPath, Title( "3.5 Year Badge" )] public string YearBadge3_5 { get; set; }
[ImageAssetPath, Title( "4 Year Badge" )] public string YearBadge4 { get; set; }
[ImageAssetPath, Title( "4.5 Year Badge" )] public string YearBadge4_5 { get; set; }
[ImageAssetPath, Title( "5 Year Badge" )] public string YearBadge5 { get; set; }
[ImageAssetPath, Title( "5.5 Year Badge" )] public string YearBadge5_5 { get; set; }
[ImageAssetPath, Title( "6 Year Badge" )] public string YearBadge6 { get; set; }
[ImageAssetPath, Title( "6.5 Year Badge" )] public string YearBadge6_5 { get; set; }
[ImageAssetPath, Title( "7 Year Badge" )] public string YearBadge7 { get; set; }
[ImageAssetPath, Title( "7.5 Year Badge" )] public string YearBadge7_5 { get; set; }
[ImageAssetPath, Title( "8 Year Badge" )] public string YearBadge8 { get; set; }
[ImageAssetPath, Title( "8.5 Year Badge" )] public string YearBadge8_5 { get; set; }
[ImageAssetPath, Title( "9 Year Badge" )] public string YearBadge9 { get; set; }
[ImageAssetPath, Title( "9.5 Year Badge" )] public string YearBadge9_5 { get; set; }
[ImageAssetPath, Title( "10 Year Badge" )] public string YearBadge10 { get; set; }
public string GetBadge( int months )
{
if ( months >= 120 && !string.IsNullOrEmpty( YearBadge10 ) ) return YearBadge10;
if ( months >= 114 && !string.IsNullOrEmpty( YearBadge9_5 ) ) return YearBadge9_5;
if ( months >= 108 && !string.IsNullOrEmpty( YearBadge9 ) ) return YearBadge9;
if ( months >= 102 && !string.IsNullOrEmpty( YearBadge8_5 ) ) return YearBadge8_5;
if ( months >= 96 && !string.IsNullOrEmpty( YearBadge8 ) ) return YearBadge8;
if ( months >= 90 && !string.IsNullOrEmpty( YearBadge7_5 ) ) return YearBadge7_5;
if ( months >= 84 && !string.IsNullOrEmpty( YearBadge7 ) ) return YearBadge7;
if ( months >= 78 && !string.IsNullOrEmpty( YearBadge6_5 ) ) return YearBadge6_5;
if ( months >= 72 && !string.IsNullOrEmpty( YearBadge6 ) ) return YearBadge6;
if ( months >= 66 && !string.IsNullOrEmpty( YearBadge5_5 ) ) return YearBadge5_5;
if ( months >= 60 && !string.IsNullOrEmpty( YearBadge5 ) ) return YearBadge5;
if ( months >= 54 && !string.IsNullOrEmpty( YearBadge4_5 ) ) return YearBadge4_5;
if ( months >= 48 && !string.IsNullOrEmpty( YearBadge4 ) ) return YearBadge4;
if ( months >= 42 && !string.IsNullOrEmpty( YearBadge3_5 ) ) return YearBadge3_5;
if ( months >= 36 && !string.IsNullOrEmpty( YearBadge3 ) ) return YearBadge3;
if ( months >= 30 && !string.IsNullOrEmpty( YearBadge2_5 ) ) return YearBadge2_5;
if ( months >= 24 && !string.IsNullOrEmpty( YearBadge2 ) ) return YearBadge2;
if ( months >= 18 && !string.IsNullOrEmpty( YearBadge1_5 ) ) return YearBadge1_5;
if ( months >= 12 && !string.IsNullOrEmpty( YearBadge1 ) ) return YearBadge1;
if ( months >= 9 && !string.IsNullOrEmpty( MonthBadge9 ) ) return MonthBadge9;
if ( months >= 6 && !string.IsNullOrEmpty( MonthBadge6 ) ) return MonthBadge6;
if ( months >= 3 && !string.IsNullOrEmpty( MonthBadge3 ) ) return MonthBadge3;
if ( months >= 2 && !string.IsNullOrEmpty( MonthBadge2 ) ) return MonthBadge2;
return DefaultBadge;
}
}