private void EventHappened(BeatmapEventData Data)
{
int value = Data.value;
Int32.TryParse(Data.type.ToString().Replace("Event", string.Empty), out int Event);
Plugin.log.Info(Event + value.ToString());
if (value < 2000000000)
{
if (Event == LightElement.LeftLasers.AsInt() || Event == LightElement.RightLasers.AsInt())
{
if (Data.time > (lastEventTime + (maxArduinoDelay * 0.001)))
{
Plugin.log.Info("Event happened: " + value.ToString());
if (Settings.instance.RainbowMode)
{
Settings.arduinoPort.Write("E9");
}
if (Event == LightElement.LeftLasers.AsInt())
{
Settings.arduinoPort.Write($"A{value}");
}
else
{
Settings.arduinoPort.Write($"B{value}");
}
lastEventTime = Data.time;
}
}
}
}
internal void EventCallback(BeatmapEventData beatmapEventData)
{
if (beatmapEventData.type == (BeatmapEventType)_eventL || beatmapEventData.type == (BeatmapEventType)_eventR)
{
int frameCount = Time.frameCount;
if (_randomGenerationFrameNum != frameCount)
{
if (!_useRandomValues)
{
_randomDirection = ((beatmapEventData.type == (BeatmapEventType)_eventL) ? 1f : -1f);
_randomStartRotation = ((beatmapEventData.type == (BeatmapEventType)_eventL) ? frameCount : (-frameCount));
}
else
{
_randomDirection = ((UnityEngine.Random.value > 0.5f) ? 1f : -1f);
_randomStartRotation = UnityEngine.Random.Range(0f, 360f);
}
_randomGenerationFrameNum = Time.frameCount;
}
if (beatmapEventData.type == (BeatmapEventType)_eventL)
{
UpdateRotationData(beatmapEventData.value, ref _rotationDataL, _randomStartRotation, _randomDirection);
}
if (beatmapEventData.type == (BeatmapEventType)_eventR)
{
UpdateRotationData(beatmapEventData.value, ref _rotationDataR, -_randomStartRotation, -_randomDirection);
}
enabled = (_rotationDataL.enabled || _rotationDataR.enabled);
}
}
public void OnEvent(BeatmapEventData eventData)
{
if (eventData.type == eventTypeForThisLight)
{
HandleEvent(eventData, true);
}
}
private static void Prefix(LightSwitchEventEffect __instance, BeatmapEventData beatmapEventData, BeatmapEventType ____event)
{
if (beatmapEventData.type == ____event)
{
__instance.SetLastValue(beatmapEventData.value);
}
}
public static LightArrangement CreateArrangement(BeatmapEventData data)
{
LightArrangement arr = new LightArrangement();
switch (data.value)
{
case 0:
arr.enabled = false;
arr.color = null;
break;
case 1:
case 2:
case 3:
arr.color = GetCSO(colour1);
arr.enabled = true;
break;
case 5:
case 6:
case 7:
arr.color = GetCSO(colour0);
arr.enabled = true;
break;
default:
arr.enabled = false;
arr.color = null;
break;
}
return(arr);
}
private void ProxyEvent(BeatmapEventData data)
{
foreach (TrackLaneRingsRotationEffectSpawner spawner in rotationSpawners)
{
ReflectionUtil.InvokeMethod(spawner, "HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger", new object[] { data });
}
}
/// <summary>
/// Gatekeeper function for <see cref="OnTrigger"/><br/>
/// (I refuse calling that a good implementation)<br/>
/// (Who the f**k did this???)<br/>
/// (Use a <see cref="System.Collections.Generic.Dictionary{TKey, TValue}"/> instead)
/// </summary>
/// <param name="songEventData">Event to evaluate</param>
private void OnSongEvent(BeatmapEventData songEventData)
{
if (songEventData.type == (BeatmapEventType)eventType && (songEventData.value == value || anyValue))
{
OnTrigger !.Invoke();
}
}
//Laser rotation
static bool Prefix(LightRotationEventEffect __instance, ref BeatmapEventData beatmapEventData, ref BeatmapEventType ____event, ref Transform ____transform, ref Quaternion ____startRotation, ref Vector3 ____rotationVector, ref float ____rotationSpeed)
{
if (beatmapEventData.type == ____event)
{
if (!IsDefaults())
{
if (beatmapEventData.value == 0)
{
__instance.enabled = false;
if (!ChromaEvent.disablePositionReset)
{
____transform.localRotation = ____startRotation;
}
}
else if (beatmapEventData.value > 0)
{
if (!ChromaEvent.disablePositionReset)
{
____transform.localRotation = ____startRotation;
____transform.Rotate(____rotationVector, UnityEngine.Random.Range(0f, 180f), Space.Self);
}
__instance.enabled = true;
____rotationSpeed = (float)beatmapEventData.value * 20f * (GetRotationDirection());
}
return(false);
}
}
return(true);
}
internal BeatmapEventData RegisterLink()
{
BeatmapEventData baseData = CreateBaseGameBeatmapEvent();
chromaEvents.Add(baseData, this);
return(baseData);
}
// 0 = off
// 1 = blue on, 5 = red on
// 2 = blue flash, 6 = red flash
// 3 = blue fade, 7 = red fade
private static void Prefix(LightSwitchEventEffect __instance, BeatmapEventData beatmapEventData, BeatmapEventType ____event)
{
if (beatmapEventData.type == ____event)
{
LightColorManager.ColorLightSwitch(__instance, beatmapEventData);
}
}
private static bool Prefix(ParticleSystemEventEffect __instance, BeatmapEventData beatmapEventData, BeatmapEventType ____colorEvent)
{
if (TechnicolorConfig.Instance.TechnicolorEnabled && beatmapEventData.type == ____colorEvent &&
beatmapEventData.value > 0 && beatmapEventData.value <= 7)
{
if (TechnicolorConfig.Instance.TechnicolorLightsGrouping == TechnicolorLightsGrouping.ISOLATED &&
TechnicolorController.TechniLightRandom.NextDouble() < TechnicolorConfig.Instance !.TechnicolorLightsFrequency)
{
ParticleSystem.MainModule mainmodule = _mainModuleAccessor(ref __instance);
ParticleSystem.Particle[] particles = _particlesAccessor(ref __instance);
ParticleSystem particleSystem = _particleSystemAccessor(ref __instance);
mainmodule.startColor = TechnicolorController.GetTechnicolor(beatmapEventData.value > 3, beatmapEventData.time, TechnicolorConfig.Instance.TechnicolorLightsStyle);
particleSystem.GetParticles(particles, particles.Length);
for (int i = 0; i < particleSystem.particleCount; i++)
{
particles[i].startColor = TechnicolorController.GetTechnicolor(beatmapEventData.value > 3, beatmapEventData.time + particles[i].randomSeed, TechnicolorConfig.Instance.TechnicolorLightsStyle);
}
particleSystem.SetParticles(particles, particleSystem.particleCount);
return(false);
}
}
return(true);
}
public static BeatmapData CreateTransformedBeatmapData(BeatmapData beatmapData, GameplayOptions gameplayOptions, GameplayMode gameplayMode)
{
BeatmapData beatmapData2 = beatmapData;
if (gameplayOptions.mirror)
{
beatmapData2 = BeatDataMirrorTransform.CreateTransformedData(beatmapData2);
}
if (gameplayMode == GameplayMode.SoloNoArrows)
{
beatmapData2 = BeatmapDataNoArrowsTransform.CreateTransformedData(beatmapData2);
}
if (gameplayOptions.obstaclesOption != GameplayOptions.ObstaclesOption.All)
{
beatmapData2 = BeatmapDataObstaclesTransform.CreateTransformedData(beatmapData2, gameplayOptions.obstaclesOption);
}
if (beatmapData2 == beatmapData)
{
beatmapData2 = beatmapData.GetCopy();
}
if (gameplayOptions.staticLights)
{
BeatmapEventData[] beatmapEventData = new BeatmapEventData[]
{
new BeatmapEventData(0f, BeatmapEventType.Event0, 1),
new BeatmapEventData(0f, BeatmapEventType.Event4, 1)
};
beatmapData2 = new BeatmapData(beatmapData2.beatmapLinesData, beatmapEventData);
}
return(beatmapData2);
}
// Laser rotation
private static void Prefix(BeatmapEventData beatmapEventData, BeatmapEventType ____eventL, BeatmapEventType ____eventR)
{
if (beatmapEventData.type == ____eventL || beatmapEventData.type == ____eventR)
{
LastLightPairRotationEventEffectData = beatmapEventData;
}
}
public void LateUpdate()
{
if (!initialized)
{
startTime = timeSource.songTime;
initialized = true;
}
for (; eventIndex < lightshowData.Length; eventIndex++)
{
BeatmapEventData eventData = lightshowData[eventIndex];
if (eventData.time > timeSource.songTime - startTime)
{
break;
}
CustomBeatmapEventManager.RaiseCustomBeatmapEvent(eventData);
}
if (eventIndex >= lightshowData.Length)
{
Destroy(this);
}
}
private void OnBeatmapEvent(BeatmapEventData eventData)
{
if (!disablePipedBeatmapEvents)
{
onPipedBeatmapEvent?.Invoke(eventData);
}
}
private void OnBeatmapEventDidTrigger(BeatmapEventData beatmapEventData)
{
Data.beatmapEventType = beatmapEventData.type;
Data.beatmapEventValue = beatmapEventData.value;
Data.StatusChange(ChangedProperties.BeatmapEvent, "beatmapEvent");
}
public void OnBeatmapEventDidTrigger(BeatmapEventData beatmapEventData)
{
statusManager.gameStatus.beatmapEventType = (int)beatmapEventData.type;
statusManager.gameStatus.beatmapEventValue = beatmapEventData.value;
statusManager.EmitStatusUpdate(ChangedProperties.BeatmapEvent, "beatmapEvent");
}
public static void RemoveChromaEvent(BeatmapEventData beatmapEvent)
{
if (chromaEvents.ContainsKey(beatmapEvent))
{
chromaEvents.Remove(beatmapEvent);
}
}
private static void Prefix(ParticleSystemEventEffect __instance, BeatmapEventData beatmapEventData, BeatmapEventType ____colorEvent)
{
if (beatmapEventData.type == ____colorEvent)
{
__instance.SetLastValue(beatmapEventData.value);
}
}
private static bool Prefix(
BeatmapEventData beatmapEventData,
LightRotationEventEffect __instance,
BeatmapEventType ____event,
Quaternion ____startRotation,
ref float ____rotationSpeed,
Vector3 ____rotationVector)
{
if (beatmapEventData.type == ____event)
{
ChromaEventData?chromaData = TryGetEventData(beatmapEventData);
if (chromaData == null)
{
return(true);
}
bool isLeftEvent = ____event == BeatmapEventType.Event12;
bool lockPosition = chromaData.LockPosition;
float precisionSpeed = chromaData.Speed.GetValueOrDefault(beatmapEventData.value);
int? dir = chromaData.Direction;
float direction = (Random.value > 0.5f) ? 1f : -1f;
switch (dir)
{
case 0:
direction = isLeftEvent ? -1 : 1;
break;
case 1:
direction = isLeftEvent ? 1 : -1;
break;
}
// Actual lasering
if (beatmapEventData.value == 0)
{
__instance.enabled = false;
if (!lockPosition)
{
__instance.transform.localRotation = ____startRotation;
}
}
else if (beatmapEventData.value > 0)
{
__instance.enabled = true;
____rotationSpeed = precisionSpeed * 20f * direction;
if (!lockPosition)
{
__instance.transform.localRotation = ____startRotation;
__instance.transform.Rotate(____rotationVector, Random.Range(0f, 180f), Space.Self);
}
}
return(false);
}
return(true);
}
private static bool Prefix(LightPairRotationEventEffect __instance, BeatmapEventType ____eventL, float startRotationOffset, float direction, object ____rotationDataL, object ____rotationDataR)
{
BeatmapEventData beatmapEventData = LightPairRotationEventEffectHandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger.LastLightPairRotationEventEffectData;
bool isLeftEvent = beatmapEventData.type == ____eventL;
if (_rotationDataType == null)
{
GetRotationData();
}
object rotationData = isLeftEvent ? ____rotationDataL : ____rotationDataR;
ChromaLaserSpeedEventData chromaData = (ChromaLaserSpeedEventData)ChromaEventDatas[beatmapEventData];
bool lockPosition = chromaData.LockPosition;
float precisionSpeed = chromaData.PreciseSpeed;
int? dir = chromaData.Direction;
switch (dir)
{
case 0:
direction = isLeftEvent ? -1 : 1;
break;
case 1:
direction = isLeftEvent ? 1 : -1;
break;
}
// Actual lasering
Transform transform = (Transform)_rotationDataType.GetField("transform").GetValue(rotationData);
Quaternion startRotation = (Quaternion)_rotationDataType.GetField("startRotation").GetValue(rotationData);
float startRotationAngle = (float)_rotationDataType.GetField("startRotationAngle").GetValue(rotationData);
Vector3 rotationVector = __instance.GetField <Vector3, LightPairRotationEventEffect>("_rotationVector");
if (beatmapEventData.value == 0)
{
_rotationDataType.GetField("enabled").SetValue(rotationData, false);
if (!lockPosition)
{
_rotationDataType.GetField("rotationAngle").SetValue(rotationData, startRotationAngle);
transform.localRotation = startRotation * Quaternion.Euler(rotationVector * startRotationAngle);
}
}
else if (beatmapEventData.value > 0)
{
_rotationDataType.GetField("enabled").SetValue(rotationData, true);
_rotationDataType.GetField("rotationSpeed").SetValue(rotationData, precisionSpeed * 20f * direction);
if (!lockPosition)
{
float rotationAngle = startRotationOffset + startRotationAngle;
_rotationDataType.GetField("rotationAngle").SetValue(rotationData, rotationAngle);
transform.localRotation = startRotation * Quaternion.Euler(rotationVector * rotationAngle);
}
}
return(false);
}
private static void Prefix(BeatmapEventData beatmapEventData, BeatmapEventType ____colorEvent)
{
if (beatmapEventData.type == ____colorEvent)
{
// Some redundancy here but f**k it
____colorEvent.GetParticleColorizers().ForEach(n => n.PreviousValue = beatmapEventData.value);
}
}
// Laser rotation
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
private static void Prefix(BeatmapEventData beatmapEventData, BeatmapEventType ____eventL, BeatmapEventType ____eventR)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
{
if (beatmapEventData.type == ____eventL || beatmapEventData.type == ____eventR)
{
LastLightPairRotationEventEffectData = beatmapEventData;
}
}
public static void ActivateTechnicolour(BeatmapEventData baseData, LightSwitchEventEffect lse, BeatmapEventType type)
{
BSLight[] lights = lse.GetField <BSLight[]>("_lights");
for (int i = 0; i < lights.Length; i++)
{
lights[i].color = ColourManager.GetTechnicolour(baseData.value > 3, baseData.time + lights[i].GetInstanceID(), ColourManager.TechnicolourStyle.PURE_RANDOM);
}
}
public override void Activate(BeatmapEventData baseData, LightSwitchEventEffect lse, BeatmapEventType type)
{
BSLight[] lights = lse.GetField <BSLight[]>("_lights");
for (int i = 0; i < lights.Length; i++)
{
lights[i].color = UnityEngine.Random.ColorHSV().ColorWithValue(1f); //ColourManager.GetTechnicolour(true, time + lights[i].GetInstanceID(), ColourManager.TechnicolourStyle.PURE_RANDOM);
}
}
public static ChromaJSONEventData GetChromaEvent(BeatmapEventData data)
{
if (chromaEvents.TryGetValue(data, out ChromaJSONEventData chromaData))
{
return(chromaData);
}
return(null);
}
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
private static void Prefix(ParticleSystemEventEffect __instance, BeatmapEventData beatmapEventData, BeatmapEventType ____colorEvent)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
{
if (beatmapEventData.type == ____colorEvent)
{
LightColorManager.ColorLightSwitch(__instance, beatmapEventData);
}
}
internal static ChromaEventData?TryGetEventData(BeatmapEventData beatmapEventData)
{
if (_chromaEventDatas.TryGetValue(beatmapEventData, out ChromaEventData chromaEventData))
{
return(chromaEventData);
}
return(null);
}
void EventHappened(BeatmapEventData Data)
{
int Event;
int value = Data.value;
Int32.TryParse(Data.type.ToString().Replace("Event", ""), out Event);
if (value < 2000000000)
{
if (lastEventNumber != value && Data.time > (lastEventTime + maxArduinoDelay * 0.001)) //Make sure to never send same signal twice AND do not oversend, otherwise arduino will display beats too late.
{
Plugin.log.Info("Event happened: " + value.ToString());
if (Settings.instance.rainbowMode)
{
Settings.arduinoPort.Write("^");
}
switch (value)
{
case 0:
Settings.arduinoPort.Write("p"); //Turn Off
break;
case 1:
Settings.arduinoPort.Write("q"); //RightTurnOn
break;
case 2:
Settings.arduinoPort.Write("w"); //RightFlashAndLeaveOn
break;
case 3:
Settings.arduinoPort.Write("e");
Settings.arduinoPort.Write("p"); //RightFlashAndTurnOff
break;
case 5:
Settings.arduinoPort.Write("r"); //LeftTurnOn
break;
case 6:
Settings.arduinoPort.Write("t"); //LeftFlashAndLeaveOn
break;
case 7:
Settings.arduinoPort.Write("y");
Settings.arduinoPort.Write("p"); //LeftFlashAndTurnOff
break;
default:
Settings.arduinoPort.Write("p"); //Turn off on error
break;
}
lastEventNumber = value;
lastEventTime = Data.time;
}
}
}
public static ChromaEvent SetChromaEvent(BeatmapEventData lightEvent, ChromaEvent chromaEvent)
{
if (chromaEvents.ContainsKey(lightEvent))
{
chromaEvents.Remove(lightEvent);
}
chromaEvents.Add(lightEvent, chromaEvent);
chromaEvent.OnEventSet(lightEvent);
return(chromaEvent);
}
