Untitled

static class Scheduler
{
    public static float ticksPerSecond = 120;

    //


    public static bool _HOLD_ { get; private set; } = false;

    //


    public static int totalTickTimer { get; private set; } = 0;
    static bool clock = false;

    static int pulseCalculationsRunning = 0;

    //Dictionary< startTick, Dictionary< precedence, List<PulseGroupGroup> > >
    static Dictionary<int, Dictionary< int, List<PulseGroupGroup> >> scheduledPulseGroupGroups = new Dictionary<int, Dictionary< int, List<PulseGroupGroup> >>(6);

    //Dictionary< startTick, Dictionary< precedence, List<PulseGroup> > >
    static Dictionary<int, Dictionary< int, List<PulseGroup> >> scheduledPulseGroups = new Dictionary<int, Dictionary< int, List<PulseGroup> >>(9);

    //Dictionary< startTick, Dictionary< precedence, List<Pulse> > >
    static Dictionary<int, Dictionary< int, List<Pulse> >> scheduledPulses = new Dictionary<int, Dictionary< int, List<Pulse> >>(512);

    static Dictionary<Vector2, ( Pulse, int endframe, int precedence )> runningPulses = new Dictionary<Vector2, ( Pulse, int endframe, int precedence )>(64);




    public static async void AwaitPulseCalcDoneThenCycle() {
        if (_HOLD_) while (_HOLD_) { await Task.Delay(1); }

        if ( pulseCalculationsRunning != 0 ) { 
            _HOLD_ = true; 
            while ( pulseCalculationsRunning != 0 ) { await Task.Delay(1); }
            _HOLD_ = false; 
        }

        _Cycle();
    }

    static void _Cycle() 
    {
        _HOLD_ = true;
        clock = !clock;
        totalTickTimer++;

        _FrameUpdate();
    }

    static void _FrameUpdate()
    {

        bool tickHasScheduledPulseGG = scheduledPulseGroupGroups.TryGetValue(totalTickTimer, out var pGGPrecedenceDict);

        if (tickHasScheduledPulseGG) {

            for (int precedence = 0; precedence < 10; precedence++) {
                if (!scheduledPulseGroupGroups.ContainsKey(precedence)) continue;


                List<PulseGroupGroup> pulseGGList = pGGPrecedenceDict[precedence];

                foreach (var pulseGG in pulseGGList) {
                    GroupConfig pulseGGConfig = pulseGG.groupConfig;


                    int tickTimerCalc = pulseGGConfig.framesBeforeStarting;

                    foreach (var pulseG in pulseGG.GetPulseGroups())
                    {
                        GroupConfig pulseGConfig = pulseG.groupConfig;


                        SchedulePulseGroup(pulseG, tickTimerCalc);

                        tickTimerCalc += pulseGGConfig.framesBetweenElements;
                    }

                    scheduledPulseGroupGroups[totalTickTimer][precedence].Remove(pulseGG);
                }
            }
        }


        bool tickHasScheduledPulseG = scheduledPulseGroups.TryGetValue(totalTickTimer, out var pGPrecedenceDict);

        if (tickHasScheduledPulseG) {
            for (int precedence = 0; precedence < 10; precedence++) {
                if (!scheduledPulseGroups.ContainsKey(precedence)) continue;


                List<PulseGroup> pulseGList = pGPrecedenceDict[precedence];

                foreach (var pulseG in pulseGList) {
                    GroupConfig pulseGConfig = pulseG.groupConfig;


                    int tickTimerCalc = pulseGConfig.framesBeforeStarting;

                    foreach (var pulse in pulseG.GetPulses())
                    {
                        PulseConfig pulseConfig = pulse.config;


                        SchedulePulse(pulse, tickTimerCalc);

                        tickTimerCalc += pulseGConfig.framesBetweenElements;
                    }

                    scheduledPulseGroups[totalTickTimer][precedence].Remove(pulseG);
                }
            }
        }


        bool tickHasScheduledPulse = scheduledPulses.TryGetValue(totalTickTimer, out var pPrecedenceDict);

        if (tickHasScheduledPulse) {
            for (int precedence = 0; precedence < 10; precedence++) {
                if (!scheduledPulseGroups.ContainsKey(precedence)) continue;


                List<Pulse> pulseList = pPrecedenceDict[precedence];

                foreach (var pulse in pulseList) {
                    PulseConfig pulseConfig = pulse.config;


                    SchedulePulse(pulse, tickTimerCalc);

                    tickTimerCalc += pulseGConfig.framesBetweenElements;
                    }

                    scheduledPulseGroups[totalTickTimer][precedence].Remove(pulseG);
                }
            }
        }

        _HOLD_ = false;

    }

    public static void SchedulePulse( Pulse pulse, int startInXTicks ) {
        PulseConfig config = pulse.config;
        int startOnTick = (totalTickTimer + 1) + startInXTicks;

        scheduledPulses.TryAdd( startOnTick, new Dictionary< int, List<Pulse> >(10) );
        scheduledPulses[startOnTick].TryAdd( config.precedence, new List<Pulse>(128) );

        scheduledPulses[startOnTick][config.precedence].Add(pulse);
    }

    public static void SchedulePulseGroup( PulseGroup pulseGroup, int startInXTicks ) {

        GroupConfig config = pulseGroup.groupConfig;
        int startOnTick = (totalTickTimer + 1) + startInXTicks;

        scheduledPulseGroups.TryAdd( startOnTick, new Dictionary< int, List<PulseGroup> >(10) );
        scheduledPulseGroups[startOnTick].TryAdd(config.precedence, new List<PulseGroup>(32) );

        scheduledPulseGroups[startOnTick][config.precedence].Add(pulseGroup);

    }
    public static void SchedulePulseGroupGroup( PulseGroupGroup pulseGroupGroup, int startInXTicks ) {

        GroupConfig config = pulseGroupGroup.groupConfig;
        int startOnTick = (totalTickTimer + 1) + startInXTicks;

        scheduledPulseGroupGroups.TryAdd( startOnTick, new Dictionary< int, List<PulseGroupGroup> >(10) );
        scheduledPulseGroupGroups[startOnTick].TryAdd(config.precedence, new List<PulseGroupGroup>(8) );

        scheduledPulseGroupGroups[startOnTick][config.precedence].Add(pulseGroupGroup);

    }
}


class PulseGroup {
    public GroupConfig groupConfig;

    List<Pulse> pulseGroup;
    public HashSet< Vector2 > pulsePositions;

    public PulseGroup( List<Pulse> pulses, GroupConfig config ) {

        pulseGroup = pulses;
        groupConfig = config;
        pulsePositions = new HashSet<Vector2>(pulses.Count);
        foreach (var pulse in pulses) { pulsePositions.Add( pulse.config.position ); }

    }
    public PulseGroup( int size, GroupConfig config ) {

        pulseGroup = new List<Pulse>(size);
        groupConfig = config;
        pulsePositions = new HashSet<Vector2>(size);

    }
    public PulseGroup( int size ) {

        pulseGroup = new List<Pulse>(size);
        pulsePositions = new HashSet<Vector2>(size);

    }
    public void SetConfig( GroupConfig config ) {

        groupConfig = config;

    }


    public void Add( Pulse pulse ) {
        pulseGroup.Add(pulse);
        pulsePositions.Add(pulse.config.position);
    }
    public List<Pulse> GetPulses() {
        if (groupConfig is null) throw new Exception("GroupConfig was null, you must set it before attempting to get the list of pulses");

        //this don't diggidy dang work because you set the size beforehand- remember that if it comes up and maybe fix it too
        if (pulsePositions.Count != pulseGroup.Count) throw new Exception("Count of pulsePositions does not match count of pulses in pulseGroup");

        return pulseGroup;
    }
}
public class GroupConfig
{
    public int precedence { get; private set; } = 4;
    public int framesBeforeStarting { get; private set; } = 0;
    public int framesBetweenElements { get; private set; } = 0;

    public GroupConfig( int _precedenceLevel, int _framesBetweenElements, int _framesBeforeStarting ) { precedence = _precedenceLevel; framesBeforeStarting = _framesBeforeStarting; framesBetweenElements = _framesBetweenElements; }
}
class PulseGroupGroup {
    public GroupConfig groupConfig;

    List<PulseGroup> pulseGroupGroup;

    public PulseGroupGroup( int size, GroupConfig config ) {
        pulseGroupGroup = new List<PulseGroup>(size);
        groupConfig = config;
    }

    public void Add( PulseGroup pulseGroup ) {
        pulseGroupGroup.Add(pulseGroup);
    }
    public List<PulseGroup> GetPulseGroups() {
        if (groupConfig is null) throw new Exception("GroupConfig was null");
        return pulseGroupGroup;
    }
}


public class PulseConfig {
    public enum BreakMode { BreakDuringTick, BreakAfterCycle, NeverBreak };

    public int precedence = 4;

    public Color resetColour = new Color(0, 0, 0, 0);
    public Color cachedColour = new Color(0, 0, 0, 0);

    public Vector2 position { get; private set; }
    public Color colour { get; private set; }
    public int holdColourForXFrames { get; private set; }
    public int lerpInXFrames { get; private set; }
    public int runXTimes { get; private set; }
    public BreakMode breakMode { get; private set; } = BreakMode.BreakDuringTick;

    public PulseConfig( Vector2 _position, Color _colour, Color _resetColour, int _precedenceLevel, int _holdColourForXFrames, int _lerpInXFrames, int _howManyTimes ) { position = _position; precedence = _precedenceLevel; colour = _colour; resetColour = _resetColour; holdColourForXFrames = _holdColourForXFrames; lerpInXFrames = _lerpInXFrames; runXTimes = _howManyTimes; }
    public PulseConfig( Vector2 _position, Color _colour,                     int _precedenceLevel, int _holdColourForXFrames, int _lerpInXFrames, int _howManyTimes ) { position = _position; colour = _colour; precedence = _precedenceLevel; holdColourForXFrames = _holdColourForXFrames; lerpInXFrames = _lerpInXFrames; runXTimes = _howManyTimes; }
    public PulseConfig( Vector2 _position, Color _colour,                     int _precedenceLevel, int _holdColourForXFrames, int _lerpInXFrames, int _howManyTimes, BreakMode _breakMode ) { position = _position; precedence = _precedenceLevel; colour = _colour; holdColourForXFrames = _holdColourForXFrames; lerpInXFrames = _lerpInXFrames; runXTimes = _howManyTimes; breakMode = _breakMode; }
    public PulseConfig( Vector2 _position, Color _colour, Color _resetColour, int _precedenceLevel, int _holdColourForXFrames, int _lerpInXFrames, int _howManyTimes, BreakMode _breakMode ) { position = _position; precedence = _precedenceLevel; colour = _colour; resetColour = _resetColour; holdColourForXFrames = _holdColourForXFrames; lerpInXFrames = _lerpInXFrames; runXTimes = _howManyTimes; breakMode = _breakMode; }

}
public class Pulse {
    public PulseConfig config;

    public int pulseFrameDuration;
    public int pulseFramesRan;

    //OLD SHITTY UNUSED SHIT FROM BEFORE REWRITE////

    //public bool __clearQueueWhenBreak = false;
    //public bool __clearQueueWhenEnd = false;

    //public bool __forceInsertAtQueueStart = false;
    //public bool __clearOtherQueuePulsesWhenCyclesEnd__ = false;

    //public bool forceStart = false;
    //public bool __forceEnd__ = false;

    //public bool __forceBreak__ = false;

    ////                           ////

    public Pulse( PulseConfig _config )
    {
        config = _config;
    }

    public void Break()
    {

    }
}