From 050e56184cc74acadeca2fa9a3823a6724d8bf7c Mon Sep 17 00:00:00 2001 From: TheMaybeast Date: Mon, 17 Aug 2020 05:18:27 -0300 Subject: [PATCH] Initial Public Commit --- DLS.sln | 25 + DLS/ActiveVehicle.cs | 140 ++ DLS/DLS.csproj | 330 ++++ DLS/DLS.xml | 8 + DLS/DLSModel.cs | 153 ++ DLS/Entrypoint.cs | 167 ++ DLS/Properties/AssemblyInfo.cs | 18 + DLS/Properties/Resources.Designer.cs | 813 +++++++++ DLS/Properties/Resources.resx | 346 ++++ DLS/Resources/3_c_off.png | Bin 0 -> 1686 bytes DLS/Resources/3_c_on.png | Bin 0 -> 1834 bytes DLS/Resources/3_l_off.png | Bin 0 -> 1686 bytes DLS/Resources/3_l_on.png | Bin 0 -> 1831 bytes DLS/Resources/3_r_off.png | Bin 0 -> 1686 bytes DLS/Resources/3_r_on.png | Bin 0 -> 1834 bytes DLS/Resources/4_cl_off.png | Bin 0 -> 1685 bytes DLS/Resources/4_cl_on.png | Bin 0 -> 1835 bytes DLS/Resources/4_cr_off.png | Bin 0 -> 1686 bytes DLS/Resources/4_cr_on.png | Bin 0 -> 1839 bytes DLS/Resources/4_l_off.png | Bin 0 -> 1687 bytes DLS/Resources/4_l_on.png | Bin 0 -> 1830 bytes DLS/Resources/4_r_off.png | Bin 0 -> 1687 bytes DLS/Resources/4_r_on.png | Bin 0 -> 1837 bytes DLS/Resources/5_c_off.png | Bin 0 -> 1686 bytes DLS/Resources/5_c_on.png | Bin 0 -> 1834 bytes DLS/Resources/5_cl_off.png | Bin 0 -> 1686 bytes DLS/Resources/5_cl_on.png | Bin 0 -> 1831 bytes DLS/Resources/5_cr_off.png | Bin 0 -> 1686 bytes DLS/Resources/5_cr_on.png | Bin 0 -> 1834 bytes DLS/Resources/5_l_off.png | Bin 0 -> 1686 bytes DLS/Resources/5_l_on.png | Bin 0 -> 1839 bytes DLS/Resources/5_r_off.png | Bin 0 -> 1688 bytes DLS/Resources/5_r_on.png | Bin 0 -> 1835 bytes DLS/Resources/6_cl_off.png | Bin 0 -> 1685 bytes DLS/Resources/6_cl_on.png | Bin 0 -> 1835 bytes DLS/Resources/6_cr_off.png | Bin 0 -> 1686 bytes DLS/Resources/6_cr_on.png | Bin 0 -> 1839 bytes DLS/Resources/6_el_off.png | Bin 0 -> 1687 bytes DLS/Resources/6_el_on.png | Bin 0 -> 1830 bytes DLS/Resources/6_er_off.png | Bin 0 -> 1687 bytes DLS/Resources/6_er_on.png | Bin 0 -> 1837 bytes DLS/Resources/6_l_off.png | Bin 0 -> 1687 bytes DLS/Resources/6_l_on.png | Bin 0 -> 1837 bytes DLS/Resources/6_r_off.png | Bin 0 -> 1687 bytes DLS/Resources/6_r_on.png | Bin 0 -> 1838 bytes DLS/Resources/background.png | Bin 0 -> 21767 bytes DLS/Resources/blkt_off.png | Bin 0 -> 2710 bytes DLS/Resources/blkt_on.png | Bin 0 -> 6130 bytes DLS/Resources/ext1_off.png | Bin 0 -> 2890 bytes DLS/Resources/ext1_on.png | Bin 0 -> 5901 bytes DLS/Resources/ext2_off.png | Bin 0 -> 3415 bytes DLS/Resources/ext2_on.png | Bin 0 -> 6790 bytes DLS/Resources/hazard_off.png | Bin 0 -> 3589 bytes DLS/Resources/hazard_on.png | Bin 0 -> 7501 bytes DLS/Resources/horn_off.png | Bin 0 -> 4728 bytes DLS/Resources/horn_on.png | Bin 0 -> 11148 bytes DLS/Resources/intlt_off.png | Bin 0 -> 4483 bytes DLS/Resources/intlt_on.png | Bin 0 -> 9006 bytes DLS/Resources/lind_off.png | Bin 0 -> 3339 bytes DLS/Resources/lind_on.png | Bin 0 -> 6115 bytes DLS/Resources/manual_off.png | Bin 0 -> 4495 bytes DLS/Resources/manual_on.png | Bin 0 -> 10520 bytes DLS/Resources/rind_off.png | Bin 0 -> 3323 bytes DLS/Resources/rind_on.png | Bin 0 -> 6272 bytes DLS/Resources/s1_off.png | Bin 0 -> 2269 bytes DLS/Resources/s1_on.png | Bin 0 -> 3639 bytes DLS/Resources/s2_off.png | Bin 0 -> 3368 bytes DLS/Resources/s2_on.png | Bin 0 -> 5685 bytes DLS/Resources/s3_off.png | Bin 0 -> 3289 bytes DLS/Resources/s3_on.png | Bin 0 -> 5790 bytes DLS/Resources/sb_off.png | Bin 0 -> 4115 bytes DLS/Resources/sb_on.png | Bin 0 -> 6912 bytes DLS/Resources/tadiv_off.png | Bin 0 -> 2505 bytes DLS/Resources/tadiv_on.png | Bin 0 -> 5126 bytes DLS/Resources/taleft_off.png | Bin 0 -> 2095 bytes DLS/Resources/taleft_on.png | Bin 0 -> 5435 bytes DLS/Resources/taright_off.png | Bin 0 -> 2633 bytes DLS/Resources/taright_on.png | Bin 0 -> 6628 bytes DLS/Resources/tawarn_off.png | Bin 0 -> 3347 bytes DLS/Resources/tawarn_on.png | Bin 0 -> 7988 bytes DLS/Resources/wail_off.png | Bin 0 -> 3351 bytes DLS/Resources/wail_on.png | Bin 0 -> 6392 bytes DLS/Resources/yelp_off.png | Bin 0 -> 2788 bytes DLS/Resources/yelp_on.png | Bin 0 -> 6240 bytes DLS/SirenApply.cs | 68 + DLS/SirenSetting.cs | 292 +++ DLS/TextureHash.cs | 58 + DLS/Threads/CleanupManager.cs | 47 + DLS/Threads/PlayerController.cs | 934 ++++++++++ DLS/Threads/SpecialModesManager.cs | 171 ++ DLS/Threads/UIManager.cs | 425 +++++ DLS/TrafficAdvisory.cs | 69 + DLS/UI/CustomUI.cs | 18 + DLS/UI/Importer.cs | 610 +++++++ DLS/UI/Resources.cs | 25 + DLS/UI/Sprite.cs | 26 + DLS/Utils/Controls.cs | 186 ++ DLS/Utils/Extensions.cs | 178 ++ DLS/Utils/Helpers.cs | 58 + DLS/Utils/Lights.cs | 1011 +++++++++++ DLS/Utils/Log.cs | 23 + DLS/Utils/Settings.cs | 40 + DLS/Utils/Sirens.cs | 95 + DLS/Utils/Sound.cs | 39 + DLS/Utils/Vehicles.cs | 183 ++ Templates/DLS.ini | 78 + Templates/custom.xml | 6 + Templates/police.xml | 2454 ++++++++++++++++++++++++++ 108 files changed, 9094 insertions(+) create mode 100644 DLS.sln create mode 100644 DLS/ActiveVehicle.cs create mode 100644 DLS/DLS.csproj create mode 100644 DLS/DLS.xml create mode 100644 DLS/DLSModel.cs create mode 100644 DLS/Entrypoint.cs create mode 100644 DLS/Properties/AssemblyInfo.cs create mode 100644 DLS/Properties/Resources.Designer.cs create mode 100644 DLS/Properties/Resources.resx create mode 100644 DLS/Resources/3_c_off.png create mode 100644 DLS/Resources/3_c_on.png create mode 100644 DLS/Resources/3_l_off.png create mode 100644 DLS/Resources/3_l_on.png create mode 100644 DLS/Resources/3_r_off.png create mode 100644 DLS/Resources/3_r_on.png create mode 100644 DLS/Resources/4_cl_off.png create mode 100644 DLS/Resources/4_cl_on.png create mode 100644 DLS/Resources/4_cr_off.png create mode 100644 DLS/Resources/4_cr_on.png create mode 100644 DLS/Resources/4_l_off.png create mode 100644 DLS/Resources/4_l_on.png create mode 100644 DLS/Resources/4_r_off.png create mode 100644 DLS/Resources/4_r_on.png create mode 100644 DLS/Resources/5_c_off.png create mode 100644 DLS/Resources/5_c_on.png create mode 100644 DLS/Resources/5_cl_off.png create mode 100644 DLS/Resources/5_cl_on.png create mode 100644 DLS/Resources/5_cr_off.png create mode 100644 DLS/Resources/5_cr_on.png create mode 100644 DLS/Resources/5_l_off.png create mode 100644 DLS/Resources/5_l_on.png create mode 100644 DLS/Resources/5_r_off.png create mode 100644 DLS/Resources/5_r_on.png create mode 100644 DLS/Resources/6_cl_off.png create mode 100644 DLS/Resources/6_cl_on.png create mode 100644 DLS/Resources/6_cr_off.png create mode 100644 DLS/Resources/6_cr_on.png create mode 100644 DLS/Resources/6_el_off.png create mode 100644 DLS/Resources/6_el_on.png create mode 100644 DLS/Resources/6_er_off.png create mode 100644 DLS/Resources/6_er_on.png create mode 100644 DLS/Resources/6_l_off.png create mode 100644 DLS/Resources/6_l_on.png create mode 100644 DLS/Resources/6_r_off.png create mode 100644 DLS/Resources/6_r_on.png create mode 100644 DLS/Resources/background.png create mode 100644 DLS/Resources/blkt_off.png create mode 100644 DLS/Resources/blkt_on.png create mode 100644 DLS/Resources/ext1_off.png create mode 100644 DLS/Resources/ext1_on.png create mode 100644 DLS/Resources/ext2_off.png create mode 100644 DLS/Resources/ext2_on.png create mode 100644 DLS/Resources/hazard_off.png create mode 100644 DLS/Resources/hazard_on.png create mode 100644 DLS/Resources/horn_off.png create mode 100644 DLS/Resources/horn_on.png create mode 100644 DLS/Resources/intlt_off.png create mode 100644 DLS/Resources/intlt_on.png create mode 100644 DLS/Resources/lind_off.png create mode 100644 DLS/Resources/lind_on.png create mode 100644 DLS/Resources/manual_off.png create mode 100644 DLS/Resources/manual_on.png create mode 100644 DLS/Resources/rind_off.png create mode 100644 DLS/Resources/rind_on.png create mode 100644 DLS/Resources/s1_off.png create mode 100644 DLS/Resources/s1_on.png create mode 100644 DLS/Resources/s2_off.png create mode 100644 DLS/Resources/s2_on.png create mode 100644 DLS/Resources/s3_off.png create mode 100644 DLS/Resources/s3_on.png create mode 100644 DLS/Resources/sb_off.png create mode 100644 DLS/Resources/sb_on.png create mode 100644 DLS/Resources/tadiv_off.png create mode 100644 DLS/Resources/tadiv_on.png create mode 100644 DLS/Resources/taleft_off.png create mode 100644 DLS/Resources/taleft_on.png create mode 100644 DLS/Resources/taright_off.png create mode 100644 DLS/Resources/taright_on.png create mode 100644 DLS/Resources/tawarn_off.png create mode 100644 DLS/Resources/tawarn_on.png create mode 100644 DLS/Resources/wail_off.png create mode 100644 DLS/Resources/wail_on.png create mode 100644 DLS/Resources/yelp_off.png create mode 100644 DLS/Resources/yelp_on.png create mode 100644 DLS/SirenApply.cs create mode 100644 DLS/SirenSetting.cs create mode 100644 DLS/TextureHash.cs create mode 100644 DLS/Threads/CleanupManager.cs create mode 100644 DLS/Threads/PlayerController.cs create mode 100644 DLS/Threads/SpecialModesManager.cs create mode 100644 DLS/Threads/UIManager.cs create mode 100644 DLS/TrafficAdvisory.cs create mode 100644 DLS/UI/CustomUI.cs create mode 100644 DLS/UI/Importer.cs create mode 100644 DLS/UI/Resources.cs create mode 100644 DLS/UI/Sprite.cs create mode 100644 DLS/Utils/Controls.cs create mode 100644 DLS/Utils/Extensions.cs create mode 100644 DLS/Utils/Helpers.cs create mode 100644 DLS/Utils/Lights.cs create mode 100644 DLS/Utils/Log.cs create mode 100644 DLS/Utils/Settings.cs create mode 100644 DLS/Utils/Sirens.cs create mode 100644 DLS/Utils/Sound.cs create mode 100644 DLS/Utils/Vehicles.cs create mode 100644 Templates/DLS.ini create mode 100644 Templates/custom.xml create mode 100644 Templates/police.xml diff --git a/DLS.sln b/DLS.sln new file mode 100644 index 0000000..2ce61fa --- /dev/null +++ b/DLS.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.30225.117 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DLS", "DLS\DLS.csproj", "{283D9119-0BBE-42A0-8F57-49E580F20584}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {283D9119-0BBE-42A0-8F57-49E580F20584}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {283D9119-0BBE-42A0-8F57-49E580F20584}.Debug|Any CPU.Build.0 = Debug|Any CPU + {283D9119-0BBE-42A0-8F57-49E580F20584}.Release|Any CPU.ActiveCfg = Release|Any CPU + {283D9119-0BBE-42A0-8F57-49E580F20584}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {AEFAC0CC-75AF-4067-B01B-AE3B4504E63E} + EndGlobalSection +EndGlobal diff --git a/DLS/ActiveVehicle.cs b/DLS/ActiveVehicle.cs new file mode 100644 index 0000000..45f9b5b --- /dev/null +++ b/DLS/ActiveVehicle.cs @@ -0,0 +1,140 @@ +using DLS.Utils; +using Rage; + +namespace DLS +{ + public class ActiveVehicle + { + public ActiveVehicle(Vehicle vehicle, bool playerVehicle = false, LightStage lightStage = LightStage.Off, SirenStage sirenStage = SirenStage.Off) + { + Vehicle = vehicle; + VehicleHash = 0; + LightStage = lightStage; + SirenStage = sirenStage; + CurrentHash = 0; + TAStage = TAStage.Off; + TempUsed = false; + TempLightStage = LightStage.Off; + TempWailLightStage = LightStage.Off; + AuxOn = false; + AuxID = 999; + HornID = 999; + SoundId = 999; + PlayerVehicle = false; + SBOn = false; + IntLightOn = false; + IndStatus = IndStatus.Off; + TAType = "off"; + TAgroup = null; + TApatternCurrentIndex = 999; + PlayerVehicle = playerVehicle; + DefaultEL = vehicle.EmergencyLighting; + IsSirenSilent = vehicle.IsSirenSilent; + IsScanOn = false; + if (vehicle && vehicle.GetDLS() != null) + { + bool temp = vehicle.IsSirenOn; + vehicle.IsSirenOn = false; + InitialLengths = new float[20]; + GameFiber.Yield(); + for (int i = 0; i < InitialLengths.Length; i++) + { + string bone = "siren" + (i + 1); + if (vehicle.HasBone(bone)) + { + InitialLengths[i] = vehicle.GetBoneOrientation(bone).LengthSquared(); + } + else + { + InitialLengths[i] = 1f; + } + } + vehicle.IsSirenOn = temp; + DLSModel vehDLS; + if (vehicle) + vehDLS = vehicle.GetDLS(); + else + vehDLS = null; + TAType = vehDLS.TrafficAdvisory.Type; + if (TAType != "off") + { + TAgroup = Entrypoint.tagroups[vehDLS.TrafficAdvisory.TAgroup]; + TApatternCurrentIndex = Entrypoint.tagroups[vehDLS.TrafficAdvisory.TAgroup].GetIndexFromTAPatternName(vehDLS.TrafficAdvisory.DefaultTApattern); + } + VehicleHash = Game.GetHashKey(vehDLS.Name); + vehicle.EmergencyLightingOverride = Vehicles.GetEL(vehicle, this); + } + } + public Vehicle Vehicle { get; set; } + public uint VehicleHash { get; set; } + public LightStage LightStage { get; set; } + public LightStage TempLightStage { get; set; } + public bool TempUsed { get; set; } = true; + public bool Wailing { get; set; } + public string TAType { get; set; } + public LightStage TempWailLightStage { get; set; } + public SirenStage SirenStage { get; set; } + public TAStage TAStage { get; set; } + public bool SBOn { get; set; } + public bool AuxOn { get; set; } + public bool HornOn { get; set; } + public bool PlayerVehicle { get; set; } + public bool IntLightOn { get; set; } + public int AuxID { get; set; } + public int HornID { get; set; } + public int SoundId { get; set; } + public IndStatus IndStatus { get; set; } + public TAgroup TAgroup { get; set; } + public int TApatternCurrentIndex { get; set; } + public uint CurrentHash { get; set; } + public float[] InitialLengths { get; set; } + public EmergencyLighting DefaultEL { get; set; } + public bool IsSirenSilent { get; set; } + public bool IsScanOn { get; set; } + } + + public enum LightStage + { + Off, + One, + Two, + Three, + CustomOne, + CustomTwo, + Empty + } + + public enum SirenStage + { + Off, + One, + Two, + Warning, + Warning2, + Horn + } + + public enum TAStage + { + Off, + Left, + Diverge, + Right, + Warn + } + + public enum IndStatus + { + Left, + Right, + Both, + Off + } + + public enum SirenStatus + { + On, + Off, + None + } +} diff --git a/DLS/DLS.csproj b/DLS/DLS.csproj new file mode 100644 index 0000000..21ed3a3 --- /dev/null +++ b/DLS/DLS.csproj @@ -0,0 +1,330 @@ + + + + + Debug + AnyCPU + {283D9119-0BBE-42A0-8F57-49E580F20584} + Library + Properties + DLS + DLS + v4.7.2 + 512 + true + + + + + true + full + true + C:\Games\Grand Theft Auto V\Plugins\ + DEBUG + prompt + 4 + x64 + false + + + false + + + pdbonly + true + C:\Games\Grand Theft Auto V\Plugins\ + + + prompt + 4 + x64 + true + + + Always + + + + ..\..\..\Dependencies\RagePluginHookSDK.dll + False + + + + + + + + + + + + + + + + + True + True + Resources.resx + + + + + + + + + + + + + + + + + + + + + + + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/DLS/DLS.xml b/DLS/DLS.xml new file mode 100644 index 0000000..9171323 --- /dev/null +++ b/DLS/DLS.xml @@ -0,0 +1,8 @@ + + + + DLS + + + + diff --git a/DLS/DLSModel.cs b/DLS/DLSModel.cs new file mode 100644 index 0000000..268bff2 --- /dev/null +++ b/DLS/DLSModel.cs @@ -0,0 +1,153 @@ +using System.Collections.Generic; +using System.Xml.Serialization; + +namespace DLS +{ + [XmlRoot("Model")] + public class DLSModel + { + public string Name { get; set; } + + [XmlElement("SpecialModes")] + public SpecialModes SpecialModes { get; set; } = new SpecialModes(); + + [XmlElement("SoundSettings")] + public SoundSettings SoundSettings { get; set; } = new SoundSettings(); + + [XmlElement("TrafficAdvisory")] + public TrafficAdvisory TrafficAdvisory { get; set; } = new TrafficAdvisory(); + + [XmlElement("Sirens")] + public Sirens Sirens { get; set; } = new Sirens(); + + public List AvailableLightStages { get; set; } + + public List AvailableSirenStages { get; set; } + } + + public class TrafficAdvisory + { + [XmlElement("Type")] + public string Type = "off"; + + [XmlElement("DivergeOnly")] + public string DivergeOnly = "false"; + + [XmlElement("AutoEnableStages")] + public string AutoEnableStages; + + [XmlElement("DefaultEnabledDirection")] + public string DefaultEnabledDirection = "diverge"; + + [XmlElement("AutoDisableStages")] + public string AutoDisableStages; + + [XmlElement("TAgroup")] + public string TAgroup = "default"; + + [XmlElement("DefaultTApattern")] + public string DefaultTApattern = "default"; + + [XmlElement("L")] + public string l; + + [XmlElement("EL")] + public string el; + + [XmlElement("CL")] + public string cl; + + [XmlElement("C")] + public string c; + + [XmlElement("CR")] + public string cr; + + [XmlElement("ER")] + public string er; + + [XmlElement("R")] + public string r; + } + + public class WailSetup + { + [XmlElement("WailSetupEnabled")] + public string WailSetupEnabled = "false"; + + [XmlElement("WailLightStage")] + public string WailLightStage; + + [XmlElement("WailSirenTone")] + public string WailSirenTone; + } + + public class Sirens + { + [XmlElement("Stage1")] + public SirenSetting Stage1Setting { get; set; } + + [XmlElement("Stage2")] + public SirenSetting Stage2Setting { get; set; } + + [XmlElement("Stage3")] + public SirenSetting Stage3Setting { get; set; } + + [XmlElement("CustomStage1")] + public SirenSetting CustomStage1 { get; set; } + + [XmlElement("CustomStage2")] + public SirenSetting CustomStage2 { get; set; } + } + + public class SoundSettings + { + [XmlElement("Tone1")] + public string Tone1 { get; set; } = ""; + + [XmlElement("Tone2")] + public string Tone2 { get; set; } = ""; + + [XmlElement("Tone3")] + public string Tone3 { get; set; } = ""; + + [XmlElement("Tone4")] + public string Tone4 { get; set; } = ""; + + [XmlElement("Horn")] + public string Horn { get; set; } = ""; + + [XmlElement("AirHornInterruptsSiren")] + public string AirHornInterruptsSiren { get; set; } = "false"; + + [XmlElement("SirenKillOverride")] + public string SirenKillOverride { get; set; } = "false"; + } + + public class SpecialModes + { + [XmlElement("SirenUI")] + public string SirenUI { get; set; } + + [XmlElement("PresetSirenOnLeaveVehicle")] + public string PresetSirenOnLeaveVehicle { get; set; } + + [XmlElement("WailSetup")] + public WailSetup WailSetup { get; set; } = new WailSetup(); + + [XmlElement("SteadyBurn")] + public SteadyBurn SteadyBurn { get; set; } = new SteadyBurn(); + } + + public class SteadyBurn + { + [XmlElement("SteadyBurnEnabled")] + public string SteadyBurnEnabled { get; set; } = "false"; + + [XmlElement("Pattern")] + public string Pattern { get; set; } + + [XmlElement("Sirens")] + public string Sirens { get; set; } + } +} \ No newline at end of file diff --git a/DLS/Entrypoint.cs b/DLS/Entrypoint.cs new file mode 100644 index 0000000..9e8ceeb --- /dev/null +++ b/DLS/Entrypoint.cs @@ -0,0 +1,167 @@ +using DLS.Threads; +using DLS.Utils; +using Rage; +using Rage.Attributes; +using Rage.Native; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; + +[assembly: Plugin("Dynamic Lighting System", Description = "Better ELS but for default lighting", Author = "TheMaybeast", PrefersSingleInstance = true, ShouldTickInPauseMenu = true, SupportUrl = "https://discord.gg/HUcXxkq")] +namespace DLS +{ + internal class Entrypoint + { + //List of Configured DLSModels by .xml files + public static List dlsModels = new List(); + //Vehicles currently being managed by DLS + public static List activeVehicles = new List(); + //List of All TAgroups + public static Dictionary tagroups = new Dictionary(); + //Pool of Available ELs + public static List AvailablePool = new List(); + //Pool of Used ELs + public static Dictionary UsedPool = new Dictionary(); + //List of used Sound IDs + public static List UsedSoundIDs = new List(); + + //If DLS is on Key Lock method + public static bool keysLocked = false; + + public static bool SCforNDLS = true; + public static bool AILightsC = true; + public static bool IndEnabled = true; + public static bool BLightsEnabled = true; + public static bool UIEnabled = true; + public static bool SirenKill = false; + + public static void Main() + { + //Initiates Log File + Log Log = new Log(); + + //Checks if .ini file is created. + Settings.IniCheck(); + + //Version check and logging. + FileVersionInfo rphVer = FileVersionInfo.GetVersionInfo("ragepluginhook.exe"); + Game.LogTrivial("Detected RPH " + rphVer.FileVersion); + if (rphVer.FileMinorPart < 78) + { + Game.LogTrivial("RPH 78+ is required to use this mod"); + "ERROR: RPH 78+ is required but not found".ToLog(); + Game.DisplayNotification($"~y~Unable to load DLS~w~\nRagePluginHook version ~b~78~w~ or later is required, you are on version ~b~{rphVer.FileMinorPart}"); + return; + } + AssemblyName pluginInfo = Assembly.GetExecutingAssembly().GetName(); + Game.LogTrivial($"LOADED DLS v{pluginInfo.Version}"); + + //Load DLS Models + dlsModels = Vehicles.GetAllModels(); + "Loaded: DLS Vehicle Configurations".ToLog(); + + //Load TAgroups + tagroups = Vehicles.GetAllTAgroups(); + "Loaded: TAgroups".ToLog(); + + //Loads Keys + Controls.RefreshKeys(); + "Loaded: DLS Keys".ToLog(); + + //Loads MPDATA audio + NativeFunction.Natives.SET_AUDIO_FLAG("LoadMPData", true); + + //Creates player controller + "Loading: DLS - Player Controller".ToLog(); + GameFiber.StartNew(delegate { PlayerController.Process(); }, "DLS - Player Controller"); + "Loaded: DLS - Player Controller".ToLog(); + + //Creates special modes managers + "Loading: DLS - Special Modes Managers".ToLog(); + GameFiber.StartNew(delegate { SpecialModesManager.ProcessAI(); }, "DLS - Special Modes AI Manager"); + GameFiber.StartNew(delegate { SpecialModesManager.ProcessPlayer(); }, "DLS - Special Modes Player Manager"); + "Loaded: DLS - Special Modes Managers".ToLog(); + + //Creates cleanup manager + "Loading: DLS - Cleanup Manager".ToLog(); + GameFiber.StartNew(delegate { Threads.CleanupManager.Process(); }, "DLS - Cleanup Manager"); + "Loaded: DLS - Cleanup Manager".ToLog(); + + //If DLS controls lights/sirens on non-DLS vehicles + SCforNDLS = Settings.ReadKey("Settings", "SirenControlNonDLS").ToBoolean(); + + //If DLS controls lights/sirens on AI vehicles + AILightsC = Settings.ReadKey("Settings", "AILightsControl").ToBoolean(); + + //If DLS controls the indicators + IndEnabled = Settings.ReadKey("Settings", "IndEnabled").ToBoolean(); + + //If DLS enables brake lights + BLightsEnabled = Settings.ReadKey("Settings", "BrakeLightsEnabled").ToBoolean(); + + //If DLS UI is enabled + UIEnabled = Settings.ReadKey("Settings", "UIEnabled").ToBoolean(); + if (UIEnabled) + UIManager.Process(); + + //If Siren Kill is enabled + SirenKill = Settings.ReadKey("Settings", "SirenKill").ToBoolean(); + } + + private static void OnUnload(bool isTerminating) + { + if (UsedSoundIDs.Count > 0) + { + "Unloading used SoundIDs".ToLog(); + foreach (int id in UsedSoundIDs) + { + NativeFunction.Natives.STOP_SOUND(id); + NativeFunction.Natives.RELEASE_SOUND_ID(id); + ("Unloaded SoundID " + id).ToLog(); + } + "Unloaded all used SoundIDs".ToLog(); + } + if (activeVehicles.Count > 0) + { + "Refreshing vehicle's default EL".ToLog(); + foreach (ActiveVehicle aVeh in activeVehicles) + { + if (aVeh.Vehicle) + { + aVeh.Vehicle.EmergencyLightingOverride = aVeh.DefaultEL; + aVeh.Vehicle.IsSirenSilent = aVeh.IsSirenSilent; + NativeFunction.Natives.SET_VEHICLE_RADIO_ENABLED(aVeh.Vehicle, true); + ("Refreshed " + aVeh.Vehicle.Handle).ToLog(); + } + else + ("Vehicle does not exist anymore!").ToLog(); + } + "Refreshed vehicle's default EL".ToLog(); + } + } + + [ConsoleCommand] + private static void Command_RefreshKeys() + { + Controls.RefreshKeys(); + Game.LogTrivial("Reloaded Keys!"); + } + + [ConsoleCommand] + private static void Command_GetStaging() + { + Vehicle veh = Game.LocalPlayer.Character.CurrentVehicle; + + if (veh && veh.GetActiveVehicle() != null) + { + ActiveVehicle aVeh = veh.GetActiveVehicle(); + Game.LogTrivial("Siren: " + aVeh.SirenStage.ToString()); + Game.LogTrivial("Light: " + aVeh.LightStage.ToString()); + Game.LogTrivial("TAStage: " + aVeh.TAStage.ToString()); + Game.LogTrivial("SBOn: " + aVeh.SBOn.ToString()); + Game.LogTrivial("TAstage: " + aVeh.TAgroup.TaPatterns[aVeh.TApatternCurrentIndex].Name); + Game.LogTrivial("ELName: " + veh.EmergencyLightingOverride.Name); + } + } + } +} \ No newline at end of file diff --git a/DLS/Properties/AssemblyInfo.cs b/DLS/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..bbd105b --- /dev/null +++ b/DLS/Properties/AssemblyInfo.cs @@ -0,0 +1,18 @@ +using System.Reflection; +using System.Runtime.InteropServices; + +[assembly: AssemblyTitle("DLS - Dynamic Lighting System")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("DLS")] +[assembly: AssemblyCopyright("Copyright © 2020")] +[assembly: AssemblyTrademark("TheMaybeast")] +[assembly: AssemblyCulture("")] + +[assembly: ComVisible(false)] + +[assembly: Guid("283d9119-0bbe-42a0-8f57-49e580f20584")] + +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/DLS/Properties/Resources.Designer.cs b/DLS/Properties/Resources.Designer.cs new file mode 100644 index 0000000..7ecedb1 --- /dev/null +++ b/DLS/Properties/Resources.Designer.cs @@ -0,0 +1,813 @@ +//------------------------------------------------------------------------------ +// +// O código foi gerado por uma ferramenta. +// Versão de Tempo de Execução:4.0.30319.42000 +// +// As alterações ao arquivo poderão causar comportamento incorreto e serão perdidas se +// o código for gerado novamente. +// +//------------------------------------------------------------------------------ + +namespace DLS.Properties { + using System; + + + /// + /// Uma classe de recurso de tipo de alta segurança, para pesquisar cadeias de caracteres localizadas etc. + /// + // Essa classe foi gerada automaticamente pela classe StronglyTypedResourceBuilder + // através de uma ferramenta como ResGen ou Visual Studio. + // Para adicionar ou remover um associado, edite o arquivo .ResX e execute ResGen novamente + // com a opção /str, ou recrie o projeto do VS. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Retorna a instância de ResourceManager armazenada em cache usada por essa classe. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("DLS.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Substitui a propriedade CurrentUICulture do thread atual para todas as + /// pesquisas de recursos que usam essa classe de recurso de tipo de alta segurança. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _3_c_off { + get { + object obj = ResourceManager.GetObject("_3_c_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _3_c_on { + get { + object obj = ResourceManager.GetObject("_3_c_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _3_l_off { + get { + object obj = ResourceManager.GetObject("_3_l_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _3_l_on { + get { + object obj = ResourceManager.GetObject("_3_l_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _3_r_off { + get { + object obj = ResourceManager.GetObject("_3_r_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _3_r_on { + get { + object obj = ResourceManager.GetObject("_3_r_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _4_cl_off { + get { + object obj = ResourceManager.GetObject("_4_cl_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _4_cl_on { + get { + object obj = ResourceManager.GetObject("_4_cl_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _4_cr_off { + get { + object obj = ResourceManager.GetObject("_4_cr_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _4_cr_on { + get { + object obj = ResourceManager.GetObject("_4_cr_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _4_l_off { + get { + object obj = ResourceManager.GetObject("_4_l_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _4_l_on { + get { + object obj = ResourceManager.GetObject("_4_l_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _4_r_off { + get { + object obj = ResourceManager.GetObject("_4_r_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _4_r_on { + get { + object obj = ResourceManager.GetObject("_4_r_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_c_off { + get { + object obj = ResourceManager.GetObject("_5_c_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_c_on { + get { + object obj = ResourceManager.GetObject("_5_c_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_cl_off { + get { + object obj = ResourceManager.GetObject("_5_cl_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_cl_on { + get { + object obj = ResourceManager.GetObject("_5_cl_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_cr_off { + get { + object obj = ResourceManager.GetObject("_5_cr_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_cr_on { + get { + object obj = ResourceManager.GetObject("_5_cr_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_l_off { + get { + object obj = ResourceManager.GetObject("_5_l_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_l_on { + get { + object obj = ResourceManager.GetObject("_5_l_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_r_off { + get { + object obj = ResourceManager.GetObject("_5_r_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _5_r_on { + get { + object obj = ResourceManager.GetObject("_5_r_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_cl_off { + get { + object obj = ResourceManager.GetObject("_6_cl_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_cl_on { + get { + object obj = ResourceManager.GetObject("_6_cl_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_cr_off { + get { + object obj = ResourceManager.GetObject("_6_cr_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_cr_on { + get { + object obj = ResourceManager.GetObject("_6_cr_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_el_off { + get { + object obj = ResourceManager.GetObject("_6_el_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_el_on { + get { + object obj = ResourceManager.GetObject("_6_el_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_er_off { + get { + object obj = ResourceManager.GetObject("_6_er_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_er_on { + get { + object obj = ResourceManager.GetObject("_6_er_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_l_off { + get { + object obj = ResourceManager.GetObject("_6_l_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_l_on { + get { + object obj = ResourceManager.GetObject("_6_l_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_r_off { + get { + object obj = ResourceManager.GetObject("_6_r_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _6_r_on { + get { + object obj = ResourceManager.GetObject("_6_r_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap background { + get { + object obj = ResourceManager.GetObject("background", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap blkt_off { + get { + object obj = ResourceManager.GetObject("blkt_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap blkt_on { + get { + object obj = ResourceManager.GetObject("blkt_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap ext1_off { + get { + object obj = ResourceManager.GetObject("ext1_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap ext1_on { + get { + object obj = ResourceManager.GetObject("ext1_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap ext2_off { + get { + object obj = ResourceManager.GetObject("ext2_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap ext2_on { + get { + object obj = ResourceManager.GetObject("ext2_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap hazard_off { + get { + object obj = ResourceManager.GetObject("hazard_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap hazard_on { + get { + object obj = ResourceManager.GetObject("hazard_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap horn_off { + get { + object obj = ResourceManager.GetObject("horn_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap horn_on { + get { + object obj = ResourceManager.GetObject("horn_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap intlt_off { + get { + object obj = ResourceManager.GetObject("intlt_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap intlt_on { + get { + object obj = ResourceManager.GetObject("intlt_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap lind_off { + get { + object obj = ResourceManager.GetObject("lind_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap lind_on { + get { + object obj = ResourceManager.GetObject("lind_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap manual_off { + get { + object obj = ResourceManager.GetObject("manual_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap manual_on { + get { + object obj = ResourceManager.GetObject("manual_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap rind_off { + get { + object obj = ResourceManager.GetObject("rind_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap rind_on { + get { + object obj = ResourceManager.GetObject("rind_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap s1_off { + get { + object obj = ResourceManager.GetObject("s1_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap s1_on { + get { + object obj = ResourceManager.GetObject("s1_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap s2_off { + get { + object obj = ResourceManager.GetObject("s2_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap s2_on { + get { + object obj = ResourceManager.GetObject("s2_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap s3_off { + get { + object obj = ResourceManager.GetObject("s3_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap s3_on { + get { + object obj = ResourceManager.GetObject("s3_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap sb_off { + get { + object obj = ResourceManager.GetObject("sb_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap sb_on { + get { + object obj = ResourceManager.GetObject("sb_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap tadiv_off { + get { + object obj = ResourceManager.GetObject("tadiv_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap tadiv_on { + get { + object obj = ResourceManager.GetObject("tadiv_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap taleft_off { + get { + object obj = ResourceManager.GetObject("taleft_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap taleft_on { + get { + object obj = ResourceManager.GetObject("taleft_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap taright_off { + get { + object obj = ResourceManager.GetObject("taright_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap taright_on { + get { + object obj = ResourceManager.GetObject("taright_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap tawarn_off { + get { + object obj = ResourceManager.GetObject("tawarn_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap tawarn_on { + get { + object obj = ResourceManager.GetObject("tawarn_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap wail_off { + get { + object obj = ResourceManager.GetObject("wail_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap wail_on { + get { + object obj = ResourceManager.GetObject("wail_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap yelp_off { + get { + object obj = ResourceManager.GetObject("yelp_off", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Consulta um recurso localizado do tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap yelp_on { + get { + object obj = ResourceManager.GetObject("yelp_on", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/DLS/Properties/Resources.resx b/DLS/Properties/Resources.resx new file mode 100644 index 0000000..1079834 --- /dev/null +++ b/DLS/Properties/Resources.resx @@ -0,0 +1,346 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + ..\Resources\background.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\blkt_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\blkt_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\ext1_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\ext1_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\ext2_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\ext2_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\hazard_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\hazard_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\horn_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\horn_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\intlt_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\intlt_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\lind_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\lind_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\manual_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\manual_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\rind_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\rind_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\s1_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\s1_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\s2_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\s2_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\s3_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\s3_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\sb_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\sb_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\tadiv_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\tadiv_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\taleft_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\taleft_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\taright_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\taright_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\tawarn_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\tawarn_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\wail_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\wail_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\yelp_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\yelp_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\3_c_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\3_c_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\3_l_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\3_l_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\3_r_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\3_r_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\4_cl_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\4_cl_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\4_cr_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\4_cr_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\4_l_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\4_l_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\4_r_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\4_r_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_cl_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_cl_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_cr_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_cr_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_c_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_c_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_l_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_l_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_r_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\5_r_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_cl_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_cl_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_cr_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_cr_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_el_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_el_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_er_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_er_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_l_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_l_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_r_off.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\6_r_on.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/DLS/Resources/3_c_off.png b/DLS/Resources/3_c_off.png new file mode 100644 index 0000000000000000000000000000000000000000..0eebc2dace3e6a5ab135608cb0a8e0e5a8f88759 GIT binary patch literal 1686 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vN2;uumf=k4{4f(-#2 zE{z^bRr%y2-@__K=4 zox4>meB0B3{y6ZT#R^EV2mtdwgMh;VW(EcahDJUhhmm**pz2XD8Umz*fc&agtfj^* UQk7dKOabZhboFyt=akR{01!Ve4gdfE literal 0 HcmV?d00001 diff --git a/DLS/Resources/3_c_on.png b/DLS/Resources/3_c_on.png new file mode 100644 index 0000000000000000000000000000000000000000..64697ed0e9a0954f060b5bf3460851c450d98345 GIT binary patch literal 1834 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mB!1mG8#WAE}&f8mxd4~f; zTrOsc3N)Y6F*st8eL8B_wg(dq7@R)PHg)y>)>Hm}pD#F2X|}6~38)(c?lME@QF1f{ zhJ6UUkQ+K){IitbUz~yA-~Qu|zaLqzl00eQiG$gbEKe5g7L8zLx2|MlV7Sm~dv3j_ zp65ANzI&7QOy2X&Lw^H1pXvohh6Vh|-Ji36#~!?6c7{oo#fpL9OHxMsx#Q1`?~CTm zTXyI6GOhZZ?asATe}Dl}VAIG4q*yshfTV`Q0$_>Yz{n&EfWbEk2!?<|q-PyN`2vOby-qT~bjiTr M>FVdQ&MBb@0CZD-TmS$7 literal 0 HcmV?d00001 diff --git a/DLS/Resources/3_l_off.png b/DLS/Resources/3_l_off.png new file mode 100644 index 0000000000000000000000000000000000000000..5ab8a6f93738a213c0606f28f9a46396dda710ed GIT binary patch literal 1686 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vN2;uumf=k4{4f(-#2 zE{z^bRr%y1wxZC=ad zlI``fVmo_zfgbrU49xWm0uBq985kTG8u@@6Miwg|$s$0!1W@@X7!3guLZD{FD)Fxg VEK*xP8GZ(7^K|udS?83{1OS;gFUJ4? literal 0 HcmV?d00001 diff --git a/DLS/Resources/3_l_on.png b/DLS/Resources/3_l_on.png new file mode 100644 index 0000000000000000000000000000000000000000..9b74952f4b89500428fa3dfa5ea7ff03c94cef2c GIT binary patch literal 1831 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mB!1m75#WAE}&f8mxeTNc6 zS}$4)vvhdM3I(6N6>)kEZ?EH{SzTd%xBf+ER7jpPT)U?-G+qIy83aCjgwUhpXb24d z5U`UQI(~ff@^mR9gTl`H*N^*8(mT2Ggy%99=Sd%{bT_cwxO%XXks)F0k)Nt3El+Md z;rUEuy~=sjOWbc5%Tz7^WiD^E*uUjFSKGEkffpbCbCxhL+?aDq|M}g=6Yq1Gzx;jY z)-tX7o$O^_-tGW~$A>y5Ss=wF04!D*0va6H85kOvSge2?5e1-O3=0?<`G6c&4xlj% z8V(DX85kTGv1sA5V`5-fvrMIU(!%$}+C`HV=FZ~EVJuSvIcW2d53Bdeci&0Lo886~ z-7pvIq#ny^mBz!vN2;uumf=k0Yz(FO(% z7e^DmzncTxm4Ddm^iPvIFt3ggs1yheR6*!bax?^ne+ayWrure~Q=I|{Nd|@=lV|P} zI`=Yf?@{gLy^mB!1mG8#WAE}&f8mxc}{^6 zEf+JJ87@B1GR(MkENYjT30r5iqfLr)v3S7cl8QNtCwwlxD$W7a3<7&>AoM6X8Un*U z1RAEZ4;??&zdXC0n}NY*_vM$*8~RmltIVEM{7fZy((Q)<8``S0{aF|obPgz=EBCaU zyvF<7PW7E?J8hKqCh$LHv0`A@z;avg`R-RRL69>%UHx3vIVCg!0BMhX=>Px# literal 0 HcmV?d00001 diff --git a/DLS/Resources/4_cl_off.png b/DLS/Resources/4_cl_off.png new file mode 100644 index 0000000000000000000000000000000000000000..5027252d359860f834c545b49ffa97f71e0d7b1f GIT binary patch literal 1685 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!u}_;uumf=k0Yv!2=FF z%#P{>XXLwIstD|>Ia?v#6cWn_R0;$Ksvz_zIT`}PKLlPwQ~eP0sm=!rNd|^@vu5f) zYp2 VWRaS+OlCJoo2RRv%Q~loCII8dEo%S( literal 0 HcmV?d00001 diff --git a/DLS/Resources/4_cl_on.png b/DLS/Resources/4_cl_on.png new file mode 100644 index 0000000000000000000000000000000000000000..e14503802f68c0e8cde831b730f9d833bf55c1cd GIT binary patch literal 1835 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mB!1l@0#WAE}&f8mxd50ZD zTrXbNQed1Knb=WyZQ9n7+=GgZiPIW+SBGqFP1|SkT*27>=i=2WK;0lE#_@h+LTOz|O$XzywmpAfj*q7)lEm8u@@6R*+!~8V(DX85kTG znPh<+E&*Wq!w}GbsimP=8K_D;dXnu)qw_n(EDv5X%Vphmpa5+9$F7Iz)t@(>;Qh8O zQ*#4rn=;Ur1^uQc7a#qw@&xa;ZRxrjSb^pe0ftg665*XuB_xM{@1*!1C53p^x4X(g OdOcnJT-G@yGywo+1cW01 literal 0 HcmV?d00001 diff --git a/DLS/Resources/4_cr_off.png b/DLS/Resources/4_cr_off.png new file mode 100644 index 0000000000000000000000000000000000000000..2d29a58f942364540d5cb10d3a4823560245861a GIT binary patch literal 1686 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vN2;uumf=k0Yz!G-`H z=Yvgieq9f;R(LpH!sv1==gF6%K&2qCh8;qWlA|Fo>_cFK+>rF*0jBAb85tV%&z_lV zP*DC_e$m}`j0_A7|2a#5-r-QV0OTk%H~=$p0|S#RP>6|xXo(>i9;1#P$PnOL^@??? VD2o&quSo{T9iFa!F6*2UngH~2FLVF^ literal 0 HcmV?d00001 diff --git a/DLS/Resources/4_cr_on.png b/DLS/Resources/4_cr_on.png new file mode 100644 index 0000000000000000000000000000000000000000..0e94081cf967b65b671f780cc1dce8e57af2d1f4 GIT binary patch literal 1839 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mB!1m44#WAE}&f8lH^A06Q zv_9O-%9ylr_K}d{+?dnrczYcmNx4k)o_^op%#nW|RBPozug<9n%~t^G2Z0S$5PFmx z4T0ew0;}1FjvsCJ?$l#o_;BBE`F!y@70F3&x@0Q+j8u2Z^08h!pfAnN$iQF~@u+70 z6XTQHPBgyvT<59hy+r&5Ge3(J1H*;G7arBzpQkHMg08t<}w3AB+h>UkaA#Tk_B?O1b`(BLqG#aPXiOkFa{BY3qaczFf{T3 zIjkHdKvKg2Q_F#4?m!u<8I$i!_IW%bc_Ooa?&X*SZW}?Mfe!rMJn^@yx4Y`qUIY3KB!Eg+Lgs)Wf)r0esYM7Jd6ygJ~{sq>63=E#G KelF{r5}E+U>V2O8 literal 0 HcmV?d00001 diff --git a/DLS/Resources/4_l_off.png b/DLS/Resources/4_l_off.png new file mode 100644 index 0000000000000000000000000000000000000000..0e4234954169469a230c351324779db0dddbfb18 GIT binary patch literal 1687 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vA};uumf=k4`_ybS>y zE{G<=27qvU7^4F3?g#ylkb81bMeg@NJH*)x+3 zlFEP2Z#;h|j2q~Y|H8m*&miEi0O%_RhDJUhhmpk!NU{hJF9B3O3PwYKgby^mB!1mVD#WAE}&f8lH^A06Q zv_9O-%9wP}H)+*QvvsN0+m0y|@-8~j`gDJbuC?a*#ajNqR+{GmHG{x|r;HHBC^;Ge z!#)J|*bE&n{_xJfr^mq1d+z!CKzYw^o@J`S(^ZNm{r(uSfh}TcZ!r@?z$?k;?JDy< zx2X!td**qrJMW=?gLzGd13SZlt93_yCfbm`rp3Q&6s;`x0S3sAdL~&Q#l=wqBsCN+084}g4M0;E8kk6sIB-l5sC%nQrOM3Z zn#(73e!j6qB!@A~4P^H#$-~<>=0gTe~DWM4f^4foH literal 0 HcmV?d00001 diff --git a/DLS/Resources/4_r_off.png b/DLS/Resources/4_r_off.png new file mode 100644 index 0000000000000000000000000000000000000000..6e6bae3c1be1329252d7bfcfa13969b80e12b378 GIT binary patch literal 1687 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vA};uumf=k0Yz!G-`H z=Yvgieq9f;R(N>6fa`KB=gF6%K&2qCh8;qWlA|Fo>_cFK+>rF*0jBAb85tP%&7P^A zxbNMya{Kapd5}khI7)ydhr$J*q(XxOFef)KFv$Xin247EnKKGTLx6-3;9K>I)#L?> T6z3dfBak*vS3j3^P6y^mB!1l${#WAE}&f8lH^A06Q zv_9O->UcEBymRHVTRW!3N=r2#F%?}K6Y)>_$H{56Ezbi*C(Nl?VXg|)4+0-PLFiF( zGz5l!2*k+^9Y6kAYJQ!Sf#F55-T#_D$|q-}XcX-;Jvk@EQjUAg!rSLg0)4XU?&Cib zo*19pcjD(ZmF+6mtCxu1a8_^RV_>+DpHoO zzRzAZ=hiZ<`kl)!?`~#fU^wt!7+9z<1T=t@H88PQ0XZTH7l1Mg7(j+GuyT|DNezbu z%nS?;j7+jX4wnF?mJOekfifl0lXEb^_t+nWEj`%ZrL z>}O2T6=2I=Y**R2O+v2gPJV9nG^S{v?olur0t7;!;r`?&(pFLm@ve!v|3PX!UHx3v IIVCg!0MGP^{Qv*} literal 0 HcmV?d00001 diff --git a/DLS/Resources/5_c_off.png b/DLS/Resources/5_c_off.png new file mode 100644 index 0000000000000000000000000000000000000000..0eebc2dace3e6a5ab135608cb0a8e0e5a8f88759 GIT binary patch literal 1686 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vN2;uumf=k4{4f(-#2 zE{z^bRr%y2-@__K=4 zox4>meB0B3{y6ZT#R^EV2mtdwgMh;VW(EcahDJUhhmm**pz2XD8Umz*fc&agtfj^* UQk7dKOabZhboFyt=akR{01!Ve4gdfE literal 0 HcmV?d00001 diff --git a/DLS/Resources/5_c_on.png b/DLS/Resources/5_c_on.png new file mode 100644 index 0000000000000000000000000000000000000000..64697ed0e9a0954f060b5bf3460851c450d98345 GIT binary patch literal 1834 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mB!1mG8#WAE}&f8mxd4~f; zTrOsc3N)Y6F*st8eL8B_wg(dq7@R)PHg)y>)>Hm}pD#F2X|}6~38)(c?lME@QF1f{ zhJ6UUkQ+K){IitbUz~yA-~Qu|zaLqzl00eQiG$gbEKe5g7L8zLx2|MlV7Sm~dv3j_ zp65ANzI&7QOy2X&Lw^H1pXvohh6Vh|-Ji36#~!?6c7{oo#fpL9OHxMsx#Q1`?~CTm zTXyI6GOhZZ?asATe}Dl}VAIG4q*yshfTV`Q0$_>Yz{n&EfWbEk2!?<|q-PyN`2vOby-qT~bjiTr M>FVdQ&MBb@0CZD-TmS$7 literal 0 HcmV?d00001 diff --git a/DLS/Resources/5_cl_off.png b/DLS/Resources/5_cl_off.png new file mode 100644 index 0000000000000000000000000000000000000000..5ab8a6f93738a213c0606f28f9a46396dda710ed GIT binary patch literal 1686 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vN2;uumf=k4{4f(-#2 zE{z^bRr%y1wxZC=ad zlI``fVmo_zfgbrU49xWm0uBq985kTG8u@@6Miwg|$s$0!1W@@X7!3guLZD{FD)Fxg VEK*xP8GZ(7^K|udS?83{1OS;gFUJ4? literal 0 HcmV?d00001 diff --git a/DLS/Resources/5_cl_on.png b/DLS/Resources/5_cl_on.png new file mode 100644 index 0000000000000000000000000000000000000000..9b74952f4b89500428fa3dfa5ea7ff03c94cef2c GIT binary patch literal 1831 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mB!1m75#WAE}&f8mxeTNc6 zS}$4)vvhdM3I(6N6>)kEZ?EH{SzTd%xBf+ER7jpPT)U?-G+qIy83aCjgwUhpXb24d z5U`UQI(~ff@^mR9gTl`H*N^*8(mT2Ggy%99=Sd%{bT_cwxO%XXks)F0k)Nt3El+Md z;rUEuy~=sjOWbc5%Tz7^WiD^E*uUjFSKGEkffpbCbCxhL+?aDq|M}g=6Yq1Gzx;jY z)-tX7o$O^_-tGW~$A>y5Ss=wF04!D*0va6H85kOvSge2?5e1-O3=0?<`G6c&4xlj% z8V(DX85kTGv1sA5V`5-fvrMIU(!%$}+C`HV=FZ~EVJuSvIcW2d53Bdeci&0Lo886~ z-7pvIq#ny^mBz!vN2;uumf=k0Yz(FO(% z7e^DmzncTxm4Ddm^iPvIFt3ggs1yheR6*!bax?^ne+ayWrure~Q=I|{Nd|@=lV|P} zI`=Yf?@{gLy^mB!1mG8#WAE}&f8mxc}{^6 zEf+JJ87@B1GR(MkENYjT30r5iqfLr)v3S7cl8QNtCwwlxD$W7a3<7&>AoM6X8Un*U z1RAEZ4;??&zdXC0n}NY*_vM$*8~RmltIVEM{7fZy((Q)<8``S0{aF|obPgz=EBCaU zyvF<7PW7E?J8hKqCh$LHv0`A@z;avg`R-RRL69>%UHx3vIVCg!0BMhX=>Px# literal 0 HcmV?d00001 diff --git a/DLS/Resources/5_l_off.png b/DLS/Resources/5_l_off.png new file mode 100644 index 0000000000000000000000000000000000000000..7e2bf8892209e70e4d4700f52ad8c6d65eeae419 GIT binary patch literal 1686 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vN2;uumf=k0Yz(FO(% z7e^DmzncTxm4Ddm^iNaTAYR7^R0;$Ksvz_zIT`}PKLlPwQ~eP0sZN1}BtygYv}axx zQRTnW8}D2Aass_@Ul^F{83Y^_Ff%YXFf{T3IgBh;K$1m(cnP5LQ7{?;B!qy?idE93 Wb6BK=#UdAhw0XMvxvXy^mB!1m44#WAE}&f8mxeTNc6 zS}$4)vvhdg_3$yxPS)LQX2RB)trcaN_(}f(f6E!=Ig7Ql^5U+Fa{%>&z#dx&JxY#- zz_1U2hVAS_$B*Z~Jlw^=@Wo>8zqnssMk+T&EpJUq@iLO;lkm8LfuUsA(VuoF z%O~YdT)ftEou}S*5B&}75Av8~85-i8yFb@fuS>|1R%_(jW7WvV;IKaS_tP4S`JaOy zW<8#fd^_Z+{&$A*-z8SS5cyFL)Wg8QB>*g27y=p`fT7gD!~&8LQMka!z_5S;XaEBP zD@O^C)Nok9%)sElh((K;9TNk?+-WM=lQLzBb&9sE%#Gs8VXWu?8o1!PZrl2|cXKDM zUYmP4B!T;YGsyhC&s3(19p0@J9(`-x&I4jV(?`Johd@R306TyP>kkC0{A4}3LLq+f Rl+T?Y^`5SNF6*2UngCuDeoFuV literal 0 HcmV?d00001 diff --git a/DLS/Resources/5_r_off.png b/DLS/Resources/5_r_off.png new file mode 100644 index 0000000000000000000000000000000000000000..281992938f9d13802082180800fdda27c64377c4 GIT binary patch literal 1688 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vZ6;uumf=k0Yv(FO+| zmxB#+eq0x_R(L4YWt->b_-WfOR-jrCIL-{AN6FC;81^AxAvYwwcz{t)8JJDqB&W@5 zN!}gpU-#zURdb+EHfT2T0VzfnDy^mB!1l@0#WAE}&f8lH^A06Q zv_9O-%9wP}H|au*^z}{IvyUkh@-8~j`gDJbuH}~Vi?#gstuoIAY6gLXuMm2a91Vft z9|B?gL&uN*F3*0=#K2JU``^F0-zTQbPYE|F^D|Q2Ip2>pTP$JoH)fz$_B5o=k)Kqf zc5~X9T9uuuJMEPBCY(Pl3@jfQ{(e(F$NzZeK@&3{roZ_dB@7G=b-O=4t*PJnWOd@( zk25~sxbo@r-_zCczZrq57c@Gs1643F$pSfCAk_>S3KxJf3mQm}*zi#ZsPWZVPdU$J zj}4zs+IabfiFi&VOCuix!-e;fhqrGmir)0i(9D-LTFh|)&;ws~tMBZSxHomp+~f1A s4~hXb4-{y)3JT9rFcd-{;o_t}45~8};=fJ*aTw%aPgg&ebxsLQ0CFIR%K!iX literal 0 HcmV?d00001 diff --git a/DLS/Resources/6_cl_off.png b/DLS/Resources/6_cl_off.png new file mode 100644 index 0000000000000000000000000000000000000000..5027252d359860f834c545b49ffa97f71e0d7b1f GIT binary patch literal 1685 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!u}_;uumf=k0Yv!2=FF z%#P{>XXLwIstD|>Ia?v#6cWn_R0;$Ksvz_zIT`}PKLlPwQ~eP0sm=!rNd|^@vu5f) zYp2 VWRaS+OlCJoo2RRv%Q~loCII8dEo%S( literal 0 HcmV?d00001 diff --git a/DLS/Resources/6_cl_on.png b/DLS/Resources/6_cl_on.png new file mode 100644 index 0000000000000000000000000000000000000000..e14503802f68c0e8cde831b730f9d833bf55c1cd GIT binary patch literal 1835 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mB!1l@0#WAE}&f8mxd50ZD zTrXbNQed1Knb=WyZQ9n7+=GgZiPIW+SBGqFP1|SkT*27>=i=2WK;0lE#_@h+LTOz|O$XzywmpAfj*q7)lEm8u@@6R*+!~8V(DX85kTG znPh<+E&*Wq!w}GbsimP=8K_D;dXnu)qw_n(EDv5X%Vphmpa5+9$F7Iz)t@(>;Qh8O zQ*#4rn=;Ur1^uQc7a#qw@&xa;ZRxrjSb^pe0ftg665*XuB_xM{@1*!1C53p^x4X(g OdOcnJT-G@yGywo+1cW01 literal 0 HcmV?d00001 diff --git a/DLS/Resources/6_cr_off.png b/DLS/Resources/6_cr_off.png new file mode 100644 index 0000000000000000000000000000000000000000..2d29a58f942364540d5cb10d3a4823560245861a GIT binary patch literal 1686 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vN2;uumf=k0Yz!G-`H z=Yvgieq9f;R(LpH!sv1==gF6%K&2qCh8;qWlA|Fo>_cFK+>rF*0jBAb85tV%&z_lV zP*DC_e$m}`j0_A7|2a#5-r-QV0OTk%H~=$p0|S#RP>6|xXo(>i9;1#P$PnOL^@??? VD2o&quSo{T9iFa!F6*2UngH~2FLVF^ literal 0 HcmV?d00001 diff --git a/DLS/Resources/6_cr_on.png b/DLS/Resources/6_cr_on.png new file mode 100644 index 0000000000000000000000000000000000000000..0e94081cf967b65b671f780cc1dce8e57af2d1f4 GIT binary patch literal 1839 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mB!1m44#WAE}&f8lH^A06Q zv_9O-%9ylr_K}d{+?dnrczYcmNx4k)o_^op%#nW|RBPozug<9n%~t^G2Z0S$5PFmx z4T0ew0;}1FjvsCJ?$l#o_;BBE`F!y@70F3&x@0Q+j8u2Z^08h!pfAnN$iQF~@u+70 z6XTQHPBgyvT<59hy+r&5Ge3(J1H*;G7arBzpQkHMg08t<}w3AB+h>UkaA#Tk_B?O1b`(BLqG#aPXiOkFa{BY3qaczFf{T3 zIjkHdKvKg2Q_F#4?m!u<8I$i!_IW%bc_Ooa?&X*SZW}?Mfe!rMJn^@yx4Y`qUIY3KB!Eg+Lgs)Wf)r0esYM7Jd6ygJ~{sq>63=E#G KelF{r5}E+U>V2O8 literal 0 HcmV?d00001 diff --git a/DLS/Resources/6_el_off.png b/DLS/Resources/6_el_off.png new file mode 100644 index 0000000000000000000000000000000000000000..0e4234954169469a230c351324779db0dddbfb18 GIT binary patch literal 1687 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vA};uumf=k4`_ybS>y zE{G<=27qvU7^4F3?g#ylkb81bMeg@NJH*)x+3 zlFEP2Z#;h|j2q~Y|H8m*&miEi0O%_RhDJUhhmpk!NU{hJF9B3O3PwYKgby^mB!1mVD#WAE}&f8lH^A06Q zv_9O-%9wP}H)+*QvvsN0+m0y|@-8~j`gDJbuC?a*#ajNqR+{GmHG{x|r;HHBC^;Ge z!#)J|*bE&n{_xJfr^mq1d+z!CKzYw^o@J`S(^ZNm{r(uSfh}TcZ!r@?z$?k;?JDy< zx2X!td**qrJMW=?gLzGd13SZlt93_yCfbm`rp3Q&6s;`x0S3sAdL~&Q#l=wqBsCN+084}g4M0;E8kk6sIB-l5sC%nQrOM3Z zn#(73e!j6qB!@A~4P^H#$-~<>=0gTe~DWM4f^4foH literal 0 HcmV?d00001 diff --git a/DLS/Resources/6_er_off.png b/DLS/Resources/6_er_off.png new file mode 100644 index 0000000000000000000000000000000000000000..6e6bae3c1be1329252d7bfcfa13969b80e12b378 GIT binary patch literal 1687 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vA};uumf=k0Yz!G-`H z=Yvgieq9f;R(N>6fa`KB=gF6%K&2qCh8;qWlA|Fo>_cFK+>rF*0jBAb85tP%&7P^A zxbNMya{Kapd5}khI7)ydhr$J*q(XxOFef)KFv$Xin247EnKKGTLx6-3;9K>I)#L?> T6z3dfBak*vS3j3^P6y^mB!1l${#WAE}&f8lH^A06Q zv_9O->UcEBymRHVTRW!3N=r2#F%?}K6Y)>_$H{56Ezbi*C(Nl?VXg|)4+0-PLFiF( zGz5l!2*k+^9Y6kAYJQ!Sf#F55-T#_D$|q-}XcX-;Jvk@EQjUAg!rSLg0)4XU?&Cib zo*19pcjD(ZmF+6mtCxu1a8_^RV_>+DpHoO zzRzAZ=hiZ<`kl)!?`~#fU^wt!7+9z<1T=t@H88PQ0XZTH7l1Mg7(j+GuyT|DNezbu z%nS?;j7+jX4wnF?mJOekfifl0lXEb^_t+nWEj`%ZrL z>}O2T6=2I=Y**R2O+v2gPJV9nG^S{v?olur0t7;!;r`?&(pFLm@ve!v|3PX!UHx3v IIVCg!0MGP^{Qv*} literal 0 HcmV?d00001 diff --git a/DLS/Resources/6_l_off.png b/DLS/Resources/6_l_off.png new file mode 100644 index 0000000000000000000000000000000000000000..52dca092142f587fd82f4ae65951783181d0d52f GIT binary patch literal 1687 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz!vA};uumf=k0Yz!3G8n zS4R`RzncTxl`S40eZS#0!;TLi%^+}%8A6YeqaiTtLm+~GNP01$@$f`OhJX2K>sl0d z-LB{Sa4EA8=#dY$jeJ0gk;Mu~vIqc+00sev1;G65z(BkNP}3+F4FM8D;6U@LU5uu? VSfqq^y^mB!1l${#WAE}&f8mxMTY`J zS|48KYwGZeQB|9@b>p;kyuFT(j08L1Ect8}aPejBhgz;mJ^#PVj6m%`&@i1H!Wbn- zLtxm4z=uym$BPg2_x>znWcXFG_urX+9!6@CT{0WhW=__5UfgKPAZuBn!_biTwy@6Y z)66FkPdao@Dxa+F|H4$wuuJg*P?za83;V6-MbG3O*15n~=e~fM;Y)VL{yF{IqxWgW z82awq;v4#}i2p)wxj!o~NdEf+6)-q3GRXotTmrxXh9RKA0a!9LFtJzxIU))`GZ_{z zH1YvCtQ;jkQo{jL%YlQ+3=AdNzME8MF4vr{b876t`we= zdpQO!I8Eid*kR|1+Sj(FYihq1mr(YS3j3^ HP6y^mBz!vA};uumf=k0Yz-i81k zmxE1neq9f;Uhts(b=x_Oj9tsafl5JOgB*k&B}YSG*oVM@s-fvc?ie><)_#zZHm~J* z$@llazw+&11p4HfFfiLQ2skWYW?*n&XygNO7+I`y^mB!1mSC#WAE}&f8lH^A06Q zv_9O->Ugwi_K}d{+?dnrczYcmNx4k)o*u8Wb@3DFS~=Dgm-)Z4F#)xMz-o2~JxY#- zz_1U24OK(OiyM}hUuR`tc(DEQ%jaj^C&f-$ccSo^iu0t~4+9d;GMVXrcLDn4&sCA< zzg6aYZgX8%>0jhqG*fBsfqCu1z!HMt%-g6r?{B~6YTK450OGH4yi&NBlg|4(uNmIDn;ELK2{h{6R%28IO;jeI~3D@O^C)Noh;ROZ0Q zBn#wlfz1nOz|_*vs}I!KFw^j)?a2$@EyXO)T`=oq-KOIN(rsXV^uyNLZMsEst8bf# z+}OkcGXKCG-IGg?7KA^sO1@pJy#eUqQ9$hwNcc)^69?S9id8E21;rHNcPM{51age0 LtDnm{r-UW|UAu@L literal 0 HcmV?d00001 diff --git a/DLS/Resources/background.png b/DLS/Resources/background.png new file mode 100644 index 0000000000000000000000000000000000000000..b2c5b6f661bdefa9d15d19ae4dbf9fe63a8bd0ea GIT binary patch literal 21767 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 literal 0 HcmV?d00001 diff --git a/DLS/Resources/blkt_off.png b/DLS/Resources/blkt_off.png new file mode 100644 index 0000000000000000000000000000000000000000..5a8fbc3983c115c4dca3663f534720058208a8da GIT binary patch literal 2710 zcmeHG|5uV%7{91V$A+_P>T-&wooYo|&9VZOw=Y`Q6sJ^XDV9qIDTGr(--LH<+O(N& zbL*6dc5>Fil+?slnsv05+7|@1&`=atia>rzkTlrq)}OHUL#OA5d(ZQE?tPx;^Lg&g z2@l(Wb6Da40KidpZjS)Kb{GIm!F+oZ2?z~22!KNjW&0KyPpDTl9$CEK4Xak3DtLI+ z&qe7|x>I*(K)SBD7$3FIj`GV^T9U2>$(sLdRPMqF*K1P7B7!aDVEsyY8I4qN;9=j5 zW>(F!ZN9#2t_Zt2;f(T|g#5KL?eH_<2WYK1V}AJW{(gP0z&o!%sqsIhs9wM1rZ>>W z2?XT(yA3+sY?s;D**UTM%w$=|SnWKd<5?IM@}_yn1kP<#7$0a{8oaq-!7%udc#H_N zhnCCIJYnnW7&niJli8ahZF5cOook$sj2q#mH2`@voJve?&g5?>3eB1af_uo>u4wb( z6{WTSK){BGI(A-f&pCSA3*1ujOokZgwQD?GVnF7r^+moAkJq&5UsLeb;9BL&8}pE# z5^_m^HZ;(DQg!P4&$(KBfD?NHGM?Bj3BXvAar(xmoJOcsbZ0-ymJLw-fsvv z6(DG;kS?7ixi#DSKKD2Is`2*rcJqqzpaDmg-X64|!-jH1WIE4!bp0*K*_Yh)OSv~qBq3nOuOK!i{gy@RYcH|a+?RBba^*Z&n2{Ly=rURiN67&i)Rf0 literal 0 HcmV?d00001 diff --git a/DLS/Resources/blkt_on.png b/DLS/Resources/blkt_on.png new file mode 100644 index 0000000000000000000000000000000000000000..7a5380a89b90a246fa4fc88211a5a002335a387c GIT binary patch literal 6130 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 literal 0 HcmV?d00001 diff --git a/DLS/Resources/ext1_off.png b/DLS/Resources/ext1_off.png new file mode 100644 index 0000000000000000000000000000000000000000..f967c7b49a201280273c442a57980766a16b3b5f GIT binary patch literal 2890 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 literal 0 HcmV?d00001 diff --git a/DLS/Resources/ext2_off.png b/DLS/Resources/ext2_off.png new file mode 100644 index 0000000000000000000000000000000000000000..42f33ea8b703e7fe529a4e9dae2b55d6622f8a3b GIT binary patch literal 3415 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 literal 0 HcmV?d00001 diff --git a/DLS/Resources/hazard_off.png b/DLS/Resources/hazard_off.png new file mode 100644 index 0000000000000000000000000000000000000000..aa82d257544b77f416ca70117a93273af6da41e9 GIT binary patch literal 3589 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 O&KEr{G@iTu&;JHM|2dri literal 0 HcmV?d00001 diff --git a/DLS/Resources/horn_off.png b/DLS/Resources/horn_off.png new file mode 100644 index 0000000000000000000000000000000000000000..a0421f37a012c364f95668d0cef3d2fbb7869218 GIT binary patch literal 4728 zcmeHK`!|&9+kYG)6iTHXhEi!)q9no?$B$ZGCWnY|9EYih zc4($42IH{VIgP^%#%X36-`jrI`zL(YyVkq*^TW)#pY^QkzV6TUxjxtDesbB`Y^V4E zaR`ETT9}($g&?762ogxzE&|@btuA^%&~Ai*XUs3UTC?BcPED57>3UlkA;{#YmF|n~1o`vTZJUs^Tw`NnxE~UV z{T%wu{;-CCAOyw93hMkh_mSdsPysAN!NS^H6oSSd#!4FLK#;Vka7css)*GFdv67q8 zQ~@Yf(o-SCclsk|I?bKiS!!2iy)Bje>a=o`AFblbJeOiDJKwr> zizcID&DM+NMbwv3^5WG8&24lYp1?=5u~5Y^uBo$ z=k4WHV$Qby7Bv*0#g%VaH3(PnKVTJ zLUu@pZ})CM$!mwrUGM46&?rk&bAttGOVQtX80S@ac0O+9Ep@rwK=0KJo10$g)*#=M z-LnUST6YRSW^2Nv&Z#{2& z_3G~BBp6Y9@X%Q_hpq3|S1u+`RV;C73QMgwLkmE02oS=`oT(JQPqlOhcCIgKb-;&v z&CaftZhF$WK^?WWFpMu8j`_Re`4xB)1m!QwPzoZAqI8|=16*!JOh-6nYYq{9O=bnw z>Ce=^S5DMh${UULQ;%^n31f~7YYc)triX+>;+`dqBvZuz{ zuxc14%ZFCsQgEg4!mp8jeN$6YEAmZRT5fsz^ zjAe=$>fh6=sbL6tM$h^aqE4z9zK{QvCKa-X0Rh#$Wk!ZN$nVaThE|Y|qTA{g-BmRD_ zbznZjttreuKK(^mE#Pam@7gwi!fuKMax9m2Z2QdV)%p5S5s{hf>}-l(WlLXE34xrU zG4fFJ2m*`*RNlX39@!^{(2-8onX3E zLpMPk3mfx9HM~upwOHw8S65eeRt1wYTPfvi$?LE3Je{EcA0i;!-^af9pO~14F+mN5 zk3_1Ju1$jCGz*7FQ~$o`=;-Kfv-bXhkXk%0S4dQH$IvFFz<8L>)gfn}m(f0;^bu`* z@)#R{wB8)Go+#|bbvXSTo?%fHQ# z2@DO8C@Lx{AR{(;Q)Y^2_RvTRN=S(F>^F^zh45YpwPuRDIhR^wDYpYH3Mo|y^F73b zC9v$Fp`o-oYi(SjB$f^8IcJV5Ry}!gPC>LcE+Z>|`1_9{%XHSwz=B*j%5@!ss?SeUsDirxS1k)$e41>T4m zRjVv56;Dl1$0jJ~+RJ^-Vl&Dr)4aSiBT}19mzI|JD>t|s%TvakiHe)tsm#pGVIfd#yK=tqOH2sEsmAwP zN#ycmtxh&}r=ouIhaJJ7A%8WM6NyME9mwDzV8UKZ$j7T!uNvuwFYx?0>=}Qe{NR?5 zzICgM+2kXPqJS3ePPQ1&Pfd;-Z@?->H}I;vPD!{5^OC)~(!9d^)CWj0n}cHGw~67* z=u?0hlLWH9W#wiIi#s+JgG9C7rBu$A;By%*9&L|fQd`(m%i;K^PuclG&|xJ3g+YVr z$81M}x7W%%ogKFTV%9pL2a($HZp2oWZ=pnd3OPr&{vN%~zlD)^8wgSABT=aU=@F+x zdY<=P99$#4-Z)gc764+BEJ=LMtOTjPtgOry8GH&%#>9gQlnXn;Z6tx}=*xr@0P%Vo zy{4zBS!*~@?nwB;NJlUIsj~Nr^i46oE+OY$pG5g`mR+K>Dwea{E6Te+_Kim?S+swN#j>&v~mUtGI_^Eb9}3 za9W$9QmHKIa1sf?_zb~P62Y+B?Jr-ZxQDI0TN^=D+7TM?McZs7&H(urnW8s^Gk03_ zvmr>#$^g567gdG^)C;!1eT!!tQ1REW$&t5C_3xKZ3yt^>>TAPI;XX$^z5^`J3MkwF z`CoEy3AOVD!}0-bOWodJ8@2i#!R)VJUk^?`rv({Mr6~tHKn`c4dF!@@vUNZ*x4zj+ z!C%Ut!X4=cASK7`(-cVz`*RTThs8?+|GXQ|JVBm zss4^+fG!@)F5SEIG*u_TSxRtKo81W`$@M1Fexrs^YF2G;ZPxY=DEvKic9>zVG+!faY;l3+w6Arz~`WuX(gfNlD2A zDV5uQpyte;?ccTXzX5e(lSUeLDPOn=tc^%O-Z_6{M=P2u=ypa5JAOWR@|sp(9U#zo ze;1luU~`p&C;eRD$k4bW?K_p4iH=i`T>3fc6y*$Nil~5sPFxb~q}~;zhsW4VM;)ke zE&GZ018pf&zW|&aK|w-U3a(KK2&R2@(<#YB9XUPJ(^; z^%uds^~DQ`TDPdUb2&;C6-^7o6YpqE)zxR%ZBmGujdz@PCAN6`_VES?3ONaqeU&sq zVU4w+)LfezYE%?wf8rcsymK8_xr-zShjR{i|i!;r|EB>$6|4or{t__^u4=Zy?-)WT3Tv^ z;IDh8Xb{Y1ABe(yQ+5GDwo8FfaUj&I)1I7tva;BHs>o|PH$NvGZ42=B_MU#ClB-<{ zT3mzRLk>uBq?2=+8jwisY&;I>1XCcDl%;O;ZZxLZO;|yEeueqjCqz{9nrgQes{>T;#Crx z;_HL=Rf1x*^Fk*bd$nk{8X$H5zTOsJ8H5>5y*7zaKuW$O;0R25mW zJGsqwt+AIMogX=aW}h01@k@u5q0Qh&judr)G2_R`Ee~)E?y7asaka`h(!&oexBh&_ o@4s>B`8VeOIRZhy?-Bonh??-Y=YYu7-b%;9)Y_!N$o=7e0IX5V_5c6? literal 0 HcmV?d00001 diff --git a/DLS/Resources/horn_on.png b/DLS/Resources/horn_on.png new file mode 100644 index 0000000000000000000000000000000000000000..1f093459911f2169034336d382267fe97b3770fc GIT binary patch literal 11148 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 literal 0 HcmV?d00001 diff --git a/DLS/Resources/intlt_off.png b/DLS/Resources/intlt_off.png new file mode 100644 index 0000000000000000000000000000000000000000..da58a2d1ce360472a2f62b29ad4d47fe397cebe0 GIT binary patch literal 4483 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 L&{MT1E?oUT5Kx3! literal 0 HcmV?d00001 diff --git a/DLS/Resources/lind_off.png b/DLS/Resources/lind_off.png new file mode 100644 index 0000000000000000000000000000000000000000..194f3e42c77d4e78b040c4acdf5c52da4740e580 GIT binary patch literal 3339 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 literal 0 HcmV?d00001 diff --git a/DLS/Resources/manual_on.png b/DLS/Resources/manual_on.png new file mode 100644 index 0000000000000000000000000000000000000000..b4780ec288684440951659d7ec06397375015887 GIT binary patch literal 10520 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 literal 0 HcmV?d00001 diff --git a/DLS/Resources/rind_off.png b/DLS/Resources/rind_off.png new file mode 100644 index 0000000000000000000000000000000000000000..c2f5ea87efa61a87dcc511cb69637e5667e0617f GIT binary patch literal 3323 zcmeHHX;)KO7L5fhA~O_GQ9>$AvI2sIO%cK%bc8SnRw;yeC{$z;kq8n_yWzGE1x?o?0s4R$2 z)ny8*>YRNeeyV`#vHyXlz@v;KdmIp+?~oSik;wXawRpDW&1)4<{rFe8(6|!b%9cFM6rBH}bPkWILd-4eScy5<~9m!}t4l1ipnpR#Zlu z32J>?de{yYPk!8x38A9f|16(XhR^u`zif@r~=wUCe;O5=*!9wNNzDU%wHZ4m`F*-cVtVKmw?m` zNlK_8I9V)7VY9J@<m!JwsuVOlP82E0^#aDDmr2A#`N@b zV!e0N%KR#gPEVlIXj`L0L;t)tFsoy(mDx_(SO_w+*i5+*?!qsW?mnW4r)&}JbLowZ zOst-|aE!w_&25Sc+ghD-@P2f<&rV56Ne78U@)fOD-?m+$cjjmpaoFsik-e*bRaGSp z4-O8RPf$wJ51V57!2p>i_>MkR3hX)O9-Mm~#irUML7Ohjc=7ML7Lal}r|yO(3dfrh z6zYOlTm0e6FmflA-q2tyFCw0uY_UPY$l@?WZCPazN`kU;VV>>lPO^^fF4MqSE;A|N zed}eJQwtZ9eG6l21Dd^{{zSf?^c1oP=0Hz@sjd?lMhpxJ3d+aokTDP z{5(Cxaw>nRa^%R7<1VhQmCO|J)^QMm?7hG6lv9Wgx<$j}E3G+>&jMskjf}c()oMyk zYV@KL%R2wTg`cLdtJ~2k5Qkg!i;n(OQ(axXo|cyO;TgHkyZ)V!$K#nU4YMqg6=+f1 z(v8lF1EmYD<6x%Y0MIx@Y5Jd#9TL1N)Goi)-Pw*?ez9MQ6lW?I8TPIKR zL6g2*v>&<2714cWXc=h0_R_9`w5i)gMd-ZEH=xlLtJrtXJ&?Fsw{UktV&eMP%beAi zN6-kB|S7{mqNivqczx4iD|?ss^Sm)Igw__W3Dak~wU=3_1g6b7&GFUgyD`EtQ_bg3ub zM1&rvHYTqxqU2OyiqLddZ#@A0rNQ$D+2AxcmubsoWo231G;P`VLt09jqx$;#0l{D3 zEO`$H&vtb4fu# zfrWx$zT}(u@sv_X;;l{b_@l4^mK-c>3K6@Rf|V#6nht8d$c+lJJUd2rwV7iC$VCcdwX?Ko9uu9<2{` zQk{NvAds>4Zlpf6q&fc6hVD(jwc*+T(LhJ`-al)mPZu@X(|jag4q8N(cYzNPpAA5J(ylPsqE59SD-T+jTX;y0ZjEHwT1`SUM4BmkRza2@%cG)0e;eBrS!a zlug>#3Jtjvepj->`G`BF)*(3cZ!#sg2LJ#7 literal 0 HcmV?d00001 diff --git a/DLS/Resources/rind_on.png b/DLS/Resources/rind_on.png new file mode 100644 index 0000000000000000000000000000000000000000..197e5ed7465a5325dcd80b6a1e3757e0870cc99a GIT binary patch literal 6272 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 M^F3aB^uqQ30dRJ(AOHXW literal 0 HcmV?d00001 diff --git a/DLS/Resources/s2_off.png b/DLS/Resources/s2_off.png new file mode 100644 index 0000000000000000000000000000000000000000..3489501f97ed4c0c77b1bc57c3a914fd02e2b1a1 GIT binary patch literal 3368 zcmeHIYdDna8va5l?R1z{wZx1F7nRv77DEd&7CAQ3Ne5Cos5H)uIhm%mhD9O`VGNx} z#jMG4$g!*$htim2WQUn;9L5lX!59YX``Ul^?|ohCx_WyR#|eI<1BXYOd^vU!51)+ZeD-Zlp>9f!=DYd70=hn`kQ&LkehZ^yMI5{8ST-C_Ph!afw zP~Uu8GTVWPq)UuB; z;qOd#*9LAh?GhC4j1WC=u?GO_H8gBMqN2&PV-;{twl4aJ8NUqkL=$+^5t&<#wjM2E zPj8aulc!rt*!2s~uae2?;#}LX(g%5YIAVXo_IS#~Yw7S=@)S>OZ*Sk_xT02Mt4b5% z*4wPm006xW%-=d_M*>_bZO_kFk37EHWjS0&ofY~8izv#zOSv{UVzuP~zsCZjfC5b* zZMBBOraRkQA2zFGpNh;#L}J&8>OO4*dGcs*urw!n&f?TA*J`vjV7Q)n3oCKHtALqd zy^q7BCUjkc(+XKpKGvkcuQdt_7S@@CHuD96T3TAXsZ?snz6<(}(V66qI zTJ}k;f3EH)l1L$r`z{iR_SMm{4wwC;`;O_l05H2t;Nb$7s266(l-kE&1|{i)QI@k((#sqYnAq4-+|{c|2J*S_9z0CM>r9FU^}UNOx<>d-aWAZ4$)@5D<#>4x;URN;E?%=l!r?_LH0d+F6{@Jw}4u=y-Th2PIEZ%&7xq=ro zRZgdl(L7^|XRfG|P}5V(a9D$g_*OjO#@&D&_fY-Oq$}llefarB0ouSk)obzK036fZERHa7`k^qYw=u*RRrs0dU|^H^73+56=tJ8YBGxD z*N*t6HVfTu9>J;=iA05ww_;;rhDIC1sRtp%3@xH=l45X!uC7Q=U*CVT?c|xTx}O=9 zdn%E)AvT)V%`i7hWvH0ZPVxHN#eszBcY#dFmyInub3i(DV&m?aM5Z(h>3V zv$LNA@7B$q@$&Mrwzl5d;yt$K4kLQiMsO;f#B6+k^7#y%l1C!LXGT8eYh+*UJLLgR z7Pc0#fJ>-`CYkJg7LuJpO79@84CjWGuDenlV+JbSVoZY@MzHExELLVDGEzN1CA(2r zeG%fDU@Xuy=6}LZNqDXO{r%l?eg&>)IFK;J5Yi42S`)#po#whqG<>U3nJ6D|TbuVx zhZoYdtgMW~jv0E#2(%3o>67|V&;7;{2Dl*LsdK9xHc4t77Zw&w-}4A=Zp|-IK6D0z z^G1glpQO+U04==CavRxOhfRemEJ|BmYu9R>|jM{YdOIP;0|u z8V*!0fngKcyQ8lLkK|0H8XU0sC=`~L@;|M;37v4^W7@YzoV~Ssfcd2}5}Lo(7Bm(@ z!YqJlb~Y9$FihBPuoKYkTEuy-9R`|s|7vuVG@9~TH*8PU1PsTth*ey>*TxXT`)P2~ z2y7@csOR4j@n|}diO$H?Z literal 0 HcmV?d00001 diff --git a/DLS/Resources/s2_on.png b/DLS/Resources/s2_on.png new file mode 100644 index 0000000000000000000000000000000000000000..51e8444d6eecc0f3701a55deedc0872f39867aba GIT binary patch literal 5685 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 bhyJ`?QgPHENr?M#*?>K}yovnp51soLkVB>p literal 0 HcmV?d00001 diff --git a/DLS/Resources/s3_on.png b/DLS/Resources/s3_on.png new file mode 100644 index 0000000000000000000000000000000000000000..46e490208f33aa46d398790c0f075b59c9cf1fa5 GIT binary patch literal 5790 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 KzUthy-~SDKqGrkf literal 0 HcmV?d00001 diff --git a/DLS/Resources/sb_off.png b/DLS/Resources/sb_off.png new file mode 100644 index 0000000000000000000000000000000000000000..a362d99a25f08ea26f83da16bb62d3cf0cfdd91a GIT binary patch literal 4115 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 L9DjWD?3Mol&!E2d literal 0 HcmV?d00001 diff --git a/DLS/Resources/taleft_off.png b/DLS/Resources/taleft_off.png new file mode 100644 index 0000000000000000000000000000000000000000..ab8d0c35e2bf94561831787ddd0ce3106bf50b63 GIT binary patch literal 2095 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mB!2ZqC#WAE}&fB|&Sz3+^ z#~+?lzERa=Qr&nYq%6*PPlNjjUY7m`tVgWOJrpBmimd$3w=K+3zJ>ju&Gi{SuGh$O zH0kX&PX3(Sz7=RB2pm|?4q=RvqaiTtL*T<}#$oTr!RbMnqf;|k7&6}6oKo9;jAtsIzAjzRX zJ&A%`K?a7pV>NdA>({S;|6Gc%y?TDR(ab3yEAG6odcCWzK0Y*bakBg3z?a{Dr<%>4 zdNu3niyM~;av1)o0v%CzLhaoD-Z#Y^H;x}az9~XSN*?IuS(}f7-MXWhkD;J#-n@CI z&YnH%D8BFJu6;KT?d!jN`!@gmD81>ad*kx&Z;x7ARA2vIouz;U=)s1$a&mHZH6{`~ z_qOlNe^g^Nca}qg@&<@;IK5ucWzBFv^3~TWYyDlf-`4#~`Fb;FTkYFVQ}-7zKPY&& zfSG~8fuWHP7;ua^h3pI#&haThs8-~O?j`)Lj-XowdlqR2ia#?u$?YD1* zuQUFTWwBy7(AjhRvA_SFw`JvQRqL<+e(!p{G&hs+T!-#EphW@>U|SosyBQcR+$fH{ zUcT&Y#i~_RnoCRcQf(O83)pEBn>Z6jK`JnsrK-(R?=LEDOlAT)afpEjU%WK)^L@hI TI8ItugWT@v>gTe~DWM4flu-hv literal 0 HcmV?d00001 diff --git a/DLS/Resources/taleft_on.png b/DLS/Resources/taleft_on.png new file mode 100644 index 0000000000000000000000000000000000000000..f155626c4513b8148934c23e932c80f47cba960c GIT binary patch literal 5435 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 NPo8J0e!O(+zX8{Ai@^W@ literal 0 HcmV?d00001 diff --git a/DLS/Resources/taright_off.png b/DLS/Resources/taright_off.png new file mode 100644 index 0000000000000000000000000000000000000000..be9731cd5ce7343b7d6444a052b1aace4084bca8 GIT binary patch literal 2633 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 L?~{b%=db=3ayT`~ literal 0 HcmV?d00001 diff --git a/DLS/Resources/tawarn_off.png b/DLS/Resources/tawarn_off.png new file mode 100644 index 0000000000000000000000000000000000000000..d594ab0d58c16ca3788fa9b1e75110346315a53e GIT binary patch literal 3347 zcmeH}Z8V!{8pngSl%}ebmch(+MrW(lsV!RX)zUH*eGwEn)cZ>$qB^a`6suEO z$0X>qra@FBNJ6w#9I_FTdTSCXl8O=%C80?6iGJDdd-j~&Idgw_p8MsT=lWm2>wn+( zlXo6+2CQ$c4+4R}zGqKg1c7uUAdptE-Zo&y&EM}T2(;s^@9C3)=@n7|J;r3#LRaSN z8bbJW+9a>M&+Axd-btMxn;goPLv@D^z3x+cKHqI%WV`ib-D`uqpq#y3{RXB%7I6K> zMNYZNeKKa%sv)OHH$3rQwt%T0lIYd9rmrcm90-N#GApK$7u? zPw{^=LCeAEW7;6l`ZOj!&t)DDv6eN=t8D+m>Wt@Vl0lCGd*&^wb4`vdwq>mzGqCMnDwQNPSof>Btp^Nr(E)vrFIick%h* zjt&k({BcT5u%o>_={FX)CZNgb=D5jPPmwj-@#c8jZ-SMTbcI67d#`BERF?OI^$yhr zHyN1O)uAwxnbvNo?^%?AB@4oi zn@9`cLcrE!7$2a98f}i{g=V1xiA6iI*4sHc1oNZ-lOpO)LD95$%9@w}O`=Ej@IRBGhETQ{>N2a1~ zjM7$jNx)amjd4lp<=GLa(D?qFp}cIsDFaifbE6k3vJ;(_2+^y|vLj&%=GE4Nl{Hli zL9{aT#u({|RQVdw;25zHuv=ps6kj5_o}kTX6kYa?WFMrp)l3aPHorn?drOHK$(I@* zfE+_yWP7J<1V6A<$52Y;AF%nK1N{J#g*%tJwx!FfM++&eB&7HRSdMgXH-oN_GuLkE z=#n~f4b9d7nrgAZdB#7UBe_qn@t$_^X`tGu#vcq;SP4_5HQ81Hn*v($PGaIj13A{;Bh@sM5`J$9d!Nj(;KO&&8ro5 zw@QQA9~-AGEEmS(?yl5T)6uly^qtxm*uDPjG>0fNn&&o7WH`8mRqSI#`?iqu7Vr5y zUOkJ*Q7_G05--Nt<_UknPPa}JkDrrl(}2n@jkkD-roQ{Nxq!mrZlC1HaEDWGVpn7n zBy2$K%w?oKm2x~&abxhHO;e`q-ASIAeJPp=YfEpGD$`0ddR~+y@Q@*p+bJ2GWU3CBi(v0~TVx)20b-&II2Rg5n2Z@RAr-j{0Q0n?{oFFE+E|Ni-%tC!=6+X~|E=YJcH@Eu>E4?C zTlp;7bcr0wxJV~|vg(6Vxnm>DqWxzIO{9yD@>+x?18d>o zfFIRuhOqTp7z~Cb85{^aT*7}MQ4y#(He&^xQv8#d2 wW~=Ek^|p?h5&!@I literal 0 HcmV?d00001 diff --git a/DLS/Resources/tawarn_on.png b/DLS/Resources/tawarn_on.png new file mode 100644 index 0000000000000000000000000000000000000000..222a18e9bdb6976a6c77a2d568822873ebc6ea11 GIT binary patch literal 7988 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 QUr;jQ=g6NJp{K9?2g}%kx&QzG literal 0 HcmV?d00001 diff --git a/DLS/Resources/wail_off.png b/DLS/Resources/wail_off.png new file mode 100644 index 0000000000000000000000000000000000000000..4f07e893249d9d9ad835740751ca89aabf6b4523 GIT binary patch literal 3351 zcmeHJ`B#%y8csk&1%f>-1r!q7aXMNc*s>#mP_cka34?61gi=HeYhsWkADd{!3JoqG zS|HHUvIG(cj1ab9rGk~R$r2%~0c;3_gc3r4B+Sj3KVZ(B`DNPE`@{Es_xsNK+;@H6 z`<0KkyWXKAhhQ+6o~MVKFASzBfWhE*59|kDFrS@^fWdTUJl$OVQc6VAo-qbtNbR`? z-0BnGh8&+OFnZhFuY@?<%yfH;`~Gbm*HF1uV$D%*hVGBY;nfFsxcK7Uchp|KLk)++A+Ek=2}>CvEw?HwE59LAk(eVh zolxNDQQO!93k%Qy+Z;V&FP>v!sLVy1Ics`3G|Up)l@rc>zk#glgCZ=B=cup zw4Ia75u}8e zm|CGx&&sA$>L;G+gp!BWXJ%&T_{NJrmoISZ!|Ms*Y+}Us@#^4lLXzMZ(|DC&xWctJ zQa_bYorTO{7Xg3l1oE-kz?jLu;bmN}1OXSgN7(`Bm@HX>_c&U=)nD3^@Tk&GSbasziqu}!vz zWU>FSvsESRC=1O3Kb;!@S)SXCG8`%{E{=J&(N|xh;-9B|b?vrh_bt@&T`^6D#( z6wh{93W0T*AI^3qi6%XqHNa76P3Bv!;cbZo|1QcVo!%$n`fiD5>j_nGXHzsvm@R*3 z5z_Vnjutu^Rj)21h53d3Qg&6!NmD+4HUv4{O0J@hoI>?K`lzC^bif4!aFue}pD z5%%xsiY%f6B)d7N(UpmKg%XnR2y32 zO`wUruuN}96HZ3%6R#q)|22R!Om@CJP_nM4r}rEp$sr|82y{;c0Mo5559me_(cQ_b zp81_i^In6=SK{Ir&5@8?60!abA}62g0qT|+ZGrD#3mo#vqk;AKunxoe(t*qBo@Et8 zVfC+(UqlY37(eSSqKWxWrl<^)9U3ABr%B1o%w%UMDP!>f@>a9ug~soLPoOdC8%mFF zGaNG=En4a;ng_k+->xgjeb?ece8MaztfLYtuYzOH#{+{|Uz~kpP4FG_)@(~vlY_#1 zV!!m`n>k(0IJ2$O`DScfu`Q$e*MZWIj-J+K5|z>#6iOzOuS7@FRn8*g@PA$z{#8nT z1Cqn618wPW2e%KPbjSR%+3snWy0WqYrR~Z@<9B24y?Z}PrBd!j!&`m0yU6>>!3rjm zNor3PBTw*9&S}-QUYWbHxQ_}r3`U$a@*qIDRTzg&AP{PVfKW0Y);9DSOnH&MWxslC zb$RCI;mV&bxx2e>W`sUgDz-QLPa|%KmzN1fYvcuDikjfESPw;qw-OQCHRr2T>&xd^ zR>7=n=%k*SOlZF2%M!W0OQ(WYe{Zcw&6kmXnL3dcUDPJvRAKu@XAq?*h?|0Twd#0P`HXWSu+z86GIad4vQ>y_%185m$OU( zC<=UI*m3lzg@&OpfN1%HS#wU?VPxP%oN`*Y3fi_tm>8sPq`WWdG%0Ok!A6&EQygcV zMn%_Y%ooU<-n}rani>6jzvS~}v1)$;Zk1XoHPL`c>m)kV5-OF-&Qrb&UrGf(jm%e& z>NzD3``@S0e;i@u5%0v$-$y0+)hV>f)HU_{Tc3s;n8z)4Sr;t%tjX2pd!F@nV}9~^ G_P+oh63Vgw literal 0 HcmV?d00001 diff --git a/DLS/Resources/wail_on.png b/DLS/Resources/wail_on.png new file mode 100644 index 0000000000000000000000000000000000000000..66e2536b585ee11ab35ab29157e012a7ae727375 GIT binary patch literal 6392 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 literal 0 HcmV?d00001 diff --git a/DLS/Resources/yelp_off.png b/DLS/Resources/yelp_off.png new file mode 100644 index 0000000000000000000000000000000000000000..6634ff6a20c9ff1b446a6afcf7e28306051e2419 GIT binary patch literal 2788 zcmeAS@N?(olHy`uVBq!ia0y~yV1B{Cz&L?}4Jcyk>y^mBz_r@b#WAE}&fB{?vqPd~ z*gqIA+Sk!_sC(88j)QK>ovu1}3OZeSW}Rad|H2<|#$G{;aif=m&L!3sktD?~jg0~> zTZFa>9!=UJU}RGvRO8Qb_S25Tvriw%F*ckjGx` zdiCkE_ZKrWFlgmY>;h5;?g(E17EKCFOjbZIxi~nmGcYu8Z~#k81_4G!SsE0wifVkfh#ta!=h~t2?_&wb#V#G`j!#(o*llpP!y4yWQDYtiGq} zt5(h5U#2|#{O#-3t-Emdu58_(9}~YxN=b1wH#h%`H~Rnk`}>!hrcIl+q5Au~n%|$E zo__hqw)$HOGdrJ8W#77(okBpLU4A)n;>0a`6A!lq#K+5<<=uG^19bUCp$juZgmNY~ z#9g>>L7-2@(kSi3-sRQdZX1&e_@7p09yHxk&Ux z`RK~Z;6O3cok{f%54C=HaIl%<8?e?%FbTgf^U_S?^iSa{g!|=er7r)yxjB9DvhVNi zS}*hW_4Uoj%bQmatR1#y#zx_f|F`{Hw`!HtN+ACC<>h7h^7r>*LnG$3eEI(Ve*4kx zzdwO~`ZytA#-)pk-JPqet8cx1c)0!Hg@w*9zdSzPf4M9=`gY6e*DqeI@YpCVE&c!H zix)pOR{;I?`(IXmeth(dy6^8|Z){5ScKrs7>IEWsh3Q^1eboMM+SW8bzj%M;=d@dP zg^ygOu;ylGN6(gVKRDYw|5?>^V5GYVUeG+bG5PqVypy6|nx2GxOggGx-F^1i+1cuM z@`0&lr`m$xN%Qa5`~$|$pZ!PmW2`GbElFZxVDOpT;CHfXzP|pQYjuBreJ!~Mbg-x} zFkEJ_lz4^Jh}!;q_j9^_yc_S`oyE)H8ls}2+)CfReCc`n`T6<%`zGAqSL=QIM{bqqEs;-{sr$ z?pm$B4GcGp=?#97d~!B3*uDUhO38~pS!=aeU%lzv&(F=3F28xSTRh!nf%yHp{~sS8 zudlAEYIEXP&GlJIN-C|S8W;lmy&RV7>@IuDwK{w~A2T!a%MF{;&$qdDKdOvcw0?bl zYJ7bB$2Foyg-@>i_4@ky^*`!>ZuL24{9?-6=jT_Nnw$IY?DA1Fez<;VLnzsJ>_3KZ)o=)_( z9KUZsZzLEoS?yo*Bl3%c%K4M!Wo65%l_mg%_cJrjt@P9YMr)n#M6a~DQ+D?28B4?0$DRFu ztoYB5j|FdUnW_sgFw79Y^9ZQAyrB+n=f=5 z%zpLiRnf`h51+qtFfufF6|qvONFi7bHTFz4$p5PUg(<}2ZIgu;&|yOkG~5s8cxW#Z VEgljn_jM`A`JS$RF6*2UngDoHk8A({ literal 0 HcmV?d00001 diff --git a/DLS/Resources/yelp_on.png b/DLS/Resources/yelp_on.png new file mode 100644 index 0000000000000000000000000000000000000000..7ca811a8564e445d514fe28f855b4b0ce0d62470 GIT binary patch literal 6240 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 H;`RRmiC0ZC literal 0 HcmV?d00001 diff --git a/DLS/SirenApply.cs b/DLS/SirenApply.cs new file mode 100644 index 0000000..52f2e18 --- /dev/null +++ b/DLS/SirenApply.cs @@ -0,0 +1,68 @@ +namespace DLS +{ + using Rage; + internal static class SirenApply + { + public static void ApplySirenSettingsToEmergencyLighting(SirenSetting setting, EmergencyLighting els) + { + els.TimeMultiplier = setting.TimeMultiplier; + els.LightFalloffMax = setting.LightFalloffMax; + els.LightFalloffExponent = setting.LightFalloffExponent; + els.LightInnerConeAngle = setting.LightInnerConeAngle; + els.LightOuterConeAngle = setting.LightOuterConeAngle; + els.LightOffset = setting.LightOffset; + els.TextureHash = setting.TextureHash; + els.SequencerBpm = setting.SequencerBPM; + els.UseRealLights = setting.UseRealLights; + els.LeftHeadLightSequence = setting.LeftHeadLightSequencer; + els.LeftHeadLightMultiples = setting.LeftHeadLightMultiples; + els.RightHeadLightSequence = setting.RightHeadLightSequencer; + els.RightHeadLightMultiples = setting.RightHeadLightMultiples; + els.LeftTailLightSequence = setting.LeftTailLightSequencer; + els.LeftTailLightMultiples = setting.LeftTailLightMultiples; + els.RightTailLightSequence = setting.RightTailLightSequencer; + els.RightTailLightMultiples = setting.RightTailLightMultiples; + + for (int i = 0; i < setting.Sirens.Length; i++) + { + SirenEntry entry = setting.Sirens[i]; + EmergencyLight light = els.Lights[i]; + + // Main light settings + light.Color = entry.LightColor; + light.Intensity = entry.Intensity; + light.LightGroup = entry.LightGroup; + light.Rotate = entry.Rotate; + light.Scale = entry.Scale; + light.ScaleFactor = entry.ScaleFactor; + light.Flash = entry.Flash; + light.SpotLight = entry.SpotLight; + light.CastShadows = entry.CastShadows; + + // Corona settings + light.CoronaIntensity = entry.Corona.CoronaIntensity; + light.CoronaSize = entry.Corona.CoronaSize; + light.CoronaPull = entry.Corona.CoronaPull; + light.CoronaFaceCamera = entry.Corona.CoronaFaceCamera; + + // Rotation settings + light.RotationDelta = entry.Rotation.DeltaDeg; + light.RotationStart = entry.Rotation.StartDeg; + light.RotationSpeed = entry.Rotation.Speed; + light.RotationSequence = entry.Rotation.Sequence; + light.RotationMultiples = entry.Rotation.Multiples; + light.RotationDirection = entry.Rotation.Direction; + light.RotationSynchronizeToBpm = entry.Rotation.SyncToBPM; + + // Flash settings + light.FlashinessDelta = entry.Flashiness.DeltaDeg; + light.FlashinessStart = entry.Flashiness.StartDeg; + light.FlashinessSpeed = entry.Flashiness.Speed; + light.FlashinessSequenceRaw = entry.Flashiness.Sequence; + light.FlashinessMultiples = entry.Flashiness.Multiples; + light.FlashinessDirection = entry.Flashiness.Direction; + light.FlashinessSynchronizeToBpm = entry.Flashiness.SyncToBPM; + } + } + } +} \ No newline at end of file diff --git a/DLS/SirenSetting.cs b/DLS/SirenSetting.cs new file mode 100644 index 0000000..e67fe78 --- /dev/null +++ b/DLS/SirenSetting.cs @@ -0,0 +1,292 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Drawing; +using System.Linq; +using System.Xml; +using System.Xml.Serialization; + +namespace DLS +{ + public class SirenSetting + { + [XmlElement("timeMultiplier")] + public ValueItem TimeMultiplier { get; set; } = 1.0f; + + [XmlElement("lightFalloffMax")] + public ValueItem LightFalloffMax { get; set; } = 50f; + + [XmlElement("lightFalloffExponent")] + public ValueItem LightFalloffExponent { get; set; } = 10f; + + [XmlElement("lightInnerConeAngle")] + public ValueItem LightInnerConeAngle { get; set; } = 30f; + + [XmlElement("lightOuterConeAngle")] + public ValueItem LightOuterConeAngle { get; set; } = 60f; + + [XmlElement("lightOffset")] + public ValueItem LightOffset { get; set; } = 0f; + + [XmlElement("textureName")] + public string TextureName { get; set; } = DLS.TextureHash.defaultLightTexture; + + [XmlIgnore] + public uint TextureHash + { + get => DLS.TextureHash.StringToHash(TextureName); + + set => TextureName = DLS.TextureHash.HashToString(value); + } + + [XmlElement("sequencerBpm")] + public ValueItem SequencerBPM { get; set; } = 100; + + [XmlElement("leftHeadLight")] + public SequencerWrapper LeftHeadLightSequencer { get; set; } = 0; + + [XmlElement("rightHeadLight")] + public SequencerWrapper RightHeadLightSequencer { get; set; } = 0; + + [XmlElement("leftTailLight")] + public SequencerWrapper LeftTailLightSequencer { get; set; } = 0; + + [XmlElement("rightTailLight")] + public SequencerWrapper RightTailLightSequencer { get; set; } = 0; + + [XmlElement("leftHeadLightMultiples")] + public ValueItem LeftHeadLightMultiples { get; set; } = 1; + + [XmlElement("rightHeadLightMultiples")] + public ValueItem RightHeadLightMultiples { get; set; } = 1; + + [XmlElement("leftTailLightMultiples")] + public ValueItem LeftTailLightMultiples { get; set; } = 1; + + [XmlElement("rightTailLightMultiples")] + public ValueItem RightTailLightMultiples { get; set; } = 1; + + [XmlElement("useRealLights")] + public ValueItem UseRealLights { get; set; } = true; + + + [XmlArray("sirens")] + [XmlArrayItem("Item")] + public SirenEntry[] Sirens + { + get => sirenList.ToArray(); + set + { + sirenList = value.ToList(); + for (int i = 0; i < sirenList.Count; i++) + { + sirenList[i].SirenIdCommentText = "Siren " + (i + 1); + } + } + } + + [XmlIgnore] + private List sirenList = new List(); + + public void AddSiren(SirenEntry item) + { + if (sirenList.Count < 20) + { + item.SirenIdCommentText = "Siren " + (sirenList.Count + 1); + sirenList.Add(item); + } + else + { + throw new IndexOutOfRangeException("A SirenSetting cannot contain more than 20 sirens"); + } + } + } + + public class SirenEntry + { + [XmlIgnore] + internal string SirenIdCommentText { get; set; } + + [XmlAnyElement("SirenIdComment")] + public XmlComment SirenIdComment + { + get => new XmlDocument().CreateComment($" {SirenIdCommentText} "); + set => SirenIdCommentText = value.InnerText; + } + + [XmlElement("rotation")] + public LightDetailEntry Rotation { get; set; } = new LightDetailEntry(); + + [XmlElement("flashiness")] + public LightDetailEntry Flashiness { get; set; } = new LightDetailEntry(); + + [XmlElement("corona")] + public CoronaEntry Corona { get; set; } = new CoronaEntry(); + + [XmlIgnore] + public Color LightColor { get; set; } = Color.White; + + [XmlElement("color")] + public ValueItem ColorString + { + get => string.Format("0x{0:X8}", LightColor.ToArgb()); + set + { + LightColor = Color.FromArgb(Convert.ToInt32(value, 16)); + } + } + + [XmlElement("intensity")] + public ValueItem Intensity { get; set; } = 0; + + [XmlElement("lightGroup")] + public ValueItem LightGroup { get; set; } = 0; + + [XmlElement("rotate")] + public ValueItem Rotate { get; set; } = false; + + [XmlElement("scale")] + public ValueItem Scale { get; set; } = true; + + [XmlElement("scaleFactor")] + public ValueItem ScaleFactor { get; set; } = 2; + + [XmlElement("flash")] + public ValueItem Flash { get; set; } = false; + + [XmlElement("light")] + public ValueItem Light { get; set; } = true; + + [XmlElement("spotLight")] + public ValueItem SpotLight { get; set; } = true; + + [XmlElement("castShadows")] + public ValueItem CastShadows { get; set; } = false; + } + + public class CoronaEntry + { + [XmlElement("intensity")] + public ValueItem CoronaIntensity { get; set; } = 50f; + + [XmlElement("size")] + public ValueItem CoronaSize { get; set; } = 0f; + + [XmlElement("pull")] + public ValueItem CoronaPull { get; set; } = 0.10f; + + [XmlElement("faceCamera")] + public ValueItem CoronaFaceCamera { get; set; } = false; + } + + public class LightDetailEntry + { + [XmlElement("delta")] + public ValueItem DeltaRad { get; set; } = 0; + + [XmlIgnore] + public float DeltaDeg + { + get => Rage.MathHelper.ConvertRadiansToDegrees(DeltaRad); + set => DeltaRad = Rage.MathHelper.ConvertDegreesToRadians(value); + } + + [XmlElement("start")] + public ValueItem StartRad { get; set; } = 0; + + [XmlIgnore] + public float StartDeg + { + get => Rage.MathHelper.ConvertRadiansToDegrees(StartRad); + set => StartRad = Rage.MathHelper.ConvertDegreesToRadians(value); + } + + [XmlElement("speed")] + public ValueItem Speed { get; set; } = 1.0f; + + [XmlElement("sequencer")] + public Sequencer Sequence { get; set; } = 0; + + [XmlElement("multiples")] + public ValueItem Multiples { get; set; } = 1; + + [XmlElement("direction")] + public ValueItem Direction { get; set; } = true; + + [XmlElement("syncToBpm")] + public ValueItem SyncToBPM { get; set; } = true; + + } + + [DebuggerDisplay("{Sequence} = {SequenceRaw}")] + public class Sequencer : ValueItem + { + public static implicit operator Sequencer(uint value) => new Sequencer(value); + public static implicit operator Sequencer(string value) => new Sequencer(value); + public static implicit operator uint(Sequencer item) => item.Value; + public static implicit operator string(Sequencer item) => Convert.ToString(item.Value, 2); + + public Sequencer(uint value) : base(value) { } + public Sequencer(string value) : base(Convert.ToUInt32(value, 2)) { } + + public Sequencer() : base() { } + + [XmlIgnore] + public uint SequenceRaw + { + get => Value; + set => Value = value; + } + + [XmlIgnore] + public string Sequence + { + get => Convert.ToString(Value, 2); + set => Value = Convert.ToUInt32(value, 2); + } + } + + [DebuggerDisplay("{Sequencer.Sequence} = {Sequencer.SequenceRaw}")] + public class SequencerWrapper + { + public static implicit operator SequencerWrapper(uint value) => new SequencerWrapper(value); + public static implicit operator SequencerWrapper(string value) => new SequencerWrapper(value); + public static implicit operator uint(SequencerWrapper item) => item.Sequencer.SequenceRaw; + public static implicit operator string(SequencerWrapper item) => item.Sequencer.Sequence; + + public SequencerWrapper(uint value) + { + Sequencer = value; + } + + public SequencerWrapper(string value) + { + Sequencer = value; + } + + public SequencerWrapper() + { + Sequencer = new Sequencer(); + } + + [XmlElement("sequencer")] + public Sequencer Sequencer { get; set; } + } + + [DebuggerDisplay("{Value}")] + public class ValueItem + { + public static implicit operator ValueItem(T value) => new ValueItem(value); + public static implicit operator T(ValueItem item) => item.Value; + + public ValueItem() { } + + public ValueItem(T value) + { + this.Value = value; + } + + [XmlAttribute("value")] + public virtual T Value { get; set; } + } +} \ No newline at end of file diff --git a/DLS/TextureHash.cs b/DLS/TextureHash.cs new file mode 100644 index 0000000..f56082a --- /dev/null +++ b/DLS/TextureHash.cs @@ -0,0 +1,58 @@ +using Rage; +using System; +using System.Collections.Generic; + +namespace DLS +{ + public static class TextureHash + { + static TextureHash() + { + string[] textureNames = new string[] + { + "VehicleLight_car_oldsquare", + "VehicleLight_car_standardmodern", + "VehicleLight_car_standard70s", + "VehicleLight_misc_searchlight", + "VehicleLight_misc_squarelight", + "VehicleLight_bicycle", + "VehicleLight_car_LED1", + "VehicleLight_car_LED2", + "VehicleLight_bike_sport", + "VehicleLight_bike_round", + "VehicleLight_car_utility", + "VehicleLight_car_antique", + "VehicleLight_sirenlight" + }; + + foreach (string name in textureNames) + LightTextureHashes[Game.GetHashKey(name)] = name; + } + + public const string defaultLightTexture = "VehicleLight_sirenlight"; + public static Dictionary LightTextureHashes { get; } = new Dictionary { }; + + public static uint StringToHash(string textureName) + { + try + { + return Convert.ToUInt32(textureName, 16); + } + catch (FormatException) + { + uint hash = Game.GetHashKey(textureName); + if (!LightTextureHashes.ContainsKey(hash)) + LightTextureHashes[hash] = textureName; + return hash; + } + } + + public static string HashToString(uint textureHash) + { + if (LightTextureHashes.TryGetValue(textureHash, out string textureName)) + return textureName; + else + return string.Format("0x{0:X8}", textureHash); + } + } +} diff --git a/DLS/Threads/CleanupManager.cs b/DLS/Threads/CleanupManager.cs new file mode 100644 index 0000000..0d2b010 --- /dev/null +++ b/DLS/Threads/CleanupManager.cs @@ -0,0 +1,47 @@ +using DLS.Utils; +using Rage; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace DLS.Threads +{ + class CleanupManager + { + static uint lastProcessTime = Game.GameTime; + static int timeBetweenChecks = 10000; + static int yieldAfterChecks = 10; + public static void Process() + { + while (true) + { + int checksDone = 0; + List UsedHashes = new List(); + + foreach (ActiveVehicle activeVeh in Entrypoint.activeVehicles.ToList()) + { + if (!activeVeh.Vehicle) + Entrypoint.activeVehicles.Remove(activeVeh); + else + UsedHashes.Add(activeVeh.CurrentHash); + + checksDone++; + if (checksDone % yieldAfterChecks == 0) + GameFiber.Yield(); + } + + foreach (uint hash in Entrypoint.UsedPool.Keys.ToList()) + { + if (!UsedHashes.Contains(hash)) + { + ("Moving " + hash + " to Available Pool").ToLog(); + Entrypoint.AvailablePool.Add(Entrypoint.UsedPool[hash]); + Entrypoint.UsedPool.Remove(hash); + } + } + GameFiber.Sleep((int)Math.Max(timeBetweenChecks, Game.GameTime - lastProcessTime)); + lastProcessTime = Game.GameTime; + } + } + } +} diff --git a/DLS/Threads/PlayerController.cs b/DLS/Threads/PlayerController.cs new file mode 100644 index 0000000..eacdaa0 --- /dev/null +++ b/DLS/Threads/PlayerController.cs @@ -0,0 +1,934 @@ +using DLS.Utils; +using Rage; +using Rage.Native; +using System; +using System.Diagnostics; +using System.Windows.Forms; + +namespace DLS.Threads +{ + class PlayerController + { + private static SirenStage sirenStageBeforeHorn = SirenStage.Off; + private static bool manActive = false; + internal static bool manButtonDown = false; + internal static bool hornButtonDown = false; + internal static bool blktOn = false; + private static Vehicle lastVehicle; + + private static Stopwatch scanTimer = new Stopwatch(); + private static Random random = new Random(); + private static int scanTiming; + + public static void Process() + { + while (true) + { + GameFiber.Yield(); + if (Game.LocalPlayer.Character.IsInAnyVehicle(false)) + { + Vehicle veh = Game.LocalPlayer.Character.CurrentVehicle; + while (veh && veh.IsEngineOn && veh.Driver == Game.LocalPlayer.Character + && !Game.IsPaused && veh.HasSiren) + { + GameFiber.Yield(); + bool tone1ButtonDown = Controls.IsDLSControlDown(DLSControls.SIREN_TONE1); + bool tone2ButtonDown = Controls.IsDLSControlDown(DLSControls.SIREN_TONE2); + bool tone3ButtonDown = Controls.IsDLSControlDown(DLSControls.SIREN_TONE3); + bool tone4ButtonDown = Controls.IsDLSControlDown(DLSControls.SIREN_TONE4); + manButtonDown = Controls.IsDLSControlDown(DLSControls.SIREN_MAN); + hornButtonDown = Controls.IsDLSControlDown(DLSControls.SIREN_HORN); + + if (veh.GetActiveVehicle() == null) + { + if (veh.IsSirenOn) + { + if (!veh.IsSirenSilent) + Entrypoint.activeVehicles.Add(new ActiveVehicle(veh, true, LightStage.Three, SirenStage.One)); + else + Entrypoint.activeVehicles.Add(new ActiveVehicle(veh, true, LightStage.Three, SirenStage.Off)); + } + else + Entrypoint.activeVehicles.Add(new ActiveVehicle(veh, true)); + } + if (Controls.IsDLSControlDown(DLSControls.GEN_LOCKALL)) + { + Entrypoint.keysLocked = !Entrypoint.keysLocked; + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "TOGGLE_ON", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + } + if (!blktOn && Entrypoint.BLightsEnabled && NativeFunction.Natives.IS_VEHICLE_STOPPED(veh)) + NativeFunction.Natives.SET_VEHICLE_BRAKE_LIGHTS(veh, true); + if (!Entrypoint.keysLocked) + { + Controls.DisableControls(); + NativeFunction.Natives.SET_VEHICLE_RADIO_ENABLED(veh, false); + ActiveVehicle activeVeh = veh.GetActiveVehicle(); + DLSModel vehDLS; + if (veh) + vehDLS = veh.GetDLS(); + else + vehDLS = null; + bool ahrnInterruptsSiren = vehDLS != null ? vehDLS.SoundSettings.AirHornInterruptsSiren.ToBoolean() : false; + if (Controls.IsDLSControlDownWithModifier(DLSControls.UI_TOGGLE)) + UIManager.IsUIOn = !UIManager.IsUIOn; + if (vehDLS != null) + { + if (lastVehicle != veh) + { + lastVehicle = veh; + if (vehDLS.SpecialModes.SirenUI != "") + UI.Importer.GetCustomSprites(vehDLS.SpecialModes.SirenUI); + else + { + UI.Importer.ResetSprites(); + UI.Importer.GetCustomSprites(); + } + } + else if (activeVeh.TempUsed + && activeVeh.TempLightStage != activeVeh.LightStage) + { + activeVeh.LightStage = activeVeh.TempLightStage; + Lights.Update(activeVeh); + activeVeh.TempUsed = false; + } + else if (activeVeh.TAType != "off" + && Controls.IsDLSControlDownWithModifier(DLSControls.LIGHT_TADVISOR)) + { + if (activeVeh.TApatternCurrentIndex + 1 < activeVeh.TAgroup.TaPatterns.Count) + activeVeh.TApatternCurrentIndex++; + else + activeVeh.TApatternCurrentIndex = 0; + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + Lights.UpdateTA(true, activeVeh); + continue; + } + else if (Game.IsKeyDown(Keys.F) || Game.IsControllerButtonDown(ControllerButtons.Y)) + { + if (vehDLS.SpecialModes.PresetSirenOnLeaveVehicle != "none") + { + if (activeVeh.LightStage != LightStage.Off && activeVeh.LightStage != LightStage.Empty) + { + activeVeh.TempLightStage = activeVeh.LightStage; + activeVeh.TempUsed = true; + Game.LocalPlayer.Character.Tasks.LeaveVehicle(veh, LeaveVehicleFlags.None); + GameFiber.Sleep(1000); + if (!veh.IsEngineOn) + veh.IsEngineOn = true; + string presetSiren = vehDLS.SpecialModes.PresetSirenOnLeaveVehicle; + switch (presetSiren) + { + case "stage1": + activeVeh.LightStage = LightStage.One; + Lights.Update(activeVeh); + break; + case "stage2": + activeVeh.LightStage = LightStage.Two; + Lights.Update(activeVeh); + break; + case "stage3": + activeVeh.LightStage = LightStage.Three; + Lights.Update(activeVeh); + break; + case "custom1": + activeVeh.LightStage = LightStage.CustomOne; + Lights.Update(activeVeh); + break; + case "custom2": + activeVeh.LightStage = LightStage.CustomOne; + Lights.Update(activeVeh); + break; + } + } + else + { + Game.LocalPlayer.Character.Tasks.LeaveVehicle(veh, LeaveVehicleFlags.None); + } + } + if (Vehicles.GetSirenKill(activeVeh) && activeVeh.SirenStage != SirenStage.Off) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh); + } + } + if (!Entrypoint.keysLocked) + { + #region Lights Manager + if (Controls.IsDLSControlDownWithModifier(DLSControls.LIGHT_SBURN)) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + blktOn = !blktOn; + if (blktOn) + { + activeVeh.IndStatus = IndStatus.Off; + activeVeh.LightStage = LightStage.Off; + activeVeh.SBOn = false; + activeVeh.TAStage = TAStage.Off; + if (activeVeh.IntLightOn) + Lights.ToggleIntLight(activeVeh); + Lights.Update(activeVeh); + Lights.UpdateIndicator(activeVeh); + NativeFunction.Natives.SET_VEHICLE_LIGHTS(veh, 1); + continue; + } + else + { + NativeFunction.Natives.SET_VEHICLE_LIGHTS(veh, 0); + continue; + } + } + else if (blktOn) + continue; + else if (vehDLS.DoesVehicleHaveLightStage(LightStage.One) + && Game.IsAltKeyDownRightNow && Game.IsKeyDown(Keys.D1)) + { + if (activeVeh.LightStage != LightStage.One) + activeVeh.LightStage = LightStage.One; + else + activeVeh.LightStage = LightStage.Off; + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + Lights.Update(activeVeh); + } + else if (vehDLS.DoesVehicleHaveLightStage(LightStage.Two) + && Game.IsAltKeyDownRightNow && Game.IsKeyDown(Keys.D2)) + { + if (activeVeh.LightStage != LightStage.Two) + activeVeh.LightStage = LightStage.Two; + else + activeVeh.LightStage = LightStage.Off; + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + Lights.Update(activeVeh); + } + else if (vehDLS.DoesVehicleHaveLightStage(LightStage.Three) + && Game.IsAltKeyDownRightNow && Game.IsKeyDown(Keys.D3)) + { + if (activeVeh.LightStage != LightStage.Three) + activeVeh.LightStage = LightStage.Three; + else + activeVeh.LightStage = LightStage.Off; + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + Lights.Update(activeVeh); + } + else if (Controls.IsDLSControlDown(DLSControls.LIGHT_TOGGLE)) + { + Lights.MoveUpStage(activeVeh); + } + else if (Controls.IsDLSControlDown(DLSControls.LIGHT_TADVISOR) + && vehDLS.TrafficAdvisory.Type.ToLower() != "off") + { + if (activeVeh.LightStage == LightStage.Off) + { + activeVeh.LightStage = LightStage.Empty; + veh.ShouldVehiclesYieldToThisVehicle = false; + veh.EmergencyLightingOverride = Vehicles.GetEL(veh); + if (activeVeh.SBOn) + Lights.UpdateSB(activeVeh); + veh.IsSirenOn = true; + veh.IsSirenSilent = true; + Lights.MoveUpStageTA(activeVeh); + continue; + } + else if (activeVeh.LightStage == LightStage.Empty) + { + Lights.MoveUpStageTA(activeVeh); + if (activeVeh.TAStage == TAStage.Off) + { + if (activeVeh.SBOn) + { + veh.EmergencyLightingOverride = Vehicles.GetEL(veh); + Lights.UpdateSB(activeVeh); + break; + } + activeVeh.LightStage = LightStage.Off; + veh.ShouldVehiclesYieldToThisVehicle = true; + veh.EmergencyLightingOverride = Vehicles.GetEL(veh); + veh.IsSirenOn = false; + } + Lights.UpdateSB(activeVeh); + continue; + } + Lights.MoveUpStageTA(activeVeh); + } + else if (Controls.IsDLSControlDown(DLSControls.LIGHT_SBURN) + && vehDLS.SpecialModes.SteadyBurn.SteadyBurnEnabled.ToBoolean()) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.SBOn = !activeVeh.SBOn; + if (activeVeh.SBOn && activeVeh.LightStage == LightStage.Off) + { + activeVeh.LightStage = LightStage.Empty; + veh.ShouldVehiclesYieldToThisVehicle = false; + veh.EmergencyLightingOverride = Vehicles.GetEL(veh); + if (activeVeh.TAStage != TAStage.Off) + Lights.UpdateTA(true, activeVeh); + veh.IsSirenOn = true; + veh.IsSirenSilent = true; + } + else if (!activeVeh.SBOn && activeVeh.LightStage == LightStage.Empty) + { + if (activeVeh.TAStage != TAStage.Off) + { + veh.EmergencyLightingOverride = Vehicles.GetEL(veh); + Lights.UpdateTA(true, activeVeh); + break; + } + activeVeh.LightStage = LightStage.Off; + veh.ShouldVehiclesYieldToThisVehicle = true; + veh.EmergencyLightingOverride = Vehicles.GetEL(veh); + veh.IsSirenOn = false; + } + else if (activeVeh.SBOn && activeVeh.LightStage != LightStage.Off) + { + + } + Lights.UpdateSB(activeVeh); + } + else if (Controls.IsDLSControlDown(DLSControls.LIGHT_INTLT)) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + Lights.ToggleIntLight(activeVeh); + } + else if (Entrypoint.IndEnabled + && Controls.IsDLSControlDown(DLSControls.LIGHT_INDL)) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + if (activeVeh.IndStatus == IndStatus.Left) + activeVeh.IndStatus = IndStatus.Off; + else + activeVeh.IndStatus = IndStatus.Left; + Lights.UpdateIndicator(activeVeh); + } + else if (Entrypoint.IndEnabled + && Controls.IsDLSControlDown(DLSControls.LIGHT_INDR)) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + if (activeVeh.IndStatus == IndStatus.Right) + activeVeh.IndStatus = IndStatus.Off; + else + activeVeh.IndStatus = IndStatus.Right; + Lights.UpdateIndicator(activeVeh); + } + else if (Entrypoint.IndEnabled + && Controls.IsDLSControlDown(DLSControls.LIGHT_HAZRD)) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + if (activeVeh.IndStatus == IndStatus.Both) + activeVeh.IndStatus = IndStatus.Off; + else + activeVeh.IndStatus = IndStatus.Both; + Lights.UpdateIndicator(activeVeh); + } + #endregion Lights Manager + #region Siren Manager + if (activeVeh.SirenStage == SirenStage.Off) + { + if (tone1ButtonDown) + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.One)) + { + activeVeh.SirenStage = SirenStage.One; + Utils.Sirens.Update(activeVeh); + + manActive = false; + } + } + else if (tone2ButtonDown) + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Two)) + { + activeVeh.SirenStage = SirenStage.Two; + Utils.Sirens.Update(activeVeh); + + manActive = false; + } + } + else if (tone3ButtonDown) + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning)) + { + activeVeh.SirenStage = SirenStage.Warning; + Utils.Sirens.Update(activeVeh); + + manActive = false; + } + } + else if (tone4ButtonDown) + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning2)) + { + activeVeh.SirenStage = SirenStage.Warning2; + Utils.Sirens.Update(activeVeh); + + manActive = false; + } + } + else if (manButtonDown && !hornButtonDown) + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.One)) + activeVeh.SirenStage = SirenStage.One; + else if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Two)) + activeVeh.SirenStage = SirenStage.Two; + else if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning)) + activeVeh.SirenStage = SirenStage.Warning; + else if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning2)) + activeVeh.SirenStage = SirenStage.Warning2; + Utils.Sirens.Update(activeVeh); + + manActive = true; + } + else if (manButtonDown && hornButtonDown) + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Two)) + activeVeh.SirenStage = SirenStage.Two; + else if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning)) + activeVeh.SirenStage = SirenStage.Warning; + else if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning2)) + activeVeh.SirenStage = SirenStage.Warning2; + Utils.Sirens.Update(activeVeh); + + manActive = true; + } + else if (!manButtonDown && hornButtonDown) + { + activeVeh.SirenStage = SirenStage.Horn; + Utils.Sirens.Update(activeVeh); + hornButtonDown = true; + manActive = true; + } + } + else if (manActive) + { + if (manButtonDown && !hornButtonDown) + { + if (activeVeh.SirenStage != SirenStage.One) + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.One)) + activeVeh.SirenStage = SirenStage.One; + else if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Two)) + activeVeh.SirenStage = SirenStage.Two; + else if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning)) + activeVeh.SirenStage = SirenStage.Warning; + else if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning2)) + activeVeh.SirenStage = SirenStage.Warning2; + Utils.Sirens.Update(activeVeh); + } + } + else if (manButtonDown && hornButtonDown) + { + if (activeVeh.SirenStage != SirenStage.Two) + { + activeVeh.SirenStage = SirenStage.Two; + Utils.Sirens.Update(activeVeh); + } + } + else if (!manButtonDown && hornButtonDown) + { + if (activeVeh.SirenStage != SirenStage.Horn) + { + activeVeh.SirenStage = SirenStage.Horn; + Utils.Sirens.Update(activeVeh); + } + } + else + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh); + hornButtonDown = false; + manActive = false; + } + } + else + { + if (!ahrnInterruptsSiren) + { + if (hornButtonDown) + { + if (!activeVeh.HornOn) + { + activeVeh.HornID = Sound.TempSoundID(); + activeVeh.HornOn = true; + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(activeVeh.HornID, vehDLS.SoundSettings.Horn, activeVeh.Vehicle, 0, 0, 0); + } + } + else if (activeVeh.HornOn) + { + Sound.ClearTempSoundID(activeVeh.HornID); + activeVeh.HornOn = false; + } + } + + if (hornButtonDown && ahrnInterruptsSiren) + { + if (sirenStageBeforeHorn == SirenStage.Off) + { + sirenStageBeforeHorn = activeVeh.SirenStage; + } + if (activeVeh.SirenStage != SirenStage.Horn) + { + activeVeh.SirenStage = SirenStage.Horn; + activeVeh.HornOn = true; + Utils.Sirens.Update(activeVeh); + } + } + else if (manButtonDown) + { + if (sirenStageBeforeHorn == SirenStage.Off) + { + sirenStageBeforeHorn = activeVeh.SirenStage; + } + if (activeVeh.SirenStage != Utils.Sirens.GetNextStage(sirenStageBeforeHorn, vehDLS)) + { + activeVeh.SirenStage = Utils.Sirens.GetNextStage(sirenStageBeforeHorn, vehDLS); + Utils.Sirens.Update(activeVeh); + } + } + else if (sirenStageBeforeHorn != SirenStage.Off) + { + activeVeh.SirenStage = sirenStageBeforeHorn; + Utils.Sirens.Update(activeVeh); + + sirenStageBeforeHorn = SirenStage.Off; + } + + if (sirenStageBeforeHorn == SirenStage.Off) + { + if (tone1ButtonDown) + { + if (activeVeh.SirenStage == SirenStage.One) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh); + } + else + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.One)) + { + activeVeh.SirenStage = SirenStage.One; + Utils.Sirens.Update(activeVeh); + } + } + } + else if (tone2ButtonDown) + { + if (activeVeh.SirenStage == SirenStage.Two) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh); + } + else + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Two)) + { + activeVeh.SirenStage = SirenStage.Two; + Utils.Sirens.Update(activeVeh); + } + } + } + else if (tone3ButtonDown) + { + if (activeVeh.SirenStage == SirenStage.Warning) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh); + } + else + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning)) + { + activeVeh.SirenStage = SirenStage.Warning; + Utils.Sirens.Update(activeVeh); + } + } + } + else if (tone4ButtonDown) + { + if (activeVeh.SirenStage == SirenStage.Warning2) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh); + } + else + { + if (vehDLS.DoesVehicleHaveSirenStage(SirenStage.Warning2)) + { + activeVeh.SirenStage = SirenStage.Warning2; + Utils.Sirens.Update(activeVeh); + } + } + } + } + } + if (Controls.IsDLSControlDown(DLSControls.SIREN_AUX)) + { + if (activeVeh.AuxOn) + { + Sound.ClearTempSoundID(activeVeh.AuxID); + activeVeh.AuxOn = false; + } + else + { + activeVeh.AuxID = Sound.TempSoundID(); + activeVeh.AuxOn = true; + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(activeVeh.AuxID, vehDLS.SoundSettings.Tone1, activeVeh.Vehicle, 0, 0, 0); + } + } + else if (activeVeh.LightStage != LightStage.Off + && Controls.IsDLSControlDown(DLSControls.SIREN_TOGGLE)) + { + if (activeVeh.SirenStage == SirenStage.Off) + { + Utils.Sirens.MoveUpStage(activeVeh, true); + } + else + { + activeVeh.SirenStage = SirenStage.Off; + activeVeh.IsScanOn = false; + Utils.Sirens.Update(activeVeh); + } + } + else if (Controls.IsDLSControlDown(DLSControls.SIREN_SCAN)) + { + if (!activeVeh.IsScanOn) + { + scanTimer.Start(); + scanTiming = random.Next(2, 8); + activeVeh.SirenStage = vehDLS.AvailableSirenStages[random.Next(1, vehDLS.AvailableSirenStages.Count - 1)]; + Utils.Sirens.Update(activeVeh); + } + if (activeVeh.IsScanOn) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh); + } + activeVeh.IsScanOn = !activeVeh.IsScanOn; + } + if (activeVeh.IsScanOn && !(manButtonDown || (vehDLS.SoundSettings.AirHornInterruptsSiren.ToBoolean() && hornButtonDown)) && scanTimer.ElapsedMilliseconds >= (scanTiming * 1000)) + { + scanTimer.Restart(); + scanTiming = random.Next(2, 8); + SirenStage old = activeVeh.SirenStage; + SirenStage _new = vehDLS.AvailableSirenStages[random.Next(1, vehDLS.AvailableSirenStages.Count)]; + while (old == _new) + { + GameFiber.Yield(); + _new = vehDLS.AvailableSirenStages[random.Next(1, vehDLS.AvailableSirenStages.Count)]; + } + activeVeh.SirenStage = _new; + Utils.Sirens.Update(activeVeh); + } + if (activeVeh.IsScanOn && (tone1ButtonDown || tone2ButtonDown || tone3ButtonDown || tone4ButtonDown)) + activeVeh.IsScanOn = false; + if (!activeVeh.IsScanOn && scanTimer.IsRunning) + scanTimer.Reset(); + #endregion Siren Manager + } + } + else + { + #region Lights Manager + if ((Game.IsKeyDown(Keys.F) || Game.IsControllerButtonDown(ControllerButtons.Y)) + && Vehicles.GetSirenKill(activeVeh) && activeVeh.SirenStage != SirenStage.Off) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh); + } + if (Controls.IsDLSControlDown(DLSControls.LIGHT_TOGGLE)) + { + switch (veh.IsSirenOn) + { + case true: + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.LightStage = LightStage.Off; + veh.IsSirenOn = false; + activeVeh.SirenStage = SirenStage.Off; + activeVeh.IsScanOn = false; + Utils.Sirens.Update(activeVeh); + break; + case false: + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.LightStage = LightStage.Three; + veh.IsSirenOn = true; + veh.IsSirenSilent = true; + break; + } + } + else if (Controls.IsDLSControlDown(DLSControls.LIGHT_INTLT)) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + Lights.ToggleIntLight(activeVeh); + } + else if (Entrypoint.IndEnabled + && Controls.IsDLSControlDown(DLSControls.LIGHT_INDL)) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + if (activeVeh.IndStatus == IndStatus.Left) + activeVeh.IndStatus = IndStatus.Off; + else + activeVeh.IndStatus = IndStatus.Left; + Lights.UpdateIndicator(activeVeh); + } + else if (Entrypoint.IndEnabled + && Controls.IsDLSControlDown(DLSControls.LIGHT_INDR)) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + if (activeVeh.IndStatus == IndStatus.Right) + activeVeh.IndStatus = IndStatus.Off; + else + activeVeh.IndStatus = IndStatus.Right; + Lights.UpdateIndicator(activeVeh); + } + else if (Entrypoint.IndEnabled + && Controls.IsDLSControlDown(DLSControls.LIGHT_HAZRD)) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + if (activeVeh.IndStatus == IndStatus.Both) + activeVeh.IndStatus = IndStatus.Off; + else + activeVeh.IndStatus = IndStatus.Both; + Lights.UpdateIndicator(activeVeh); + } + #endregion Lights Manager + #region Siren Manager + if (activeVeh.SirenStage == SirenStage.Off) + { + if (tone1ButtonDown) + { + activeVeh.SirenStage = SirenStage.One; + Utils.Sirens.Update(activeVeh, false); + + manActive = false; + } + else if (tone2ButtonDown) + { + activeVeh.SirenStage = SirenStage.Two; + Utils.Sirens.Update(activeVeh, false); + + manActive = false; + } + else if (tone3ButtonDown) + { + activeVeh.SirenStage = SirenStage.Warning; + Utils.Sirens.Update(activeVeh, false); + + manActive = false; + } + else if (tone4ButtonDown) + { + activeVeh.SirenStage = SirenStage.Warning2; + Utils.Sirens.Update(activeVeh, false); + + manActive = false; + } + else if (manButtonDown && !hornButtonDown) + { + activeVeh.SirenStage = SirenStage.One; + Utils.Sirens.Update(activeVeh, false); + + manActive = true; + } + else if (manButtonDown && hornButtonDown) + { + activeVeh.SirenStage = SirenStage.Two; + Utils.Sirens.Update(activeVeh, false); + + manActive = true; + } + else if (!manButtonDown && hornButtonDown) + { + activeVeh.SirenStage = SirenStage.Horn; + Utils.Sirens.Update(activeVeh, false); + + manActive = true; + } + } + else if (manActive) + { + if (manButtonDown && !hornButtonDown) + { + if (activeVeh.SirenStage != SirenStage.One) + { + activeVeh.SirenStage = SirenStage.One; + Utils.Sirens.Update(activeVeh, false); + } + } + else if (manButtonDown && hornButtonDown) + { + if (activeVeh.SirenStage != SirenStage.Two) + { + activeVeh.SirenStage = SirenStage.Two; + Utils.Sirens.Update(activeVeh, false); + } + } + else if (!manButtonDown && hornButtonDown) + { + if (activeVeh.SirenStage != SirenStage.Horn) + { + activeVeh.SirenStage = SirenStage.Horn; + Utils.Sirens.Update(activeVeh, false); + } + } + else + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh, false); + manActive = false; + } + } + else + { + if (hornButtonDown) + { + if (sirenStageBeforeHorn == SirenStage.Off) + { + sirenStageBeforeHorn = activeVeh.SirenStage; + } + if (activeVeh.SirenStage != SirenStage.Horn) + { + activeVeh.SirenStage = SirenStage.Horn; + Utils.Sirens.Update(activeVeh, false); + } + } + else if (manButtonDown) + { + if (sirenStageBeforeHorn == SirenStage.Off) + { + sirenStageBeforeHorn = activeVeh.SirenStage; + } + if (activeVeh.SirenStage != Utils.Sirens.GetNextStage(sirenStageBeforeHorn)) + { + activeVeh.SirenStage = Utils.Sirens.GetNextStage(sirenStageBeforeHorn); + Utils.Sirens.Update(activeVeh, false); + } + } + else if (sirenStageBeforeHorn != SirenStage.Off) + { + activeVeh.SirenStage = sirenStageBeforeHorn; + Utils.Sirens.Update(activeVeh, false); + + sirenStageBeforeHorn = SirenStage.Off; + } + + if (sirenStageBeforeHorn == SirenStage.Off) + { + if (tone1ButtonDown) + { + if (activeVeh.SirenStage == SirenStage.One) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh, false); + } + else + { + activeVeh.SirenStage = SirenStage.One; + Utils.Sirens.Update(activeVeh, false); + } + } + else if (tone2ButtonDown) + { + if (activeVeh.SirenStage == SirenStage.Two) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh, false); + } + else + { + activeVeh.SirenStage = SirenStage.Two; + Utils.Sirens.Update(activeVeh, false); + } + } + else if (tone3ButtonDown) + { + if (activeVeh.SirenStage == SirenStage.Warning) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh, false); + } + else + { + activeVeh.SirenStage = SirenStage.Warning; + Utils.Sirens.Update(activeVeh, false); + } + } + else if (tone4ButtonDown) + { + if (activeVeh.SirenStage == SirenStage.Warning2) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh, false); + } + else + { + activeVeh.SirenStage = SirenStage.Warning2; + Utils.Sirens.Update(activeVeh, false); + } + } + } + } + if (Controls.IsDLSControlDown(DLSControls.SIREN_AUX)) + { + if (activeVeh.AuxOn) + { + Sound.ClearTempSoundID(activeVeh.AuxID); + activeVeh.AuxOn = false; + } + else + { + activeVeh.AuxID = Sound.TempSoundID(); + activeVeh.AuxOn = true; + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(activeVeh.AuxID, "VEHICLES_HORNS_SIREN_1", activeVeh.Vehicle, 0, 0, 0); + } + } + else if (activeVeh.LightStage != LightStage.Off + && Controls.IsDLSControlDown(DLSControls.SIREN_TOGGLE)) + { + if (activeVeh.SirenStage == SirenStage.Off) + Utils.Sirens.MoveUpStage(activeVeh); + else + { + activeVeh.SirenStage = SirenStage.Off; + activeVeh.IsScanOn = false; + Utils.Sirens.Update(activeVeh); + } + } + else if (Controls.IsDLSControlDown(DLSControls.SIREN_SCAN)) + { + if (!activeVeh.IsScanOn) + { + scanTimer.Start(); + scanTiming = random.Next(2, 8); + activeVeh.SirenStage = (SirenStage)random.Next(1, 4); + Utils.Sirens.Update(activeVeh, false); + } + if (activeVeh.IsScanOn) + { + activeVeh.SirenStage = SirenStage.Off; + Utils.Sirens.Update(activeVeh, false); + } + activeVeh.IsScanOn = !activeVeh.IsScanOn; + } + if (activeVeh.IsScanOn && !manButtonDown && !hornButtonDown && scanTimer.ElapsedMilliseconds >= (scanTiming * 1000)) + { + scanTimer.Restart(); + scanTiming = random.Next(2, 8); + SirenStage old = activeVeh.SirenStage; + SirenStage _new = (SirenStage)random.Next(1, 4); + while (old == _new) + { + GameFiber.Yield(); + _new = (SirenStage)random.Next(1, 4); + } + activeVeh.SirenStage = _new; + Utils.Sirens.Update(activeVeh, false); + } + if (activeVeh.IsScanOn && (tone1ButtonDown || tone2ButtonDown || tone3ButtonDown || tone4ButtonDown)) + activeVeh.IsScanOn = false; + if (!activeVeh.IsScanOn && scanTimer.IsRunning) + scanTimer.Reset(); + #endregion Siren Manager + } + } + } + } + } + } + } +} diff --git a/DLS/Threads/SpecialModesManager.cs b/DLS/Threads/SpecialModesManager.cs new file mode 100644 index 0000000..308e518 --- /dev/null +++ b/DLS/Threads/SpecialModesManager.cs @@ -0,0 +1,171 @@ +using DLS.Utils; +using Rage; +using System; + +namespace DLS.Threads +{ + class SpecialModesManager + { + public static void ProcessAI() + { + uint lastProcessTime = Game.GameTime; + int timeBetweenChecks = 500; + int yieldAfterChecks = 50; + + while (true) + { + int checksDone = 0; + + if (Entrypoint.AILightsC) + { + Vehicle[] allWorldVehicles = World.GetAllVehicles(); + foreach (Vehicle veh in allWorldVehicles) + { + if (veh && veh.HasSiren && veh.GetDLS() != null && !veh.IsPlayerVehicle()) + { + if (veh.GetActiveVehicle() == null) + { + if (veh.IsSirenOn) + { + if (!veh.IsSirenSilent) + Entrypoint.activeVehicles.Add(new ActiveVehicle(veh, false, LightStage.Three, SirenStage.One)); + else + Entrypoint.activeVehicles.Add(new ActiveVehicle(veh, false, LightStage.Three, SirenStage.Off)); + } + else + Entrypoint.activeVehicles.Add(new ActiveVehicle(veh, false)); + } + ActiveVehicle activeVeh = veh.GetActiveVehicle(); + DLSModel dlsModel; + if (veh) + dlsModel = veh.GetDLS(); + else + dlsModel = null; + if (veh.IsSirenOn && veh.IsSirenSilent == false && activeVeh.SirenStage == SirenStage.Off) + activeVeh.SirenStage = SirenStage.One; + if (veh.IsSirenOn && activeVeh.LightStage == LightStage.Off) + activeVeh.LightStage = LightStage.Three; + if (dlsModel != null && dlsModel.SpecialModes.PresetSirenOnLeaveVehicle != "none" + && veh.IsSirenOn) + { + if (!veh.HasDriver) + { + if (!veh.IsEngineOn) + veh.IsEngineOn = true; + string presetSiren = dlsModel.SpecialModes.PresetSirenOnLeaveVehicle; + switch (presetSiren) + { + case "stage1": + if (activeVeh.LightStage != LightStage.One) + { + activeVeh.LightStage = LightStage.One; + Lights.Update(activeVeh); + } + break; + case "stage2": + if (activeVeh.LightStage != LightStage.Two) + { + activeVeh.LightStage = LightStage.Two; + Lights.Update(activeVeh); + } + break; + case "stage3": + if (activeVeh.LightStage != LightStage.Three) + { + activeVeh.LightStage = LightStage.Three; + Lights.Update(activeVeh); + } + break; + case "custom1": + if (activeVeh.LightStage != LightStage.CustomOne) + { + activeVeh.LightStage = LightStage.CustomOne; + Lights.Update(activeVeh); + } + break; + case "custom2": + if (activeVeh.LightStage != LightStage.CustomTwo) + { + activeVeh.LightStage = LightStage.CustomTwo; + Lights.Update(activeVeh); + } + break; + } + } + + if (dlsModel.DoesVehicleHaveLightStage(LightStage.Three) + && veh.HasDriver + && veh.EmergencyLighting.Name != dlsModel.Name + " | " + activeVeh.LightStage.ToString() + " | " + activeVeh.TAStage.ToString() + " | " + activeVeh.SBOn.ToString()) + { + activeVeh.LightStage = LightStage.Three; + Lights.Update(activeVeh); + } + } + } + } + + checksDone++; + if (checksDone % yieldAfterChecks == 0) + { + GameFiber.Yield(); + } + } + GameFiber.Sleep((int)Math.Max(timeBetweenChecks, Game.GameTime - lastProcessTime)); + lastProcessTime = Game.GameTime; + } + } + + public static void ProcessPlayer() + { + uint lastProcessTime = Game.GameTime; + int timeBetweenChecks = 100; + while (true) + { + Vehicle veh = Game.LocalPlayer.Character.CurrentVehicle; + if (veh && veh.HasSiren && veh.GetDLS() != null) + { + if (veh.GetActiveVehicle() == null) + { + if (veh.IsSirenOn) + { + if (!veh.IsSirenSilent) + Entrypoint.activeVehicles.Add(new ActiveVehicle(veh, true, LightStage.Three, SirenStage.One)); + else + Entrypoint.activeVehicles.Add(new ActiveVehicle(veh, true, LightStage.Three, SirenStage.Off)); + } + else + Entrypoint.activeVehicles.Add(new ActiveVehicle(veh, true)); + } + ActiveVehicle activeVeh = veh.GetActiveVehicle(); + DLSModel vehDLS; + if (veh) + vehDLS = veh.GetDLS(); + else + vehDLS = null; + if (vehDLS.SpecialModes.WailSetup.WailSetupEnabled.ToBoolean()) + { + if (activeVeh.LightStage != LightStage.Off && activeVeh.LightStage != LightStage.Empty + && activeVeh.SirenStage == (SirenStage)vehDLS.SpecialModes.WailSetup.WailSirenTone.ToInt32() + && activeVeh.LightStage != (LightStage)vehDLS.SpecialModes.WailSetup.WailLightStage.ToInt32()) + { + activeVeh.TempWailLightStage = activeVeh.LightStage; + activeVeh.LightStage = (LightStage)vehDLS.SpecialModes.WailSetup.WailLightStage.ToInt32(); + Lights.Update(activeVeh); + activeVeh.Wailing = true; + } + if (activeVeh.Wailing + && activeVeh.SirenStage != (SirenStage)vehDLS.SpecialModes.WailSetup.WailSirenTone.ToInt32()) + { + activeVeh.LightStage = veh.GetActiveVehicle().TempWailLightStage; + Lights.Update(activeVeh); + activeVeh.Wailing = false; + } + } + } + GameFiber.Sleep((int)Math.Max(timeBetweenChecks, Game.GameTime - lastProcessTime)); + lastProcessTime = Game.GameTime; + } + } + } +} + diff --git a/DLS/Threads/UIManager.cs b/DLS/Threads/UIManager.cs new file mode 100644 index 0000000..4788dcf --- /dev/null +++ b/DLS/Threads/UIManager.cs @@ -0,0 +1,425 @@ +using DLS.UI; +using DLS.Utils; +using Rage; +using System.Drawing; + +namespace DLS.Threads +{ + internal static class UIManager + { + internal static int sizeX = 550; + internal static int sizeY = 220; + + internal static bool IsUIOn = false; + + // Background (printed first) + internal static Sprite Background = new Sprite(Properties.Resources.background, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Horn + internal static Sprite Horn_On = new Sprite(Properties.Resources.horn_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Horn_Off = new Sprite(Properties.Resources.horn_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Manual + internal static Sprite Manual_On = new Sprite(Properties.Resources.manual_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Manual_Off = new Sprite(Properties.Resources.manual_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Wail + internal static Sprite Wail_On = new Sprite(Properties.Resources.wail_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Wail_Off = new Sprite(Properties.Resources.wail_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Yelp + internal static Sprite Yelp_On = new Sprite(Properties.Resources.yelp_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Yelp_Off = new Sprite(Properties.Resources.yelp_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Hi-lo + internal static Sprite Ext1_On = new Sprite(Properties.Resources.ext1_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Ext1_Off = new Sprite(Properties.Resources.ext1_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Phaser + internal static Sprite Ext2_On = new Sprite(Properties.Resources.ext2_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Ext2_Off = new Sprite(Properties.Resources.ext2_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Hazards + internal static Sprite Hazard_On = new Sprite(Properties.Resources.hazard_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Hazard_Off = new Sprite(Properties.Resources.hazard_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Left Indicator + internal static Sprite Lind_On = new Sprite(Properties.Resources.lind_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Lind_Off = new Sprite(Properties.Resources.lind_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Right Indicator + internal static Sprite Rind_On = new Sprite(Properties.Resources.rind_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Rind_Off = new Sprite(Properties.Resources.rind_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Stage 1 + internal static Sprite S1_On = new Sprite(Properties.Resources.s1_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite S1_Off = new Sprite(Properties.Resources.s1_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Stage 2 + internal static Sprite S2_On = new Sprite(Properties.Resources.s2_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite S2_Off = new Sprite(Properties.Resources.s2_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Stage 3 + internal static Sprite S3_On = new Sprite(Properties.Resources.s3_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite S3_Off = new Sprite(Properties.Resources.s3_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // TA Left + internal static Sprite Taleft_On = new Sprite(Properties.Resources.taleft_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Taleft_Off = new Sprite(Properties.Resources.taleft_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // TA Right + internal static Sprite Taright_On = new Sprite(Properties.Resources.taright_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Taright_Off = new Sprite(Properties.Resources.taright_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // TA Diverge + internal static Sprite Tadiv_On = new Sprite(Properties.Resources.tadiv_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Tadiv_Off = new Sprite(Properties.Resources.tadiv_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // TA Warn + internal static Sprite Tawarn_On = new Sprite(Properties.Resources.tawarn_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Tawarn_Off = new Sprite(Properties.Resources.tawarn_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Interior Light + internal static Sprite Intlt_On = new Sprite(Properties.Resources.intlt_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Intlt_Off = new Sprite(Properties.Resources.intlt_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Steady Burn + internal static Sprite SB_On = new Sprite(Properties.Resources.sb_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite SB_Off = new Sprite(Properties.Resources.sb_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Steady Burn + internal static Sprite Blkt_On = new Sprite(Properties.Resources.blkt_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite Blkt_Off = new Sprite(Properties.Resources.blkt_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + // Traffic Advisories + internal static Sprite _3_l_On = new Sprite(Properties.Resources._3_l_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _3_l_Off = new Sprite(Properties.Resources._3_l_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _3_c_On = new Sprite(Properties.Resources._3_c_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _3_c_Off = new Sprite(Properties.Resources._3_c_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _3_r_On = new Sprite(Properties.Resources._3_r_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _3_r_Off = new Sprite(Properties.Resources._3_r_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + + internal static Sprite _4_l_On = new Sprite(Properties.Resources._4_l_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _4_l_Off = new Sprite(Properties.Resources._4_l_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _4_cl_On = new Sprite(Properties.Resources._4_cl_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _4_cl_Off = new Sprite(Properties.Resources._4_cl_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _4_cr_On = new Sprite(Properties.Resources._4_cr_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _4_cr_Off = new Sprite(Properties.Resources._4_cr_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _4_r_On = new Sprite(Properties.Resources._4_r_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _4_r_Off = new Sprite(Properties.Resources._4_r_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + + internal static Sprite _5_l_On = new Sprite(Properties.Resources._5_l_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _5_l_Off = new Sprite(Properties.Resources._5_l_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _5_cl_On = new Sprite(Properties.Resources._5_cl_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _5_cl_Off = new Sprite(Properties.Resources._5_cl_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _5_c_On = new Sprite(Properties.Resources._5_c_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _5_c_Off = new Sprite(Properties.Resources._5_c_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _5_cr_On = new Sprite(Properties.Resources._5_cr_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _5_cr_Off = new Sprite(Properties.Resources._5_cr_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _5_r_On = new Sprite(Properties.Resources._5_r_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _5_r_Off = new Sprite(Properties.Resources._5_r_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + + internal static Sprite _6_l_On = new Sprite(Properties.Resources._6_l_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_l_Off = new Sprite(Properties.Resources._6_l_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_el_On = new Sprite(Properties.Resources._6_el_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_el_Off = new Sprite(Properties.Resources._6_el_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_cl_On = new Sprite(Properties.Resources._6_cl_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_cl_Off = new Sprite(Properties.Resources._6_cl_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_cr_On = new Sprite(Properties.Resources._6_cr_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_cr_Off = new Sprite(Properties.Resources._6_cr_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_er_On = new Sprite(Properties.Resources._6_er_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_er_Off = new Sprite(Properties.Resources._6_er_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_r_On = new Sprite(Properties.Resources._6_r_on, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + internal static Sprite _6_r_Off = new Sprite(Properties.Resources._6_r_off, new System.Drawing.Point(1920 - sizeX, 1080 - sizeY), new System.Drawing.Size(sizeX, sizeY)); + + internal static void Process() + { + sizeX = Settings.ReadKey("UI", "Width").ToInt32(); + sizeY = Settings.ReadKey("UI", "Height").ToInt32(); + Importer.GetCustomSprites(); + _ = UIHelper.player; + Game.RawFrameRender += RawFrameRender; + } + + static void RawFrameRender(object sender, GraphicsEventArgs e) + { + int w = Game.Resolution.Width; + int h = Game.Resolution.Height; + string text = "Warning - DLS Key Lock Active"; + float size = 16.0f; + SizeF graphicSize = Rage.Graphics.MeasureText(text, "Arial Bold", size); + if (!Game.IsPaused && Entrypoint.keysLocked) + { + if (IsUIOn) + e.Graphics.DrawText(text, "Arial Bold", size, new PointF(w - graphicSize.Width - 8, h + graphicSize.Height - sizeY), Color.DarkRed); + else + e.Graphics.DrawText(text, "Arial Bold", size, new PointF(w - graphicSize.Width - 8, h - graphicSize.Height - 8), Color.DarkRed); + } + Ped player = UIHelper.player; + if (IsUIOn && UIHelper.IsUIAbleToDisplay && UIHelper.IsInAnyVehicle) + { + Vehicle veh = UIHelper.currentVehicle; + if (UIHelper.IsUIAbleToDisplay && UIHelper.IsVehicleValid && UIHelper.IsPlayerDriver + && (UIHelper.dlsModel != null || Entrypoint.SCforNDLS) + && UIHelper.activeVeh != null) + { + ActiveVehicle aVeh = UIHelper.activeVeh; + Background.Draw(e.Graphics); + if (Entrypoint.IndEnabled) + { + switch (aVeh.IndStatus) + { + case IndStatus.Off: + Hazard_Off.Draw(e.Graphics); + Lind_Off.Draw(e.Graphics); + Rind_Off.Draw(e.Graphics); + break; + case IndStatus.Both: + Hazard_On.Draw(e.Graphics); + Lind_Off.Draw(e.Graphics); + Rind_Off.Draw(e.Graphics); + break; + case IndStatus.Left: + Hazard_Off.Draw(e.Graphics); + Lind_On.Draw(e.Graphics); + Rind_Off.Draw(e.Graphics); + break; + case IndStatus.Right: + Hazard_Off.Draw(e.Graphics); + Lind_Off.Draw(e.Graphics); + Rind_On.Draw(e.Graphics); + break; + default: + Hazard_Off.Draw(e.Graphics); + Lind_Off.Draw(e.Graphics); + Rind_Off.Draw(e.Graphics); + break; + } + } + else + { + Hazard_Off.Draw(e.Graphics); + Lind_Off.Draw(e.Graphics); + Rind_Off.Draw(e.Graphics); + } + switch (aVeh.SirenStage) + { + case SirenStage.Off: + Wail_Off.Draw(e.Graphics); + Yelp_Off.Draw(e.Graphics); + Ext1_Off.Draw(e.Graphics); + Ext2_Off.Draw(e.Graphics); + break; + case SirenStage.One: + Wail_On.Draw(e.Graphics); + Yelp_Off.Draw(e.Graphics); + Ext1_Off.Draw(e.Graphics); + Ext2_Off.Draw(e.Graphics); + break; + case SirenStage.Two: + Wail_Off.Draw(e.Graphics); + Yelp_On.Draw(e.Graphics); + Ext1_Off.Draw(e.Graphics); + Ext2_Off.Draw(e.Graphics); + break; + case SirenStage.Warning: + Wail_Off.Draw(e.Graphics); + Yelp_Off.Draw(e.Graphics); + Ext1_On.Draw(e.Graphics); + Ext2_Off.Draw(e.Graphics); + break; + case SirenStage.Warning2: + Wail_Off.Draw(e.Graphics); + Yelp_Off.Draw(e.Graphics); + Ext1_Off.Draw(e.Graphics); + Ext2_On.Draw(e.Graphics); + break; + case SirenStage.Horn: + Wail_Off.Draw(e.Graphics); + Yelp_Off.Draw(e.Graphics); + Ext1_Off.Draw(e.Graphics); + Ext2_Off.Draw(e.Graphics); + break; + default: + Wail_Off.Draw(e.Graphics); + Yelp_Off.Draw(e.Graphics); + Ext1_Off.Draw(e.Graphics); + Ext2_Off.Draw(e.Graphics); + break; + } + switch (aVeh.LightStage) + { + case LightStage.Off: + S1_Off.Draw(e.Graphics); + S2_Off.Draw(e.Graphics); + S3_Off.Draw(e.Graphics); + break; + case LightStage.One: + S1_On.Draw(e.Graphics); + S2_Off.Draw(e.Graphics); + S3_Off.Draw(e.Graphics); + break; + case LightStage.Two: + S1_Off.Draw(e.Graphics); + S2_On.Draw(e.Graphics); + S3_Off.Draw(e.Graphics); + break; + case LightStage.Three: + S1_Off.Draw(e.Graphics); + S2_Off.Draw(e.Graphics); + S3_On.Draw(e.Graphics); + break; + default: + S1_Off.Draw(e.Graphics); + S2_Off.Draw(e.Graphics); + S3_Off.Draw(e.Graphics); + break; + } + switch (aVeh.TAStage) + { + case TAStage.Off: + Taleft_Off.Draw(e.Graphics); + Tadiv_Off.Draw(e.Graphics); + Taright_Off.Draw(e.Graphics); + Tawarn_Off.Draw(e.Graphics); + break; + case TAStage.Left: + Taleft_On.Draw(e.Graphics); + Tadiv_Off.Draw(e.Graphics); + Taright_Off.Draw(e.Graphics); + Tawarn_Off.Draw(e.Graphics); + break; + case TAStage.Diverge: + Taleft_Off.Draw(e.Graphics); + Tadiv_On.Draw(e.Graphics); + Taright_Off.Draw(e.Graphics); + Tawarn_Off.Draw(e.Graphics); + break; + case TAStage.Right: + Taleft_Off.Draw(e.Graphics); + Tadiv_Off.Draw(e.Graphics); + Taright_On.Draw(e.Graphics); + Tawarn_Off.Draw(e.Graphics); + break; + case TAStage.Warn: + Taleft_Off.Draw(e.Graphics); + Tadiv_Off.Draw(e.Graphics); + Taright_Off.Draw(e.Graphics); + Tawarn_On.Draw(e.Graphics); + break; + default: + Taleft_Off.Draw(e.Graphics); + Tadiv_Off.Draw(e.Graphics); + Taright_Off.Draw(e.Graphics); + Tawarn_Off.Draw(e.Graphics); + break; + } + if (PlayerController.hornButtonDown) + Horn_On.Draw(e.Graphics); + else + Horn_Off.Draw(e.Graphics); + if (aVeh.SBOn) + SB_On.Draw(e.Graphics); + else + SB_Off.Draw(e.Graphics); + if (aVeh.IntLightOn) + Intlt_On.Draw(e.Graphics); + else + Intlt_Off.Draw(e.Graphics); + if (PlayerController.manButtonDown) + Manual_On.Draw(e.Graphics); + else + Manual_Off.Draw(e.Graphics); + if (PlayerController.blktOn) + Blkt_On.Draw(e.Graphics); + else + Blkt_Off.Draw(e.Graphics); + if (UIHelper.dlsModel != null) + { + DLSModel dlsModel = UIHelper.dlsModel; + switch (aVeh.TAType) + { + case "three": + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.l.ToInt32() - 1] == SirenStatus.On) + _3_l_On.Draw(e.Graphics); + else + _3_l_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.c.ToInt32() - 1] == SirenStatus.On) + _3_c_On.Draw(e.Graphics); + else + _3_c_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.r.ToInt32() - 1] == SirenStatus.On) + _3_r_On.Draw(e.Graphics); + else + _3_r_Off.Draw(e.Graphics); + break; + case "four": + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.l.ToInt32() - 1] == SirenStatus.On) + _4_l_On.Draw(e.Graphics); + else + _4_l_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.cl.ToInt32() - 1] == SirenStatus.On) + _4_cl_On.Draw(e.Graphics); + else + _4_cl_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.cr.ToInt32() - 1] == SirenStatus.On) + _4_cr_On.Draw(e.Graphics); + else + _4_cr_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.r.ToInt32() - 1] == SirenStatus.On) + _4_r_On.Draw(e.Graphics); + else + _4_r_Off.Draw(e.Graphics); + break; + case "five": + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.l.ToInt32() - 1] == SirenStatus.On) + _5_l_On.Draw(e.Graphics); + else + _5_l_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.cl.ToInt32() - 1] == SirenStatus.On) + _5_cl_On.Draw(e.Graphics); + else + _5_cl_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.c.ToInt32() - 1] == SirenStatus.On) + _5_c_On.Draw(e.Graphics); + else + _5_c_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.cr.ToInt32() - 1] == SirenStatus.On) + _5_cr_On.Draw(e.Graphics); + else + _5_cr_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.r.ToInt32() - 1] == SirenStatus.On) + _5_r_On.Draw(e.Graphics); + else + _5_r_Off.Draw(e.Graphics); + break; + case "six": + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.l.ToInt32() - 1] == SirenStatus.On) + _6_l_On.Draw(e.Graphics); + else + _6_l_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.el.ToInt32() - 1] == SirenStatus.On) + _6_el_On.Draw(e.Graphics); + else + _6_el_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.cl.ToInt32() - 1] == SirenStatus.On) + _6_cl_On.Draw(e.Graphics); + else + _6_cl_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.cr.ToInt32() - 1] == SirenStatus.On) + _6_cr_On.Draw(e.Graphics); + else + _6_cr_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.er.ToInt32() - 1] == SirenStatus.On) + _6_er_On.Draw(e.Graphics); + else + _6_er_Off.Draw(e.Graphics); + if (aVeh.TAStage != TAStage.Off && UIHelper.IsSirenOn[dlsModel.TrafficAdvisory.r.ToInt32() - 1] == SirenStatus.On) + _6_r_On.Draw(e.Graphics); + else + _6_r_Off.Draw(e.Graphics); + break; + default: + _6_l_Off.Draw(e.Graphics); + _6_el_Off.Draw(e.Graphics); + _6_cl_Off.Draw(e.Graphics); + _6_cr_Off.Draw(e.Graphics); + _6_er_Off.Draw(e.Graphics); + _6_r_Off.Draw(e.Graphics); + break; + } + } + else + { + _6_l_Off.Draw(e.Graphics); + _6_el_Off.Draw(e.Graphics); + _6_cl_Off.Draw(e.Graphics); + _6_cr_Off.Draw(e.Graphics); + _6_er_Off.Draw(e.Graphics); + _6_r_Off.Draw(e.Graphics); + } + } + } + } + } +} \ No newline at end of file diff --git a/DLS/TrafficAdvisory.cs b/DLS/TrafficAdvisory.cs new file mode 100644 index 0000000..762e374 --- /dev/null +++ b/DLS/TrafficAdvisory.cs @@ -0,0 +1,69 @@ +using System.Collections.Generic; +using System.Xml.Serialization; + +namespace DLS +{ + [XmlRoot("TAgroup")] + public class TAgroup + { + [XmlElement("TApattern")] + public List TaPatterns; + } + + public class TApattern + { + [XmlAttribute("name")] + public string Name; + + [XmlElement("Three")] + public TApatternNumber Three = new TApatternNumber(); + + [XmlElement("Four")] + public TApatternNumber Four = new TApatternNumber(); + + [XmlElement("Five")] + public TApatternNumber Five = new TApatternNumber(); + + [XmlElement("Six")] + public TApatternNumber Six = new TApatternNumber(); + } + + public class TApatternNumber + { + [XmlElement("Left")] + public DirectionTAPattern Left = new DirectionTAPattern(); + + [XmlElement("Diverge")] + public DirectionTAPattern Diverge = new DirectionTAPattern(); + + [XmlElement("Right")] + public DirectionTAPattern Right = new DirectionTAPattern(); + + [XmlElement("Warn")] + public DirectionTAPattern Warn = new DirectionTAPattern(); + } + + public class DirectionTAPattern + { + [XmlElement("L")] + public string L = "00000000000000000000000000000000"; + + [XmlElement("EL")] + public string EL = "00000000000000000000000000000000"; + + [XmlElement("CL")] + public string CL = "00000000000000000000000000000000"; + + [XmlElement("C")] + public string C = "00000000000000000000000000000000"; + + [XmlElement("CR")] + public string CR = "00000000000000000000000000000000"; + + [XmlElement("ER")] + public string ER = "00000000000000000000000000000000"; + + [XmlElement("R")] + public string R = "00000000000000000000000000000000"; + } +} \ No newline at end of file diff --git a/DLS/UI/CustomUI.cs b/DLS/UI/CustomUI.cs new file mode 100644 index 0000000..59682d7 --- /dev/null +++ b/DLS/UI/CustomUI.cs @@ -0,0 +1,18 @@ +using System.Xml.Serialization; + +namespace DLS.UI +{ + [XmlRoot("UI")] + public class CustomUI + { + [XmlElement("SWidth")] + public string SWidth { get; set; } = "550"; + + [XmlElement("SHeight")] + public string SHeight { get; set; } = "220"; + + public int Width { get; set; } + + public int Height { get; set; } + } +} diff --git a/DLS/UI/Importer.cs b/DLS/UI/Importer.cs new file mode 100644 index 0000000..cd82603 --- /dev/null +++ b/DLS/UI/Importer.cs @@ -0,0 +1,610 @@ +using DLS.Threads; +using DLS.Utils; +using Rage; +using System; +using System.IO; +using System.Xml.Serialization; + +namespace DLS.UI +{ + class Importer + { + public static void GetCustomSprites() + { + string path = @"Plugins\DLS\UI"; + CustomUI customUI = new CustomUI(); + customUI.Width = UIManager.sizeX; + customUI.Height = UIManager.sizeY; + if (File.Exists(path + @"\custom.xml")) + { + try + { + XmlSerializer mySerializer = new XmlSerializer(typeof(CustomUI)); + StreamReader streamReader = new StreamReader(path + @"\custom.xml"); + customUI = (CustomUI)mySerializer.Deserialize(streamReader); + streamReader.Close(); + customUI.Height = customUI.SHeight.ToInt32(); + customUI.Width = customUI.SWidth.ToInt32(); + } + catch (Exception e) + { + ("CUSTOM.xml ERROR: " + e.Message).ToLog(); + Game.LogTrivial("CUSTOM.xml ERROR: " + e.Message); + } + } + if (Directory.Exists(path)) + { + foreach (string file in Directory.EnumerateFiles(path, "*.png")) + { + switch (Path.GetFileNameWithoutExtension(file)) + { + case "background": + UIManager.Background = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "hazard_off": + UIManager.Hazard_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "hazard_on": + UIManager.Hazard_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "horn_off": + UIManager.Horn_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "horn_on": + UIManager.Horn_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "ext1_off": + UIManager.Ext1_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "ext1_on": + UIManager.Ext1_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "intlt_off": + UIManager.Intlt_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "intlt_on": + UIManager.Intlt_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "lind_off": + UIManager.Lind_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "lind_on": + UIManager.Lind_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "manual_off": + UIManager.Manual_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "manual_on": + UIManager.Manual_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "ext2_off": + UIManager.Ext2_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "ext2_on": + UIManager.Ext2_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "rind_off": + UIManager.Rind_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "rind_on": + UIManager.Rind_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s1_off": + UIManager.S1_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s1_on": + UIManager.S1_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s2_off": + UIManager.S2_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s2_on": + UIManager.S2_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s3_off": + UIManager.S3_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s3_on": + UIManager.S3_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "sb_off": + UIManager.SB_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "sb_on": + UIManager.SB_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "blkt_off": + UIManager.Blkt_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "blkt_on": + UIManager.Blkt_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "tadiv_off": + UIManager.Tadiv_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "tadiv_on": + UIManager.Tadiv_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "taleft_off": + UIManager.Taleft_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "taleft_on": + UIManager.Taleft_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "taright_off": + UIManager.Taright_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "taright_on": + UIManager.Taright_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "tawarn_off": + UIManager.Tawarn_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "tawarn_on": + UIManager.Tawarn_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "wail_off": + UIManager.Wail_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "wail_on": + UIManager.Wail_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "yelp_off": + UIManager.Yelp_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "yelp_on": + UIManager.Yelp_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_l_off": + UIManager._3_l_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_l_on": + UIManager._3_l_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_c_off": + UIManager._3_c_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_c_on": + UIManager._3_c_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_r_off": + UIManager._3_r_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_r_on": + UIManager._3_r_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_l_off": + UIManager._4_l_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_l_on": + UIManager._4_l_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_cl_off": + UIManager._4_cl_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_cl_on": + UIManager._4_cl_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_cr_off": + UIManager._4_cr_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_cr_on": + UIManager._4_cr_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_r_off": + UIManager._4_r_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_r_on": + UIManager._4_r_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_l_off": + UIManager._5_l_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_l_on": + UIManager._5_l_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_cl_off": + UIManager._5_cl_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_cl_on": + UIManager._5_cl_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_c_off": + UIManager._5_c_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_c_on": + UIManager._5_c_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_cr_off": + UIManager._5_cr_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_cr_on": + UIManager._5_cr_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_r_off": + UIManager._5_r_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_r_on": + UIManager._5_r_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_l_off": + UIManager._6_l_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_l_on": + UIManager._6_l_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_el_off": + UIManager._6_el_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_el_on": + UIManager._6_el_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_cl_off": + UIManager._6_cl_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_cl_on": + UIManager._6_cl_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_cr_off": + UIManager._6_cr_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_cr_on": + UIManager._6_cr_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_er_off": + UIManager._6_er_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_er_on": + UIManager._6_er_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_r_off": + UIManager._6_r_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_r_on": + UIManager._6_r_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + } + } + } + } + + public static void GetCustomSprites(string customFolder) + { + string path = @"Plugins\DLS\UI\" + customFolder; + if (Directory.Exists(path)) + { + CustomUI customUI = new CustomUI(); + customUI.Width = UIManager.sizeX; + customUI.Height = UIManager.sizeY; + if (File.Exists(path + @"\" + customFolder + ".xml")) + { + try + { + XmlSerializer mySerializer = new XmlSerializer(typeof(CustomUI)); + StreamReader streamReader = new StreamReader(path + @"\" + customFolder + ".xml"); + customUI = (CustomUI)mySerializer.Deserialize(streamReader); + streamReader.Close(); + customUI.Height = customUI.SHeight.ToInt32(); + customUI.Width = customUI.SWidth.ToInt32(); + } + catch (Exception e) + { + ("ERROR (" + customFolder + "): " + e.Message).ToLog(); + Game.LogTrivial("ERROR (" + customFolder + "): " + e.Message); + } + } + foreach (string file in Directory.EnumerateFiles(path, "*.png")) + { + + switch (Path.GetFileNameWithoutExtension(file)) + { + case "background": + UIManager.Background = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "hazard_off": + UIManager.Hazard_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "hazard_on": + UIManager.Hazard_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "horn_off": + UIManager.Horn_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "horn_on": + UIManager.Horn_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "ext1_off": + UIManager.Ext1_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "ext1_on": + UIManager.Ext1_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "intlt_off": + UIManager.Intlt_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "intlt_on": + UIManager.Intlt_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "lind_off": + UIManager.Lind_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "lind_on": + UIManager.Lind_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "manual_off": + UIManager.Manual_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "manual_on": + UIManager.Manual_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "ext2_off": + UIManager.Ext2_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "ext2_on": + UIManager.Ext2_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "rind_off": + UIManager.Rind_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "rind_on": + UIManager.Rind_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s1_off": + UIManager.S1_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s1_on": + UIManager.S1_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s2_off": + UIManager.S2_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s2_on": + UIManager.S2_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s3_off": + UIManager.S3_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "s3_on": + UIManager.S3_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "sb_off": + UIManager.SB_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "sb_on": + UIManager.SB_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "blkt_off": + UIManager.Blkt_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "blkt_on": + UIManager.Blkt_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "tadiv_off": + UIManager.Tadiv_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "tadiv_on": + UIManager.Tadiv_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "taleft_off": + UIManager.Taleft_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "taleft_on": + UIManager.Taleft_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "taright_off": + UIManager.Taright_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "taright_on": + UIManager.Taright_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "tawarn_off": + UIManager.Tawarn_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "tawarn_on": + UIManager.Tawarn_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "wail_off": + UIManager.Wail_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "wail_on": + UIManager.Wail_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "yelp_off": + UIManager.Yelp_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "yelp_on": + UIManager.Yelp_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_l_off": + UIManager._3_l_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_l_on": + UIManager._3_l_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_c_off": + UIManager._3_c_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_c_on": + UIManager._3_c_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_r_off": + UIManager._3_r_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "3_r_on": + UIManager._3_r_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_l_off": + UIManager._4_l_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_l_on": + UIManager._4_l_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_cl_off": + UIManager._4_cl_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_cl_on": + UIManager._4_cl_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_cr_off": + UIManager._4_cr_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_cr_on": + UIManager._4_cr_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_r_off": + UIManager._4_r_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "4_r_on": + UIManager._4_r_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_l_off": + UIManager._5_l_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_l_on": + UIManager._5_l_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_cl_off": + UIManager._5_cl_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_cl_on": + UIManager._5_cl_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_c_off": + UIManager._5_c_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_c_on": + UIManager._5_c_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_cr_off": + UIManager._5_cr_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_cr_on": + UIManager._5_cr_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_r_off": + UIManager._5_r_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "5_r_on": + UIManager._5_r_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_l_off": + UIManager._6_l_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_l_on": + UIManager._6_l_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_el_off": + UIManager._6_el_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_el_on": + UIManager._6_el_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_cl_off": + UIManager._6_cl_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_cl_on": + UIManager._6_cl_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_cr_off": + UIManager._6_cr_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_cr_on": + UIManager._6_cr_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_er_off": + UIManager._6_er_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_er_on": + UIManager._6_er_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_r_off": + UIManager._6_r_Off = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + case "6_r_on": + UIManager._6_r_On = new Sprite(Game.CreateTextureFromFile(file), new System.Drawing.Point(1920 - customUI.Width, 1080 - customUI.Height), new System.Drawing.Size(customUI.Width, customUI.Height)); + break; + } + } + } + } + + public static void ResetSprites() + { + UIManager.Background = new Sprite(Properties.Resources.background, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Horn_On = new Sprite(Properties.Resources.horn_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Horn_Off = new Sprite(Properties.Resources.horn_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Manual_On = new Sprite(Properties.Resources.manual_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Manual_Off = new Sprite(Properties.Resources.manual_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Wail_On = new Sprite(Properties.Resources.wail_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Wail_Off = new Sprite(Properties.Resources.wail_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Yelp_On = new Sprite(Properties.Resources.yelp_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Yelp_Off = new Sprite(Properties.Resources.yelp_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Ext1_On = new Sprite(Properties.Resources.ext1_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Ext1_Off = new Sprite(Properties.Resources.ext1_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Ext2_On = new Sprite(Properties.Resources.ext2_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Ext2_Off = new Sprite(Properties.Resources.ext2_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Hazard_On = new Sprite(Properties.Resources.hazard_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Hazard_Off = new Sprite(Properties.Resources.hazard_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Lind_On = new Sprite(Properties.Resources.lind_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Lind_Off = new Sprite(Properties.Resources.lind_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Rind_On = new Sprite(Properties.Resources.rind_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Rind_Off = new Sprite(Properties.Resources.rind_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.S1_On = new Sprite(Properties.Resources.s1_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.S1_Off = new Sprite(Properties.Resources.s1_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.S2_On = new Sprite(Properties.Resources.s2_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.S2_Off = new Sprite(Properties.Resources.s2_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.S3_On = new Sprite(Properties.Resources.s3_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.S3_Off = new Sprite(Properties.Resources.s3_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Taleft_On = new Sprite(Properties.Resources.taleft_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Taleft_Off = new Sprite(Properties.Resources.taleft_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Taright_On = new Sprite(Properties.Resources.taright_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Taright_Off = new Sprite(Properties.Resources.taright_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Tadiv_On = new Sprite(Properties.Resources.tadiv_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Tadiv_Off = new Sprite(Properties.Resources.tadiv_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Tawarn_On = new Sprite(Properties.Resources.tawarn_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Tawarn_Off = new Sprite(Properties.Resources.tawarn_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Intlt_On = new Sprite(Properties.Resources.intlt_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Intlt_Off = new Sprite(Properties.Resources.intlt_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.SB_On = new Sprite(Properties.Resources.sb_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.SB_Off = new Sprite(Properties.Resources.sb_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Blkt_On = new Sprite(Properties.Resources.blkt_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager.Blkt_Off = new Sprite(Properties.Resources.blkt_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._3_l_On = new Sprite(Properties.Resources._3_l_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._3_l_Off = new Sprite(Properties.Resources._3_l_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._3_c_On = new Sprite(Properties.Resources._3_c_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._3_c_Off = new Sprite(Properties.Resources._3_c_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._3_r_On = new Sprite(Properties.Resources._3_r_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._3_r_Off = new Sprite(Properties.Resources._3_r_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._4_l_On = new Sprite(Properties.Resources._4_l_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._4_l_Off = new Sprite(Properties.Resources._4_l_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._4_cl_On = new Sprite(Properties.Resources._4_cl_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._4_cl_Off = new Sprite(Properties.Resources._4_cl_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._4_cr_On = new Sprite(Properties.Resources._4_cr_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._4_cr_Off = new Sprite(Properties.Resources._4_cr_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._4_r_On = new Sprite(Properties.Resources._4_r_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._4_r_Off = new Sprite(Properties.Resources._4_r_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_l_On = new Sprite(Properties.Resources._5_l_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_l_Off = new Sprite(Properties.Resources._5_l_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_cl_On = new Sprite(Properties.Resources._5_cl_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_cl_Off = new Sprite(Properties.Resources._5_cl_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_c_On = new Sprite(Properties.Resources._5_c_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_c_Off = new Sprite(Properties.Resources._5_c_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_cr_On = new Sprite(Properties.Resources._5_cr_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_cr_Off = new Sprite(Properties.Resources._5_cr_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_r_On = new Sprite(Properties.Resources._5_r_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._5_r_Off = new Sprite(Properties.Resources._5_r_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_l_On = new Sprite(Properties.Resources._6_l_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_l_Off = new Sprite(Properties.Resources._6_l_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_el_On = new Sprite(Properties.Resources._6_el_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_el_Off = new Sprite(Properties.Resources._6_el_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_cl_On = new Sprite(Properties.Resources._6_cl_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_cl_Off = new Sprite(Properties.Resources._6_cl_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_cr_On = new Sprite(Properties.Resources._6_cr_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_cr_Off = new Sprite(Properties.Resources._6_cr_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_er_On = new Sprite(Properties.Resources._6_er_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_er_Off = new Sprite(Properties.Resources._6_er_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_r_On = new Sprite(Properties.Resources._6_r_on, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + UIManager._6_r_Off = new Sprite(Properties.Resources._6_r_off, new System.Drawing.Point(1920 - UIManager.sizeX, 1080 - UIManager.sizeY), new System.Drawing.Size(UIManager.sizeX, UIManager.sizeY)); + } + } +} diff --git a/DLS/UI/Resources.cs b/DLS/UI/Resources.cs new file mode 100644 index 0000000..89ac186 --- /dev/null +++ b/DLS/UI/Resources.cs @@ -0,0 +1,25 @@ +using Rage; +using System.CodeDom.Compiler; +using System.Drawing; +using System.IO; + +namespace DLS.UI +{ + internal class Resources + { + public static Texture GetTextureFromResource(Bitmap resource) + { + using (var tempFiles = new TempFileCollection()) + { + string filePath = tempFiles.AddExtension("png"); + + resource.Save(filePath); + if (File.Exists(filePath)) + { + return Game.CreateTextureFromFile(filePath); + } + } + return null; + } + } +} diff --git a/DLS/UI/Sprite.cs b/DLS/UI/Sprite.cs new file mode 100644 index 0000000..41ac010 --- /dev/null +++ b/DLS/UI/Sprite.cs @@ -0,0 +1,26 @@ +using Rage; +using System.Drawing; + +namespace DLS.UI +{ + internal class Sprite + { + internal Sprite(Bitmap resource, Point position, Size size) + { + Position = position; + Size = size; + Texture = Resources.GetTextureFromResource(resource); + } + + internal Sprite(Texture texture, Point position, Size size) + { + Position = position; + Size = size; + Texture = texture; + } + + internal Point Position { get; set; } + internal Size Size { get; set; } + internal Texture Texture { get; set; } + } +} diff --git a/DLS/Utils/Controls.cs b/DLS/Utils/Controls.cs new file mode 100644 index 0000000..3e038cf --- /dev/null +++ b/DLS/Utils/Controls.cs @@ -0,0 +1,186 @@ +using Rage; +using Rage.Native; +using System; +using System.Collections.Generic; +using System.Windows.Forms; + +namespace DLS.Utils +{ + internal class Controls + { + private static Dictionary listKeys = new Dictionary(); + private static string ModKey = "Shift"; + private static List DisabledControls = new List(); + + public static bool IsDLSControlDown(DLSControls controls) + { + switch (controls) + { + case DLSControls.SIREN_TOGGLE: + return Game.IsKeyDown(listKeys[DLSControls.SIREN_TOGGLE]) + || Game.IsControllerButtonDown(ControllerButtons.DPadDown); + case DLSControls.SIREN_TONE1: + return Game.IsKeyDown(listKeys[DLSControls.SIREN_TONE1]); + case DLSControls.SIREN_TONE2: + return Game.IsKeyDown(listKeys[DLSControls.SIREN_TONE2]); + case DLSControls.SIREN_TONE3: + return Game.IsKeyDown(listKeys[DLSControls.SIREN_TONE3]); + case DLSControls.SIREN_TONE4: + return Game.IsKeyDown(listKeys[DLSControls.SIREN_TONE4]); + case DLSControls.SIREN_SCAN: + return Game.IsKeyDown(listKeys[DLSControls.SIREN_SCAN]); + case DLSControls.SIREN_HORN: + return Game.IsKeyDownRightNow(listKeys[DLSControls.SIREN_HORN]) + || Game.IsControllerButtonDownRightNow(ControllerButtons.LeftThumb) + || Game.IsControlPressed(2, GameControl.VehicleHorn); + case DLSControls.SIREN_AUX: + return Game.IsKeyDown(listKeys[DLSControls.SIREN_AUX]) + || Game.IsControllerButtonDown(ControllerButtons.DPadUp); + case DLSControls.SIREN_MAN: + return Game.IsKeyDownRightNow(listKeys[DLSControls.SIREN_MAN]) + || Game.IsControllerButtonDownRightNow(ControllerButtons.B); + case DLSControls.LIGHT_TOGGLE: + return Game.IsKeyDown(listKeys[DLSControls.LIGHT_TOGGLE]) + || Game.IsControllerButtonDown(ControllerButtons.DPadLeft); + case DLSControls.LIGHT_TADVISOR: + return Game.IsKeyDown(listKeys[DLSControls.LIGHT_TADVISOR]); + case DLSControls.GEN_LOCKALL: + return Game.IsKeyDown(listKeys[DLSControls.GEN_LOCKALL]); + case DLSControls.LIGHT_SBURN: + return Game.IsKeyDown(listKeys[DLSControls.LIGHT_SBURN]); + case DLSControls.LIGHT_INTLT: + return Game.IsKeyDown(listKeys[DLSControls.LIGHT_INTLT]); + case DLSControls.LIGHT_INDL: + return Game.IsKeyDown(listKeys[DLSControls.LIGHT_INDL]); + case DLSControls.LIGHT_INDR: + return Game.IsKeyDown(listKeys[DLSControls.LIGHT_INDR]); + case DLSControls.LIGHT_HAZRD: + return Game.IsKeyDown(listKeys[DLSControls.LIGHT_HAZRD]); + default: + return false; + } + } + + public static bool IsDLSControlDownWithModifier(DLSControls controls) + { + switch (controls) + { + case DLSControls.LIGHT_TADVISOR: + switch (ModKey) + { + case "Shift": + return Game.IsShiftKeyDownRightNow + && Game.IsKeyDown(listKeys[DLSControls.LIGHT_TADVISOR]); + case "Control": + return Game.IsControlKeyDownRightNow + && Game.IsKeyDown(listKeys[DLSControls.LIGHT_TADVISOR]); + case "Alt": + return Game.IsAltKeyDownRightNow + && Game.IsKeyDown(listKeys[DLSControls.LIGHT_TADVISOR]); + default: + return false; + } + case DLSControls.UI_TOGGLE: + switch (ModKey) + { + case "Shift": + return Game.IsShiftKeyDownRightNow + && Game.IsKeyDown(listKeys[DLSControls.UI_TOGGLE]); + case "Control": + return Game.IsControlKeyDownRightNow + && Game.IsKeyDown(listKeys[DLSControls.UI_TOGGLE]); + case "Alt": + return Game.IsAltKeyDownRightNow + && Game.IsKeyDown(listKeys[DLSControls.UI_TOGGLE]); + default: + return false; + } + case DLSControls.LIGHT_SBURN: + switch (ModKey) + { + case "Shift": + return Game.IsShiftKeyDownRightNow + && Game.IsKeyDown(listKeys[DLSControls.LIGHT_SBURN]); + case "Control": + return Game.IsControlKeyDownRightNow + && Game.IsKeyDown(listKeys[DLSControls.LIGHT_SBURN]); + case "Alt": + return Game.IsAltKeyDownRightNow + && Game.IsKeyDown(listKeys[DLSControls.LIGHT_SBURN]); + default: + return false; + } + default: + return false; + } + } + + public static void DisableControls() + { + foreach (int i in DisabledControls) + NativeFunction.Natives.DISABLE_CONTROL_ACTION(0, i, true); + } + + public static void RefreshKeys() + { + listKeys.Clear(); + try + { + listKeys.Add(DLSControls.SIREN_TOGGLE, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "SirenToggle"))); + listKeys.Add(DLSControls.SIREN_TONE1, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "Tone1"))); + listKeys.Add(DLSControls.SIREN_TONE2, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "Tone2"))); + listKeys.Add(DLSControls.SIREN_TONE3, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "Tone3"))); + listKeys.Add(DLSControls.SIREN_TONE4, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "Tone4"))); + listKeys.Add(DLSControls.SIREN_SCAN, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "Scan"))); + listKeys.Add(DLSControls.SIREN_HORN, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "Horn"))); + listKeys.Add(DLSControls.SIREN_AUX, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "AuxToggle"))); + listKeys.Add(DLSControls.SIREN_MAN, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "Manual"))); + + listKeys.Add(DLSControls.LIGHT_TOGGLE, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "LightStage"))); + listKeys.Add(DLSControls.LIGHT_TADVISOR, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "TAdvisor"))); + listKeys.Add(DLSControls.LIGHT_SBURN, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "SteadyBurn"))); + listKeys.Add(DLSControls.LIGHT_INTLT, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "InteriorLT"))); + listKeys.Add(DLSControls.LIGHT_INDL, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "IndL"))); + listKeys.Add(DLSControls.LIGHT_INDR, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "IndR"))); + listKeys.Add(DLSControls.LIGHT_HAZRD, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "Hazard"))); + + listKeys.Add(DLSControls.GEN_LOCKALL, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "LockAll"))); + + listKeys.Add(DLSControls.UI_TOGGLE, (Keys)Enum.Parse(typeof(Keys), Settings.ReadKey("Keyboard", "UIKey"))); + ModKey = Settings.ReadKey("Keyboard", "Modifier"); + + string[] disabledControls = Settings.ReadKey("Keyboard", "Disabled").Replace(" ", "").Trim().Split(','); + foreach (string control in disabledControls) + DisabledControls.Add(control.ToInt32()); + } + catch (Exception e) + { + ("Key Parse ERROR: " + e.Message).ToLog(); + Game.LogTrivial("Key Parse ERROR: " + e.Message); + } + + } + } + + internal enum DLSControls + { + SIREN_TOGGLE, + SIREN_TONE1, + SIREN_TONE2, + SIREN_TONE3, + SIREN_TONE4, + SIREN_SCAN, + SIREN_HORN, + SIREN_AUX, + SIREN_MAN, + LIGHT_TOGGLE, + LIGHT_TADVISOR, + LIGHT_SBURN, + LIGHT_INTLT, + LIGHT_INDL, + LIGHT_INDR, + LIGHT_HAZRD, + GEN_LOCKALL, + UI_TOGGLE + } +} \ No newline at end of file diff --git a/DLS/Utils/Extensions.cs b/DLS/Utils/Extensions.cs new file mode 100644 index 0000000..ed08965 --- /dev/null +++ b/DLS/Utils/Extensions.cs @@ -0,0 +1,178 @@ +using DLS.UI; +using Rage; +using System; +using System.Collections.Generic; +using System.Drawing; +using System.IO; +using System.Reflection; +using System.Runtime.CompilerServices; + +namespace DLS.Utils +{ + internal static class Extensions + { + internal static void Draw(this Sprite sprite, Rage.Graphics graphics) + { + Texture texture = sprite.Texture; + var origRes = Game.Resolution; + float aspectRaidou = origRes.Width / (float)origRes.Height; + PointF pos = new PointF(sprite.Position.X / (1080 * aspectRaidou), sprite.Position.Y / 1080f); + SizeF siz = new SizeF(sprite.Size.Width / (1080 * aspectRaidou), sprite.Size.Height / 1080f); + if (texture != null) + graphics.DrawTexture(texture, pos.X * Game.Resolution.Width, pos.Y * Game.Resolution.Height, siz.Width * Game.Resolution.Width, siz.Height * Game.Resolution.Height); + } + internal static DLSModel GetDLS(this Vehicle veh) + { + if (!veh) + return null; + for (int i = 0; i < Entrypoint.dlsModels.Count; i++) + { + if (Entrypoint.dlsModels[i].Name == veh.Model.Hash.ToString()) + return Entrypoint.dlsModels[i]; + } + return null; + } + internal static ActiveVehicle GetActiveVehicle(this Vehicle veh) + { + if (!veh) + return null; + for (int i = 0; i < Entrypoint.activeVehicles.Count; i++) + { + if (Entrypoint.activeVehicles[i].Vehicle == veh) + return Entrypoint.activeVehicles[i]; + } + return null; + } + internal static void ToLog(this string log) + { + string path = @"Plugins/DLS.log"; + using (StreamWriter writer = new StreamWriter(path, true)) + { + writer.WriteLine("[" + DateTime.Now.ToString() + "] " + log); + writer.Close(); + } + } + internal static int ToInt32(this string text, [CallerMemberName] string callingMethod = null) + { + int i = 0; + try + { + i = Convert.ToInt32(text); + } + catch (Exception e) + { + string message = "ERROR: " + e.Message + " ( " + text + " ) [" + callingMethod + "() -> " + MethodBase.GetCurrentMethod().Name + "()]"; + (message).ToLog(); + Game.LogTrivial(message); + } + return i; + } + internal static float ToFloat(this string text, [CallerMemberName] string callingMethod = null) + { + float i = 0f; + try + { + i = float.Parse(text, System.Globalization.CultureInfo.InvariantCulture); + } + catch (Exception e) + { + string message = "ERROR: " + e.Message + " ( " + text + " ) [" + callingMethod + "() -> " + MethodBase.GetCurrentMethod().Name + "()]"; + (message).ToLog(); + Game.LogTrivial(message); + } + return i; + } + internal static Color HexToColor(this string text, [CallerMemberName] string callingMethod = null) + { + Color i = new Color(); + try + { + i = ColorTranslator.FromHtml("#" + text); + } + catch (Exception e) + { + string message = "ERROR: " + e.Message + " ( " + text + " ) [" + callingMethod + "() -> " + MethodBase.GetCurrentMethod().Name + "()]"; + (message).ToLog(); + Game.LogTrivial(message); + } + return i; + } + internal static bool ToBoolean(this string text, [CallerMemberName] string callingMethod = null) + { + bool i = false; + try + { + i = Convert.ToBoolean(text); + } + catch (Exception e) + { + string message = "ERROR: " + e.Message + " ( " + text + " ) [" + callingMethod + "() -> " + MethodBase.GetCurrentMethod().Name + "()]"; + (message).ToLog(); + Game.LogTrivial(message); + } + return i; + } + internal static bool IsPlayerVehicle(this Vehicle veh) + { + ActiveVehicle vehActive = veh.GetActiveVehicle(); + if (Game.LocalPlayer.Character.CurrentVehicle == veh || Game.LocalPlayer.Character.LastVehicle == veh) + return true; + foreach (ActiveVehicle activeVeh in Entrypoint.activeVehicles) + { + if (activeVeh == vehActive && activeVeh.PlayerVehicle) + return true; + } + return false; + } + internal static int GetIndexFromTAPatternName(this TAgroup taGroup, string name) + { + foreach (TApattern taP in taGroup.TaPatterns) + { + if (taP.Name == name) + return taGroup.TaPatterns.IndexOf(taP); + } + return 999; + } + internal static bool DoesVehicleHaveLightStage(this DLSModel dlsModel, LightStage lightStage) + { + return dlsModel.AvailableLightStages.Contains(lightStage); + } + internal static bool DoesVehicleHaveSirenStage(this DLSModel dlsModel, SirenStage sirenStage) + { + return dlsModel.AvailableSirenStages.Contains(sirenStage); + } + internal static LightStage NextLightStage(this List list, LightStage currentItem, bool includeFirst = true) + { + if (currentItem != LightStage.Empty && !list.Contains(currentItem)) + return currentItem; + int index; + if (currentItem == LightStage.Empty) + index = list.IndexOf(LightStage.Off) + 1; + else + index = list.IndexOf(currentItem) + 1; + if (index > list.Count - 1) + { + if (includeFirst) + index = 0; + else + index = 1; + } + return list[index]; + } + + internal static SirenStage NextSirenStage(this List list, SirenStage currentItem, bool includeFirst = true) + { + if (!list.Contains(currentItem)) + return currentItem; + int index = list.IndexOf(currentItem) + 1; + if (index > list.Count - 1) + { + if (includeFirst) + index = 0; + else + index = 1; + } + return list[index]; + } + } +} diff --git a/DLS/Utils/Helpers.cs b/DLS/Utils/Helpers.cs new file mode 100644 index 0000000..f28ebc6 --- /dev/null +++ b/DLS/Utils/Helpers.cs @@ -0,0 +1,58 @@ +using Rage; + +namespace DLS.Utils +{ + internal static class UIHelper + { + public static bool IsUIAbleToDisplay { get; set; } = false; + public static DLSModel dlsModel { get; set; } = null; + public static ActiveVehicle activeVeh { get; set; } = null; + public static Ped player { get; set; } = null; + public static bool IsInAnyVehicle { get; set; } = false; + public static Vehicle currentVehicle { get; set; } + public static bool IsPlayerDriver { get; set; } = false; + public static bool IsVehicleValid { get; set; } = false; + public static SirenStatus[] IsSirenOn { get; set; } = new SirenStatus[20]; + + private static void Process() + { + while (true) + { + GameFiber.Yield(); + if (!Game.IsPaused && !Game.IsLoading && !Game.IsScreenFadedOut) + IsUIAbleToDisplay = true; + else + IsUIAbleToDisplay = false; + player = Game.LocalPlayer.Character; + IsInAnyVehicle = player.IsInAnyVehicle(false); + currentVehicle = player.CurrentVehicle; + if (currentVehicle) + { + IsVehicleValid = true; + if (currentVehicle.IsEngineOn && currentVehicle.HasSiren) + IsVehicleValid = true; + if (currentVehicle.Driver == player) + IsPlayerDriver = true; + else + IsPlayerDriver = false; + dlsModel = currentVehicle.GetDLS(); + activeVeh = currentVehicle.GetActiveVehicle(); + if (IsPlayerDriver && activeVeh != null && dlsModel != null && currentVehicle.HasSiren) + { + for (int i = 1; i <= 20; i++) + { + IsSirenOn[i - 1] = Lights.GetSirenStatus(activeVeh, i); + } + } + } + else + IsVehicleValid = false; + } + } + + static UIHelper() + { + GameFiber.StartNew(Process, "DLS - UI Helper"); + } + } +} diff --git a/DLS/Utils/Lights.cs b/DLS/Utils/Lights.cs new file mode 100644 index 0000000..b9979a7 --- /dev/null +++ b/DLS/Utils/Lights.cs @@ -0,0 +1,1011 @@ +using Rage; +using Rage.Native; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace DLS.Utils +{ + class Lights + { + public static void Update(ActiveVehicle activeVeh) + { + switch (activeVeh.LightStage) + { + case LightStage.Off: + activeVeh.Vehicle.IsSirenOn = false; + activeVeh.SirenStage = SirenStage.Off; + activeVeh.TAStage = TAStage.Off; + activeVeh.SBOn = false; + activeVeh.IsScanOn = false; + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + Sirens.Update(activeVeh); + UpdateTA(false, activeVeh); + UpdateSB(activeVeh); + break; + case LightStage.One: + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + activeVeh.Vehicle.IsSirenOn = true; + activeVeh.Vehicle.IsSirenSilent = true; + UpdateTA(false, activeVeh); + UpdateSB(activeVeh); + break; + case LightStage.Two: + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + activeVeh.Vehicle.IsSirenOn = true; + activeVeh.Vehicle.IsSirenSilent = true; + UpdateTA(false, activeVeh); + UpdateSB(activeVeh); + break; + case LightStage.Three: + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + activeVeh.Vehicle.IsSirenOn = true; + activeVeh.Vehicle.IsSirenSilent = true; + UpdateTA(false, activeVeh); + UpdateSB(activeVeh); + break; + case LightStage.CustomOne: + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + activeVeh.Vehicle.IsSirenOn = true; + activeVeh.Vehicle.IsSirenSilent = true; + UpdateTA(false, activeVeh); + UpdateSB(activeVeh); + break; + case LightStage.CustomTwo: + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + activeVeh.Vehicle.IsSirenOn = true; + activeVeh.Vehicle.IsSirenSilent = true; + UpdateTA(false, activeVeh); + UpdateSB(activeVeh); + break; + default: + break; + } + } + + public static void UpdateTA(bool taCalled, ActiveVehicle activeVeh) + { + DLSModel dlsModel = activeVeh.Vehicle.GetDLS(); + if (dlsModel.TrafficAdvisory.Type != "off") + { + if (!taCalled) + { + List enableStages = new List(); + List disableStages = new List(); + if (dlsModel.TrafficAdvisory.AutoEnableStages != "") + { + foreach (int i in dlsModel.TrafficAdvisory.AutoEnableStages.Split(',').Select(n => int.Parse(n)).ToList()) + enableStages.Add((LightStage)i); + } + if (dlsModel.TrafficAdvisory.AutoDisableStages != "") + { + foreach (int i in dlsModel.TrafficAdvisory.AutoDisableStages.Split(',').Select(n => int.Parse(n)).ToList()) + disableStages.Add((LightStage)i); + } + if (enableStages.Contains(activeVeh.LightStage)) + { + if (activeVeh.TAStage == TAStage.Off) + { + switch (dlsModel.TrafficAdvisory.DefaultEnabledDirection.ToLower()) + { + case "left": + activeVeh.TAStage = TAStage.Left; + break; + case "diverge": + activeVeh.TAStage = TAStage.Diverge; + break; + case "right": + activeVeh.TAStage = TAStage.Right; + break; + case "warn": + activeVeh.TAStage = TAStage.Warn; + break; + } + } + } + if (disableStages.Contains(activeVeh.LightStage)) + activeVeh.TAStage = TAStage.Off; + } + if (dlsModel.TrafficAdvisory.DivergeOnly.ToBoolean()) + { + if (activeVeh.TAStage != TAStage.Off) + { + switch (dlsModel.TrafficAdvisory.Type) + { + case "three": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00110000110000110000110000110000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "11000011000011000011000011000011"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00110000110000110000110000110000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "four": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00110000110000110000110000110000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "11000011000011000011000011000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "11000011000011000011000011000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00110000110000110000110000110000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "five": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00001100000011000000110000001100"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00110000001100000011000000110000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "11000000110000001100000011000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00110000001100000011000000110000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00001100000011000000110000001100"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "six": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00001100000011000000110000001100"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.el.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00110000001100000011000000110000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "11000000110000001100000011000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "11000000110000001100000011000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.er.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00110000001100000011000000110000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00001100000011000000110000001100"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + } + } + else + { + if (taCalled) + { + switch (dlsModel.TrafficAdvisory.Type) + { + case "three": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "four": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "five": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "six": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.el.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.er.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + } + } + else + return; + } + } + else + { + switch (activeVeh.TAStage) + { + case TAStage.Left: + switch (dlsModel.TrafficAdvisory.Type) + { + case "three": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Left.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Left.C; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Left.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "four": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Left.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Left.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Left.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Left.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "five": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Left.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Left.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Left.C; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Left.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Left.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "six": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Left.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.el.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Left.EL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Left.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Left.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.er.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Left.ER; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Left.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + } + break; + case TAStage.Diverge: + switch (dlsModel.TrafficAdvisory.Type) + { + case "three": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Diverge.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Diverge.C; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Diverge.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "four": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Diverge.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Diverge.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Diverge.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Diverge.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "five": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Diverge.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Diverge.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Diverge.C; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Diverge.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Diverge.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "six": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Diverge.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.el.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Diverge.EL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Diverge.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Diverge.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.er.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Diverge.ER; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Diverge.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + } + break; + case TAStage.Right: + switch (dlsModel.TrafficAdvisory.Type) + { + case "three": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Right.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Right.C; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Right.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "four": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Right.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Right.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Right.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Right.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "five": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Right.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Right.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Right.C; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Right.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Right.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "six": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Right.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.el.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Right.EL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Right.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Right.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.er.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Right.ER; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Right.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + } + break; + case TAStage.Warn: + switch (dlsModel.TrafficAdvisory.Type) + { + case "three": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Warn.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Warn.C; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Three.Warn.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "four": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Warn.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Warn.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Warn.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Four.Warn.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "five": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Warn.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Warn.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Warn.C; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Warn.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Five.Warn.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "six": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Warn.L; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.el.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Warn.EL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Warn.CL; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Warn.CR; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.er.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Warn.ER; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = activeVeh.TAgroup.TaPatterns[activeVeh.TApatternCurrentIndex].Six.Warn.R; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + } + break; + case TAStage.Off: + if (taCalled) + { + switch (dlsModel.TrafficAdvisory.Type) + { + case "three": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "four": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "five": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.c.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + case "six": + foreach (int i in dlsModel.TrafficAdvisory.l.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.el.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cl.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.cr.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.er.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + foreach (int i in dlsModel.TrafficAdvisory.r.Split(',').Select(n => int.Parse(n)).ToList()) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = "00000000000000000000000000000000"; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + break; + } + } + else + return; + if (!activeVeh.SBOn) + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + else + { + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + UpdateSB(activeVeh); + } + break; + } + } + } + } + + public static void UpdateSB(ActiveVehicle activeVeh) + { + DLSModel dlsModel = activeVeh.Vehicle.GetDLS(); + if (dlsModel.SpecialModes.SteadyBurn.SteadyBurnEnabled.ToBoolean()) + { + List ssb = dlsModel.SpecialModes.SteadyBurn.Sirens.Replace(" ", "").Split(',').Select(n => int.Parse(n)).ToList(); + if (activeVeh.SBOn) + { + foreach (int i in ssb) + { + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].FlashinessSequence = dlsModel.SpecialModes.SteadyBurn.Pattern; + activeVeh.Vehicle.EmergencyLightingOverride.Lights[i - 1].Flash = true; + } + } + else + { + if (activeVeh.TAStage == TAStage.Off) + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + else + { + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + UpdateTA(true, activeVeh); + } + + } + } + } + + public static void MoveUpStage(ActiveVehicle activeVeh) + { + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.LightStage = activeVeh.Vehicle.GetDLS().AvailableLightStages.NextLightStage(activeVeh.LightStage); + Update(activeVeh); + } + + public static void MoveUpStageTA(ActiveVehicle activeVeh) + { + if (!activeVeh.Vehicle.GetDLS().TrafficAdvisory.DivergeOnly.ToBoolean()) + { + switch (activeVeh.TAStage) + { + case TAStage.Off: + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.TAStage = TAStage.Left; + if (activeVeh.LightStage == LightStage.Off || activeVeh.LightStage == LightStage.Empty) + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + UpdateTA(true, activeVeh); + break; + case TAStage.Left: + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.TAStage = TAStage.Diverge; + if (activeVeh.LightStage == LightStage.Off || activeVeh.LightStage == LightStage.Empty) + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + UpdateTA(true, activeVeh); + break; + case TAStage.Diverge: + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.TAStage = TAStage.Right; + if (activeVeh.LightStage == LightStage.Off || activeVeh.LightStage == LightStage.Empty) + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + UpdateTA(true, activeVeh); + break; + case TAStage.Right: + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.TAStage = TAStage.Warn; + if (activeVeh.LightStage == LightStage.Off || activeVeh.LightStage == LightStage.Empty) + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + UpdateTA(true, activeVeh); + break; + case TAStage.Warn: + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.TAStage = TAStage.Off; + if (activeVeh.LightStage == LightStage.Off || activeVeh.LightStage == LightStage.Empty) + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + UpdateTA(true, activeVeh); + break; + } + } + else + { + switch (activeVeh.TAStage) + { + case TAStage.Off: + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.TAStage = TAStage.Diverge; + if (activeVeh.LightStage == LightStage.Off || activeVeh.LightStage == LightStage.Empty) + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + UpdateTA(true, activeVeh); + break; + case TAStage.Diverge: + NativeFunction.Natives.PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true); + activeVeh.TAStage = TAStage.Off; + if (activeVeh.LightStage == LightStage.Off || activeVeh.LightStage == LightStage.Empty) + activeVeh.Vehicle.EmergencyLightingOverride = Vehicles.GetEL(activeVeh.Vehicle); + UpdateTA(true, activeVeh); + break; + } + } + } + + public static void ToggleIntLight(ActiveVehicle activeVeh) + { + Vehicle veh = activeVeh.Vehicle; + veh.IsInteriorLightOn = !veh.GetActiveVehicle().IntLightOn; + veh.GetActiveVehicle().IntLightOn = !veh.GetActiveVehicle().IntLightOn; + } + + public static void UpdateIndicator(ActiveVehicle activeVeh) + { + switch (activeVeh.IndStatus) + { + case IndStatus.Off: + NativeFunction.Natives.SET_VEHICLE_INDICATOR_LIGHTS(activeVeh.Vehicle, 0, false); + NativeFunction.Natives.SET_VEHICLE_INDICATOR_LIGHTS(activeVeh.Vehicle, 1, false); + break; + case IndStatus.Left: + NativeFunction.Natives.SET_VEHICLE_INDICATOR_LIGHTS(activeVeh.Vehicle, 0, false); + NativeFunction.Natives.SET_VEHICLE_INDICATOR_LIGHTS(activeVeh.Vehicle, 1, true); + break; + case IndStatus.Right: + NativeFunction.Natives.SET_VEHICLE_INDICATOR_LIGHTS(activeVeh.Vehicle, 0, true); + NativeFunction.Natives.SET_VEHICLE_INDICATOR_LIGHTS(activeVeh.Vehicle, 1, false); + break; + case IndStatus.Both: + NativeFunction.Natives.SET_VEHICLE_INDICATOR_LIGHTS(activeVeh.Vehicle, 0, true); + NativeFunction.Natives.SET_VEHICLE_INDICATOR_LIGHTS(activeVeh.Vehicle, 1, true); + break; + } + } + + public static SirenStatus GetSirenStatus(ActiveVehicle activeVeh, int sirenID, bool includeBroken = true) + { + Vehicle v = activeVeh.Vehicle; + string bone = "siren" + sirenID; + if (v.HasBone(bone) && (includeBroken || v.GetBonePosition(bone).DistanceTo(Vector3.Zero) > 1)) + { + float length = v.GetBoneOrientation(bone).LengthSquared(); + bool on = Math.Round(length, 2) != Math.Round(activeVeh.InitialLengths[sirenID - 1], 2); + if (on) + return SirenStatus.On; + else + return SirenStatus.Off; + } + else + return SirenStatus.None; + } + } +} diff --git a/DLS/Utils/Log.cs b/DLS/Utils/Log.cs new file mode 100644 index 0000000..f4cb4cb --- /dev/null +++ b/DLS/Utils/Log.cs @@ -0,0 +1,23 @@ +using System; +using System.IO; +using System.Reflection; + +namespace DLS.Utils +{ + class Log + { + public Log() + { + string message = "DLS - Dynamic Lighting System - v" + Assembly.GetExecutingAssembly().GetName().Version; + message += Environment.NewLine; + message += "-----------------------------------------------------------"; + message += Environment.NewLine; + string path = @"Plugins/DLS.log"; + using (StreamWriter writer = new StreamWriter(path, false)) + { + writer.WriteLine(message); + writer.Close(); + } + } + } +} diff --git a/DLS/Utils/Settings.cs b/DLS/Utils/Settings.cs new file mode 100644 index 0000000..d866586 --- /dev/null +++ b/DLS/Utils/Settings.cs @@ -0,0 +1,40 @@ +using Rage; +using System; +using System.Globalization; +using System.IO; + +namespace DLS.Utils +{ + class Settings + { + private static string _location = @"Plugins\DLS.ini"; + public static void IniCheck() + { + if (File.Exists(_location)) return; "Loaded: DLS.ini".ToLog(); + "ERROR: DLS.ini was not found!".ToLog(); + } + + public static InitializationFile InitializeIni() + { + var ini = new InitializationFile(_location, CultureInfo.InvariantCulture, false); + ini.Create(); + return ini; + } + + public static string ReadKey(string sectionName, string keyName) + { + var value = ""; + try + { + var ini = InitializeIni(); + value = ini.ReadString(sectionName, keyName); + } + catch (Exception e) + { + ("DLS.ini ERROR: " + e.Message).ToLog(); + Game.LogTrivial("DLS.ini ERROR: " + e.Message); + } + return value; + } + } +} diff --git a/DLS/Utils/Sirens.cs b/DLS/Utils/Sirens.cs new file mode 100644 index 0000000..d5e4bdf --- /dev/null +++ b/DLS/Utils/Sirens.cs @@ -0,0 +1,95 @@ +using Rage.Native; + +namespace DLS.Utils +{ + internal static class Sirens + { + public static void Update(ActiveVehicle activeVeh, bool dls = true) + { + switch (activeVeh.SirenStage) + { + case SirenStage.Off: + Sound.NewSoundID(activeVeh); + break; + case SirenStage.One: + if (dls) + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), activeVeh.Vehicle.GetDLS().SoundSettings.Tone1, activeVeh.Vehicle, 0, 0, 0); + else + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), "VEHICLES_HORNS_SIREN_1", activeVeh.Vehicle, 0, 0, 0); + break; + case SirenStage.Two: + if (dls) + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), activeVeh.Vehicle.GetDLS().SoundSettings.Tone2, activeVeh.Vehicle, 0, 0, 0); + else + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), "VEHICLES_HORNS_SIREN_2", activeVeh.Vehicle, 0, 0, 0); + break; + case SirenStage.Warning: + if (dls) + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), activeVeh.Vehicle.GetDLS().SoundSettings.Tone3, activeVeh.Vehicle, 0, 0, 0); + else + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), "VEHICLES_HORNS_POLICE_WARNING", activeVeh.Vehicle, 0, 0, 0); + break; + case SirenStage.Warning2: + if (dls) + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), activeVeh.Vehicle.GetDLS().SoundSettings.Tone4, activeVeh.Vehicle, 0, 0, 0); + else + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), "VEHICLES_HORNS_AMBULANCE_WARNING", activeVeh.Vehicle, 0, 0, 0); + break; + case SirenStage.Horn: + if (dls) + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), activeVeh.Vehicle.GetDLS().SoundSettings.Horn, activeVeh.Vehicle, 0, 0, 0); + else + NativeFunction.Natives.PLAY_SOUND_FROM_ENTITY(Sound.NewSoundID(activeVeh), "SIRENS_AIRHORN", activeVeh.Vehicle, 0, 0, 0); + break; + default: + break; + } + } + + public static void MoveUpStage(ActiveVehicle activeVeh, bool isDLS = false, bool isMan = false) + { + if (isDLS) + { + activeVeh.SirenStage = GetNextStage(activeVeh.SirenStage); + } + else + { + switch (activeVeh.SirenStage) + { + case SirenStage.Off: + activeVeh.SirenStage = SirenStage.One; + break; + case SirenStage.One: + activeVeh.SirenStage = SirenStage.Two; + break; + case SirenStage.Two: + activeVeh.SirenStage = SirenStage.Warning; + break; + case SirenStage.Warning: + activeVeh.SirenStage = SirenStage.Warning2; + break; + case SirenStage.Warning2: + activeVeh.SirenStage = SirenStage.Off; + break; + } + } + Update(activeVeh, isDLS); + } + + public static SirenStage GetNextStage(SirenStage sirenStage) + { + if (sirenStage != SirenStage.Warning2) + { + return sirenStage + 1; + } + else + { + return SirenStage.One; + } + } + public static SirenStage GetNextStage(SirenStage sirenStage, DLSModel vehDLS) + { + return vehDLS.AvailableSirenStages.NextSirenStage(sirenStage, false); + } + } +} \ No newline at end of file diff --git a/DLS/Utils/Sound.cs b/DLS/Utils/Sound.cs new file mode 100644 index 0000000..ef8f15d --- /dev/null +++ b/DLS/Utils/Sound.cs @@ -0,0 +1,39 @@ +using Rage.Native; + +namespace DLS.Utils +{ + class Sound + { + public static int NewSoundID(ActiveVehicle activeVeh) + { + if (activeVeh.SoundId != 999) + { + NativeFunction.Natives.STOP_SOUND(activeVeh.SoundId); + NativeFunction.Natives.RELEASE_SOUND_ID(activeVeh.SoundId); + Entrypoint.UsedSoundIDs.Remove(activeVeh.SoundId); + ("Deallocated SoundID " + activeVeh.SoundId).ToLog(); + } + int newID = NativeFunction.Natives.GET_SOUND_ID(); + activeVeh.SoundId = newID; + Entrypoint.UsedSoundIDs.Add(newID); + ("Allocated SoundID " + newID).ToLog(); + return newID; + } + + public static int TempSoundID() + { + int newID = NativeFunction.Natives.GET_SOUND_ID(); + Entrypoint.UsedSoundIDs.Add(newID); + ("Allocated TempSoundID " + newID).ToLog(); + return newID; + } + + public static void ClearTempSoundID(int id) + { + NativeFunction.Natives.STOP_SOUND(id); + NativeFunction.Natives.RELEASE_SOUND_ID(id); + Entrypoint.UsedSoundIDs.Remove(id); + ("Deallocated SoundID " + id).ToLog(); + } + } +} diff --git a/DLS/Utils/Vehicles.cs b/DLS/Utils/Vehicles.cs new file mode 100644 index 0000000..cbb69b3 --- /dev/null +++ b/DLS/Utils/Vehicles.cs @@ -0,0 +1,183 @@ +using Rage; +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml.Serialization; + +namespace DLS.Utils +{ + class Vehicles + { + public static List GetAllModels() + { + string path = @"Plugins\DLS\"; + _ = new DLSModel(); + List listModels = new List(); + foreach (string file in Directory.EnumerateFiles(path, "*.xml")) + { + try + { + XmlSerializer mySerializer = new XmlSerializer(typeof(DLSModel)); + StreamReader streamReader = new StreamReader(file); + + DLSModel model = (DLSModel)mySerializer.Deserialize(streamReader); + streamReader.Close(); + + model.Name = Game.GetHashKey(Path.GetFileNameWithoutExtension(file)).ToString(); + + model.AvailableLightStages.Add(LightStage.Off); + if (model.Sirens.Stage1Setting != null) + model.AvailableLightStages.Add(LightStage.One); + if (model.Sirens.Stage2Setting != null) + model.AvailableLightStages.Add(LightStage.Two); + if (model.Sirens.Stage3Setting != null) + model.AvailableLightStages.Add(LightStage.Three); + + model.AvailableSirenStages.Add(SirenStage.Off); + if (model.SoundSettings.Tone1 != "") + model.AvailableSirenStages.Add(SirenStage.One); + if (model.SoundSettings.Tone2 != "") + model.AvailableSirenStages.Add(SirenStage.Two); + if (model.SoundSettings.Tone3 != "") + model.AvailableSirenStages.Add(SirenStage.Warning); + if (model.SoundSettings.Tone4 != "") + model.AvailableSirenStages.Add(SirenStage.Warning2); + + listModels.Add(model); + ("Added: " + model.Name).ToLog(); + } + catch (Exception e) + { + ("VCF IMPORT ERROR (" + Path.GetFileNameWithoutExtension(file) + "): " + e.Message).ToLog(); + Game.LogTrivial("VCF IMPORT ERROR (" + Path.GetFileNameWithoutExtension(file) + "): " + e.Message); + } + } + return listModels; + } + + public static Dictionary GetAllTAgroups() + { + string path = @"Plugins\DLS\Traffic Advisory\"; + _ = new TAgroup(); + Dictionary listTAgroups = new Dictionary(); + foreach (string file in Directory.EnumerateFiles(path, "*.xml")) + { + try + { + XmlSerializer mySerializer = new XmlSerializer(typeof(TAgroup)); + StreamReader streamReader = new StreamReader(file); + + TAgroup taGroup = (TAgroup)mySerializer.Deserialize(streamReader); + streamReader.Close(); + + string name = Path.GetFileNameWithoutExtension(file); + + listTAgroups.Add(name, taGroup); + ("Added TAgroup: " + name).ToLog(); + } + catch (Exception e) + { + ("TAGROUP IMPORT ERROR (" + Path.GetFileNameWithoutExtension(file) + "): " + e.Message).ToLog(); + Game.LogTrivial("TAGROUP IMPORT ERROR (" + Path.GetFileNameWithoutExtension(file) + "): " + e.Message); + } + } + return listTAgroups; + } + + public static EmergencyLighting GetEL(Vehicle veh, ActiveVehicle activeVeh = null) + { + DLSModel dlsModel = veh.GetDLS(); + if (activeVeh == null) + activeVeh = veh.GetActiveVehicle(); + string name = dlsModel.Name + " | " + activeVeh.LightStage.ToString() + " | " + activeVeh.TAStage.ToString() + " | " + activeVeh.SBOn.ToString(); + uint key = Game.GetHashKey(name); + EmergencyLighting eL; + if (Entrypoint.UsedPool.Count > 0 && Entrypoint.UsedPool.ContainsKey(key)) + { + eL = Entrypoint.UsedPool[key]; + ("Allocated \"" + name + "\" (" + key + ") for " + veh.Handle + " from Used Pool").ToLog(); + } + else if (Entrypoint.AvailablePool.Count > 0) + { + eL = Entrypoint.AvailablePool[0]; + Entrypoint.AvailablePool.Remove(eL); + ("Removed \"" + eL.Name + "\" from Available Pool").ToLog(); + ("Allocated \"" + name + "\" (" + key + ") for " + veh.Handle + " from Available Pool").ToLog(); + } + else + { + if (EmergencyLighting.GetByName(name) == null) + { + Model model = new Model("police"); + eL = model.EmergencyLighting.Clone(); + eL.Name = name; + ("Created \"" + name + "\" (" + key + ") for " + veh.Handle).ToLog(); + } + else + { + eL = EmergencyLighting.GetByName(name); + ("Allocated \"" + name + "\" (" + key + ") for " + veh.Handle + " from Game Memory").ToLog(); + } + } + if (activeVeh.LightStage != LightStage.Off && activeVeh.LightStage != LightStage.Empty) + { + switch (activeVeh.LightStage) + { + case LightStage.One: + SirenApply.ApplySirenSettingsToEmergencyLighting(dlsModel.Sirens.Stage1Setting, eL); + break; + case LightStage.Two: + SirenApply.ApplySirenSettingsToEmergencyLighting(dlsModel.Sirens.Stage2Setting, eL); + break; + case LightStage.Three: + SirenApply.ApplySirenSettingsToEmergencyLighting(dlsModel.Sirens.Stage3Setting, eL); + break; + case LightStage.CustomOne: + SirenApply.ApplySirenSettingsToEmergencyLighting(dlsModel.Sirens.CustomStage1, eL); + break; + case LightStage.CustomTwo: + SirenApply.ApplySirenSettingsToEmergencyLighting(dlsModel.Sirens.CustomStage2, eL); + break; + default: + SirenApply.ApplySirenSettingsToEmergencyLighting(dlsModel.Sirens.Stage3Setting, eL); + break; + } + } + else + { + SirenApply.ApplySirenSettingsToEmergencyLighting(dlsModel.Sirens.Stage3Setting, eL); + eL.LeftHeadLightSequence = "00000000000000000000000000000000"; + eL.LeftTailLightSequence = "00000000000000000000000000000000"; + eL.RightHeadLightSequence = "00000000000000000000000000000000"; + eL.RightTailLightSequence = "00000000000000000000000000000000"; + for (int i = 0; i < eL.Lights.Length; i++) + { + EmergencyLight eLig = eL.Lights[i]; + eLig.FlashinessSequence = "00000000000000000000000000000000"; + eLig.RotationSequence = "00000000000000000000000000000000"; + } + } + if (!Entrypoint.UsedPool.ContainsKey(key)) + Entrypoint.UsedPool.Add(key, eL); + activeVeh.CurrentHash = key; + return eL; + } + + public static bool GetSirenKill(ActiveVehicle activeVehicle) + { + Vehicle veh = activeVehicle.Vehicle; + if (veh) + { + DLSModel dlsModel = veh.GetDLS(); + if (dlsModel != null) + { + bool _ = Entrypoint.SirenKill; + if (dlsModel.SoundSettings.SirenKillOverride.ToBoolean() == true) + _ = dlsModel.SoundSettings.SirenKillOverride.ToBoolean(); + return _; + } + } + return false; + } + } +} diff --git a/Templates/DLS.ini b/Templates/DLS.ini new file mode 100644 index 0000000..05a615d --- /dev/null +++ b/Templates/DLS.ini @@ -0,0 +1,78 @@ +[Keyboard] +//https://msdn.microsoft.com/en-us/library/system.windows.forms.keys(v=vs.110).aspx + +//Key to toggle light stage (Default = J) +LightStage=J + +//Key to toggle traffic advisor stage (Default = K) +TAdvisor=K + +//Key to toggle siren (Default = G) +SirenToggle=G + +//Key to trigger sound stage 1 (Default = D1) +Tone1=D1 + +//Key to trigger sound stage 2 (Default = D2) +Tone2=D2 + +//Key to trigger sound stage 3 (Default = D3) +Tone3=D3 + +//Key to trigger sound stage 4 (Default = D4) +Tone4=D4 + +//Key to trigger aux siren (Default = D6) +AuxToggle=D6 + +//Key to Manual Siren (Default = T) +Manual=T + +//Key to Horn (Default = Y) +Horn=Y + +//Key to enable/disable the Steady Burn (Default = OemOpenBrackets) +SteadyBurn=OemOpenBrackets + +//Key to enable/disable the Interior Light (Default = OemCloseBrackets) +InteriorLT=OemCloseBrackets + +// Key to trigger the left indicator (Default = OemMinus) +IndL=OemMinus + +// Key to trigger the right indicator (Default = Oemplus) +IndR=Oemplus + +// Key to trigger the hazard lights (Default = Back) +Hazard=Back + +//Key to lock/unlock all DLS keys (Default = Scroll) +LockAll=Scroll + +//UI Modifier Key ("Shift", "Alt" or "Control") (Default = Shift) +UIModifier=Shift + +//UI Key (Default = E) +UIKey=E + +[Settings] + +//Enable or disable Siren Control for non-DLS enabled vehicles. +SirenControlNonDLS=true + +//Enable or disable Lights Control for AI vehicles. +AILightsControl=true + +//Enable or disable indicators +IndEnabled=true + +//Enable or disable Brake Lights +BrakeLightsEnabled=true + +[UI] + +//Width of the UI (Default = 550) +Width=550 + +//Height of the UI (Default = 220) +Height=220 \ No newline at end of file diff --git a/Templates/custom.xml b/Templates/custom.xml new file mode 100644 index 0000000..29de789 --- /dev/null +++ b/Templates/custom.xml @@ -0,0 +1,6 @@ + + + + 550 + 220 + \ No newline at end of file diff --git a/Templates/police.xml b/Templates/police.xml new file mode 100644 index 0000000..56a0093 --- /dev/null +++ b/Templates/police.xml @@ -0,0 +1,2454 @@ + + + + + + true + + true + + true + + false + + false + + false + + + + + + none + + + false + + + + + + + + false + + + + + + + + VEHICLES_HORNS_SIREN_1 + VEHICLES_HORNS_SIREN_2 + VEHICLES_HORNS_POLICE_WARNING + VEHICLES_HORNS_AMBULANCE_WARNING + SIRENS_AIRHORN + + false + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + off + + false + + + + + + + + + + + + + + + + + + + + + + + + VehicleLight_sirenlight + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VehicleLight_sirenlight + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VehicleLight_sirenlight + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file