private void OnRegisterVeh(Command cmd)
        {
            var closeVeh = Cache.PlayerPed.CurrentVehicle;

            if (closeVeh == null)
            {
                closeVeh = GTAHelpers.GetClosestVehicle(6.0f);
            }

            if (closeVeh == null)
            {
                Log.ToChat("No vehicle found nearby");
                return;
            }

            closeVeh.LockStatus = VehicleLockStatus.Unlocked;
            Client.TriggerServerEvent("Vehicle.CreateExternalVehicle", VehicleDataPacker.PackVehicleData(closeVeh));

            Log.ToChat("Registered and unlocked the closest vehicle to you");
        }
Beispiel #2
0
        protected virtual async Task <Vehicle> CreateJobVehicle(VehicleHash hash, Vector3 location, float heading)
        {
            var vehModel = new Model(hash);

            while (!vehModel.IsLoaded)
            {
                await vehModel.Request(0);
            }

            JobVehicle = await World.CreateVehicle(vehModel, location, heading);

            JobVehicle.PlaceOnGround();
            JobVehicle.LockStatus   = VehicleLockStatus.Unlocked;
            JobVehicle.IsPersistent = true;
            JobVehicle.Mods.Livery  = 1;
            Game.PlayerPed.Task.WarpIntoVehicle(JobVehicle, VehicleSeat.Driver);
            Client.Instance.TriggerServerEvent("Vehicle.CreateExternalVehicle", VehicleDataPacker.PackVehicleData(JobVehicle), true);
            vehModel.MarkAsNoLongerNeeded();

            return(JobVehicle);
        }
            public static async Task ReplaceCurrentVehicleByIndex(int index)
            {
                await new Model(VehicleHashValues[index]).Request(10000);
                if (EmergencyServicesVehicleMenu.serviceVehicle != null)
                {
                    EmergencyServicesVehicleMenu.serviceVehicle.Delete();
                    serviceVehicle = null;
                }

                var model = new Model(VehicleHashValues[index]);

                while (!model.IsLoaded)
                {
                    await model.Request(0);
                }

                var v = await CitizenFX.Core.World.CreateVehicle(model, Game.PlayerPed.GetOffsetPosition(new Vector3(0, 3, 0)));

                serviceVehicle = v;
                Client.Instance.TriggerServerEvent("Vehicle.CreateExternalVehicle", VehicleDataPacker.PackVehicleData(serviceVehicle), true);
            }
Beispiel #4
0
        private async void SpawnBoughtVehicle(string vehModel, string vehPlate, string vehStoreMenu, string vehMods)
        {
            var targetVehModel = loadedModels.ContainsKey(vehModel) ? loadedModels[vehModel] : new Model(vehModel);

            while (!targetVehModel.IsLoaded)
            {
                await targetVehModel.Request(0);
            }

            if (Game.PlayerPed.IsInVehicle())
            {
                Game.PlayerPed.CurrentVehicle.Delete();
            }

            previewVehicle = null;
            var newVehicle = await VehicleDataPacker.UnpackVehicleData(JsonConvert.DeserializeObject <VehicleDataModel>(vehMods), vehicleSpawnLocations[vehStoreMenu].First(o => o.DistanceToSquared(Game.PlayerPed.Position) < 500.0f), 339);

            Game.PlayerPed.IsVisible = true;
            newVehicle.PlaceOnGround();
            newVehicle.Mods.LicensePlate = vehPlate;
            newVehicle.IsPersistent      = true;
            Game.PlayerPed.Task.WarpIntoVehicle(newVehicle, VehicleSeat.Driver);
            InteractionUI.Observer.CloseMenu(true);
        }
Beispiel #5
0
        public VehicleStoreMenu(Client client) : base(client)
        {
            try
            {
                client.RegisterTickHandler(OnTick);
                client.RegisterEventHandler("Vehicle.Store.SpawnBoughtVehicle", new Action <string, string, string, string>(SpawnBoughtVehicle));
                client.RegisterEventHandler("Player.CheckForInteraction", new Action(OnInteraction));
                markerLocations.ForEach(o => MarkerHandler.AddMarker(new Marker(o, MarkerType.HorizontalCircleFat, System.Drawing.Color.FromArgb(100, 204, 204, 0), 3)));
                EntityDecoration.RegisterProperty("Vehicle.IsPreviewVehicle", DecorationType.Bool);

                StoreMenus.ToList().ForEach(async o =>
                {
                    var menuCategories = new Dictionary <string, List <VehicleModel> >();
                    var storeMenuItems = new List <MenuItem>();
                    o.Value.ForEach(vehData =>
                    {
                        if (!menuCategories.ContainsKey(vehData.vehicleCategory))
                        {
                            menuCategories.Add(vehData.vehicleCategory, new List <VehicleModel>());
                        }

                        menuCategories[vehData.vehicleCategory].Add(vehData);
                    });
                    foreach (var i in menuCategories)
                    {
                        var vehicleList         = i.Value.OrderBy(a => a.displayName).ToList();
                        var categoryItems       = new List <MenuItem>();
                        var vehicleCategoryMenu = new MenuModel {
                            headerTitle = i.Key, menuItems = categoryItems
                        };
                        await vehicleList.ForEachAsync(async veh =>
                        {
                            categoryItems.Add(new MenuItemStandard
                            {
                                Title      = $"{veh.displayName}",
                                OnActivate = async state =>
                                {
                                    isBuying = true;
                                    InteractionUI.Observer.CloseMenu(true);
                                    if (!loadedModels.ContainsKey(veh.modelName))
                                    {
                                        loadedModels[veh.modelName] = new Model(Game.GenerateHash(veh.modelName));
                                    }

                                    var vehModel = loadedModels[veh.modelName];
                                    //if (!Cache.PlayerPed.IsInVehicle() || previewVehicle == null)
                                    {
                                        Log.ToChat("[Store]", "Purchasing vehicle...", ConstantColours.Green);
                                        while (!vehModel.IsLoaded)
                                        {
                                            await vehModel.Request(0);
                                        }

                                        deletePreviewVehicle();

                                        var spawnLocation = vehiclePreviewLocation[o.Key].First(b => b.DistanceToSquared(Game.PlayerPed.Position) < 250.0f);
                                        previewVehicle    = new CitizenFX.Core.Vehicle(API.CreateVehicle((uint)vehModel.Hash, spawnLocation.X, spawnLocation.Y, spawnLocation.Z, 0.0f, false, false))
                                        {
                                            IsPositionFrozen = true,
                                            LockStatus       = VehicleLockStatus.StickPlayerInside,
                                            IsDriveable      = false,
                                            IsInvincible     = true
                                        }; // No network
                                        previewVehicle.SetDecor("Vehicle.IsPreviewVehicle", true);
                                        Game.PlayerPed.Task.WarpIntoVehicle(previewVehicle, VehicleSeat.Driver);
                                        await BaseScript.Delay(1000);
                                    }

                                    var vehData = VehicleDataPacker.PackVehicleData(previewVehicle);
                                    if (vehData == null)
                                    {
                                        Log.ToChat("[Store]", "There was an error purchasing this vehicle. Please try again", ConstantColours.Store);
                                        isBuying = false;
                                        return;
                                    }

                                    var vehDataModel = JsonConvert.DeserializeObject <VehicleDataModel>(vehData);
                                    if (vehDataModel.Model != 0 && vehModel.Hash == Cache.PlayerPed.CurrentVehicle.Model.Hash)
                                    {
                                        Magicallity.Client.Client.Instance.TriggerServerEvent("Vehicle.Store.BuyVehicle", veh.modelName, veh.price, o.Key, vehData);
                                    }
                                    else
                                    {
                                        Log.ToChat("[Store]", "There was an error purchasing this vehicle. Please try again", ConstantColours.Store);
                                    }

                                    isBuying = false;
                                },
                                OnSelect = state =>
                                {
                                    var modelLoaded = loadedModels.ContainsKey(veh.modelName);
                                    if (currentLoadingCategory != veh.vehicleCategory || !modelLoaded)
                                    {
                                        requestModelsForVehicleType(o.Key, vehicleCategoryMenu, veh.vehicleCategory);
                                    }

                                    if (!modelLoaded)
                                    {
                                        return;
                                    }

                                    var vehModel = loadedModels[veh.modelName];
                                    deletePreviewVehicle();

                                    var spawnLocation = vehiclePreviewLocation[o.Key].First(b => b.DistanceToSquared(Game.PlayerPed.Position) < 250.0f);
                                    previewVehicle    = new CitizenFX.Core.Vehicle(API.CreateVehicle((uint)vehModel.Hash, spawnLocation.X, spawnLocation.Y, spawnLocation.Z, 0.0f, false, false))
                                    {
                                        IsPositionFrozen = true,
                                        LockStatus       = VehicleLockStatus.StickPlayerInside,
                                        IsDriveable      = false,
                                        IsInvincible     = true
                                    }; // No network
                                    previewVehicle.SetDecor("Vehicle.IsPreviewVehicle", true);
                                    Game.PlayerPed.Task.WarpIntoVehicle(previewVehicle, VehicleSeat.Driver);
                                },
                                Detail = veh.price == 0 ? $"Free" : $"(${veh.price})",
                            });
                            await BaseScript.Delay(0);
                        });
                        storeMenuItems.Add(new MenuItemSubMenu
                        {
                            Title      = i.Key,
                            SubMenu    = vehicleCategoryMenu,
                            OnActivate = item =>
                            {
                                deletePreviewVehicle();

                                requestModelsForVehicleType(o.Key, vehicleCategoryMenu, i.Key);

                                vehicleCategoryMenu.menuItems[vehicleCategoryMenu.SelectedIndex].OnSelect(new MenuItemStandard());
                            }
                        });
                        await BaseScript.Delay(0);
                    }
                    var menuThing = new MenuModel {
                        headerTitle = o.Key.AddSpacesToCamelCase(), menuItems = storeMenuItems
                    };
                    storeMenus[o.Key] = menuThing;
                    client.Get <InteractionUI>().RegisterInteractionMenuItem(new MenuItemSubMenu
                    {
                        Title   = o.Key.AddSpacesToCamelCase(),
                        SubMenu = menuThing
                    }, () => vehiclePreviewLocation.ContainsKey(o.Key) && vehiclePreviewLocation[o.Key].Any(loc => loc.DistanceToSquared(Game.PlayerPed.Position) < 250.0f), 510);
                });
                vehiclePreviewLocation.ToList().ForEach(loc =>
                {
                    BlipHandler.AddBlip(loc.Key.AddSpacesToCamelCase(), loc.Value, new BlipOptions
                    {
                        Sprite = (BlipSprite)326
                    });
                });
            }
            catch (Exception e)
            {
                Log.Error(e);
            }
        }
        private async void OnInteraction()
        {
            var closeOwnedVeh = Client.Get <VehicleHandler>().GetClosestOwnedVehicle();

            if (Cache.PlayerPed.IsInVehicle() && closeOwnedVeh != null && closeOwnedVeh.HasDecor("Vehicle.ID") && closeOwnedVeh.GetDecor <int>("Vehicle.ID") < 1000000 && Cache.PlayerPed.CurrentVehicle == closeOwnedVeh && isInRangeOfVehicleGarage(false) && closestGarage.DisplayName != "Impound")
            {
                InteractionUI.Observer.CloseMenu(true);
                Log.Verbose($"Close to garage {closestGarage.Name} attempting to store vehicle {closeOwnedVeh.GetDecor<int>("Vehicle.ID")}");
                Client.TriggerServerEvent("Vehicle.Garage.AttemptStoreVehicle", closeOwnedVeh.GetDecor <int>("Vehicle.ID"), VehicleDataPacker.PackVehicleData(closeOwnedVeh) /*, closestGarage.Name*/);
            }
            else if (isInRangeOfVehicleGarage())
            {
                populateGarageMenu();
            }
        }