Support Elite: Dangerous

Project-Aurora/Project-Aurora/Profiles/EliteDangerous/Control_EliteDangerous.xaml

@@ -0,0 +1,55 @@
+<UserControl
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:Aurora.Profiles.EliteDangerous"
+             xmlns:System="clr-namespace:System;assembly=mscorlib" 
+             xmlns:EnumDeviceKeys="clr-namespace:Aurora.Devices"
+             xmlns:EnumPercentEffectType="clr-namespace:Aurora.Settings"
+             xmlns:EnumValueConverters="clr-namespace:Aurora.Utils"
+             xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
+             xmlns:Controls="clr-namespace:Aurora.Controls" x:Class="Aurora.Profiles.EliteDangerous.Control_EliteDangerous"
+             mc:Ignorable="d" 
+             d:DesignHeight="300" Height="Auto" Width="Auto" d:DesignWidth="850">
+    <UserControl.Resources>
+        <ResourceDictionary>
+            <ObjectDataProvider x:Key="PercentEffectType" MethodName="GetValues" ObjectType="{x:Type System:Enum}">
+                <ObjectDataProvider.MethodParameters>
+                    <x:Type TypeName="EnumPercentEffectType:PercentEffectType" />
+                </ObjectDataProvider.MethodParameters>
+            </ObjectDataProvider>
+            <EnumValueConverters:PercentEffectTypeToStringVC x:Key="PercentEffectTypeToStringVC"/>
+            <DataTemplate x:Key="PercentEffectTypeTemplate">
+                <TextBlock Text="{Binding Converter={StaticResource PercentEffectTypeToStringVC}}" />
+            </DataTemplate>
+
+            <EnumValueConverters:DeviceKeysToStringVC x:Key="DeviceKeysToStringVC"/>
+            <DataTemplate x:Key="DeviceKeys">
+                <TextBlock Text="{Binding Converter={StaticResource DeviceKeysToStringVC}}" />
+            </DataTemplate>
+        </ResourceDictionary>
+    </UserControl.Resources>
+
+    <Grid>
+        <TabControl>
+            <TabItem Header="Overview">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="Auto"/>
+                    </Grid.RowDefinitions>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+
+                    <TextBlock Grid.Row="2" Margin="18,15,10,10" VerticalAlignment="Top" TextWrapping="Wrap" HorizontalAlignment="Left">Note: if using default Elite: Dangerous controls, the game needs to be launched at least once.</TextBlock>
+
+                    <TextBlock Grid.Row="1" Margin="18,0,10,10" VerticalAlignment="Top" TextWrapping="Wrap">Elite: Dangerous support works using the games Journal API. This means that no memory reading or other potentially bannable methods are involved.</TextBlock>
+                    <CheckBox Grid.Row="0" Margin="10,10,10,10" x:Name="game_enabled" Content="Enable Aurora to provide lighting effects with Elite: Dangerous" HorizontalAlignment="Left" VerticalAlignment="Top" Checked="game_enabled_Checked" Unchecked="game_enabled_Checked"/>
+                </Grid>
+            </TabItem>
+        </TabControl>
+    </Grid>
+</UserControl>

Project-Aurora/Project-Aurora/Profiles/EliteDangerous/Control_EliteDangerous.xaml.cs

@@ -0,0 +1,72 @@
+using Aurora.Controls;
+using Aurora.Utils;
+using System;
+using System.IO;
+using Ionic.Zip;
+using System.Timers;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Navigation;
+using Aurora.Devices;
+using Aurora.Settings;
+using Xceed.Wpf.Toolkit;
+using Aurora.Profiles.EliteDangerous.GSI;
+using MessageBox = System.Windows.MessageBox;
+
+namespace Aurora.Profiles.EliteDangerous
+{
+    /// <summary>
+    /// Interaction logic for Control_EliteDangerous.xaml
+    /// </summary>
+    public partial class Control_EliteDangerous : UserControl
+    {
+        private Application profile_manager;
+
+        public Control_EliteDangerous(Application profile)
+        {
+            InitializeComponent();
+
+            profile_manager = profile;
+
+            SetSettings();
+
+            if (!(profile_manager.Settings as FirstTimeApplicationSettings).IsFirstTimeInstalled)
+            {
+                (profile_manager.Settings as FirstTimeApplicationSettings).IsFirstTimeInstalled = true;
+            }
+
+            profile_manager.ProfileChanged += Control_EliteDangerous_ProfileChanged;
+
+        }
+
+        private void Control_EliteDangerous_ProfileChanged(object sender, EventArgs e)
+        {
+            SetSettings();
+        }
+
+        private void SetSettings()
+        {
+            this.game_enabled.IsChecked = profile_manager.Settings.IsEnabled;
+
+        }
+
+        //Overview
+
+        private void game_enabled_Checked(object sender, RoutedEventArgs e)
+        {
+            if (IsLoaded)
+            {
+                profile_manager.Settings.IsEnabled = (this.game_enabled.IsChecked.HasValue) ? this.game_enabled.IsChecked.Value : false;
+                profile_manager.SaveProfiles();
+            }
+        }
+
+        private void Hyperlink_RequestNavigate(object sender, RequestNavigateEventArgs e)
+        {
+            System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(e.Uri.AbsoluteUri));
+            e.Handled = true;
+        }
+    }
+}

Project-Aurora/Project-Aurora/Profiles/EliteDangerous/EliteConfig.cs

@@ -0,0 +1,26 @@
+using System;
+using System.IO;
+
+namespace Aurora.Profiles.EliteDangerous
+{
+    public static class EliteConfig
+    {
+        public const int KEY_BLINK_SPEED = 20;
+        public static readonly string JOURNAL_API_DIR = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+            "Saved Games",
+            "Frontier Developments",
+            "Elite Dangerous"
+        );
+        public static readonly string STATUS_FILE = Path.Combine(JOURNAL_API_DIR, "Status.json");
+
+        public static readonly string BINDINGS_DIR = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "Frontier Developments",
+            "Elite Dangerous",
+            "Options",
+            "Bindings"
+        );
+        public static readonly string BINDINGS_PRESET_FILE = Path.Combine(BINDINGS_DIR, "StartPreset.start");
+    }
+}

Project-Aurora/Project-Aurora/Profiles/EliteDangerous/EliteDangerousApplication.cs

@@ -0,0 +1,41 @@
+using Aurora.Settings;
+using Aurora.Profiles.EliteDangerous.Layers;
+using System.Collections.Generic;
+using CSScriptLibrary;
+
+namespace Aurora.Profiles.EliteDangerous
+{
+    public class EliteDangerous : Application
+    {
+        public EliteDangerous()
+            : base(new LightEventConfig
+            {
+                Name = "Elite: Dangerous",
+                ID = "EliteDangerous",
+                ProcessNames = new[] { "EliteDangerous64.exe" },
+                UpdateInterval = 16,
+                SettingsType = typeof(EliteDangerousSettings),
+                ProfileType = typeof(EliteDangerousProfile),
+                OverviewControlType = typeof(Control_EliteDangerous),
+                GameStateType = typeof(GSI.GameState_EliteDangerous),
+                Event = new GameEvent_EliteDangerous(),
+                IconURI = "Resources/elite_dangerous_256x256.png"
+            })
+        {
+
+            var extra = new List<LayerHandlerEntry>
+            {
+                new LayerHandlerEntry("EliteDangerousBackground", "Elite: Dangerous Background Layer", typeof(EliteDangerousBackgroundLayerHandler)),
+                new LayerHandlerEntry("EliteDangerousKeyBinds", "Elite: Dangerous Key Binds Layer", typeof(EliteDangerousKeyBindsLayerHandler)),
+                new LayerHandlerEntry("EliteDangerousAnimations", "Elite: Dangerous Animation Layer", typeof(EliteDangerousAnimationLayerHandler)),
+            };
+
+            Global.LightingStateManager.RegisterLayerHandlers(extra, false);
+
+            foreach (var entry in extra)
+            {
+                Config.ExtraAvailableLayers.Add(entry.Key);
+            }
+        }
+    }
+}

Project-Aurora/Project-Aurora/Profiles/EliteDangerous/EliteDangerousProfile.cs

@@ -0,0 +1,30 @@
+using Aurora.Settings;
+using Aurora.Settings.Layers;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Aurora.Profiles.EliteDangerous
+{
+    public class EliteDangerousProfile : ApplicationProfile
+    {
+        public EliteDangerousProfile() : base()
+        {
+
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            Layers = new System.Collections.ObjectModel.ObservableCollection<Layer>()
+            {
+                new Layer("Animations", new Layers.EliteDangerousAnimationLayerHandler()),
+                new Layer("Key Binds", new Layers.EliteDangerousKeyBindsLayerHandler()),
+                new Layer("Background", new Layers.EliteDangerousBackgroundLayerHandler()),
+            };
+        }
+    }
+}

Project-Aurora/Project-Aurora/Profiles/EliteDangerous/EliteDangerousSettings.cs

@@ -0,0 +1,11 @@
+using Aurora.Settings;
+
+namespace Aurora.Profiles.EliteDangerous
+{
+    public class EliteDangerousSettings : FirstTimeApplicationSettings
+    {
+        private string gamePath = "";
+
+        public string GamePath { get { return gamePath; } set { gamePath = value; InvokePropertyChanged(); } }
+    }
+}

Project-Aurora/Project-Aurora/Profiles/EliteDangerous/GSI/GameState_EliteDangerous.cs

@@ -0,0 +1,125 @@
+using System;
+using Aurora.Profiles.EliteDangerous.GSI.Nodes;
+using Aurora.Profiles.EliteDangerous.Layers;
+
+namespace Aurora.Profiles.EliteDangerous.GSI
+{
+    public class GameStateCondition
+    {
+        long flagsSet;
+        long flagsNotSet;
+        GuiFocus[] guiFocus;
+
+        private Func<GameState_EliteDangerous, bool> callback = null;
+
+        public GameStateCondition(long flagsSet = Flag.UNSPECIFIED, long flagsNotSet = Flag.UNSPECIFIED, GuiFocus[] guiFocus = null,
+            Func<GameState_EliteDangerous, bool> callback = null)
+        {
+            this.flagsSet = flagsSet;
+            this.guiFocus = guiFocus;
+            this.flagsNotSet = flagsNotSet;
+            this.callback = callback;
+        }
+
+        public GameStateCondition(Func<GameState_EliteDangerous, bool> callback)
+        {
+            this.callback = callback;
+        }
+
+        public bool IsSatisfied(GameState_EliteDangerous gameState)
+        {
+            if (callback != null && !callback(gameState))
+            {
+                return false;
+            }
+
+            if (guiFocus != null && Array.IndexOf(guiFocus, gameState.Status.GuiFocus) == Flag.UNSPECIFIED)
+            {
+                return false;
+            }
+
+            if (flagsSet != Flag.UNSPECIFIED && !Flag.IsFlagSet(gameState.Status.Flags, flagsSet))
+            {
+                return false;
+            }
+
+            if (flagsNotSet != Flag.UNSPECIFIED && Flag.AtLeastOneFlagSet(gameState.Status.Flags, flagsNotSet))
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+
+    public class NeedsGameState
+    {
+        public GameStateCondition NeededGameStateCondition;
+
+        public NeedsGameState()
+        {
+        }
+
+        public NeedsGameState(GameStateCondition neededGameStateCondition)
+        {
+            this.NeededGameStateCondition = neededGameStateCondition;
+        }
+
+        public bool IsSatisfied(GameState_EliteDangerous gameState)
+        {
+            if (NeededGameStateCondition != null)
+            {
+                return NeededGameStateCondition.IsSatisfied(gameState);
+            }
+
+            return true;
+        }
+    }
+
+    public class GameState_EliteDangerous : GameState<GameState_EliteDangerous>
+    {
+        private Status status;
+        private Nodes.Journal journal;
+        private Nodes.Controls controls;
+
+        public Nodes.Journal Journal
+        {
+            get
+            {
+                if (journal == null)
+                    journal = new Nodes.Journal();
+
+                return journal;
+            }
+        }
+
+        public Status Status
+        {
+            get
+            {
+                if (status == null)
+                    status = new Status();
+
+                return status;
+            }
+        }
+
+        public Nodes.Controls Controls
+        {
+            get
+            {
+                if (controls == null)
+                    controls = new Nodes.Controls();
+
+                return controls;
+            }
+        }
+
+        /// <summary>
+        /// Creates a default GameState_EliteDangerous instance.
+        /// </summary>
+        public GameState_EliteDangerous() : base()
+        {
+        }
+    }
+}