private void FixedUpdate()
{
if ( !Player.IsInVehicle )
{
return;
}
if ( cachedVeh != Player.CurrentVehicle )
{
cachedVeh = Player.CurrentVehicle;
}
if ( cachedVeh.fuel < 100 && AutoRefuel )
{
VehicleManager.sendVehicleFuel( cachedVeh, cachedVeh.asset.fuel );
cachedVeh.fuel = cachedVeh.asset.fuel;
}
if ( !AutoRepair )
{
return;
}
VehicleManager.sendVehicleHealth( cachedVeh, cachedVeh.asset.health );
cachedVeh.health = cachedVeh.asset.health;
}
public static bool GetVehicleBySeat(UnturnedPlayer player, out InteractableVehicle currentVehicle, out BarricadeRegion vehicleBarricadeRegion)
{
currentVehicle = player.CurrentVehicle;
vehicleBarricadeRegion = null;
if (currentVehicle == null)
{
return(false);
}
vehicleBarricadeRegion = BarricadeManager.getRegionFromVehicle(currentVehicle);
return(true);
}
private void OnExitVehicleRequested(Player nativePlayer, InteractableVehicle vehicle, ref bool shouldAllow, ref Vector3 pendingLocation, ref float pendingYaw)
{
UnturnedPlayer player = GetUnturnedPlayer(nativePlayer);
UnturnedPlayerExitingVehicleEvent @event = new UnturnedPlayerExitingVehicleEvent(player, new UnturnedVehicle(vehicle), pendingLocation.ToSystemVector(), pendingYaw);
Emit(@event);
shouldAllow = [email protected];
pendingLocation = @event.PendingLocation.ToUnityVector();
pendingYaw = @event.PendingYaw;
}
private void Events_OnVehicleLockUpdated(InteractableVehicle vehicle, Player nativePlayer, CSteamID group, bool isLocked)
{
var player = GetUnturnedPlayer(nativePlayer);
var @event = new UnturnedVehicleLockUpdatedEvent(
instigator: player !,
vehicle: new UnturnedVehicle(vehicle),
group: group == CSteamID.Nil ? null : group,
isLocked: isLocked);
Emit(@event);
}
private void OnVehicleCarjacked(InteractableVehicle vehicle, Player instigatingPlayer, ref bool allow, ref Vector3 force, ref Vector3 torque)
{
UnturnedPlayer instigator = GetUnturnedPlayer(instigatingPlayer);
UnturnedVehicleCarjackingEvent @event = new UnturnedVehicleCarjackingEvent(new UnturnedVehicle(vehicle), instigator, force.ToSystemVector(), torque.ToSystemVector());
Emit(@event);
allow = [email protected];
force = @event.Force.ToUnityVector();
torque = @event.Torque.ToUnityVector();
}
private void OnSwapSeatRequested(Player player, InteractableVehicle vehicle, ref bool shouldAllow, byte fromSeatIndex, ref byte toSeatIndex)
{
if (toSeatIndex == 0)
{
var untPlayer = UnturnedPlayer.FromPlayer(player);
shouldAllow = this.CanPlayerDrive(untPlayer);
if (!shouldAllow)
{
UnturnedChat.Say(untPlayer, Translate("RequireDriveLicense"), MessageColor);
}
}
}
private void OnEnterVehicleRequested(Player player, InteractableVehicle vehicle, ref bool shouldAllow)
{
if (vehicle.tryAddPlayer(out byte seat, player) && seat == 0)
{
var untPlayer = UnturnedPlayer.FromPlayer(player);
shouldAllow = this.CanPlayerDrive(untPlayer);
if (!shouldAllow)
{
UnturnedChat.Say(untPlayer, Translate("RequireDriveLicense"), MessageColor);
}
}
}
private void OnDamageTireRequested(CSteamID instigatorSteamId, InteractableVehicle vehicle, int tireIndex, ref bool shouldAllow, EDamageOrigin damageOrigin)
{
var @event = new UnturnedVehicleDamagingTireEvent(new UnturnedVehicle(vehicle), instigatorSteamId,
tireIndex, damageOrigin)
{
IsCancelled = !shouldAllow
};
Emit(@event);
shouldAllow = [email protected];
}
public bool CanClearVehicle(InteractableVehicle vehicle)
{
if (vehicle.passengers.Any(p => p.player != null) || vehicle.asset.engine == EEngine.TRAIN)
{
return(false);
}
if (config.ProtectLocked && vehicle.isLocked)
{
return(false);
}
if (config.ClearAll)
{
return(true);
}
if (config.ClearExploded && vehicle.isExploded)
{
return(true);
}
if (config.ClearDrowned)
{
if (vehicle.isDrowned && vehicle.transform.FindChild("Buoyancy") == null)
{
return(true);
}
}
if (config.ClearNoTires)
{
var tires = vehicle.transform.FindChild("Tires");
if (tires != null)
{
var totalTires = vehicle.transform.FindChild("Tires").childCount;
if (totalTires == 0)
{
return(false);
}
var aliveTires = 0;
for (var i = 0; i < totalTires; i++)
{
if (tires.GetChild(i).gameObject.activeSelf)
{
aliveTires++;
}
}
if (aliveTires == 0)
{
return(true);
}
}
}
return(false);
}
private void OnEnterVehicleRequested(Player nativePlayer, InteractableVehicle vehicle, ref bool shouldAllow)
{
var player = GetUnturnedPlayer(nativePlayer);
var @event = new UnturnedPlayerEnteringVehicleEvent(player !, new UnturnedVehicle(vehicle))
{
IsCancelled = !shouldAllow
};
Emit(@event);
shouldAllow = [email protected];
}
public IEnumerator DelayedUnlockVehicle(InteractableVehicle vehicle, float delay)
{
yield return(new WaitForSecondsRealtime(delay));
VehicleManager.instance.channel.send(
"tellVehicleLock",
ESteamCall.ALL,
ESteamPacket.UPDATE_RELIABLE_BUFFER,
vehicle.instanceID,
CSteamID.Nil,
CSteamID.Nil,
false);
}
public void Start()
{
iv = gameObject.GetComponent <InteractableVehicle>();
backup_Engine = iv.asset.engine;
backup_LockedMouse = iv.asset.hasLockMouse;
backup_Sleds = iv.asset.hasSleds;
backup_Traction = iv.asset.hasTraction;
backup_Lift = iv.asset.lift;
backup_Breaks = iv.asset.brake;
backup_SteerMin = iv.asset.steerMin;
backup_SteerMax = iv.asset.steerMax;
}
private void Events_OnVehicleReplacingBattery(InteractableVehicle vehicle, Player nativePlayer, byte amount, ref bool cancel)
{
var player = GetUnturnedPlayer(nativePlayer);
var @event = new UnturnedVehicleReplacingBatteryEvent(player !, new UnturnedVehicle(vehicle), amount)
{
IsCancelled = cancel
};
Emit(@event);
cancel = @event.IsCancelled;
}
private void OnDamageVehicle(CSteamID instigatorSteamID, InteractableVehicle vehicle, ref ushort pendingTotalDamage, ref bool canRepair, ref bool shouldAllow, EDamageOrigin damageOrigin)
{
var currentRegion = GetRegionAt(vehicle.transform.position);
if (currentRegion == null)
{
return;
}
if (currentRegion.Flags.Exists(fg => fg.Name.Equals("NoVehicleDamage", StringComparison.OrdinalIgnoreCase)) && !R.Permissions.HasPermission(new RocketPlayer(instigatorSteamID.m_SteamID.ToString()), Configuration.Instance.NoVehicleDamageIgnorePermission) && !Configuration.Instance.NoDestroyIgnoredItems.Exists(k => k == vehicle.id))
{
shouldAllow = false;
}
}
private void OnVehicleLockpicked(InteractableVehicle vehicle, Player instigatingPlayer, ref bool allow)
{
var instigator = GetUnturnedPlayer(instigatingPlayer);
var @event = new UnturnedVehicleLockpickingEvent(new UnturnedVehicle(vehicle), instigator !)
{
IsCancelled = allow
};
Emit(@event);
allow = [email protected];
}
// ReSharper disable once RedundantAssignment
public static void PreRemovePlayer(InteractableVehicle __instance, byte seatIndex, ref Player?__state)
{
__state = null;
if (__instance.passengers is null || seatIndex >= __instance.passengers.Length)
{
return;
}
var passenger = __instance.passengers[seatIndex];
__state = passenger.player?.player;
}
private void OnRepairVehicleRequested(CSteamID instigatorSteamId, InteractableVehicle vehicle, ref ushort pendingTotalHealing, ref bool shouldAllow)
{
var @event =
new UnturnedVehicleRepairingEvent(new UnturnedVehicle(vehicle), instigatorSteamId, pendingTotalHealing)
{
IsCancelled = !shouldAllow
};
Emit(@event);
pendingTotalHealing = @event.PendingTotalHealing;
shouldAllow = [email protected];
}
private void OnCarjacked(InteractableVehicle vehicle, Player instigatingPlayer, ref bool allow, ref Vector3 force, ref Vector3 torque)
{
SteamPlayerID spID = instigatingPlayer.channel.owner.playerID;
if (!vehicle.isLocked || vehicle.lockedOwner == spID.steamID || vehicle.lockedGroup == spID.group)
{
allow = true;
}
else
{
allow = false;
}
}
internal bool Sell(decimal curBallance, UnturnedPlayer player, RaycastInfo raycastInfo, out decimal totalCost, out short actualCount)
{
bool sufficientAmount = false;
totalCost = 0;
actualCount = 0;
InteractableVehicle vehicle = null;
if (RestrictBuySell == RestrictBuySell.BuyOnly)
{
actualCount = -1;
return(false);
}
VehicleInfo vInfo = DShop.Instance.Database.GetVehicleInfo((ulong)player.CSteamID, ItemID);
if (vInfo == null)
{
// The car the player's looking at hasn't been bought before from them, from the shop.
actualCount = -2;
return(false);
}
else
{
vehicle = raycastInfo.vehicle;
sufficientAmount = true;
actualCount = 1;
if (DShop.Instance.Configuration.Instance.VehicleSellDropElements)
{
BarricadeRegion vregion = null;
byte x;
byte y;
ushort plant;
if (BarricadeManager.tryGetPlant(vehicle.transform, out x, out y, out plant, out vregion))
{
for (int j = 0; j < vregion.drops.Count; j++)
{
if (j < vregion.drops.Count && vregion.barricades[j].barricade.id > 0)
{
Item item = new Item(vregion.barricades[j].barricade.id, true);
ItemManager.dropItem(item, vregion.drops[j].model.position, false, true, true);
}
}
}
}
DShop.Instance.Database.DeleteVehicleInfo(vInfo);
vehicle.askDamage(ushort.MaxValue, false);
totalCost = decimal.Multiply(BuyCost, SellMultiplier);
DShop.Instance._OnShopSell(decimal.Add(curBallance, totalCost), player, 1, this, ItemType.Vehicle, BuyCost, totalCost, actualCount, 0);
}
return(sufficientAmount);
}
public void Execute(IRocketPlayer caller, string[] command)
{
UnturnedPlayer player = (UnturnedPlayer)caller;
if (Physics.Raycast(player.Player.look.aim.position, player.Player.look.aim.forward, out hit, 10, RayMasks.BARRICADE_INTERACT))
{
byte x;
byte y;
ushort plant;
ushort index;
BarricadeRegion r;
StructureRegion s;
Transform transform = hit.transform;
InteractableVehicle vehicle = transform.gameObject.GetComponent <InteractableVehicle>();
if (transform.GetComponent <InteractableDoorHinge>() != null)
{
transform = transform.parent.parent;
}
if (BarricadeManager.tryGetInfo(transform, out x, out y, out plant, out index, out r))
{
var bdata = r.barricades[index];
Library.TellInfo(caller, (CSteamID)bdata.owner, (CSteamID)bdata.group);
player.Player.sendBrowserRequest("SteamProfile", "http://steamcommunity.com/profiles/" + (CSteamID)bdata.owner);
}
else if (StructureManager.tryGetInfo(transform, out x, out y, out index, out s))
{
var sdata = s.structures[index];
Library.TellInfo(caller, (CSteamID)sdata.owner, (CSteamID)sdata.group);
player.Player.sendBrowserRequest("SteamProfile", "http://steamcommunity.com/profiles/" + (CSteamID)sdata.owner);
}
else if (vehicle != null)
{
if (vehicle.lockedOwner != CSteamID.Nil)
{
Library.TellInfo(caller, vehicle.lockedOwner, vehicle.lockedGroup);
player.Player.sendBrowserRequest("SteamProfile", "http://steamcommunity.com/profiles/" + vehicle.lockedOwner);
return;
}
UnturnedChat.Say(caller, "Vehicle does not have an owner.");
}
}
}
public void Execute(IRocketPlayer caller, string[] command)
{
if (command.Length == 0)
{
UnturnedChat.Say(caller, TeleportUtil.Instance.Translate("tprel_help"));
return;
}
// Only allow the command to be ran with all three parameters.
if (command.Length != 3)
{
UnturnedChat.Say(caller, TeleportUtil.Instance.Translate("invalid_arg"));
return;
}
else
{
float? x = command.GetFloatParameter(0);
float? y = command.GetFloatParameter(1);
float? z = command.GetFloatParameter(2);
UnturnedPlayer unturnedCaller = (UnturnedPlayer)caller;
Vector3 newLocation;
if (x.HasValue && y.HasValue && z.HasValue)
{
// Compute new location from the relative location parameters entered into the command.
if (unturnedCaller.IsInVehicle)
{
InteractableVehicle vehicle = unturnedCaller.CurrentVehicle;
newLocation = new Vector3(vehicle.transform.position.x + x.Value, vehicle.transform.position.y + y.Value, vehicle.transform.position.z + z.Value);
if (vehicle.TeleportCar(unturnedCaller, newLocation))
{
UnturnedChat.Say(caller, TeleportUtil.Instance.Translate("tp_success", newLocation.xyz_Location()));
}
else
{
UnturnedChat.Say(caller, TeleportUtil.Instance.Translate("tp_fail_vehicle"));
}
}
else
{
newLocation = new Vector3(unturnedCaller.Position.x + x.Value, unturnedCaller.Position.y + y.Value, unturnedCaller.Position.z + z.Value);
unturnedCaller.Teleport(newLocation, unturnedCaller.Rotation);
UnturnedChat.Say(caller, TeleportUtil.Instance.Translate("tp_success", newLocation.xyz_Location()));
}
}
else
{
UnturnedChat.Say(caller, TeleportUtil.Instance.Translate("invalid_arg"));
return;
}
}
}
private static void PreRemovePlayer(InteractableVehicle __instance, byte seatIndex, ref Player __state)
{
__state = null;
if (seatIndex < __instance.passengers?.Length)
{
Passenger passenger = __instance.passengers[seatIndex];
if (passenger?.player?.player != null)
{
__state = passenger.player.player;
}
}
}
private static void SwapPlayer(InteractableVehicle __instance, byte fromSeatIndex, byte toSeatIndex)
{
if (fromSeatIndex < __instance.passengers?.Length && toSeatIndex < __instance.passengers?.Length)
{
Passenger passenger = __instance.passengers[toSeatIndex];
Player player = passenger?.player?.player;
if (player != null)
{
OnVehicleSwapped?.Invoke(__instance, player, fromSeatIndex, toSeatIndex);
}
}
}
//Lockpick prevention
private void VehicleManager_onVehicleLockpicked(InteractableVehicle vehicle, Player instigatingPlayer, ref bool allow)
{
UnturnedPlayer sameplayer = UnturnedPlayer.FromPlayer(instigatingPlayer);
Logger.Log($"{sameplayer.DisplayName}({sameplayer.CSteamID}) has attempted to lockpick a vehicle!");
if (Configuration.Instance.ShouldAllowLockpick == false)
{
allow = false;
}
if (Configuration.Instance.ShouldWarnCriminal)
{
UnturnedChat.Say(sameplayer, $"{Configuration.Instance.ShouldWarnCriminalMessage}");
}
}
public static void Unlock()
{
using (List <InteractableVehicle> .Enumerator enumerator = VehicleManager.vehicles.GetEnumerator())
{
while (enumerator.MoveNext())
{
InteractableVehicle vehicle = enumerator.Current;
if (vehicle != null)
{
VehicleManager.unlockVehicle(vehicle);
}
}
}
}
private UnturnedPlayer GetDriver(InteractableVehicle vehicle, UnturnedPlayer cliente)
{
int count = Colectivero.Count;
foreach (CSteamID posibleDriver in Colectivero)
{
if (vehicle.checkDriver(posibleDriver))
{
return(UnturnedPlayer.FromCSteamID(posibleDriver));
}
}
return(cliente);
}
public static void askRepair(this InteractableVehicle Vehicle, ushort amount)
{
if (amount == 0 || Vehicle.isExploded)
{
return;
}
UnturnedVehicle vehicle = UnturnedServer.Vehicles.FirstOrDefault(v => v.InstanceID == Vehicle.instanceID);
VehicleEvents.RunVehicleRepair(vehicle, amount);
DetourManager.CallOriginal(typeof(InteractableVehicle).GetMethod("askRepair", BindingFlags.Public | BindingFlags.Instance),
Vehicle, amount);
}
private void VehicleManager_OnToggledVehicleLock(InteractableVehicle vehicle)
{
var player = GetUnturnedPlayer(vehicle.passengers?[0].player);
var group = vehicle.lockedGroup;
var isLocked = vehicle.isLocked;
var @event = new UnturnedVehicleLockUpdatedEvent(
instigator: player !,
vehicle: new UnturnedVehicle(vehicle),
group: group == CSteamID.Nil ? null : group,
isLocked: isLocked);
Emit(@event);
}
public Wheel(InteractableVehicle newVehicle, WheelCollider newWheel, bool newSteered, bool newPowered)
{
this._vehicle = newVehicle;
this._wheel = newWheel;
if (this.wheel != null)
{
this.sidewaysFriction = this.wheel.sidewaysFriction;
this.forwardFriction = this.wheel.forwardFriction;
this.wheel.forceAppPointDistance = 0f;
}
this._isSteered = newSteered;
this._isPowered = newPowered;
this.isAlive = true;
}
private void OnDamageVehicle(CSteamID instigatorSteamID, InteractableVehicle vehicle, ref ushort pendingTotalDamage, ref bool canRepair, ref bool shouldAllow, EDamageOrigin damageOrigin)
{
UnturnedPlayer player = UnturnedPlayer.FromCSteamID(instigatorSteamID);
// uff zombie detector and player -_-
if (pendingTotalDamage <= 2)
{
return;
}
if (player == null)
{
return;
}
// need to do some changes here, with health update, because when u hit a player still working this function, nelson nigger don't want to fix this...
if (damageOrigin.ToString() == "Vehicle_Collision_Self_Damage")
{
if (player.CurrentVehicle.asset.engine == EEngine.CAR)
{
if (player.CurrentVehicle.health < VehicleCrash.Instance.Configuration.Instance.ifvehiclehasXhealthStopWork)
{
burn_Fuel(player.CurrentVehicle);
vehicle.forceRemoveAllPlayers();
if (VehicleCrash.Instance.Configuration.Instance.autowarnmechanic)
{
ChatManager.serverSendMessage(VehicleCrash.Instance.Translate("warning", player.DisplayName).Replace('(', '<').Replace(')', '>'), Color.white, null, null, EChatMode.SAY, VehicleCrash.Instance.Translate("iconwarning", player.DisplayName), true);
}
}
else
{
tire_Damage(player, UnityEngine.Random.Range(1, 2), UnityEngine.Random.value);
foreach (var passenger in vehicle.passengers)
{
UnturnedPlayer jugador = UnturnedPlayer.FromSteamPlayer(passenger.player);
if (jugador != null && !jugador.GetComponent <PlayerComponent>().niggagetwork)
{
StartCoroutine(crash(jugador));
}
// break; my cucumber idk, for prevent bugs
break;
}
}
}
}
}
// lgtm [cs/too-many-ref-parameters]
private void OnSiphonVehicleRequested(InteractableVehicle vehicle, Player instigatingPlayer, ref bool shouldAllow, ref ushort desiredAmount)
{
var instigator = GetUnturnedPlayer(instigatingPlayer);
var @event = new UnturnedVehicleSiphoningEvent(new UnturnedVehicle(vehicle), instigator !, desiredAmount)
{
IsCancelled = !shouldAllow
};
Emit(@event);
shouldAllow = [email protected];
desiredAmount = @event.DesiredAmount;
}
public PlayerVehicleFeatures()
{
cachedVeh = Player.CurrentVehicle;
}
bool checkForPassengers(InteractableVehicle v)
{
foreach (var passenger in v.passengers)
{
if (passenger.player == null) { }
else
return true;
}
return false;
}
bool checkForBarricades(InteractableVehicle v, bool ignoreVehiclesWithBarricades)
{
byte x;
byte y;
ushort plant;
BarricadeRegion region;
if (godmode.Instance.Configuration.Instance.IgnoreVehiclesWithBarricades)
{
if (ignoreVehiclesWithBarricades)
{
if (BarricadeManager.tryGetPlant(v.transform, out x, out y, out plant, out region))
{
if (region.drops.Count > 0)
{
return true;
}
}
else { }
}
}
return false;
}
public static bool VehicleDamaged(InteractableVehicle vehicle, ref ushort amount, ref bool repairable)
{
// TODO: causes?
VehicleTag vehicleTag = new VehicleTag(vehicle);
if (!repairable && (vehicle.isDead || amount >= vehicle.health))
{
VehicleDestroyedEventArgs explodeevt = new VehicleDestroyedEventArgs();
explodeevt.Vehicle = vehicleTag;
explodeevt.Amount = new NumberTag(amount);
explodeevt.Repairable = new BooleanTag(repairable);
UnturnedFreneticEvents.OnVehicleDestroyed.Fire(explodeevt);
amount = (ushort)explodeevt.Amount.Internal;
repairable = explodeevt.Repairable.Internal;
return explodeevt.Cancelled || EntityDestroyed(vehicleTag, ref amount);
}
VehicleDamagedEventArgs evt = new VehicleDamagedEventArgs();
evt.Vehicle = vehicleTag;
evt.Amount = new NumberTag(amount);
evt.Repairable = new BooleanTag(repairable);
UnturnedFreneticEvents.OnVehicleDamaged.Fire(evt);
amount = (ushort)evt.Amount.Internal;
return evt.Cancelled || EntityDamaged(vehicleTag, ref amount);
}
public VehicleTag(InteractableVehicle vehicle)
{
Internal = vehicle;
}
