API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 27th, 2022
194
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 27.57 KB | None | 0 0
raw download clone embed print report
  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
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!