OpenCS2hock.sln.DotSettings

@@ -6,6 +6,5 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=libraryfolders/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=NYAA/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=OpenCS2hock/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=Sharecode/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=steamapps/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=steamid/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

OpenCS2hock.sln.DotSettings.user

@@ -1,11 +1,4 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/AddReferences/RecentPaths/=C_003A_005CUsers_005CGlax_005CRiderProjects_005CCShocker_005CCShocker_005Cbin_005CDebug_005Cnet7_002E0_005CCShocker_002Edll/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/AddReferences/RecentPaths/=C_003A_005CUsers_005CGlax_005CRiderProjects_005CCShocker_005CCShocker_005Cbin_005CRelease_005Cnet7_002E0_005Cpublish_005CCShocker_002Edll/@EntryIndexedValue">True</s:Boolean>
-	<s:String x:Key="/Default/Environment/AssemblyExplorer/XmlDocument/@EntryValue">&lt;AssemblyExplorer&gt;&#xD;
-  &lt;Assembly Path="C:\Users\Glax\RiderProjects\CShocker\CShocker\bin\Debug\net7.0\CShocker.dll" /&gt;&#xD;
-&lt;/AssemblyExplorer&gt;</s:String>
-	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=b6376c03_002D06ba_002D424d_002Db00f_002Dbee38277f47a/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" Name="All tests from Solution" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;&#xD;
-  &lt;Solution /&gt;&#xD;
-&lt;/SessionState&gt;</s:String>
 	
 	<s:Boolean x:Key="/Default/ResxEditorPersonal/Initialized/@EntryValue">True</s:Boolean></wpf:ResourceDictionary>

OpenCS2hock/Configuration.cs

@@ -1,7 +1,4 @@
-using CShocker.Devices.Abstract;
-using CShocker.Devices.Additional;
-using CShocker.Shockers.Abstract;
-using CShocker.Shockers.Additional;
+using CShocker.Shockers.Abstract;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 
@@ -11,49 +8,37 @@ public struct Configuration
 {
     public LogLevel LogLevel = LogLevel.Information;
 
-    public List<ShockerAction> ShockerActions { get; init; }
+    public List<Shocker> Shockers = new();
 
-    public List<Api> Apis { get; init; }
-
-    public Dictionary<int, Shocker> Shockers { get; init; }
+    public List<ShockerAction> ShockerActions = new ();
 
     public Configuration()
     {
-        ShockerActions = new ();
-        Apis = new();
-        Shockers = new();
+        
     }
 
     public override string ToString()
     {
         return $"Loglevel: {Enum.GetName(typeof(LogLevel), LogLevel)}\n" +
-               $"Apis:\n{string.Join("\n---\n", Apis)}\n" +
-               $"Shockers:\n{string.Join("\n---\n", Shockers)}\n" +
-               $"Actions:\n{string.Join("\n---\n", ShockerActions)}\n";
+               $"Shockers: {string.Join("\n---", Shockers)}\n" +
+               $"Actions: {string.Join("\n---", ShockerActions)}";
     }
     
     internal static Configuration GetConfigurationFromFile(string? path = null, ILogger? logger = null)
     {
         string settingsFilePath = path ?? "config.json";
-        Configuration c;
         if (!File.Exists(settingsFilePath))
-            c = Setup.Run().SaveConfiguration();
-        else
-            c = JsonConvert.DeserializeObject<Configuration>(File.ReadAllText(settingsFilePath), new ApiJsonConverter(), new ShockerJsonConverter());
-        if (!c.ConfigurationValid())
-            throw new Exception("Configuration validation failed.");
+            Setup.Run().SaveConfiguration();
+          
+        Configuration c = JsonConvert.DeserializeObject<Configuration>(File.ReadAllText(settingsFilePath), new CShocker.Shockers.ShockerJsonConverter());
+        foreach (Shocker cShocker in c.Shockers)
+            cShocker.SetLogger(logger);
         return c;
     }
 
-    internal Configuration SaveConfiguration(string? path = null)
+    internal void SaveConfiguration(string? path = null)
     {
         string settingsFilePath = path ?? "config.json";
         File.WriteAllText(settingsFilePath, JsonConvert.SerializeObject(this, Formatting.Indented));
-        return this;
-    }
-
-    private bool ConfigurationValid()
-    {
-        return true; //TODO Check values
     }
 }

OpenCS2hock/Logger.cs

@@ -0,0 +1,65 @@
+using Microsoft.Extensions.Logging;
+
+namespace OpenCS2hock;
+
+public class Logger : ILogger
+{
+    private LogLevel _enabledLoglevel;
+    private readonly ConsoleColor _defaultForegroundColor = Console.ForegroundColor;
+    private readonly ConsoleColor _defaultBackgroundColor = Console.BackgroundColor;
+
+    public Logger(LogLevel logLevel = LogLevel.Trace)
+    {
+        _enabledLoglevel = logLevel;
+    }
+
+    public void UpdateLogLevel(LogLevel logLevel)
+    {
+        this._enabledLoglevel = logLevel;
+    }
+    
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+    {
+        if (!IsEnabled(logLevel))
+            return;
+        Console.ForegroundColor = ForegroundColorForLogLevel(logLevel);
+        Console.BackgroundColor = BackgroundColorForLogLevel(logLevel);
+        Console.Write(logLevel.ToString()[..3].ToUpper());
+        Console.ResetColor();
+        // ReSharper disable once LocalizableElement
+        Console.Write($" [{DateTime.UtcNow:HH:mm:ss.fff}] ");
+        Console.WriteLine(formatter.Invoke(state, exception));
+    }
+
+    public bool IsEnabled(LogLevel logLevel)
+    {
+        return logLevel >= _enabledLoglevel;
+    }
+
+    public IDisposable? BeginScope<TState>(TState state) where TState : notnull
+    {
+        return null;
+    }
+
+    private ConsoleColor ForegroundColorForLogLevel(LogLevel logLevel)
+    {
+        return logLevel switch
+        {
+            LogLevel.Error or LogLevel.Critical => ConsoleColor.Black,
+            LogLevel.Debug => ConsoleColor.Black,
+            LogLevel.Information => ConsoleColor.White,
+            _ => _defaultForegroundColor
+        };
+    }
+    
+    private ConsoleColor BackgroundColorForLogLevel(LogLevel logLevel)
+    {
+        return logLevel switch
+        {
+            LogLevel.Error or LogLevel.Critical => ConsoleColor.Red,
+            LogLevel.Debug => ConsoleColor.Yellow,
+            LogLevel.Information => ConsoleColor.Black,
+            _ => _defaultBackgroundColor
+        };
+    }
+}

OpenCS2hock/OpenCS2hock.cs

@@ -1,7 +1,8 @@
 using Microsoft.Extensions.Logging;
 using CS2GSI;
-using GlaxLogger;
-using CS2Event = CS2GSI.CS2Event;
+using CShocker.Ranges;
+using CShocker.Shockers.Abstract;
+using CS2Event = CS2GSI.CS2GSI.CS2Event;
 
 namespace OpenCS2hock;
 
@@ -34,43 +35,75 @@ public class OpenCS2hock
         this._logger?.Log(LogLevel.Information, "Setting up EventHandlers...");
         foreach (ShockerAction shockerAction in this._configuration.ShockerActions)
         {
-            switch (shockerAction.TriggerEvent)
+            foreach (string shockerId in shockerAction.ShockerIds)
+            {
+                Shocker shocker = this._configuration.Shockers.First(s => s.ShockerIds.Contains(shockerId));
+                switch (shockerAction.TriggerEvent)
                 {
-                    case CS2Event.OnKill: this._cs2GSI.OnKill += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnHeadshot: this._cs2GSI.OnHeadshot += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnDeath: this._cs2GSI.OnDeath += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnFlashed: this._cs2GSI.OnFlashed += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnBurning: this._cs2GSI.OnBurning += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnSmoked: this._cs2GSI.OnSmoked += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnRoundStart: this._cs2GSI.OnRoundStart += args => EventHandler(args,shockerAction); break;
-                    case CS2Event.OnRoundOver: this._cs2GSI.OnRoundOver += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnRoundWin: this._cs2GSI.OnRoundWin += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnRoundLoss: this._cs2GSI.OnRoundLoss += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnDamageTaken: this._cs2GSI.OnDamageTaken += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnMatchStart: this._cs2GSI.OnMatchStart += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnMatchOver: this._cs2GSI.OnMatchOver += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnMoneyChange: this._cs2GSI.OnMoneyChange += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnHealthChange: this._cs2GSI.OnHealthChange += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnArmorChange: this._cs2GSI.OnArmorChange += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnHelmetChange: this._cs2GSI.OnHelmetChange += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnEquipmentValueChange: this._cs2GSI.OnEquipmentValueChange += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnTeamChange: this._cs2GSI.OnTeamChange += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnPlayerChange: this._cs2GSI.OnPlayerChange += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnHalfTime: this._cs2GSI.OnHalfTime += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnFreezeTime: this._cs2GSI.OnFreezeTime += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnBombPlanted: this._cs2GSI.OnBombPlanted += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnBombDefused: this._cs2GSI.OnBombDefused += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.OnBombExploded: this._cs2GSI.OnBombExploded += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.AnyEvent: this._cs2GSI.AnyEvent += args => EventHandler(args, shockerAction); break;
-                    case CS2Event.AnyMessage: this._cs2GSI.AnyMessage += args => EventHandler(args, shockerAction); break;
+                    case CS2Event.OnKill: this._cs2GSI.OnKill += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnHeadshot: this._cs2GSI.OnHeadshot += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnDeath: this._cs2GSI.OnDeath += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnFlashed: this._cs2GSI.OnFlashed += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnBurning: this._cs2GSI.OnBurning += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnSmoked: this._cs2GSI.OnSmoked += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnRoundStart: this._cs2GSI.OnRoundStart += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnRoundOver: this._cs2GSI.OnRoundOver += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnRoundWin: this._cs2GSI.OnRoundWin += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnRoundLoss: this._cs2GSI.OnRoundLoss += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnDamageTaken: this._cs2GSI.OnDamageTaken += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnMatchStart: this._cs2GSI.OnMatchStart += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnMatchOver: this._cs2GSI.OnMatchOver += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnMoneyChange: this._cs2GSI.OnMoneyChange += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnHealthChange: this._cs2GSI.OnHealthChange += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnArmorChange: this._cs2GSI.OnArmorChange += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnHelmetChange: this._cs2GSI.OnHelmetChange += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnEquipmentValueChange: this._cs2GSI.OnEquipmentValueChange += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnTeamChange: this._cs2GSI.OnTeamChange += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnPlayerChange: this._cs2GSI.OnPlayerChange += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnHalfTime: this._cs2GSI.OnHalfTime += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnFreezeTime: this._cs2GSI.OnFreezeTime += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnBombPlanted: this._cs2GSI.OnBombPlanted += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnBombDefused: this._cs2GSI.OnBombDefused += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.OnBombExploded: this._cs2GSI.OnBombExploded += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.AnyEvent: this._cs2GSI.AnyEvent += args => EventHandler(args, shockerId, shocker, shockerAction); break;
+                    case CS2Event.AnyMessage: this._cs2GSI.AnyMessage += args => EventHandler(args, shockerId, shocker, shockerAction); break;
                     default: this._logger?.Log(LogLevel.Debug, $"CS2Event {nameof(shockerAction.TriggerEvent)} unknown."); break;
                 }
+            }
         }
     }
 
-    private void EventHandler(CS2EventArgs cs2EventArgs, ShockerAction shockerAction)
+    private void EventHandler(CS2EventArgs cs2EventArgs, string shockerId, Shocker shocker, ShockerAction shockerAction)
     {
-        this._logger?.Log(LogLevel.Information, $"Action {shockerAction}\nEventArgs: {cs2EventArgs}");
-        shockerAction.Execute(_configuration.Shockers, cs2EventArgs);
+        this._logger?.Log(LogLevel.Information, $"Shocker: {shocker}\nID: {shockerId}\nAction: {shockerAction}\nEventArgs: {cs2EventArgs}");
+        shocker.Control(shockerAction.Action, shockerId,
+            GetIntensity(shockerAction.ValueFromInput, shockerAction.TriggerEvent, cs2EventArgs, shockerId));
+    }
+
+    private int GetIntensity(bool valueFromInput, CS2Event cs2Event, CS2EventArgs eventArgs, string shockerId)
+    {
+        return valueFromInput
+            ? IntensityFromCS2Event(cs2Event, eventArgs, shockerId)
+            : this._configuration.Shockers.First(shocker => shocker.ShockerIds.Contains(shockerId))
+                .IntensityRange.GetRandomRangeValue();
+    }
+
+    private int IntensityFromCS2Event(CS2Event cs2Event, CS2EventArgs eventArgs, string shockerId)
+    {
+        IntensityRange configuredRangeForShocker = this._configuration.Shockers
+            .First(shocker => shocker.ShockerIds.Contains(shockerId))
+            .IntensityRange;
+        return cs2Event switch
+        {
+            CS2Event.OnDamageTaken => MapInt(eventArgs.ValueAsOrDefault<int>(), 0, 100, configuredRangeForShocker.Min, configuredRangeForShocker.Max),
+            CS2Event.OnArmorChange => MapInt(eventArgs.ValueAsOrDefault<int>(), 0, 100, configuredRangeForShocker.Min, configuredRangeForShocker.Max),
+            _ => configuredRangeForShocker.GetRandomRangeValue()
+        };
+    }
+
+    private int MapInt(int input, int fromLow, int fromHigh, int toLow, int toHigh) 
+    {
+        int mappedValue = (input - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow;
+        return mappedValue;
     }
 }

OpenCS2hock/OpenCS2hock.csproj

@@ -10,9 +10,8 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="CS2GSI" Version="1.0.8" />
-      <PackageReference Include="CShocker" Version="2.5.1" />
-      <PackageReference Include="GlaxLogger" Version="1.0.7.2" />
+      <PackageReference Include="CS2GSI" Version="1.0.6" />
+      <PackageReference Include="CShocker" Version="1.1.11" />
       <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     </ItemGroup>
 

OpenCS2hock/Program.cs

@@ -1,5 +1,4 @@
-using GlaxLogger;
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 
 namespace OpenCS2hock;
 

OpenCS2hock/Setup.cs

@@ -1,14 +1,10 @@
-using System.Runtime.InteropServices;
-using System.Runtime.Versioning;
-using System.Text.RegularExpressions;
-using CShocker.Devices.Abstract;
-using CShocker.Devices.Additional;
-using CShocker.Devices.APIs;
+using System.Text.RegularExpressions;
 using CShocker.Ranges;
 using CShocker.Shockers;
 using CShocker.Shockers.Abstract;
+using CShocker.Shockers.APIS;
 using Microsoft.Extensions.Logging;
-using CS2Event = CS2GSI.CS2Event;
+using CS2Event = CS2GSI.CS2GSI.CS2Event;
 
 namespace OpenCS2hock;
 
@@ -20,13 +16,36 @@ public static class Setup
         Console.Clear();
         Console.WriteLine("Running first-time setup.");
         Configuration c = new();
+        
+        Console.WriteLine("First adding APIs:");
+        Console.WriteLine("Press Enter.");
+        while (Console.ReadKey().Key != ConsoleKey.Enter)
+        {//NYAA
+        }
 
-        AddApisWorkflow(ref c);
+        bool addShocker = true;
+        while (c.Shockers.Count < 1 || addShocker)
+        {
+            Console.Clear();
+            AddShockerApi(ref c);
+            Console.WriteLine("Add another Shocker-API (Y/N):");
+            addShocker = Console.ReadKey().Key == ConsoleKey.Y;
+        }
         
         Console.Clear();
-        
-        AddActionsWorkflow(ref c);
-        
+        Console.WriteLine("Now adding Actions:");
+        Console.WriteLine("Press Enter.");
+        while (Console.ReadKey().Key != ConsoleKey.Enter)
+        {//NYAA
+        }
+        bool addAction = true;
+        while (c.ShockerActions.Count < 1 || addAction)
+        {
+            Console.Clear();
+            AddAction(ref c);
+            Console.WriteLine("Add another Action (Y/N):");
+            addAction = Console.ReadKey().Key == ConsoleKey.Y;
+        }
         return c;
     }
 
@@ -36,222 +55,106 @@ public static class Setup
         while (pressedKey is not ConsoleKey.X && pressedKey is not ConsoleKey.Q)
         {
             Console.Clear();
-            Console.WriteLine("Config Edit Mode.\n");
+            Console.WriteLine("Config Edit Mode.");
+            Console.WriteLine("What do you want to edit?");
             Console.WriteLine("1) LogLevel");
-            Console.WriteLine("2) Add API");
-            Console.WriteLine("3) Refresh Shockers (OpenShock)");
-            Console.WriteLine("4) Add Action");
+            Console.WriteLine("2) Shocker-APIs");
+            Console.WriteLine("3) Event Actions");
             Console.WriteLine("\nq) Quit Edit Mode");
             pressedKey = Console.ReadKey().Key;
             switch (pressedKey)
             {
                 case ConsoleKey.D1:
+                    Console.WriteLine("New LogLevel:");
                     string[] levels = Enum.GetNames<LogLevel>();
+                    for(int i = 0; i < levels.Length; i++)
+                        Console.WriteLine($"{i}) {levels[i]}");
                     int selected;
-                    do
-                    {
-                        Console.Clear();
-                        Console.WriteLine("New LogLevel:");
-                        for (int i = 0; i < levels.Length; i++)
-                            Console.WriteLine($"{i}) {levels[i]}");
-                    } while (!int.TryParse(Console.ReadKey().KeyChar.ToString(), out selected) || selected < 0 || selected >= levels.Length);
-                    Console.WriteLine();//NewLine after Input
+                    while (!int.TryParse(Console.ReadKey().KeyChar.ToString(), out selected) || selected < 0 ||
+                           selected >= levels.Length)
+                    {//NYAA
+                    }
                     c.LogLevel = Enum.Parse<LogLevel>(levels[selected]);
                     break;
                 case ConsoleKey.D2:
-                    AddApisWorkflow(ref c);
+                    bool addShocker = true;
+                    while (c.Shockers.Count < 1 || addShocker)
+                    {
+                        Console.Clear();
+                        AddShockerApi(ref c);
+                        Console.WriteLine("Add another Shocker-API (Y/N):");
+                        addShocker = Console.ReadKey().Key == ConsoleKey.Y;
+                    }
                     break;
                 case ConsoleKey.D3:
-                    // ReSharper disable once PossibleInvalidCastExceptionInForeachLoop Only returning OpenShockApi Objects
-                    foreach (OpenShockApi api in c.Apis.Where(a => a is OpenShockApi))
+                    bool addAction = true;
+                    while (c.ShockerActions.Count < 1 || addAction)
                     {
-                        Configuration configuration = c;
-                        foreach(OpenShockShocker s in api.GetShockers().Where(s => !configuration.Shockers.ContainsValue(s)))
-                            c.Shockers.Add(c.Shockers.Any() ? c.Shockers.Keys.Max() + 1 : 0, s);
+                        Console.Clear();
+                        AddAction(ref c);
+                        Console.WriteLine("Add another Action (Y/N):");
+                        addAction = Console.ReadKey().Key == ConsoleKey.Y;
                     }
-
-                    break;
-                case ConsoleKey.D4:
-                    AddActionsWorkflow(ref c);
                     break;
             }
         }
         c.SaveConfiguration();
     }
 
-    private static void AddApisWorkflow(ref Configuration c)
-    {
-        Console.WriteLine("Adding APIs.");
-        bool addApis = true;
-        while (c.Apis.Count < 1 || addApis)
-        {
-            Console.Clear();
-            AddShockerApi(ref c);
-            Console.WriteLine("Add another Api (Y/N):");
-            addApis = Console.ReadKey().Key == ConsoleKey.Y;
-            Console.WriteLine();//NewLine after Input
-        }
-    }
-
-    private static void AddActionsWorkflow(ref Configuration c)
-    {
-        Console.WriteLine("Adding Actions.");
-        bool addAction = true;
-        while (c.ShockerActions.Count < 1 || addAction)
-        {
-            Console.Clear();
-            AddAction(ref c);
-            Console.WriteLine("Add another Action (Y/N):");
-            addAction = Console.ReadKey().Key == ConsoleKey.Y;
-            Console.WriteLine();//NewLine after Input
-        }
-    }
-
     private static void AddShockerApi(ref Configuration c)
     {
         Console.WriteLine("Select API:");
         Console.WriteLine("1) OpenShock (HTTP)");
-        Console.WriteLine("2) OpenShock (Serial Windows Only)");
-        Console.WriteLine("3) PiShock (HTTP) NotImplemented"); //TODO
-        Console.WriteLine("4) PiShock (Serial Windows Only) NotImplemented"); //TODO
-        char selectedChar = Console.ReadKey().KeyChar;
+        Console.WriteLine("2) OpenShock (Serial)");
+        Console.WriteLine("3) PiShock (HTTP)");
+        Console.WriteLine("4) PiShock (Serial)");
+        string? selectedChar = Console.ReadLine();
         int selected;
-        while (!int.TryParse(selectedChar.ToString(), out selected) || selected < 1 || selected > 4)
-            selectedChar = Console.ReadKey().KeyChar;
-        Console.WriteLine();//NewLine after Input
+        while (!int.TryParse(selectedChar, out selected) || selected < 1 || selected > 1)
+            selectedChar = Console.ReadLine();
 
-        string apiUri, apiKey;
-        Api? api = null;
+        Shocker newShocker;
         switch (selected)
         {
             case 1: //OpenShock (HTTP)
-                apiUri = QueryString($"OpenShock API-Endpoint ({OpenShockApi.DefaultEndpoint}):", OpenShockApi.DefaultEndpoint);
-                apiKey = QueryString("OpenShock API-Key:","");
-                api = new OpenShockHttp(apiKey, apiUri);
-                foreach(OpenShockShocker shocker in ((OpenShockHttp)api).GetShockers())
-                    c.Shockers.Add(c.Shockers.Any() ? c.Shockers.Keys.Max() + 1 : 0, shocker);
-                goto default;
-            case 2: //OpenShock (Serial)
-                if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                    throw new PlatformNotSupportedException("Serial is only supported on Windows.");
-                apiUri = QueryString($"OpenShock API-Endpoint ({OpenShockApi.DefaultEndpoint}):", OpenShockApi.DefaultEndpoint);
-                apiKey = QueryString("OpenShock API-Key:","");
-                SerialPortInfo serialPort = SelectSerialPort();
-                api = new OpenShockSerial(serialPort, apiKey, apiUri);
-                foreach (OpenShockShocker shocker in ((OpenShockSerial)api).GetShockers())
-                    c.Shockers.Add(c.Shockers.Any() ? c.Shockers.Keys.Max() + 1 : 0, shocker);
-                goto default;
-            case 3: //PiShock (HTTP)
-                goto default;
-            case 4: //PiShock (Serial)
-                if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                    throw new PlatformNotSupportedException("Serial is only supported on Windows.");
-                goto default;
-            default:
-                if (api is null)
-                    throw new NotImplementedException();
-                c.Apis.Add(api);
+                string apiUri = QueryString("OpenShock API-Endpoint (https://api.shocklink.net):",
+                    "https://api.shocklink.net");
+                string apiKey = QueryString("OpenShock API-Key:","");
+                Console.WriteLine("Shocker IDs associated with this API:");
+                List<string> shockerIds = GetShockerIds(c.Shockers);
+                IntensityRange intensityRange = GetIntensityRange();
+                DurationRange durationRange = GetDurationRange();
+
+                newShocker = new OpenShockHttp(shockerIds, intensityRange, durationRange, apiUri, apiKey);
                 break;
+            // ReSharper disable thrice RedundantCaseLabel
+            case 2: //OpenShock (Serial)
+            case 3: //PiShock (HTTP)
+            case 4: //PiShock (Serial)
+            default:
+                throw new NotImplementedException();
         }
-    }
-
-    [SupportedOSPlatform("windows")]
-    private static SerialPortInfo SelectSerialPort()
-    {
-        List<SerialPortInfo> serialPorts = SerialHelper.GetSerialPorts();
-
-        int selectedPort;
-        do
-        {
-            Console.Clear();
-            for(int i = 0; i < serialPorts.Count; i++)
-                Console.WriteLine($"{i}) {serialPorts[i]}");
-            Console.WriteLine($"Select Serial Port [0-{serialPorts.Count-1}]:");
-        } while (!int.TryParse(Console.ReadLine(), out selectedPort) || selectedPort < 0 || selectedPort >= serialPorts.Count);
-        Console.WriteLine();//NewLine after Input
-
-        return serialPorts[selectedPort];
+        c.Shockers.Add(newShocker);
     }
 
     private static void AddAction(ref Configuration c)
     {
         CS2Event triggerEvent = GetTrigger();
-        int shockerId = GetShockerId(c.Shockers);
+        Console.WriteLine("Shocker IDs to trigger when Event occurs:");
+        List<string> shockerIds = GetShockerIds(c.Shockers);
         ControlAction action = GetControlAction();
-        bool useEventArgsValue = QueryBool("Try using EventArgs to control Intensity (within set limits)?", false);
-        IntegerRange intensityRange = GetIntegerRange(0, 100, "%");
-        IntegerRange durationRange = GetIntegerRange(0, 30000, "ms");
+        bool useEventArgsValue = QueryBool("Try using EventArgs to control Intensity (within set limits)?", "false");
             
-        c.ShockerActions.Add(new(triggerEvent, shockerId, action, useEventArgsValue, intensityRange, durationRange));
+        c.ShockerActions.Add(new ShockerAction(triggerEvent, shockerIds, action, useEventArgsValue));
     }
 
-    private static int GetShockerId(Dictionary<int, Shocker> shockersDict)
+    private static bool QueryBool(string queryString, string defaultResult)
     {
-        List<Shocker> shockers = shockersDict.Values.ToList();
-        int selectedShockerIndex;
-        do
-        {
-            Console.Clear();
-            Console.WriteLine("Select Shocker:");
-            for (int i = 0; i < shockers.Count; i++)
-                Console.WriteLine($"{i}) {shockers[i]}");
-        } while (!int.TryParse(Console.ReadLine(), out selectedShockerIndex) || selectedShockerIndex < 0 || selectedShockerIndex > shockersDict.Count);
-        Console.WriteLine();//NewLine after Input
-
-        Shocker shocker = shockers[selectedShockerIndex];
-
-        return shockersDict.First(s => s.Value == shocker).Key;
-    }
-
-    private static IntegerRange GetIntegerRange(int min, int max, string? unit = null)
-    {
-        Regex rangeRex = new (@"([0-9]{1,5})\-([0-9]{1,5})");
-
-        string intensityRangeStr;
-        do
-        {
-            intensityRangeStr = QueryString($"Range ({min}-{max}) {(unit is null ? "" : $"in {unit}")}:", "0-100");
-        } while (!rangeRex.IsMatch(intensityRangeStr));
-        return new IntegerRange(short.Parse(rangeRex.Match(intensityRangeStr).Groups[1].Value), short.Parse(rangeRex.Match(intensityRangeStr).Groups[2].Value));
-    }
-
-    private static CS2Event GetTrigger()
-    {
-        string[] eventNames = Enum.GetNames(typeof(CS2Event));
-
-        int selectedIndex;
-        do
-        {
-            Console.Clear();
-            Console.WriteLine("Select CS2 Trigger-Event:");
-            for (int i = 0; i < eventNames.Length; i++)
-                Console.WriteLine($"{i}) {eventNames[i]}");
-        } while (!int.TryParse(Console.ReadLine(), out selectedIndex) || selectedIndex < 0 || selectedIndex >= eventNames.Length);
-
-        return Enum.Parse<CS2Event>(eventNames[selectedIndex]);
-    }
-
-    private static ControlAction GetControlAction()
-    {
-        string[] actionNames = Enum.GetNames(typeof(ControlAction));
-        int selectedIndex;
-        do
-        {
-            Console.Clear();
-            Console.WriteLine("Select Action:");
-            for (int i = 0; i < actionNames.Length; i++)
-                Console.WriteLine($"{i}) {actionNames[i]}");
-        } while (!int.TryParse(Console.ReadLine(), out selectedIndex) || selectedIndex < 0 || selectedIndex >= actionNames.Length);
-
-        return Enum.Parse<ControlAction>(actionNames[selectedIndex]);
-    }
-
-    private static bool QueryBool(string queryString, bool defaultResult)
-    {
-        Console.WriteLine(queryString);
-        char userInput = Console.ReadKey().KeyChar;
-        Console.WriteLine();//NewLine after Input
-        return bool.TryParse(userInput.ToString(), out bool ret) ? ret : defaultResult;
+        string value = QueryString(queryString, defaultResult);
+        bool ret;
+        while (bool.TryParse(value, out ret))
+            value = QueryString(queryString, defaultResult);
+        return ret;
     }
 
     private static string QueryString(string queryString, string defaultResult)
@@ -260,4 +163,80 @@ public static class Setup
         string? userInput = Console.ReadLine();
         return userInput?.Length > 0 ? userInput : defaultResult;
     }
+
+    private static IntensityRange GetIntensityRange()
+    {
+        Regex intensityRangeRex = new (@"([0-9]{1,3})\-(1?[0-9]{1,2})");
+        string intensityRangeStr = "";
+        while(!intensityRangeRex.IsMatch(intensityRangeStr))
+            intensityRangeStr = QueryString("Intensity Range (0-100) in %:", "0-100");
+        short min = short.Parse(intensityRangeRex.Match(intensityRangeStr).Groups[1].Value);
+        short max = short.Parse(intensityRangeRex.Match(intensityRangeStr).Groups[2].Value);
+        return new IntensityRange(min, max);
+    }
+    
+    private static DurationRange GetDurationRange()
+    {
+        Regex intensityRangeRex = new (@"([0-9]{1,4})\-([0-9]{1,5})");
+        string intensityRangeStr = "";
+        while(!intensityRangeRex.IsMatch(intensityRangeStr))
+            intensityRangeStr = QueryString("Duration Range (500-30000) in ms:", "500-30000");
+        short min = short.Parse(intensityRangeRex.Match(intensityRangeStr).Groups[1].Value);
+        short max = short.Parse(intensityRangeRex.Match(intensityRangeStr).Groups[2].Value);
+        return new DurationRange(min, max);
+    }
+
+    private static List<string> GetShockerIds(List<Shocker> shockers)
+    {
+        List<string> allShockerIds = new();
+        foreach(Shocker shocker in shockers)
+            allShockerIds.AddRange(shocker.ShockerIds);
+
+        List<string> ids = new();
+        bool addAnother = true;
+        while (ids.Count < 1 || addAnother)
+        {
+            
+            for (int i = 0; i < allShockerIds.Count; i++)
+                Console.WriteLine($"{i}) {allShockerIds[i]}");
+
+            int selectedIndex;
+            while (!int.TryParse(Console.ReadLine(), out selectedIndex) || selectedIndex < 0 || selectedIndex >= allShockerIds.Count)
+                Console.WriteLine("Select ID:");
+            
+            ids.Add(allShockerIds[selectedIndex]);
+            
+            Console.WriteLine("Add another ID? (Y/N):");
+            addAnother = Console.ReadKey().Key == ConsoleKey.Y;
+        }
+        return ids;
+    }
+
+    private static CS2Event GetTrigger()
+    {
+        string[] names = Enum.GetNames(typeof(CS2Event));
+        Console.WriteLine("Select CS2 Trigger-Event:");
+        for (int i = 0; i < names.Length; i++)
+            Console.WriteLine($"{i}) {names[i]}");
+
+        int selectedIndex;
+        while (!int.TryParse(Console.ReadLine(), out selectedIndex))
+            Console.WriteLine("Select CS2 Trigger-Event:");
+
+        return Enum.Parse<CS2Event>(names[selectedIndex]);
+    }
+
+    private static ControlAction GetControlAction()
+    {
+        string[] names = Enum.GetNames(typeof(ControlAction));
+        Console.WriteLine("Select Action:");
+        for (int i = 0; i < names.Length; i++)
+            Console.WriteLine($"{i}) {names[i]}");
+
+        int selectedIndex;
+        while (!int.TryParse(Console.ReadLine(), out selectedIndex))
+            Console.WriteLine("Select Action:");
+
+        return Enum.Parse<ControlAction>(names[selectedIndex]);
+    }
 }

OpenCS2hock/ShockerAction.cs

@@ -1,58 +1,28 @@
-using CS2GSI;
-using CShocker.Devices.Additional;
-using CShocker.Ranges;
-using CShocker.Shockers.Abstract;
+using CShocker.Shockers;
+using CS2Event = CS2GSI.CS2GSI.CS2Event;
 
 namespace OpenCS2hock;
 
 public struct ShockerAction
 {
     public CS2Event TriggerEvent;
-    // ReSharper disable MemberCanBePrivate.Global -> exposed
-    public int ShockerId;
+    // ReSharper disable thrice FieldCanBeMadeReadOnly.Global JsonDeserializer will throw a fit
+    public List<string> ShockerIds;
     public ControlAction Action;
     public bool ValueFromInput;
-    public IntegerRange IntensityRange, DurationRange;
 
-    public ShockerAction(CS2Event trigger, int shockerId, ControlAction action, bool valueFromInput, IntegerRange intensityRange, IntegerRange durationRange)
+    public ShockerAction(CS2Event trigger, List<string> shockerIds, ControlAction action, bool valueFromInput = false)
     {
         this.TriggerEvent = trigger;
-        this.ShockerId = shockerId;
+        this.ShockerIds = shockerIds;
         this.Action = action;
         this.ValueFromInput = valueFromInput;
-        this.IntensityRange = intensityRange;
-        this.DurationRange = durationRange;
-    }
-
-    public void Execute(Dictionary<int, Shocker> shockers, CS2EventArgs cs2EventArgs)
-    {
-        if (!shockers.ContainsKey(ShockerId))
-            return;
-        int intensity = ValueFromInput ? IntensityFromCS2Event(cs2EventArgs) : IntensityRange.RandomValueWithinLimits();
-        int duration = DurationRange.RandomValueWithinLimits();
-        shockers[ShockerId].Control(Action, intensity, duration);
-    }
-
-    private int IntensityFromCS2Event(CS2EventArgs cs2EventArgs)
-    {
-        return TriggerEvent switch
-        {
-            CS2Event.OnDamageTaken => MapInt(cs2EventArgs.ValueAsOrDefault<int>(), 0, 100, IntensityRange.Min, IntensityRange.Max),
-            CS2Event.OnArmorChange => MapInt(cs2EventArgs.ValueAsOrDefault<int>(), 0, 100, IntensityRange.Min, IntensityRange.Max),
-            _ => IntensityRange.RandomValueWithinLimits()
-        };
-    }
-
-    private int MapInt(int input, int fromLow, int fromHigh, int toLow, int toHigh) 
-    {
-        int mappedValue = (input - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow;
-        return mappedValue;
     }
 
     public override string ToString()
     {
         return $"Trigger Event: {Enum.GetName(typeof(CS2Event), this.TriggerEvent)}\n" +
-               $"ShockerId: {ShockerId}\n" +
+               $"ShockerIds: {string.Join(", ", ShockerIds)}\n" +
                $"Action: {Enum.GetName(typeof(ControlAction), this.Action)}\n" +
                $"ValueFromInput: {ValueFromInput}";
     }

README.md

@@ -2,7 +2,7 @@
 ![GitHub License](https://img.shields.io/github/license/c9glax/OpenCS2hock)
 ![GitHub Release](https://img.shields.io/github/v/release/c9glax/OpenCS2hock)
 
-Electrifying your Counter-Strike experience. With [OpenShock](https://openshock.org/) and [PiShock](https://pishock.com/#/)! (Not Associated)
+Electrifying your Counter-Strike experience. With [OpenShock](https://openshock.org/)!
 
 ## How to use
 
@@ -43,58 +43,30 @@ Example `config.json`. Place next to executable. Will also be generated on first
 }
 ```
 
-## LogLevel 
-[Levels](https://learn.microsoft.com/de-de/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-8.0)
-
-## Shockers
-
 ### ApiKey 
-- For OpenShock (HTTP) get token [here](https://shocklink.net/#/dashboard/tokens)
-- For PiShock (HTTP) get information [here](https://apidocs.pishock.com/#header-authenticating)
-
-### ApiType
-CShocker [![Github](https://img.shields.io/badge/Github-8A2BE2)](https://github.com/C9Glax/cshocker) [here](https://github.com/C9Glax/CShocker/blob/master/CShocker/Shockers/Abstract/ShockerApi.cs)
+For OpenShock get token [here](https://shocklink.net/#/dashboard/tokens)
 
 ### ShockerIds
-List of Shocker-Ids, comma seperated.
+List of Shocker-Ids, comma seperated. Get Id [here](https://shocklink.net/#/dashboard/shockers/own). Press the three dots -> Edit
 
-`[ "ID-1-asdasd", "ID-2-fghfgh" ]`
+Example `[ "ID-1", "ID-2" ]`
 
 ### Intensity Range
-in percent
+`0-100`%
 
-`0-100`
 
 ### Duration Range
 in ms
-- `0-30000` OpenShock
-- `0-15000` PiShock
 
-### Username (PiShockHttp only)
-For PiShock (HTTP) get information [here](https://apidocs.pishock.com/#header-authenticating)
-
-### Sharecode (PiShockHttp only)
-For PiShock (HTTP) get information [here](https://apidocs.pishock.com/#header-authenticating)
-
-## ShockerActions
-
-### TriggerEvent IDs
-From CS2GSI [![Github](https://img.shields.io/badge/Github-8A2BE2)](https://github.com/C9Glax/CS2GSI) [here](https://github.com/C9Glax/CS2GSI/blob/master/CS2GSI/CS2Event.cs)
-
-### ShockerIds
-List of Shocker-Ids, comma seperated. (Same as in configured Shocker)
-
-`[ "ID-1", "ID-2" ]`
-
-### Actions
-From CShocker [![Github](https://img.shields.io/badge/Github-8A2BE2)](https://github.com/C9Glax/cshocker) [here](https://github.com/C9Glax/CShocker/blob/master/CShocker/Shockers/ControlAction.cs)
-
-### ValueFromInput
-Use CS2GSI EventArgs value to determine Intensity (within configured IntensityRange)
+### Values for `Actions`
+- Beep
+- Shock
+- Vibrate
+- Nothing
 
 # Using
 ### CS2GSI
-[![GitHub License](https://img.shields.io/github/license/c9glax/CS2GSI)](https://img.shields.io/github/license/c9glax/CS2GSI/LICENSE)
+[![GitHub License](https://img.shields.io/github/license/c9glax/CS2GSI)](/LICENSE)
 [![NuGet Version](https://img.shields.io/nuget/v/CS2GSI)](https://www.nuget.org/packages/CS2GSI/)
 [![Github](https://img.shields.io/badge/Github-8A2BE2)](https://github.com/C9Glax/CS2GSI)
 [![GitHub Release](https://img.shields.io/github/v/release/c9glax/CS2GSI)](https://github.com/C9Glax/CS2GSI/releases/latest)