private void CloseMenu(MenuItemStandard m)
 {
     if (Root.Observer.CurrentMenu == this)
     {
         Root.Observer.CloseMenu();
     }
 }
        private async void SaveAndExit(MenuItemStandard m)
        {
            var playerSession = Client.LocalSession;

            if (playerSession == null)
            {
                return;
            }

            //Log.ToChat( "CharacterEditorMenu SaveAndExit" );
            if (!Root.IsClothingStore)
            {
                CharacterEditorMenu.skinData = Root.AdditionalSaveData.getSaveableData(Root.IsClothingStore) /*.ToExpando()*/;
                Client.Instance.TriggerServerEvent("Skin.UpdatePlayerSkin", JsonConvert.SerializeObject(CharacterEditorMenu.skinData));
                Client.Instance.TriggerServerEvent("Skin.OnFinishInitialCreation");
                BaseScript.TriggerEvent("Player.OnSkinLoaded");
                Root.cleanCloseMenu();
            }
            else
            {
                var clothingStorePrice = CitizenFX.Core.Native.API.GetConvarInt("mg_clothingStorePrice", 25);
                if (await playerSession.CanPayForItem(clothingStorePrice))
                {
                    CharacterEditorMenu.skinData = Root.AdditionalSaveData.getSaveableData(Root.IsClothingStore) /*.ToExpando()*/;
                    Log.ToChat("[Bank]", $"You paid ${clothingStorePrice} to change your clothes", ConstantColours.Bank);
                    Client.Instance.TriggerServerEvent("Skin.UpdatePlayerSkin", JsonConvert.SerializeObject(CharacterEditorMenu.skinData));
                    BaseScript.TriggerEvent("Player.OnSkinLoaded");
                    Root.cleanCloseMenu();
                }
                else
                {
                    Log.ToChat("[Bank]", "You cannot afford this", ConstantColours.Bank);
                }
            }
        }
        static public void Init()
        {
            PeriodicDamageCheck();
            PeriodicNearbyRefresh();
            Function.Call(Hash.DECOR_REGISTER, $"Damage.Petrol", 3);
            Function.Call(Hash.DECOR_REGISTER, $"Damage.Projectile", 3);
            Function.Call(Hash.DECOR_REGISTER, $"Damage.Melee.Sharp", 3);
            Function.Call(Hash.DECOR_REGISTER, $"Damage.Melee.Blunt", 3);
            Function.Call(Hash.DECOR_REGISTER, $"Damage.Vehicle", 3);
            Function.Call(Hash.DECOR_REGISTER, $"Damage.KillerCategory", 3);

            var pedList = new PedList();

            // Gate after testing
            var weaponSourceMenuItem = new MenuItemStandard {
                Title = "Check Closest for Weapon Source", OnActivate = (item) => { CheckWeaponSources(new PedList().Select(p => new Ped(p)).Where(p => p != Game.PlayerPed).OrderBy(p => p.Position.DistanceToSquared(Game.PlayerPed.Position)).First()); }
            };

            InteractionListMenu.RegisterInteractionMenuItem(weaponSourceMenuItem, () => pedList.Select(p => new Ped(p)).Where(p => p != Game.PlayerPed).Where(p => p.Position.DistanceToSquared(Game.PlayerPed.Position) < 9f).Count() > 0, 1029);

            var damageSourceMenuItem = new MenuItemStandard {
                Title = "Check Closest for Damage Source Type", OnActivate = (item) => { Enum.GetValues(typeof(CountedDamageType)).OfType <CountedDamageType>().ToList().ForEach(dt => { CheckDamageSourceType(new PedList().Select(p => new Ped(p)).Where(p => p != Game.PlayerPed).OrderBy(p => p.Position.DistanceToSquared(Game.PlayerPed.Position)).First(), dt); }); }
            };

            InteractionListMenu.RegisterInteractionMenuItem(damageSourceMenuItem, () => pedList.Select(p => new Ped(p)).Where(p => p != Game.PlayerPed).Where(p => p.Position.DistanceToSquared(Game.PlayerPed.Position) < 9f).Count() > 0, 1030);

            var damageLocationMenuItem = new MenuItemStandard {
                Title = "Check Closest for Damage Location", OnActivate = (item) => { CheckDamageLocation(new PedList().Select(p => new Ped(p)).Where(p => p != Game.PlayerPed).OrderBy(p => p.Position.DistanceToSquared(Game.PlayerPed.Position)).First()); }
            };

            InteractionListMenu.RegisterInteractionMenuItem(damageLocationMenuItem, () => pedList.Select(p => new Ped(p)).Where(p => p != Game.PlayerPed).Where(p => p.Position.DistanceToSquared(Game.PlayerPed.Position) < 9f).Count() > 0, 1031);
        }
Exemple #4
0
 private void CloseComponentMenu(MenuItemStandard m)
 {
     if (Root.Observer.CurrentMenu == Menu)
     {
         Root.Observer.CloseMenu();
     }
 }
        static public void Init()
        {
            Function.Call(Hash.DECOR_REGISTER, "Vehicle.Fuel", 1);
            Function.Call(Hash.DECOR_REGISTER, "Vehicle.FuelUsageMultiplier", 1);
            //Client.GetInstance().ClientCommands.Register("/refuel", HandleRefuel);

            //var RefuelPayCashItem = new MenuItemStandard
            //{
            //    Title = "Refuel to Full: Pay Cash",
            //    OnActivate = (item) => Refuel(100)
            //};

            //var RefuelPayDebitItem = new MenuItemStandard
            //{
            //    Title = "Refuel to Full",
            //    OnActivate = (item) => Refuel(100)
            //};

            MenuItem ToRefuelMenuItem = new MenuItemStandard {
                Title = "Refuel to Full", OnActivate = (item) => Refuel(100)
            };

            InteractionListMenu.RegisterInteractionMenuItem(ToRefuelMenuItem, () => { return(isNearFuelPump); }, 1150);

            PeriodicCheck();
        }
        private void SaveAndExit(MenuItemStandard m)
        {
            Log.ToChat("CharacterEditorMenu SaveAndExit");

            // TODO: Proper support for this
            Roleplay.Client.CharacterEditor.Save();
            Roleplay.Client.CharacterEditor.Exit();
        }
        private void ExitWithoutSaving(MenuItemStandard m)
        {
            //Log.ToChat( "CharacterEditorMenu ExitWithoutSaving" );
            Root.cleanCloseMenu();
            var pedData = JsonConvert.DeserializeObject <PedData>(Client.Instance.Instances.Session.GetPlayer(Game.Player).GetGlobalData("Character.SkinData", ""));

            CharacterEditorMenu.handleSkinCreate(pedData);
        }
        public static void Init()
        {
            Client.GetInstance().RegisterTickHandler(OnTick);
            Client.GetInstance().ClientCommands.Register("/gsr", TriggerChecks);
            Client.GetInstance().RegisterEventHandler("Player.GSRTest", new Action <int>(Check));
            Client.GetInstance().RegisterEventHandler("Player.GsrResult", new Action <string, bool>(ReceiveResult));
            MenuItem gsrTestMenuItem = new MenuItemStandard {
                Title = "GSR Test Nearby", OnActivate = (item) => TriggerChecks(new Command(""))
            };

            InteractionListMenu.RegisterInteractionMenuItem(gsrTestMenuItem, () => true, 980);
        }
        static public void Init()
        {
            Client.ActiveInstance.RegisterEventHandler("Duty.UpdateDuty", new Action <int, int, bool>(HandleUpdateDuty));
            Client.ActiveInstance.RegisterEventHandler("Duty.InitialDuty", new Action <string>(HandleInitialDuty));
            Client.ActiveInstance.RegisterEventHandler("playerSpawned", new Action(HandlePlayerSpawned));
            Client.ActiveInstance.RegisterEventHandler("Duty.UpdateVehicleBlip", new Action <int>(HandleUpdateBlip));

            var menuItem = new MenuItemStandard {
                Title = "Toggle Duty", OnActivate = (item) => { AttemptDutyToggle(); }
            };

            InteractionListMenu.RegisterInteractionMenuItem(menuItem, () => isAtValidDutyLocation, 1050);
            Client.ActiveInstance.RegisterTickHandler(OnTick);
            RegularBlipCleanup();
        }
        private void buildUIElements()
        {
            foreach (var loc in Locations.TransitLocations.TrainStations)
            {
                var interactItem = new MenuItemStandard
                {
                    Title      = loc.Key,
                    OnActivate = item =>
                    {
                        checkCanGoToLocation(Locations.TransitLocations.TrainStations.Values.ToList(), loc.Value, "train");
                    }
                };
                trainMenu.menuItems.Add(interactItem);
            }

            foreach (var loc in Locations.TransitLocations.BusStops)
            {
                var interactItem = new MenuItemStandard
                {
                    Title      = loc.Key,
                    OnActivate = item =>
                    {
                        checkCanGoToLocation(Locations.TransitLocations.BusStops.Values.ToList(), loc.Value, "bus");
                    }
                };
                busMenu.menuItems.Add(interactItem);
            }

            Client.Get <InteractionUI>().RegisterInteractionMenuItem(new MenuItemSubMenu
            {
                Title   = "Train station",
                SubMenu = trainMenu
            }, () => IsNearLocation(Locations.TransitLocations.TrainStations.Values.ToList()), 600);

            Client.Get <InteractionUI>().RegisterInteractionMenuItem(new MenuItemSubMenu
            {
                Title   = "Bus station",
                SubMenu = busMenu
            }, () => IsNearLocation(Locations.TransitLocations.BusStops.Values.ToList()), 600);
        }
        protected DeliveryJob()
        {
            ReturnVehicleItem = new MenuItemStandard
            {
                Title = "Return Job Vehicle",
                OnActivate = async item =>
                {
                    if (Game.PlayerPed.Position.DistanceToSquared(VehicleSpawnLocation) < 400.0f && JobVehicle != null && (JobVehicle.Position.DistanceToSquared(VehicleSpawnLocation) < 400.0f || JobVehicle.IsDead))
                    {
                        if (Game.PlayerPed.IsInVehicle() && Game.PlayerPed.CurrentVehicle == JobVehicle)
                            Game.PlayerPed.Task.LeaveVehicle(JobVehicle, true);

                        Log.ToChat("[Job]", "Returning job vehicle", ConstantColours.Job);
                        await BaseScript.Delay(3000);
                        RemoveJobVehicle();
                        EndJob();
                        Client.Get<InteractionUI>().RemoveInteractionMenuItem(ReturnVehicleItem);
                    }
                }
            };

            Client.RegisterEventHandler("Player.CheckForInteraction", new Action(OnInteraction));
        }
Exemple #12
0
        internal static void InitMenu()
        {
            Log.Verbose($"GarageMenu InitMenu");
            try
            {
                var item = new MenuItemStandard()
                {
                    Title      = "Park Vehicle",
                    OnActivate = ParkCarFromMenu
                };
                InteractionListMenu.RegisterInteractionMenuItem(item, CheckPedGarageProximity, 500);

                // Vehicle Selection, requires sub menu
                var items = new List <MenuItemStandard>()
                {
                    new MenuItemStandard()
                    {
                        Title      = "SomeCar",
                        OnActivate = TestEvent
                    }
                };
                VehicleSelectMenu = new MenuItemSubMenu()
                {
                    Title   = "Vehicle Select",
                    SubMenu = new MenuModel()
                    {
                        headerTitle = "Some sub menu"
                    }
                };
                VehicleSelectMenu.SubMenu.MenuItems.AddRange(items);
                InteractionListMenu.RegisterInteractionMenuItem(VehicleSelectMenu, CheckPedGarageProximity, 500);
            }
            catch (Exception ex)
            {
                Log.Error($"GarageMenu InitMenu Error: {ex.Message}");
            }
        }
Exemple #13
0
 private void OpenComponentMenu(MenuItemStandard m)
 {
     Root.Observer.OpenMenu(Menu);
 }
 private void AbortExit(MenuItemStandard m)
 {
     Root.Observer.CloseMenu();
 }
 private void OpenExitPrompt(MenuItemStandard m)
 {
     Root.Observer.OpenMenu(Prompt);
 }
        static public void Init()
        {
            Client.GetInstance().ClientCommands.Register("/emote", HandleEmote);
            Client.GetInstance().RegisterTickHandler(OnTick);

            var CancelMenuItem = new MenuItemStandard
            {
                Title      = "Cancel Emote",
                OnActivate = (item) =>
                {
                    //if (!(Arrest.playerCuffState == CuffState.None)) return;
                    Game.PlayerPed.Task.ClearAll();
                    isPlayingEmote = false;
                    InteractionListMenu.Observer.CloseMenu();
                }
            };

            var CancelImmediatelyMenuItem = new MenuItemStandard
            {
                Title      = "Cancel Emote (Immediately)",
                OnActivate = (item) =>
                {
                    //if (!(Arrest.playerCuffState == CuffState.None)) return;
                    Game.PlayerPed.Task.ClearAllImmediately();
                    isPlayingEmote = false;
                    InteractionListMenu.Observer.CloseMenu();
                }
            };

            InteractionListMenu.RegisterInteractionMenuItem(CancelMenuItem, () => { return(isPlayingEmote); }, 1150);
            InteractionListMenu.RegisterInteractionMenuItem(CancelImmediatelyMenuItem, () => { return(isPlayingEmote); }, 1149);

            var CancelEmoteMenu = new MenuModel {
                headerTitle = "Emotes", menuItems = new List <MenuItem>()
                {
                    CancelMenuItem, CancelImmediatelyMenuItem
                }
            };

            List <MenuItem> EmotesMenuItems = new List <MenuItem>();

            scenarios.OrderBy(x => x.Key).ToList().ForEach(s =>
            {
                EmotesMenuItems.Add(new MenuItemStandard
                {
                    Title      = $"{s.Key.ToTitleCase()}",
                    OnActivate = (item) =>
                    {
                        PlayEmote(item.Title.ToLower());
                        InteractionListMenu.Observer.OpenMenu(CancelEmoteMenu);
                    }
                });
            });
            var EmotesMenu = new MenuModel {
                headerTitle = "Emotes", menuItems = EmotesMenuItems
            };
            var ToEmotesMenuItem = new MenuItemSubMenu {
                Title = "Emotes", SubMenu = EmotesMenu
            };

            InteractionListMenu.RegisterInteractionMenuItem(ToEmotesMenuItem, () => { return(!isPlayingEmote && !Game.PlayerPed.IsInVehicle()); }, 1150);
        }
 private void ExitWithoutSaving(MenuItemStandard m)
 {
     //TODO: Proper support for this
     Roleplay.Client.CharacterEditor.Exit(false);
     Log.ToChat("CharacterEditorMenu ExitWithoutSaving");
 }