Advertisement
Guest User

Untitled

a guest
Oct 27th, 2022
172
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 27.57 KB | None | 0 0
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Windows.Forms;
  4. using GTA;
  5. using NativeUI;
  6. using System.Runtime.InteropServices;
  7. using System.Drawing;
  8. using GTA.Native;
  9. using GTA.Math;
  10. using System.Linq;
  11. using System.Runtime.Serialization.Formatters.Binary;
  12. using System.IO;
  13.  
  14. namespace Smooth_Throttle
  15. {
  16.  
  17.     public class Smooth_Throttle : Script
  18.     {
  19.         public const string version_num = "1.2";
  20.         public const string version = "Smooth Throttle" + " " + version_num;
  21.  
  22.         private UIMenu mainMenu;
  23.         private UIMenu kb_key_mappings_menu;
  24.         private MenuPool _menuPool;
  25.         //private UIMenuItem test;
  26.         private UIMenuItem menuItem_kb_key_mappings;
  27.  
  28.         //private UIMenuItem UIMI_kb_key_OPENMENU;
  29.         private UIMenuItem UIMI_kb_key_ACCELERATE;
  30.         private UIMenuItem UIMI_kb_key_INC;
  31.         private UIMenuItem UIMI_kb_key_DEC;
  32.         private UIMenuItem UIMI_kb_key_DIRECTION;
  33.         private UIMenuItem UIMI_INTERVAL;
  34.         private UIMenuCheckboxItem UIMCBI_MOUSEWHEEL;
  35.         private UIMenuCheckboxItem UIMCBI_MOD_ENABLED;
  36.         private UIMenuCheckboxItem UIMCBI_NOTIFICATION;
  37.  
  38.         private UIMenuItem savesettings;
  39.  
  40.  
  41.         [Serializable]
  42.         public struct ST_Settings
  43.         {
  44.             public bool MOD_ENABLED;
  45.             public bool NOTIFICATION;
  46.             public long INTERVAL;
  47.             public float THROTTLEVALUEPERCENT;
  48.             public bool MOUSEWHEEL;
  49.             //public List<Keys> OPENMENU_KEYS;
  50.             public List<Keys> ACCELERATE_KEYS;
  51.             public List<Keys> INCREASE_KEYS;
  52.             public List<Keys> DECREASE_KEYS;
  53.             public List<Keys> DIRECTION_KEYS;
  54.         }
  55.  
  56.         private ST_Settings settings = new ST_Settings();
  57.  
  58.         public int ShowNotification(string message)
  59.         {
  60.             Function.Call(Hash._SET_NOTIFICATION_TEXT_ENTRY, new InputArgument[] { "STRING" });
  61.             Function.Call(Hash._ADD_TEXT_COMPONENT_STRING, new InputArgument[] { message });
  62.             int haNotificationDeletitionLastTimee = Function.Call<int>(Hash._DRAW_NOTIFICATION, new InputArgument[] { false, false });
  63.             return haNotificationDeletitionLastTimee;
  64.         }
  65.  
  66.         private void saveSettings()
  67.         {
  68.             FileStream fs = new FileStream(@"scripts//Smooth_Throttle_settings.bin", FileMode.Create);
  69.             BinaryFormatter formatter = new BinaryFormatter();
  70.             formatter.Serialize(fs, settings);
  71.             fs.Close();
  72.         }
  73.  
  74.         private void loadSettings()
  75.         {
  76.             FileStream fs = new FileStream(@"scripts//Smooth_Throttle_settings.bin", FileMode.Open);
  77.             BinaryFormatter formatter = new BinaryFormatter();
  78.             settings = (ST_Settings)formatter.Deserialize(fs);
  79.             fs.Close();
  80.         }
  81.  
  82.         public Smooth_Throttle()
  83.         {
  84.             if (!File.Exists(@"scripts//Smooth_Throttle_settings.bin"))
  85.             {
  86.                 //settings.OPENMENU_KEYS = new List<Keys>();
  87.                 settings.ACCELERATE_KEYS = new List<Keys>();
  88.                 settings.INCREASE_KEYS = new List<Keys>();
  89.                 settings.DECREASE_KEYS = new List<Keys>();
  90.                 settings.DIRECTION_KEYS = new List<Keys>();
  91.                 //settings.OPENMENU_KEYS.Add(Keys.Divide);
  92.                 settings.ACCELERATE_KEYS.Add(Keys.ControlKey);
  93.                 settings.INCREASE_KEYS.Add(Keys.NumPad8);
  94.                 settings.DECREASE_KEYS.Add(Keys.NumPad2);
  95.                 settings.DIRECTION_KEYS.Add(Keys.Space);
  96.                 settings.MOD_ENABLED = true;
  97.                 settings.NOTIFICATION = true;
  98.                 settings.INTERVAL = 100;
  99.                 settings.THROTTLEVALUEPERCENT = 0.5f;
  100.                 settings.MOUSEWHEEL = false;
  101.  
  102.             }
  103.             else
  104.             {
  105.                 loadSettings();
  106.             }
  107.  
  108.             this.KeyDown += this.OnKeyDown;
  109.             this.KeyUp += this.OnKeyUp;
  110.             this.Tick += this.OnTick;
  111.  
  112.             setupUIMenu();
  113.         }
  114.  
  115.         private void setupUIMenu()
  116.         {
  117.  
  118.             _menuPool = new MenuPool();
  119.  
  120.             mainMenu = new UIMenu(version, "~b~By Kryo4lex");
  121.             _menuPool.Add(mainMenu);
  122.  
  123.             //test = new UIMenuItem("How to use", "Description");
  124.             //mainMenu.AddItem(test);
  125.  
  126.             menuItem_kb_key_mappings = new UIMenuItem("Keyboard key assignment", "Change the keyboard controls");
  127.             mainMenu.AddItem(menuItem_kb_key_mappings);
  128.  
  129.             savesettings = new UIMenuItem("Save settings", "Save your settings, to play with the same settings on the next startup of the game.");
  130.  
  131.             kb_key_mappings_menu = new UIMenu(version, "~b~Keyboard key assignment");
  132.             _menuPool.Add(kb_key_mappings_menu);
  133.             //kb_key_mappings_menu.AddItem(UIMI_kb_key_OPENMENU = new UIMenuItem("Open menu: " + getStringPressedKeys(settings.OPENMENU_KEYS), "Select to change the assigned keys and then press the new keys."));
  134.             kb_key_mappings_menu.AddItem(UIMI_kb_key_ACCELERATE = new UIMenuItem("Accelerate: " + getStringPressedKeys(settings.ACCELERATE_KEYS), "Select to change the assigned keys and then press the new keys."));
  135.             kb_key_mappings_menu.AddItem(UIMI_kb_key_INC = new UIMenuItem("Increase throttle: " + getStringPressedKeys(settings.INCREASE_KEYS), "Select to change the assigned keys and then press the new keys."));
  136.             kb_key_mappings_menu.AddItem(UIMI_kb_key_DEC = new UIMenuItem("Decrease throttle: " + getStringPressedKeys(settings.DECREASE_KEYS), "Select to change the assigned keys and then press the new keys."));
  137.             kb_key_mappings_menu.AddItem(UIMI_kb_key_DIRECTION = new UIMenuItem("Change direction/gear: " + getStringPressedKeys(settings.DIRECTION_KEYS), "Select to change the assigned keys and then press the new keys."));
  138.  
  139.  
  140.             mainMenu.AddItem(UIMI_INTERVAL = new UIMenuItem("Interval: " + settings.INTERVAL.ToString() + " ms", "Select to change the interval in milliseconds of the throttle change keys, and enter a number."));
  141.  
  142.             mainMenu.AddItem(UIMCBI_MOUSEWHEEL = new UIMenuCheckboxItem("Mousewheel", settings.MOUSEWHEEL, "Enable this to use the mousewheel to change the throttle value."));
  143.             mainMenu.AddItem(UIMCBI_NOTIFICATION = new UIMenuCheckboxItem("Notfications", settings.NOTIFICATION, "Enable this to get notifications when the throttle value is changed."));
  144.             mainMenu.AddItem(UIMCBI_MOD_ENABLED = new UIMenuCheckboxItem("Mod enabled", settings.MOD_ENABLED, "Use this to toggle Smooth Throttle."));
  145.  
  146.             mainMenu.AddItem(savesettings);
  147.             mainMenu.BindMenuToItem(kb_key_mappings_menu, menuItem_kb_key_mappings);
  148.             mainMenu.RefreshIndex();
  149.             mainMenu.OnItemSelect += OnItemSelect;
  150.             mainMenu.OnCheckboxChange += OnCheckboxChange;
  151.             kb_key_mappings_menu.OnItemSelect += OnItemSelect;
  152.         }
  153.  
  154.         public void OnItemSelect(UIMenu sender, UIMenuItem selectedItem, int index)
  155.         {
  156.             if (selectedItem == savesettings)
  157.             {
  158.                 saveSettings();
  159.                 UI.Notify("~b~Smooth Throttle settings saved!");
  160.             }
  161.             else if (selectedItem == UIMI_INTERVAL)
  162.             {
  163.                 IntervalString = "";
  164.                 ChangeIntervalActive = true;
  165.                 UI.ShowSubtitle("~b~Enter a number for the new interval in milliseconds of the throttle change keys. Confirm with SPACE, abort with ESCAPE, delete with BACKSPACE", Int32.MaxValue);
  166.             }
  167.             /*
  168.             if (selectedItem == UIMI_kb_key_OPENMENU)
  169.             {
  170.                 ChangeKeyAssignment = true;
  171.                 KeyToChangeIndex = 0;
  172.             }
  173.             */
  174.             /*else*/
  175.             if (selectedItem == UIMI_kb_key_ACCELERATE)
  176.             {
  177.                 ChangeKeyAssignment = true;
  178.                 KeyToChangeIndex = 1;
  179.             }
  180.             else if (selectedItem == UIMI_kb_key_INC)
  181.             {
  182.                 ChangeKeyAssignment = true;
  183.                 KeyToChangeIndex = 2;
  184.             }
  185.             else if (selectedItem == UIMI_kb_key_DEC)
  186.             {
  187.                 ChangeKeyAssignment = true;
  188.                 KeyToChangeIndex = 3;
  189.             }
  190.             else if (selectedItem == UIMI_kb_key_DIRECTION)
  191.             {
  192.                 ChangeKeyAssignment = true;
  193.                 KeyToChangeIndex = 4;
  194.             }
  195.         }
  196.  
  197.         public void OnCheckboxChange(UIMenu sender, UIMenuCheckboxItem checkbox, bool Checked)
  198.         {
  199.             if (checkbox == UIMCBI_MOD_ENABLED)
  200.             {
  201.                 settings.MOD_ENABLED = UIMCBI_MOD_ENABLED.Checked;
  202.             }
  203.             else if (checkbox == UIMCBI_NOTIFICATION)
  204.             {
  205.                 settings.NOTIFICATION = UIMCBI_NOTIFICATION.Checked;
  206.             }
  207.             else if (checkbox == UIMCBI_MOUSEWHEEL)
  208.             {
  209.                 settings.MOUSEWHEEL = UIMCBI_MOUSEWHEEL.Checked;
  210.             }
  211.         }
  212.  
  213.         long LastTimeIncrease = 0;
  214.         long LastTimeDecrease = 0;
  215.  
  216.         bool NotificationDeletitionNecessary = false;
  217.         long NotificationDeletitionLastTime = 0;
  218.  
  219.         bool IsDirectionForward = true;
  220.         bool DirectionChangeLastState = false;
  221.  
  222.         private List<Keys> newKeys = new List<Keys>();
  223.  
  224.         void OnTick(object sender, EventArgs e)
  225.         {
  226.             if (Game.Player.Character.IsInVehicle())
  227.             {
  228.                 if (settings.MOD_ENABLED)
  229.                 {
  230.  
  231.  
  232.                     if (NotificationDeletitionNecessary)
  233.                     {
  234.                         if (NotificationDeletitionLastTime + 1000 <= Environment.TickCount)
  235.                         {
  236.                             NotificationDeletitionNecessary = false;
  237.                             Function.Call(Hash._REMOVE_NOTIFICATION, new InputArgument[] { NotificationHandle });
  238.                         }
  239.                     }
  240.  
  241.                     if (ChangeKeyAssignment)
  242.                     {
  243.  
  244.                         switch (KeyAssignmentStepIndex)
  245.                         {
  246.                             case 0:
  247.                                 mainMenu.Visible = false;
  248.                                 kb_key_mappings_menu.Visible = false;
  249.                                 UI.ShowSubtitle("~b~In 3 seconds, you have 4 seconds, to hold the key(s), for " + stFunction(KeyToChangeIndex), 3000);
  250.  
  251.                                 if (!s1_started)
  252.                                 {
  253.                                     s1_started = true;
  254.                                     t_s1 = Environment.TickCount + 3000;
  255.                                 }
  256.  
  257.                                 if (Environment.TickCount >= t_s1)
  258.                                     KeyAssignmentStepIndex++;
  259.                                 break;
  260.                             case 1:
  261.                                 newKeys.Clear();
  262.                                 newKeys = new List<Keys>(pressedKeys);
  263.                                 UI.ShowSubtitle("~b~Key(s):\n" + getStringPressedKeys(newKeys), 4000);
  264.  
  265.                                 if (!s2_started)
  266.                                 {
  267.                                     s2_started = true;
  268.                                     t_s2 = Environment.TickCount + 4000;
  269.                                 }
  270.  
  271.                                 if (Environment.TickCount >= t_s2)
  272.                                     KeyAssignmentStepIndex++;
  273.                                 break;
  274.                             case 2:
  275.                                 kb_key_mappings_menu.Visible = true;
  276.                                 s1_started = false;
  277.                                 s2_started = false;
  278.                                 ChangeKeyAssignment = false;
  279.                                 KeyAssignmentStepIndex = 0;
  280.                                 if (newKeys.Count != 0)
  281.                                 {
  282.                                     switch (KeyToChangeIndex)
  283.                                     {
  284.                                         /*
  285.                                         case 0:
  286.                                             settings.OPENMENU_KEYS.Clear();
  287.                                             settings.OPENMENU_KEYS = new List<Keys>(newKeys);
  288.                                             UIMI_kb_key_OPENMENU.Text = "Open menu: " + getStringPressedKeys(settings.OPENMENU_KEYS);
  289.                                             break;
  290.                                             */
  291.                                         case 1:
  292.                                             settings.ACCELERATE_KEYS.Clear();
  293.                                             settings.ACCELERATE_KEYS = new List<Keys>(newKeys);
  294.                                             UIMI_kb_key_ACCELERATE.Text = "Accelerate: " + getStringPressedKeys(settings.ACCELERATE_KEYS);
  295.                                             break;
  296.                                         case 2:
  297.                                             settings.INCREASE_KEYS.Clear();
  298.                                             settings.INCREASE_KEYS = new List<Keys>(newKeys);
  299.                                             UIMI_kb_key_INC.Text = "Increase throttle: " + getStringPressedKeys(settings.INCREASE_KEYS);
  300.                                             break;
  301.                                         case 3:
  302.                                             settings.DECREASE_KEYS.Clear();
  303.                                             settings.DECREASE_KEYS = new List<Keys>(newKeys);
  304.                                             UIMI_kb_key_DEC.Text = "Decrease throttle: " + getStringPressedKeys(settings.DECREASE_KEYS);
  305.                                             break;
  306.                                         case 4:
  307.                                             settings.DIRECTION_KEYS.Clear();
  308.                                             settings.DIRECTION_KEYS = new List<Keys>(newKeys);
  309.                                             UIMI_kb_key_DIRECTION.Text = "Change direction/gear: " + getStringPressedKeys(settings.DIRECTION_KEYS);
  310.                                             break;
  311.                                     }
  312.                                     UI.ShowSubtitle("~b~Successfully assinged " + stFunction(KeyToChangeIndex) + " to " + getStringPressedKeys(pressedKeys), 3000);
  313.                                 }
  314.                                 else
  315.                                 {
  316.                                     UI.ShowSubtitle("~b~No key(s) have been changed!", 3000);
  317.                                 }
  318.  
  319.                                 break;
  320.                         }
  321.                     }
  322.                     else
  323.                     {
  324.                         if (!ChangeKeyAssignment)
  325.                         {
  326.  
  327.                             if (LinqHelper.ContainsAll(pressedKeys, settings.ACCELERATE_KEYS))
  328.                             {
  329.                                 //drawuirect(0.944f, 0.5425f, 0.007f, 0.007f, Color.Green);
  330.                                 if (IsDirectionForward)
  331.                                 {
  332.                                     Game.SetControlNormal(0, GTA.Control.VehicleAccelerate, 0.25f + (0.75f * settings.THROTTLEVALUEPERCENT));
  333.                                     Game.SetControlNormal(0, GTA.Control.VehicleFlyThrottleUp, 0.25f + (0.75f * settings.THROTTLEVALUEPERCENT));
  334.                                 }
  335.                                 else
  336.                                 {
  337.                                     Game.SetControlNormal(0, GTA.Control.VehicleBrake, 0.25f + (0.75f * settings.THROTTLEVALUEPERCENT));
  338.                                 }
  339.                             }
  340.  
  341.                             if (LinqHelper.ContainsAll(pressedKeys, settings.DIRECTION_KEYS))
  342.                             {
  343.                                 if (!DirectionChangeLastState)//IsDirectionForward != IsDirectionForwardLast)
  344.                                 {
  345.                                     IsDirectionForward = !IsDirectionForward;
  346.                                     if (settings.NOTIFICATION)
  347.                                     {
  348.                                         notifyDirectionChange(IsDirectionForward);
  349.                                     }
  350.                                     NotificationDeletitionNecessary = true;
  351.                                     NotificationDeletitionLastTime = Environment.TickCount;
  352.                                 }
  353.                                 DirectionChangeLastState = true;
  354.                             }
  355.                             else
  356.                             {
  357.                                 DirectionChangeLastState = false;
  358.                             }
  359.  
  360.                             if (((LinqHelper.ContainsAll(pressedKeys, settings.INCREASE_KEYS) || (Game.IsControlJustPressed(0, GTA.Control.PrevWeapon) && settings.MOUSEWHEEL)) && !(settings.THROTTLEVALUEPERCENT >= 1.0f) && (LastTimeIncrease + settings.INTERVAL <= Environment.TickCount)))
  361.                             {
  362.                                 settings.THROTTLEVALUEPERCENT = (float)Math.Round((double)settings.THROTTLEVALUEPERCENT, 2);
  363.  
  364.                                 if (settings.THROTTLEVALUEPERCENT >= 0.05f)
  365.                                     settings.THROTTLEVALUEPERCENT += 0.05f;
  366.                                 else
  367.                                     settings.THROTTLEVALUEPERCENT += 0.01f;
  368.  
  369.                                 LastTimeIncrease = Environment.TickCount;
  370.                                 if (settings.NOTIFICATION)
  371.                                 {
  372.                                     notifyThrottleChange(IsDirectionForward);
  373.                                 }
  374.                                 NotificationDeletitionNecessary = true;
  375.                                 NotificationDeletitionLastTime = Environment.TickCount;
  376.  
  377.                             }
  378.  
  379.                             if (((LinqHelper.ContainsAll(pressedKeys, settings.DECREASE_KEYS) || (Game.IsControlJustPressed(0, GTA.Control.SniperZoomOutOnly) && settings.MOUSEWHEEL)) && !(settings.THROTTLEVALUEPERCENT <= 0.0f) && (LastTimeDecrease + settings.INTERVAL <= Environment.TickCount)))
  380.                             {
  381.                                 settings.THROTTLEVALUEPERCENT = (float)Math.Round((double)settings.THROTTLEVALUEPERCENT, 2);
  382.  
  383.  
  384.                                 if (settings.THROTTLEVALUEPERCENT <= 0.05f)
  385.                                     settings.THROTTLEVALUEPERCENT -= 0.01f;
  386.                                 else
  387.                                     settings.THROTTLEVALUEPERCENT -= 0.05f;
  388.  
  389.                                 LastTimeDecrease = Environment.TickCount;
  390.                                 if (settings.NOTIFICATION)
  391.                                 {
  392.                                     notifyThrottleChange(IsDirectionForward);
  393.                                 }
  394.                                 NotificationDeletitionNecessary = true;
  395.                                 NotificationDeletitionLastTime = Environment.TickCount;
  396.                             }
  397.                         }
  398.                     }
  399.                 }
  400.                 _menuPool.ProcessMenus();
  401.  
  402.             }
  403.  
  404.         }
  405.  
  406.         int NotificationHandle;
  407.  
  408.         private void notifyThrottleChange(bool direction)
  409.         {
  410.             Function.Call(Hash._REMOVE_NOTIFICATION, new InputArgument[] { NotificationHandle });
  411.             if (direction)
  412.             {
  413.                 NotificationHandle = ShowNotification(("Throttle: " + "~b~" + (Math.Round(settings.THROTTLEVALUEPERCENT * 100f, 2)).ToString() + "%").ToString() + " (F)");
  414.             }
  415.             else
  416.             {
  417.                 NotificationHandle = ShowNotification(("Throttle: " + "~r~" + (Math.Round(settings.THROTTLEVALUEPERCENT * 100f, 2)).ToString() + "%").ToString() + " (R)");
  418.             }
  419.         }
  420.  
  421.         private void notifyDirectionChange(bool direction)
  422.         {
  423.             Function.Call(Hash._REMOVE_NOTIFICATION, new InputArgument[] { NotificationHandle });
  424.             if (direction)
  425.             {
  426.                 NotificationHandle = ShowNotification("Direction: ~b~FORWARD");
  427.             }
  428.             else
  429.             {
  430.                 NotificationHandle = ShowNotification("Direction: ~r~REVERSE");
  431.             }
  432.         }
  433.  
  434.         private void printPressedKeys(List<Keys> listkeys)
  435.         {
  436.             string str = "";
  437.             int i = 0;
  438.             foreach (var key in listkeys)
  439.             {
  440.                 str += key.ToString();
  441.                 if (i != (listkeys.Count - 1))
  442.                 {
  443.                     str += " + ";
  444.                 }
  445.                 i++;
  446.             }
  447.             UI.ShowSubtitle(str);
  448.         }
  449.  
  450.         private string getStringPressedKeys(List<Keys> listkeys)
  451.         {
  452.             string str = "";
  453.             int i = 0;
  454.             foreach (var key in listkeys)
  455.             {
  456.                 str += key.ToString();
  457.                 if (i != (listkeys.Count - 1))
  458.                 {
  459.                     str += " + ";
  460.                 }
  461.                 i++;
  462.             }
  463.             return str;
  464.         }
  465.  
  466.         string stFunction(int index)
  467.         {
  468.             switch (index)
  469.             {
  470.                 case 0:
  471.                     return "Open menu";
  472.                 case 1:
  473.                     return "Accelerate";
  474.                 case 2:
  475.                     return "Increase throttle";
  476.                 case 3:
  477.                     return "Decrease throttle";
  478.             }
  479.             return "";
  480.         }
  481.  
  482.         int KeyToChangeIndex = 0;
  483.         bool ChangeKeyAssignment = false;
  484.         int KeyAssignmentStepIndex = 0;
  485.         bool s1_started = false;
  486.         long t_s1 = 0;
  487.         bool s2_started = false;
  488.         long t_s2 = 0;
  489.  
  490.         private List<Keys> pressedKeys = new List<Keys>();
  491.  
  492.         int MenuToggleStep = 0;
  493.  
  494.         bool ChangeIntervalActive = false;
  495.         string IntervalString = "";
  496.  
  497.     Dictionary<Keys, int> KeysInt = new Dictionary<Keys, int>()
  498.         {
  499.             {Keys.D0, 0},
  500.             {Keys.D1, 1},
  501.             {Keys.D2, 2},
  502.             {Keys.D3, 3},
  503.             {Keys.D4, 4},
  504.             {Keys.D5, 5},
  505.             {Keys.D6, 6},
  506.             {Keys.D7, 7},
  507.             {Keys.D8, 8},
  508.             {Keys.D9, 9},
  509.             {Keys.NumPad0, 0},
  510.             {Keys.NumPad1, 1},
  511.             {Keys.NumPad2, 2},
  512.             {Keys.NumPad3, 3},
  513.             {Keys.NumPad4, 4},
  514.             {Keys.NumPad5, 5},
  515.             {Keys.NumPad6, 6},
  516.             {Keys.NumPad7, 7},
  517.             {Keys.NumPad8, 8},
  518.             {Keys.NumPad9, 9}
  519.         };
  520.  
  521.     private void OnKeyDown(object sender, KeyEventArgs e)
  522.         {
  523.  
  524.             if (!(pressedKeys.Contains(e.KeyCode)))
  525.                 pressedKeys.Add(e.KeyCode);
  526.  
  527.             //printPressedKeys(pressedKeys);
  528.             /*
  529.             if(!ChangeKeyAssignment && LinqHelper.ContainsAll(pressedKeys, settings.OPENMENU_KEYS) && !kb_key_mappings_menu.Visible)
  530.                 mainMenu.Visible = !mainMenu.Visible;
  531.                 */
  532.  
  533.             if (Game.Player.Character.IsInVehicle())
  534.             {
  535.                 if (e.KeyCode == Keys.T && MenuToggleStep == 0)
  536.                 {
  537.                     MenuToggleStep++;
  538.                 }
  539.                 else if (e.KeyCode == Keys.H && MenuToggleStep == 1)
  540.                 {
  541.                     MenuToggleStep++;
  542.                 }
  543.                 else if (e.KeyCode == Keys.R && MenuToggleStep == 2)
  544.                 {
  545.                     MenuToggleStep++;
  546.                 }
  547.                 else if (e.KeyCode == Keys.T && MenuToggleStep == 3)
  548.                 {
  549.                     MenuToggleStep++;
  550.                 }
  551.                 else if (e.KeyCode == Keys.L && MenuToggleStep == 4)
  552.                 {
  553.                     mainMenu.Visible = !mainMenu.Visible;
  554.                     MenuToggleStep = 0;
  555.                 }
  556.                 else
  557.                 {
  558.                     MenuToggleStep = 0;
  559.                 }
  560.  
  561.                 if (ChangeIntervalActive)
  562.                 {
  563.                     if (e.KeyCode == Keys.Escape)
  564.                     {
  565.                         ChangeIntervalActive = false;
  566.                         UI.ShowSubtitle("~b~Change of throttle value interval aborted!", 3000);
  567.                         return;
  568.                     }
  569.  
  570.                     if (e.KeyCode == Keys.Back)
  571.                     {
  572.                         IntervalString = IntervalString.Remove(IntervalString.Length - 1);
  573.                         UI.ShowSubtitle("~b~" + IntervalString, Int32.MaxValue);
  574.                         return;
  575.                     }
  576.  
  577.                     if (e.KeyCode == Keys.Space)
  578.                     {
  579.                         settings.INTERVAL = Convert.ToInt32(IntervalString);
  580.                         UIMI_INTERVAL.Text = "Interval: " + settings.INTERVAL.ToString() + " ms";
  581.                         UI.ShowSubtitle("~b~New throttle value interval: " + IntervalString + " ms", 5000);
  582.                         ChangeIntervalActive = false;
  583.                         return;
  584.                     }
  585.  
  586.                     if ((e.KeyCode >= Keys.D0 && e.KeyCode <= Keys.D9) || (e.KeyCode >= Keys.NumPad0 && e.KeyCode <= Keys.NumPad9))
  587.                     {
  588.                         if (IntervalString.Length <= 4)
  589.                         {
  590.                             IntervalString += KeysInt[e.KeyCode].ToString();
  591.                         }
  592.                         UI.ShowSubtitle("~b~" + IntervalString, Int32.MaxValue);
  593.                     }
  594.                 }
  595.             }
  596.  
  597.  
  598.             /*
  599.             if(e.KeyCode == Keys.Divide)
  600.             {
  601.                 re = !re;
  602.                 if (!re)
  603.                 {
  604.                     // Create a campfire model
  605.                     var model = new Model("prop_riot_shield");
  606.                     model.Request(250);
  607.  
  608.                     // Check the model is valid
  609.                     if (model.IsInCdImage && model.IsValid)
  610.                     {
  611.                         // Ensure the model is loaded before we try to create it in the world
  612.                         while (!model.IsLoaded) Script.Wait(50);
  613.  
  614.                         // Create the prop in the world
  615.                         //for(int i =0;i<=10;i++)
  616.                         lol = World.CreateProp(model, Game.Player.Character.GetOffsetInWorldCoords(new Vector3(0, 0, 0)), true, true);
  617.                         //lol.AttachTo(Game.Player.Character, 0xeeeb, new Vector3(-0.1f, 0.5f, -0.01f), new Vector3(0, 0, 205.0f));
  618.                         GTA.Native.Function.Call(Hash.ATTACH_ENTITY_TO_ENTITY, lol, Game.Player.Character, 0x5c01, -0.1f, 0.5f, -0.2f, 0, 0, 180.0f,true,true,true,true,0,true);
  619.                     }
  620.  
  621.                     // Mark the model as no longer needed to remove it from memory.
  622.                     model.MarkAsNoLongerNeeded();
  623.                     //mainMenu.Visible = !mainMenu.Visible;
  624.                 }
  625.                 else
  626.                     lol.Delete();
  627.             }
  628.             */
  629.         }
  630.  
  631.         private void OnKeyUp(object sender, KeyEventArgs e)
  632.         {
  633.             pressedKeys.Remove(e.KeyCode);
  634.  
  635.             //printPressedKeys(pressedKeys);
  636.         }
  637.  
  638.     }
  639.  
  640.     public static class LinqHelper
  641.     {
  642.         public static bool ContainsAll<T>(this IEnumerable<T> containingList, IEnumerable<T> lookupList)
  643.         {
  644.             return !lookupList.Except(containingList).Any();
  645.         }
  646.  
  647.         public static IList<T> Clone<T>(this IList<T> listToClone) where T : ICloneable
  648.         {
  649.             return listToClone.Select(item => (T)item.Clone()).ToList();
  650.         }
  651.     }
  652.  
  653. }
  654.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement