private static void CheckForDrownedVehicles()
{
var vehicles = VehicleManager.vehicles;
for (var i = vehicles.Count - 1; i >= 0; i--)
{
if (!VehicleUtil.VehicleHasOwner(vehicles[i]))
{
continue;
}
if (!vehicles[i].isDrowned)
{
continue;
}
var vName = vehicles[i].asset.vehicleName;
var vId = vehicles[i].asset.id;
var vOwner = vehicles[i].lockedOwner;
var vehicleCount = DbManager.GetVehicleCount(vOwner.m_SteamID.ToString(), "Drown");
if (vehicleCount >= Conf.DrownGarageSlot && Conf.DrownGarageSlot != -1)
{
continue;
}
var drownedVehicleRegion = BarricadeManager.getRegionFromVehicle(vehicles[i]);
GarageUtil.SaveVgVehicleToSql(vOwner.m_SteamID, "Drown", "Drowned", vehicles[i],
drownedVehicleRegion);
if (UnturnedPlayer.FromCSteamID(vOwner) != null)
{
UnturnedPlayer.FromCSteamID(vOwner).SendChat(
Inst.Translate("rfgarage_autogarage_drown_success", vName, vId), MsgColor,
Conf.AnnouncerIconUrl);
}
Logger.LogWarning(
$"[RFGarage] {vName} [{vId}] has been added automatically to {vOwner.m_SteamID}'s garage due to Drown");
}
}
public static void InitVehicleCommands()
{
API.RegisterCommand("sv", new Action <int, List <object> >((src, args) =>
{
var argList = args.Select(o => o.ToString()).ToList();
if (argList.Any() && Enum.TryParse(argList[0], true, out VehicleHash vehicle))
{
VehicleUtil.SpawnVehicle(vehicle);
}
}
), false);
API.RegisterCommand("fix", new Action <int>((src) =>
{
if (Game.PlayerPed.IsInVehicle())
{
Game.Player.LastVehicle.Repair();
}
}
), false);
API.RegisterCommand("impound", new Action <int>((src) =>
{
Ped playerPed = Game.PlayerPed;
Vector3 playerPos = playerPed.Position;
Vector3 playerOffset = API.GetOffsetFromEntityGivenWorldCoords(playerPed.Handle, 0, 1f, 0);
int rayHandle = API.StartShapeTestCapsule(playerPos.X, playerPos.Y, playerPos.Z, playerOffset.X, playerOffset.Y, playerOffset.Z, 1, 10, playerPed.Handle, 7);
bool hit = false;
Vector3 endPoint = playerPos;
Vector3 surfaceNormal = playerPos;
int veh = 0;
API.GetShapeTestResult(rayHandle, ref hit, ref endPoint, ref surfaceNormal, ref veh);
if (veh != 0)
{
Vehicle vehicle = new Vehicle(veh);
//TODO should probably check if vehicel has passengers
vehicle.Delete();
}
}
), false);
API.RegisterCommand("engine", new Action <int>(src =>
{
Vehicle veh = Game.PlayerPed.CurrentVehicle;
if (veh != null)
{
if (veh.IsEngineRunning)
{
API.SetVehicleEngineOn(veh.Handle, false, false, true);
}
else
{
API.SetVehicleEngineOn(veh.Handle, true, false, true);
}
}
}), false);
}
public static void UnloadPassengersPost(State __state)
{
if (VehicleManager.instance.m_vehicles.m_buffer[__state.vehicleID].m_leadingVehicle != 0)
{
return;
}
var currentPassengers =
VehicleUtil.GetTotalPassengerCount(__state.vehicleID, CachedVehicleData.MaxVehicleCount);
var passengersOut = Mathf.Max(0, __state.currentPassengers - currentPassengers);
CachedVehicleData.m_cachedVehicleData[__state.vehicleID]
.DisembarkPassengers(passengersOut, __state.currentStop);
CachedNodeData.m_cachedNodeData[__state.currentStop].PassengersOut += passengersOut;
}
public static bool UnloadPassengersPre(ushort vehicleID, ushort currentStop, out State __state)
{
if (VehicleManager.instance.m_vehicles.m_buffer[vehicleID].m_leadingVehicle != 0)
{
__state = new State();
return(true);
}
__state = new State()
{
vehicleID = vehicleID,
currentStop = currentStop,
currentPassengers = VehicleUtil.GetTotalPassengerCount(vehicleID, CachedVehicleData.MaxVehicleCount)
};
return(true);
}
public static void LoadPassengersPost(State __state)
{
var data = VehicleManager.instance.m_vehicles.m_buffer[__state.vehicleID];
if (data.m_leadingVehicle != 0)
{
return;
}
var currentPassengers =
VehicleUtil.GetTotalPassengerCount(__state.vehicleID, CachedVehicleData.MaxVehicleCount);
var passengersIn = Mathf.Max(0, currentPassengers - __state.currentPassengers);
CachedVehicleData.m_cachedVehicleData[__state.vehicleID]
.BoardPassengers(passengersIn, VehicleUtil.GetTicketPrice(__state.vehicleID), __state.currentStop);
CachedNodeData.m_cachedNodeData[__state.currentStop].PassengersIn += passengersIn;
}
private static void AddColorItems(Menu colorTypeMenu, String colorType)
{
Vehicle veh = Game.PlayerPed.CurrentVehicle;
Array vehicleColors = Enum.GetValues(typeof(VehicleColor));
string[] vehicleColors2 = vehicleColors.OfType <object>().Select(o => o.ToString()).ToArray();
Array.Sort <string>(vehicleColors2);
foreach (string vehCS in vehicleColors2)
{
Enum.TryParse <VehicleColor>(vehCS, out VehicleColor vehC);
ArrayList dataList = new ArrayList();
dataList.Add(vehC);
dataList.Add(colorType);
MenuItem colorMenuItem = new MenuItem(vehC.ToString())
{
ItemData = dataList
};
if (("Primary".Equals(colorType) && vehC.Equals(veh.Mods.PrimaryColor)) ||
("Secondary".Equals(colorType) && vehC.Equals(veh.Mods.SecondaryColor)) ||
("Pearlescent".Equals(colorType) && vehC.Equals(veh.Mods.PearlescentColor)) ||
("Rim".Equals(colorType) && vehC.Equals(veh.Mods.RimColor)) ||
("Neon".Equals(colorType) && vehC.Equals(veh.Mods.NeonLightsColor)) ||
("Tire smoke".Equals(colorType) && vehC.Equals(veh.Mods.TireSmokeColor)))
{
colorMenuItem.RightIcon = MenuItem.Icon.TICK;
}
colorTypeMenu.AddMenuItem(colorMenuItem);
}
colorTypeMenu.OnIndexChange += (_menu, _oldItem, _newItem, _oldIndex, _newIndex) =>
{
VehicleUtil.SetColorOnVehicle(_newItem.ItemData[1], _newItem.ItemData[0]);
};
colorTypeMenu.OnItemSelect += (_menu, _item, _index) =>
{
foreach (MenuItem menuItem in _menu.GetMenuItems())
{
if (menuItem.RightIcon.Equals(MenuItem.Icon.TICK))
{
menuItem.RightIcon = MenuItem.Icon.NONE;
break;
}
}
_item.RightIcon = MenuItem.Icon.TICK;
};
colorTypeMenu.OnMenuClose += (_menu) =>
{
foreach (MenuItem menuItem in _menu.GetMenuItems())
{
if (menuItem.RightIcon.Equals(MenuItem.Icon.TICK))
{
VehicleUtil.SetColorOnVehicle(menuItem.ItemData[1], menuItem.ItemData[0]);
break;
}
}
};
}
public static void SpawnVehicleMenu(Menu menu)
{
Menu spawnVehicleMenu = new Menu("Spawn vehicle", "Spawn a vehicle");
MenuController.AddSubmenu(menu, spawnVehicleMenu);
MenuItem spawnVehicleMenuItem = new MenuItem("Spawn vehicle", "Spawn a vehicle")
{
Label = "→"
};
foreach (VehicleClass vehicleClass in Enum.GetValues(typeof(VehicleClass)))
{
Menu vehicleMenu = new Menu(vehicleClass.ToString());
MenuController.AddSubmenu(spawnVehicleMenu, vehicleMenu);
MenuItem menuItem = new MenuItem(vehicleClass.ToString(), vehicleClass.ToString())
{
Label = "→"
};
spawnVehicleMenu.AddMenuItem(menuItem);
MenuController.BindMenuItem(spawnVehicleMenu, vehicleMenu, menuItem);
foreach (VehicleHash veh in VehicleUtil.GetVehsForVehicleClass(vehicleClass))
{
MenuItem vehicleMenuItem = new MenuItem(veh.ToString(), veh.ToString())
{
};
vehicleMenuItem.ItemData = veh;
vehicleMenu.AddMenuItem(vehicleMenuItem);
}
vehicleMenu.OnIndexChange += async(_menu, _oldItem, _newItem, _oldIndex, _newIndex) =>
{
Vehicle oldVeh = Game.PlayerPed.CurrentVehicle;
Model model = new Model(_newItem.ItemData);
Vector3 position;
if (Game.PlayerPed.IsInVehicle())
{
position = Game.PlayerPed.CurrentVehicle.Position;
oldVeh.Delete();
}
else
{
position = Game.PlayerPed.Position;
}
Vehicle newVeh = await World.CreateVehicle(model, position, Game.PlayerPed.Heading);
API.SetVehicleEngineOn(newVeh.Handle, true, false, true);
Game.PlayerPed.SetIntoVehicle(newVeh, VehicleSeat.Driver);
};
vehicleMenu.OnItemSelect += (_menu, _item, _index) =>
{
Vehicle veh = Game.PlayerPed.CurrentVehicle;
veh.Mods.InstallModKit();
veh.Mods[VehicleModType.Engine].Index = veh.Mods[VehicleModType.Engine].ModCount - 1;
veh.Mods[VehicleModType.Brakes].Index = veh.Mods[VehicleModType.Brakes].ModCount - 1;
veh.Mods[VehicleModType.Transmission].Index = veh.Mods[VehicleModType.Transmission].ModCount - 1;
veh.Mods[VehicleToggleModType.Turbo].IsInstalled = true;
veh.Mods[VehicleToggleModType.XenonHeadlights].IsInstalled = true;
MenuController.CloseAllMenus();
};
vehicleMenu.OnMenuClose += (_menu) =>
{
Vehicle oldVeh = Game.PlayerPed.CurrentVehicle;
if (oldVeh != null && !oldVeh.Mods[VehicleToggleModType.XenonHeadlights].IsInstalled)
{
oldVeh.Delete();
}
};
}
menu.AddMenuItem(spawnVehicleMenuItem);
MenuController.BindMenuItem(menu, spawnVehicleMenu, spawnVehicleMenuItem);
}
private CommandResult VehicleCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
switch (args.Length)
{
case 1:
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
var optAsset = VehicleUtil.GetVehicle(args[0].ToString());
if (optAsset.IsAbsent)
{
return(CommandResult.Lang("INVALID_VEHICLE_ID", args[0]));
}
var id = optAsset.Value.id;
if (UEssentials.Config.VehicleBlacklist.Contains(id) &&
!src.HasPermission("essentials.bypass.blacklist.vehicle"))
{
return(CommandResult.Lang("BLACKLISTED_VEHICLE", $"{optAsset.Value.vehicleName} ({id})"));
}
VehicleTool.giveVehicle(src.ToPlayer().UnturnedPlayer, id);
EssLang.Send(src, "RECEIVED_VEHICLE", optAsset.Value.vehicleName, id);
break;
case 2:
if (!src.HasPermission($"{cmd.Permission}.other"))
{
return(CommandResult.Lang("COMMAND_NO_PERMISSION"));
}
optAsset = VehicleUtil.GetVehicle(args[1].ToString());
if (optAsset.IsAbsent)
{
return(CommandResult.Lang("INVALID_VEHICLE_ID", args[1]));
}
var vehAsset = optAsset.Value;
if (args[0].Equals("*"))
{
UServer.Players.ForEach(p => {
VehicleTool.giveVehicle(p.UnturnedPlayer, vehAsset.id);
});
EssLang.Send(src, "GIVEN_VEHICLE_ALL", vehAsset.vehicleName, vehAsset.id);
}
else if (!args[0].IsValidPlayerIdentifier)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
}
else
{
var target = args[0].ToPlayer;
VehicleTool.giveVehicle(target.UnturnedPlayer, vehAsset.id);
EssLang.Send(src, "GIVEN_VEHICLE", vehAsset.vehicleName, vehAsset.id, target.DisplayName);
}
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
public Vehicle(VehicleType vehicleType)
{
this.vehicleType = vehicleType;
this.id = VehicleUtil.CreateVehicleId();
}
public static void InitPlayerPedCommands()
{
API.RegisterCommand("gw", new Action <int, List <object>, string>((src, args, raw) =>
{
var argList = args.Select(o => o.ToString()).ToList();
if (argList.Any() && Enum.TryParse(argList[0], true, out WeaponHash weapon))
{
Game.PlayerPed.Weapons.Give(weapon, 250, true, false);
}
else
{
ChatUtil.SendMessageToClient("Error", "Usage : /gw [WeaponName]", 255, 0, 0);
}
}
), false);
API.RegisterCommand("heal", new Action <int, List <object>, string>((src, args, raw) =>
{
Game.PlayerPed.Armor = Game.Player.MaxArmor;
Game.PlayerPed.Health = Game.PlayerPed.MaxHealth;
Game.PlayerPed.ResetVisibleDamage();
}
), false);
API.RegisterCommand("killme", new Action <int, List <object>, string>((src, args, raw) =>
{
Game.PlayerPed.Kill();
}
), false);
API.RegisterCommand("tp", new Action <int, List <object>, string>((src, args, raw) =>
{
int waypoint = API.GetFirstBlipInfoId(8);
Vector3 waypointCoords = API.GetBlipCoords(waypoint);
Debug.WriteLine("Waypointcoords " + waypointCoords.X + waypointCoords.Y + waypointCoords.Z);
float height = 10000f;
API.GetGroundZFor_3dCoord(waypointCoords[0], waypointCoords[1], height, ref height, false);
Game.PlayerPed.Position = new Vector3(waypointCoords[0], waypointCoords[1], height + 2f);
}
), false);
API.RegisterCommand("coords", new Action <int>(src =>
{
Vector3 playerLocation = Game.PlayerPed.Position;
ChatUtil.SendMessageToClient("[Coords", "Your coordinates are x " + playerLocation.X + " y " + playerLocation.Y + " z " + playerLocation.Z, 255, 255, 255);
}), false);
API.RegisterCommand("interior", new Action <int>(src =>
{
Vector3 playerLocation = Game.PlayerPed.Position;
int interiorId = API.GetInteriorAtCoords(playerLocation.X, playerLocation.Y, playerLocation.Z);
ChatUtil.SendMessageToClient("[Interior]", "Current playerposition interiorID = " + interiorId, 255, 255, 255);
}), false);
API.RegisterCommand("revive", new Action <int>(src =>
{
if (Game.PlayerPed.IsDead)
{
if (Game.PlayerPed.IsInVehicle())
{
Vehicle veh = Game.PlayerPed.CurrentVehicle;
API.ClearAllPedVehicleForcedSeatUsage(Game.Player.Handle);
}
Game.PlayerPed.Resurrect();
}
}), false);
API.RegisterKeyMapping("shuffleSeat", "Shuffle", "keyboard", "h");
API.RegisterCommand("shuffleSeat", (new Action <int>(async src =>
{
if (Game.PlayerPed.IsInVehicle() &&
(API.GetPedInVehicleSeat(Game.PlayerPed.CurrentVehicle.Handle, 0) == Game.PlayerPed.Handle || API.GetPedInVehicleSeat(Game.PlayerPed.CurrentVehicle.Handle, 1) == Game.PlayerPed.Handle) &&
!PlayerValues.shuffleSeat)
{
PlayerValues.shuffleSeat = true;
Debug.WriteLine("shuffleSeat = true");
await Delay(4000);
PlayerValues.shuffleSeat = false;
Debug.WriteLine("shuffleSeat = false");
}
})), false);
API.RegisterCommand("drag", (new Action <int, List <object> >((src, args) =>
{
List <string> argList = args.Select(o => o.ToString()).ToList();
if (argList.Any() && argList[0].Equals("reset"))
{
Debug.WriteLine("Resetting drag");
PlayerValues.attachedEntity = 0;
return;
}
if (argList.Any() && argList[0].Equals("check"))
{
Debug.WriteLine("attachedEntity = " + PlayerValues.attachedEntity);
return;
}
if (argList.Any() && argList[0].Equals("pos"))
{
Vector3 pos = API.GetEntityCoords(PlayerValues.attachedEntity, true);
Debug.WriteLine("attachedEntityPosition = x " + pos.X + " y " + pos.Y + " z " + pos.Z);
return;
}
Ped playerPed = Game.PlayerPed;
if (PlayerValues.attachedEntity != 0)
{
Debug.WriteLine("Detaching entity " + PlayerValues.attachedEntity);
API.DetachEntity(PlayerValues.attachedEntity, true, true);
PlayerValues.attachedEntity = 0;
return;
}
Vector3 playerPos = playerPed.Position;
Vector3 playerOffset = API.GetOffsetFromEntityGivenWorldCoords(playerPed.Handle, 0, 5f, 0);
int rayHandle = API.StartShapeTestCapsule(playerPos.X, playerPos.Y, playerPos.Z, playerOffset.X, playerOffset.Y, playerOffset.Z, 1, 12, playerPed.Handle, 7);
bool hit = false;
Vector3 endPoint = playerPos;
Vector3 surfaceNormal = playerPos;
int ped = 0;
API.GetShapeTestResult(rayHandle, ref hit, ref endPoint, ref surfaceNormal, ref ped);
if (ped != 0)
{
Debug.WriteLine("Would try to attach " + ped + " to " + playerPed.Handle);
API.AttachEntityToEntity(ped, playerPed.Handle, 4103, 0, 0.7f, 0, 0f, 0f, 0f, true, false, false, false, 2, true);
PlayerValues.attachedEntity = ped;
}
else
{
Debug.WriteLine("shit");
}
})), false);
API.RegisterCommand("e", new Action <int, List <object> >((src, args) =>
{
List <string> argList = args.Select(o => o.ToString()).ToList();
if (Game.PlayerPed.IsInVehicle())
{
ChatUtil.SendMessageToClient("[Error]", "You cannot perform an emote while in a vehicle.", 255, 255, 255);
return;
}
else
{
string emote = Emote.Get(argList[0]);
if (emote != null)
{
API.TaskStartScenarioInPlace(Game.PlayerPed.Handle, emote, 0, true);
}
else
{
ChatUtil.SendMessageToClient("[Error]", "Invalid emote specified", 255, 255, 255);
}
}
}), false);
API.RegisterKeyMapping("cancelEmote", "Cancel emote", "keyboard", "space");
API.RegisterCommand("cancelEmote", new Action <int>(src =>
{
if (API.IsPedActiveInScenario(Game.PlayerPed.Handle))
{
API.ClearPedTasksImmediately(Game.PlayerPed.Handle);
}
}), false);
API.RegisterKeyMapping("enterClosestVehicleDoor", "Enter the closest vehicle door", "keyboard", "f");
API.RegisterCommand("enterClosestVehicleDoor", new Action <int>(src =>
{
if (Game.PlayerPed.IsInVehicle())
{
return;
}
if (API.IsControlJustPressed(1, 23))
{
Vector3 playerPos = Game.PlayerPed.Position;
int veh = API.GetClosestVehicle(playerPos.X, playerPos.Y, playerPos.Z, 3f, 0, 70);
if (veh != 0)
{
Vehicle vehicle = new Vehicle(veh);
API.SetVehicleEngineOn(veh, vehicle.IsEngineRunning, false, true);
if (!VehicleClass.Motorcycles.Equals(vehicle.ClassType) && !VehicleClass.Cycles.Equals(vehicle.ClassType))
{
int closestDoor = VehicleUtil.GetClosestVehicleDoor(veh, playerPos);
API.TaskEnterVehicle(Game.PlayerPed.Handle, veh, 10000, closestDoor, 2.0f, 1, 0);
}
}
}
}), false);
API.RegisterCommand("piv", new Action <int>(async src =>
{
Vector3 playerPos = Game.PlayerPed.Position;
int veh = API.GetClosestVehicle(playerPos.X, playerPos.Y, playerPos.Z, 2.5f, 0, 70);
if (veh != 0)
{
Vehicle vehicle = new Vehicle(veh);
if (!VehicleClass.Motorcycles.Equals(vehicle.ClassType) && !VehicleClass.Cycles.Equals(vehicle.ClassType))
{
int closestSeat = VehicleUtil.GetClosestVehicleDoor(veh, playerPos);
int closestDoor = closestSeat + 1;
int ped = API.GetPedInVehicleSeat(veh, closestSeat);
if (PlayerValues.attachedEntity == 0)
{
if (ped == 0)
{
return;
}
API.TaskLeaveVehicle(ped, veh, 16);
await Delay(200);
API.AttachEntityToEntity(ped, Game.PlayerPed.Handle, 4103, 0, 0.7f, 0, 0f, 0f, 0f, true, false, false, false, 2, true);
PlayerValues.attachedEntity = ped;
}
else
{
if (ped != 0)
{
return;
}
vehicle.Doors[VehicleUtil.GetVehicleDoorIndexFromSeatIndex(closestDoor)].Open();
await Delay(200);
API.DetachEntity(PlayerValues.attachedEntity, true, true);
API.SetPedIntoVehicle(PlayerValues.attachedEntity, veh, closestSeat);
PlayerValues.attachedEntity = 0;
}
await Delay(500);
vehicle.Doors[VehicleUtil.GetVehicleDoorIndexFromSeatIndex(closestDoor)].Close();
}
}
}), false);
API.RegisterCommand("invis", new Action <int>(src =>
{
API.SetPlayerInvisibleLocally(Game.Player.Handle, true);
}), false);
API.RegisterCommand("character", new Action <int, List <object> >((src, args) =>
{
List <string> argList = args.Select(o => o.ToString()).ToList();
if (!argList.Any())
{
ChatUtil.SendMessageToClient("ERROR", "No argument given, usage: /character [create, list, change]", 255, 0, 0);
}
else if (argList[0].Equals("create"))
{
if (argList.Count >= 3)
{
if (argList[1].All(Char.IsLetter) && argList[2].All(Char.IsLetter))
{
Debug.WriteLine("Sending saveNewCharacter event to server");
TriggerServerEvent("saveNewCharacter", argList[1], argList[2]);
return;
}
}
ChatUtil.SendMessageToClient("ERROR", "Wrong input, usage: /character create [firstname(a-z)] [lastname(a-z)]", 255, 0, 0);
}
else if (argList[0].Equals("change"))
{
if (argList.Count >= 2)
{
if (argList[1].All(Char.IsNumber))
{
TriggerServerEvent("changeCharacter", argList[1]);
}
}
else
{
ChatUtil.SendMessageToClient("ERROR", "Wrong input, usage: /character change [id]", 255, 0, 0);
}
}
else if (argList[0].Equals("list"))
{
TriggerServerEvent("listCharactersForAccount");
}
else if (argList[0].Equals("current"))
{
TriggerServerEvent("currentCharacter");
}
}), false);
}
