/// <summary>
/// Zwraca true jeśli gracz posiada uprawnienia ownera pojazdu, inaczej false.
/// </summary>
/// <param name="charData"></param>
/// <param name="vehId"></param>
/// <returns></returns>
public static bool DoesPlayerHasVehicleOwner(Character charData, int vehId)
{
if (charData == null)
{
return(false);
}
Vehicle vehData = GetVehicleData(vehId);
if (vehData == null)
{
return(false);
}
if (charData.AdminLevel > 0 && charData.HasAdminDuty)
{
return(true);
}
if (vehData.OwnerType == OwnerType.Player)
{
if (vehData.Owner == charData.Id)
{
return(true);
}
}
else if (vehData.OwnerType == OwnerType.Group)
{
// TODO: permy grup
}
return(false);
}
/// <summary>
/// Parkuje pojazd na podanych koordynatach.
/// </summary>
/// <param name="player"></param>
/// <param name="vehData"></param>
/// <param name="position"></param>
/// <param name="rotation"></param>
/// <param name="dimension"></param>
public static void ParkVehicle(Client player, Vehicle vehData, Vector3 position,
Vector3 rotation, int dimension)
{
if (vehData == null)
{
return;
}
if (!DoesParkPlaceFree(position, dimension))
{
if (player != null)
{
Ui.ShowWarning(player, "To miejsce parkingowe jest już zajęte.");
}
return;
}
vehData.Dimension = dimension;
vehData.X = position.X;
vehData.Y = position.Y;
vehData.Z = position.Z;
vehData.Rx = rotation.X;
vehData.Ry = rotation.Y;
vehData.Rz = rotation.Z;
vehData.Save();
if (player != null)
{
Ui.ShowInfo(player, $"Pojazd {GetVehicleFormattedName(vehData)} został zaparkowany.");
}
}
/// <summary>
/// Zwraca true jeśli gracz posiada uprawnienia do kierowania pojazdem, inaczej false.
/// </summary>
/// <param name="charData"></param>
/// <param name="vehId"></param>
/// <returns></returns>
public static bool DoesPlayerHasVehiclePerm(Character charData, int vehId)
{
if (charData == null)
{
return(false);
}
Vehicle vehData = GetVehicleData(vehId);
if (vehData == null)
{
return(false);
}
if (charData.AdminLevel > 0 && charData.HasAdminDuty)
{
return(true);
}
if (vehData.OwnerType == OwnerType.Player)
{
if (vehData.Owner == charData.Id)
{
return(true);
}
// TODO: Wypożyczanie
}
else if (vehData.OwnerType == OwnerType.Group)
{
return(Groups.Library.DoesPlayerHasPerm(charData, vehData.Owner, Permissions.RankVehKeys));
}
return(false);
}
public void CmdTankuj(Client player)
{
Character charData = Account.GetPlayerData(player);
if (charData == null)
{
return;
}
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Nie jesteś w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Nie jesteś w pojeździe.");
return;
}
// NAPI.ClientEvent.TriggerClientEvent(player, "client.gassstations.cmd", vehData.MaxFuel - vehData.Fuel);
player.TriggerEvent("clgascommand", (vehData.MaxFuel - vehData.Fuel).ToString());
}
/// <summary>
/// Zwraca nazwę właściciela pojazdu.
/// </summary>
/// <param name="vehData"></param>
/// <returns></returns>
public static string GetVehicleOwnerName(Vehicle vehData)
{
string output = "Nieznany";
if (vehData == null)
{
return(output);
}
if (vehData.OwnerType == OwnerType.Player)
{
using (Database.Database db = new Database.Database())
{
Character charData = db.Characters.FirstOrDefault(t => t.Id == vehData.Owner);
if (charData != null)
{
output = $"{charData.Name} {charData.Lastname} (UID: {charData.Id})";
}
}
}
else if (vehData.OwnerType == OwnerType.Group)
{
Group groupData = Groups.Library.GetGroupData(vehData.Owner);
if (groupData != null)
{
output = $"{groupData.Name} (UID: {groupData.Id})";
}
}
return(output);
}
/// <summary>
/// Usuwa istniejący pojazd.
/// </summary>
/// <param name="vehId"></param>
public static void DestroyVehicle(int vehId)
{
Vehicle vehData = GetVehicleData(vehId);
if (vehData == null)
{
return;
}
List <ItemEntity> items = ItemsManager.Items
.Where(t => t.OwnerType == New.Enums.OwnerType.Vehicle && t.Owner == vehData.Id)
.ToList();
for (int i = items.Count - 1; i > -1; i--)
{
items[1].Delete();
}
if (vehData.Spawned && vehData.VehicleHandle != null && NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
NAPI.Entity.DeleteEntity(vehData.VehicleHandle);
}
using (Database.Database db = new Database.Database())
{
int vehicleId = vehData.Id;
db.Vehicles.Attach(vehData);
db.Vehicles.Remove(vehData);
db.SaveChanges();
VehiclesList.Remove(vehicleId);
}
}
/// <summary>
/// Zwraca pojazd znajdujący się najbliżej danej pozycji na danym vw i danej odległości.
/// </summary>
/// <param name="position"></param>
/// <param name="dimension"></param>
/// <param name="range"></param>
/// <returns></returns>
public static Vehicle GetNearestVehicle(Vector3 position, uint dimension, double range = 5.0)
{
double nearestRange = range;
Vehicle nearestVehicle = null;
foreach (KeyValuePair <int, Vehicle> entry in VehiclesList)
{
if (!entry.Value.Spawned || entry.Value.VehicleHandle == null ||
!NAPI.Entity.DoesEntityExist(entry.Value.VehicleHandle))
{
continue;
}
if (entry.Value.VehicleHandle.Dimension != dimension)
{
continue;
}
double mathDistance = Global.GetDistanceBetweenPositions(position, entry.Value.VehicleHandle.Position);
if (mathDistance < nearestRange)
{
nearestRange = mathDistance;
nearestVehicle = entry.Value;
}
}
return(nearestVehicle);
}
public void Event_VehicleEngine(Client player)
{
if (!player.IsInVehicle)
{
return;
}
Character charData = Account.GetPlayerData(player);
if (charData == null)
{
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
return;
}
if (Bw.Library.DoesPlayerHasBw(charData))
{
return;
}
Library.ToggleVehicleEngine(charData, vehData, !vehData.Engine);
}
public void Event_GasStationOffer(Client player, int fuel, int cash)
{
if (!player.IsInVehicle)
{
return;
}
Character charData = Account.GetPlayerData(player);
if (charData == null)
{
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
return;
}
if (!vehData.Spawned)
{
return;
}
Dictionary <string, object> offerData = new Dictionary <string, object>
{
{ "vehicle", player.Vehicle },
{ "fuel", fuel }
};
Offers.Library.CreateOffer(null, charData.PlayerHandle, OfferType.GasStation, (uint)cash, offerData,
"Tankowanie pojazdu", true);
}
/// <summary>
/// Synchronizuje jedną informację o pojeździe dla gracza (lub wszystkich, jeśli player == null).
/// </summary>
/// <param name="player"></param>
/// <param name="remoteId"></param>
/// <param name="name"></param>
/// <param name="value"></param>
public static void SyncVehicleForPlayer(Client player, int remoteId, string name, object value)
{
GTANetworkAPI.Vehicle remoteVehicle = NAPI.Pools.GetAllVehicles().Find(t => t.Value == remoteId);
if (remoteVehicle == default(GTANetworkAPI.Vehicle))
{
return;
}
Vehicle vehData = GetVehicleData(remoteVehicle);
if (vehData == null)
{
return;
}
if (player == null)
{
foreach (Client entry in NAPI.Pools.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry, "client.vehicle.sync.option", remoteId, name, value);
}
}
else
{
NAPI.ClientEvent.TriggerClientEvent(player, "client.vehicle.sync.option", remoteId, name, value);
}
}
public void Event_VehicleBindKey(Client player, string type)
{
if (!player.IsInVehicle)
{
return;
}
Character charData = Account.GetPlayerData(player);
if (charData == null)
{
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
return;
}
if (!vehData.Spawned)
{
return;
}
switch (type)
{
case "left-indicator":
vehData.LeftIndicator = !vehData.LeftIndicator;
foreach (Client entry in NAPI.Pools.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry, "client.vehicle.sync.indicator",
vehData.VehicleHandle.Value, vehData.LeftIndicator, vehData.RightIndicator);
}
break;
case "right-indicator":
vehData.RightIndicator = !vehData.RightIndicator;
foreach (Client entry in NAPI.Pools.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry, "client.vehicle.sync.indicator",
vehData.VehicleHandle.Value, vehData.LeftIndicator, vehData.RightIndicator);
}
break;
case "siren":
vehData.SirenSound = !vehData.SirenSound;
foreach (Client entry in NAPI.Pools.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry, "client.vehicle.sync.siren",
vehData.VehicleHandle.Value, vehData.SirenSound);
}
break;
}
}
public void Event_VehicleMileage(Client player, double mileageToAppend)
{
if (!player.IsInVehicle)
{
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
vehData.Mileage += mileageToAppend; // it's always positive number of km to append
}
/// <summary>
/// Spawnuje pojazd.
/// </summary>
/// <param name="vehId"></param>
public static void SpawnVehicle(int vehId)
{
Vehicle vehData = GetVehicleData(vehId);
if (vehData == null)
{
return;
}
if (vehData.Spawned)
{
return;
}
if (vehData.VehicleHandle != null && NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
NAPI.Entity.DeleteEntity(vehData.VehicleHandle);
}
if (vehData.VehicleHash != 0)
{
vehData.Spawned = true;
vehData.VehicleHandle = NAPI.Vehicle.CreateVehicle((uint)vehData.VehicleHash,
new Vector3(vehData.X, vehData.Y, vehData.Z), vehData.Rz, vehData.FirstColor, vehData.SecondColor,
vehData.NumberPlate, 255, vehData.Closed, vehData.Engine, (uint)vehData.Dimension);
vehData.VehicleHandle.Rotation = new Vector3(vehData.Rx, vehData.Ry, vehData.Rz);
vehData.VehicleHandle.Livery = vehData.Livery;
vehData.VehicleHandle.SetData("vehicle.id", vehData.Id);
if (vehData.Health < 0)
{
vehData.Health = 100;
}
vehData.VehicleHandle.Health = vehData.Health;
vehData.VehicleHandle.EngineStatus = false;
vehData.Engine = false;
vehData.EngineToggle = false;
vehData.VehicleHandle.Locked = true;
vehData.Closed = true;
vehData.TestHandling = new Dictionary <string, double>();
using (Database.Database db = new Database.Database())
{
List <VehicleMod> vehMods = db.VehicleMods.Where(t => t.VehicleId == vehData.Id).ToList();
foreach (VehicleMod entry in vehMods)
{
NAPI.Vehicle.SetVehicleMod(vehData.VehicleHandle, (int)entry.ModId, entry.ModVal);
}
}
}
}
/// <summary>
/// Tworzy nowy pojazd.
/// </summary>
/// <param name="vehicleHash"></param>
/// <param name="position"></param>
/// <param name="rotation"></param>
/// <param name="colorFirst"></param>
/// <param name="colorSecond"></param>
/// <param name="ownerTypeType"></param>
/// <param name="dimension"></param>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="createdBy"></param>
/// <returns></returns>
public static Vehicle CreateVehicle(long vehicleHash, Vector3 position, Vector3 rotation,
int colorFirst, int colorSecond, OwnerType ownerTypeType, int dimension, int owner, string name,
string createdBy = "System")
{
VehConsumption vehCon = GetDefaultConsumption(vehicleHash);
Vehicle veh = new Vehicle
{
VehicleHash = vehicleHash,
Name = name,
OwnerType = ownerTypeType,
Owner = owner,
Dimension = dimension,
NumberPlate = "BRAK",
PlateType = 1,
Spawned = false,
X = position.X,
Y = position.Y,
Z = position.Z,
Rx = rotation.X,
Ry = rotation.Y,
Rz = rotation.Z,
Closed = true,
FirstColor = colorFirst,
SecondColor = colorSecond,
MaxFuel = vehCon.MaxFuel,
Fuel = (int)Math.Floor((double)vehCon.MaxFuel / 2),
Livery = 0,
Extras = "",
FuelMultiplier = vehCon.Consumption,
Health = 1000.0f,
Blocked = false,
BlockValue = 0,
Modifications = "",
Mileage = 0.0,
MappedExtras = new Dictionary <int, bool>()
};
using (Database.Database db = new Database.Database())
{
db.Vehicles.Add(veh);
db.SaveChanges();
Log.ConsoleLog("VEHICLE", $"Utworzono pojazd \"{veh.Name}\" (UID: {veh.Id}) [{createdBy}]",
LogType.Debug);
VehiclesList.Add(veh.Id, veh);
SpawnVehicle(veh.Id);
return(veh);
}
}
/// <summary>
/// Synchronizuje wszystkie informacje o pojeździe dla gracza (lub wszystkich, jeśli player == null).
/// </summary>
/// <param name="player"></param>
/// <param name="remoteId"></param>
public static void SyncVehicleForPlayer(Client player, int remoteId)
{
// if (player != null)
// {
// Log.ConsoleLog("VEHICLE", $"Sync vehicle {remoteId} for player {player.SocialClubName}", LogType.Debug);
// }
// else
// {
// Log.ConsoleLog("VEHICLE", $"Sync vehicle {remoteId} for all playes.", LogType.Debug);
// }
GTANetworkAPI.Vehicle remoteVehicle = NAPI.Pools.GetAllVehicles().Find(t => t.Value == remoteId);
if (remoteVehicle == default(GTANetworkAPI.Vehicle))
{
return;
}
Vehicle vehData = GetVehicleData(remoteVehicle);
if (vehData == null)
{
return;
}
if (player == null)
{
foreach (Client entry in NAPI.Pools.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry, "client.vehicle.sync", vehData.VehicleHandle.Value,
!vehData.SirenSound, vehData.LeftIndicator, vehData.RightIndicator, vehData.Hood, vehData.Trunk,
vehData.Health, vehData.Livery, vehData.FirstColor, vehData.SecondColor,
vehData.VehicleHandle.Siren, JsonConvert.SerializeObject(vehData.MappedExtras),
JsonConvert.SerializeObject(vehData.TestHandling), vehData.VehicleDescription);
}
}
else
{
NAPI.ClientEvent.TriggerClientEvent(player, "client.vehicle.sync", vehData.VehicleHandle.Value,
!vehData.SirenSound, vehData.LeftIndicator, vehData.RightIndicator, vehData.Hood, vehData.Trunk,
vehData.Health, vehData.Livery, vehData.FirstColor, vehData.SecondColor,
vehData.VehicleHandle.Siren, JsonConvert.SerializeObject(vehData.MappedExtras),
JsonConvert.SerializeObject(vehData.TestHandling), vehData.VehicleDescription);
}
}
/// <summary>
/// Odspawnowuje pojazd.
/// </summary>
/// <param name="vehId"></param>
public static void UnspawnVehicle(int vehId)
{
Vehicle vehData = GetVehicleData(vehId);
if (vehData == null)
{
return;
}
if (!vehData.Spawned)
{
return;
}
vehData.Spawned = false;
vehData.Engine = false;
if (NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
NAPI.Entity.DeleteEntity(vehData.VehicleHandle);
}
}
/// <summary>
/// Przeładowuje dodatki pojazdu.
/// </summary>
/// <param name="vehData"></param>
public static void ReloadVehicleExtra(Vehicle vehData)
{
if (vehData == null)
{
return;
}
if (!vehData.Spawned || vehData.VehicleHandle == null ||
!NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
return;
}
if (vehData.MappedExtras == null)
{
vehData.MappedExtras = new Dictionary <int, bool>();
}
foreach (Client entry in NAPI.Pools.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry, "client.vehicle.sync.option", vehData.VehicleHandle.Value,
"extra", JsonConvert.SerializeObject(vehData.MappedExtras, Formatting.None));
}
}
/// <summary>
/// Funkcja wykonująca się za każdym razem uruchomienia timera.
/// </summary>
public void OnTimer()
{
if (TimeLeft <= 0)
{
OnSuccess();
return;
}
if (Type == ProgressType.FixVehicle)
{
// Data["veh"] = Database.Models.Vehicle
// charData - klient
// targetData - mechanik
Vehicle vehData = (Vehicle)Data["veh"];
if (vehData == null)
{
SendMessage("Pojazd nie istnieje.");
Destroy();
return;
}
if (vehData.VehicleHandle == null || !NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
SendMessage("Pojazd nie jest zespawnowany.");
Destroy();
return;
}
if (TargetData == null || TargetData.PlayerHandle == null ||
!NAPI.Entity.DoesEntityExist(TargetData.PlayerHandle))
{
SendMessage("Mechanik wyszedł z gry.");
Destroy();
return;
}
if (vehData.Engine)
{
return;
}
if (Global.GetDistanceBetweenPositions(TargetData.PlayerHandle.Position,
vehData.VehicleHandle.Position) > 5.0)
{
if (Global.GetDistanceBetweenPositions(TargetData.PlayerHandle.Position,
vehData.VehicleHandle.Position) > 20.0 ||
TargetData.PlayerHandle.Dimension != vehData.VehicleHandle.Dimension)
{
SendMessage("Mechanik odszedł zbyt daleko od pojazdu.");
Destroy();
return;
}
return;
}
}
else if (Type == ProgressType.TattooCreate)
{
if (Global.GetDistanceBetweenPositions(TargetData.PlayerHandle.Position,
CharData.PlayerHandle.Position) > 5.0)
{
if (Global.GetDistanceBetweenPositions(TargetData.PlayerHandle.Position,
CharData.PlayerHandle.Position) > 20.0 ||
TargetData.PlayerHandle.Dimension != CharData.PlayerHandle.Dimension)
{
SendMessage("Tatuażysta odszedł zbyt daleko od gracza.");
Destroy();
return;
}
return;
}
}
TimeLeft--;
Update();
}
/// <summary>
/// Zwraca nazwę pojazdu.
/// </summary>
/// <param name="vehData"></param>
/// <returns></returns>
public static string GetVehicleFormattedName(Vehicle vehData)
{
return(vehData == null ? "Nieznany pojazd" : $"\"{vehData.Name}\" (UID: {vehData.Id})");
}
/// <summary>
/// Zmiana stanu silnika (odpalanie, gaszenie).
/// </summary>
/// <param name="charData"></param>
/// <param name="vehData"></param>
/// <param name="state"></param>
public static void ToggleVehicleEngine(Character charData, Vehicle vehData, bool state)
{
if (charData == null || vehData == null)
{
return;
}
if (vehData.EngineToggle)
{
return;
}
if (!charData.PlayerHandle.IsInVehicle || charData.PlayerHandle.Vehicle != vehData.VehicleHandle ||
charData.PlayerHandle.VehicleSeat != -1)
{
return;
}
if (!DoesPlayerHasVehiclePerm(charData, vehData.Id))
{
Ui.ShowError(charData.PlayerHandle, "Nie posiadasz kluczy do tego pojazdu.");
return;
}
// TODO: Jeśli pojazd jest w naprawie zablokuj odpalanie auta
if (state)
{
if (vehData.Engine)
{
return;
}
if (vehData.Health < 100)
{
Ui.ShowError(charData.PlayerHandle, "Pojazd jest zniszczony. Musisz wezwać pomoc drogową.");
return;
}
if (vehData.Blocked)
{
Ui.ShowError(charData.PlayerHandle,
$"Pojazd ma założoną blokadę na koło. Kwota odblokowania: ${vehData.BlockValue}");
return;
}
if (vehData.Fuel <= 0)
{
Ui.ShowError(charData.PlayerHandle, "W baku nie ma już paliwa.");
return;
}
Chat.Library.SendPlayerMeMessage(charData, "przekręca kluczyk w stacyjce i próbuje uruchomić silnik",
true);
vehData.EngineToggle = true;
NAPI.Task.Run(() =>
{
vehData.EngineToggle = false;
vehData.Engine = true;
vehData.VehicleHandle.EngineStatus = true;
foreach (Client entry in NAPI.Pools.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry, "client.vehicle.engine", vehData.VehicleHandle.Value,
true);
}
Chat.Library.SendPlayerDoMessage(charData, "Silnik odpalił.", true);
}, 2000);
}
else
{
if (!vehData.Engine)
{
return;
}
vehData.Engine = false;
vehData.VehicleHandle.EngineStatus = false;
foreach (Client entry in NAPI.Pools.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry, "client.vehicle.engine", vehData.VehicleHandle.Value,
false);
}
}
}
/// <summary>
/// Pokazuje interfejs dla gracza.
/// </summary>
/// <param name="charData"></param>
/// <param name="uiType"></param>
/// <param name="vehId"></param>
public static void ShowUi(Character charData, UiType uiType, int vehId)
{
if (charData == null)
{
return;
}
Account.RemoveServerData(charData, Account.ServerData.DialogVehicleAdminEdit);
if (uiType == UiType.VehicleInfo)
{
Vehicle vehData = GetVehicleData(vehId);
if (vehData == null)
{
return;
}
List <DialogColumn> dialogColumns = new List <DialogColumn>
{
new DialogColumn("", 40),
new DialogColumn("", 50)
};
List <DialogRow> dialogRows = new List <DialogRow>
{
new DialogRow(null, new[] { "UID pojazdu", vehData.Id.ToString() }),
new DialogRow(null, new[] { "Nazwa pojazdu", vehData.Name }),
new DialogRow(null, new[] { "Pozycja", $"{vehData.X:F1}, {vehData.Y:F1}, {vehData.Z:F1}" }),
new DialogRow(null, new[] { "Zamknięty", vehData.Closed ? "Tak" : "Nie" }),
new DialogRow(null, new[] { "Kolor pojazdu", $"[{vehData.FirstColor}] [{vehData.SecondColor}]" }),
new DialogRow(null, new[] { "Paliwo", $"{vehData.Fuel:F1}/{vehData.MaxFuel:F1}L" }),
new DialogRow(null, new[] { "Wytrzymałość", $"{vehData.Health:F1} HP" }),
new DialogRow(null, new[] { "Typ właściciela", GetVehicleOwnerTypeName(vehData.OwnerType) }),
new DialogRow(null, new[] { "Nazwa właściciela", GetVehicleOwnerName(vehData) })
};
string[] dialogButtons = { "Zamknij" };
Dialogs.Library.CreateDialog(charData.PlayerHandle, DialogId.None, "Informacje o pojeździe",
dialogColumns, dialogRows, dialogButtons);
}
else if (uiType == UiType.VehiclesList)
{
List <Vehicle> playerVehicles = GetVehiclesList(OwnerType.Player, charData.Id);
if (playerVehicles.Count == 0)
{
Ui.ShowWarning(charData.PlayerHandle, "Nie posiadasz żadnych pojazdów.");
return;
}
List <DialogColumn> dialogColumns = new List <DialogColumn>
{
new DialogColumn("UID", 20),
new DialogColumn("Nazwa", 50),
new DialogColumn("Zespawnowany", 20)
};
List <DialogRow> dialogRows = new List <DialogRow>();
foreach (Vehicle entry in playerVehicles)
{
dialogRows.Add(new DialogRow(entry.Id,
new[]
{
entry.Id.ToString(),
entry.Spawned ? $"<span style=\"color: green;\">{entry.Name}</span>" : entry.Name,
entry.Spawned ? "Tak" : "Nie"
}));
}
string[] dialogButtons = { "Opcje", "Zamknij" };
/*List<DialogData> dialogData = new List<DialogData>();
* foreach (Database.Models.Vehicle entry in playerVehicles)
* {
* if (entry.Spawned)
* {
* dialogData.Add(new DialogData(
* $"<span style=\"color: green; font-weight: bold;\">{Global.EscapeHtml(entry.Name)} " +
* $"({entry.Id})</span>", entry.Id));
* }
* else
* {
* dialogData.Add(new DialogData($"{Global.EscapeHtml(entry.Name)} ({entry.Id})", entry.Id));
* }
* }*/
Dialogs.Library.CreateDialog(charData.PlayerHandle, DialogId.VehicleList, "Lista posiadanych pojazdów",
dialogColumns, dialogRows, dialogButtons);
// Dialogs.Library.CreateDialog(charData.PlayerHandle, DialogId.VehicleList, "Twoje pojazdy",
// "Wybierz opcję", dialogData, DialogType.List);
}
else if (uiType == UiType.VehicleOptions)
{
Vehicle vehData = GetVehicleData(vehId);
if (vehData == null)
{
return;
}
List <DialogColumn> dialogColumns = new List <DialogColumn>
{
new DialogColumn("", 90)
};
List <DialogRow> dialogRows = new List <DialogRow>
{
new DialogRow("info", new[] { "Informacje o pojeździe" }),
new DialogRow("spawn", new[] { "(Un)spawn pojazdu" }),
new DialogRow("locate", new[] { "Namierz pojazd" }),
new DialogRow("rent", new[] { "Wypożycz pojazd" }),
new DialogRow("platetype", new[] { "Wygląd tablicy rejestracyjnej" })
};
if (charData.HasAdminDuty)
{
dialogRows.Add(new DialogRow("delete", new[] { "Usuń pojazd" }));
}
dialogRows.Add(new DialogRow("back", new[] { "Powrót do listy pojazdów" }));
string[] dialogButtons = { "Wybierz", "Anuluj" };
Account.SetServerData(charData, Account.ServerData.DialogVehicleId, vehData.Id);
Dialogs.Library.CreateDialog(charData.PlayerHandle, DialogId.VehicleOptions,
"Opcje zarządzania pojazdem", dialogColumns, dialogRows, dialogButtons);
}
else if (uiType == UiType.VehicleEditAdmin)
{
Vehicle vehData = GetVehicleData(vehId);
if (vehData == null)
{
return;
}
List <DialogColumn> dialogColumns = new List <DialogColumn>
{
new DialogColumn("", 45),
new DialogColumn("", 45)
};
List <DialogRow> dialogRows = new List <DialogRow>
{
new DialogRow(null, new[] { "UID", vehData.Id.ToString() }),
new DialogRow("editName", new[] { "Nazwa", vehData.Name }),
new DialogRow("editColor1", new[] { "Kolor 1", vehData.FirstColor.ToString() }),
new DialogRow("editColor2", new[] { "Kolor 2", vehData.SecondColor.ToString() })
};
string[] dialogButtons = { "Wybierz", "Anuluj" };
Account.SetServerData(charData, Account.ServerData.DialogVehicleId, vehData.Id);
Dialogs.Library.CreateDialog(charData.PlayerHandle, DialogId.VehicleEditAdmin, "Edycja pojazdu",
dialogColumns, dialogRows, dialogButtons);
}
}
public void Command_Oferuj(Client player, string args = "")
{
Character charData = Account.GetPlayerData(player);
if (charData == null)
{
return;
}
const string legend =
"/o(feruj) [przedmiot, pojazd, leczenie, naprawe, lakierowanie, montaz, mandat, rp, tatuaz]";
string[] arguments = Command.GetCommandArguments(args);
if (arguments.Length < 1)
{
Ui.ShowUsage(player, legend);
return;
}
if (Library.DoesPlayerHasActiveOffer(player))
{
Ui.ShowError(player, "Posiadasz już aktywną inną ofertę.");
return;
}
string offerType = arguments[0].ToLower();
if (offerType == "przedmiot")
{
if (arguments.Length - 1 < 3)
{
Ui.ShowUsage(player, "/o(feruj) przedmiot [ID przedmiotu] [ID gracza] [cena]");
return;
}
int itemId = Command.GetNumberFromString(arguments[1]);
int playerId = Command.GetNumberFromString(arguments[2]);
int price = Command.GetNumberFromString(arguments[3]);
if (itemId == Command.InvalidNumber || playerId == Command.InvalidNumber ||
price == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne parametry komendy.");
return;
}
if (price < 0)
{
Ui.ShowWarning(player, "Kwota oferty musi być większa lub równa 0.");
return;
}
Character target = Account.GetPlayerDataByServerId(playerId);
if (target == null)
{
Ui.ShowError(player, "Nie znaleziono gracza o podanym ID.");
return;
}
if (Library.DoesPlayerHasActiveOffer(target.PlayerHandle))
{
Ui.ShowError(player, "Gracz posiada już inną aktywną ofertę.");
return;
}
if (Global.GetDistanceBetweenPositions(player.Position, target.PlayerHandle.Position) > 3.0 ||
player.Dimension != target.PlayerHandle.Dimension)
{
Ui.ShowError(player, "Gracz jest za daleko.");
return;
}
ItemEntity itemData = ItemsManager.Items.FirstOrDefault(t => t.Id == itemId);
if (itemData == null)
{
Ui.ShowError(player, "Nie znaleziono przedmiotu o podanym Id.");
return;
}
if (!itemData.CheckOwner(charData))
{
Ui.ShowError(player, "Przedmiot nie należy do Ciebie.");
return;
}
if (itemData.Used)
{
Ui.ShowError(player, "Przedmiot nie może być używany.");
return;
}
Dictionary <string, object> offerData = new Dictionary <string, object>
{
{ "Id", itemData.Id }
};
Library.CreateOffer(player, target.PlayerHandle, OfferType.SellItem, (uint)price, offerData,
$"sprzedaż przedmiotu {itemData.Name}");
}
else if (offerType == "pojazd")
{
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe, aby uzyć tej komendy.");
return;
}
if (arguments.Length - 1 < 2)
{
Ui.ShowUsage(player, "/o(feruj) pojazd [ID gracza] [cena]");
return;
}
int playerId = Command.GetNumberFromString(arguments[1]);
int price = Command.GetNumberFromString(arguments[2]);
if (playerId == Command.InvalidNumber || price == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne parametry komendy.");
return;
}
if (price < 0)
{
Ui.ShowWarning(player, "Kwota oferty musi być większa lub równa 0.");
return;
}
Character target = Account.GetPlayerDataByServerId(playerId);
if (target == null)
{
Ui.ShowError(player, "Nie znaleziono gracza o podanym ID.");
return;
}
if (Library.DoesPlayerHasActiveOffer(target.PlayerHandle))
{
Ui.ShowError(player, "Gracz posiada już inną aktywną ofertę.");
return;
}
if (Global.GetDistanceBetweenPositions(player.Position, target.PlayerHandle.Position) > 3.0 ||
player.Dimension != target.PlayerHandle.Dimension)
{
Ui.ShowError(player, "Gracz jest za daleko.");
return;
}
Vehicle vehData = Vehicles.Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd nie istnieje.");
return;
}
if (vehData.OwnerType != Vehicles.OwnerType.Player || vehData.Owner != charData.Id)
{
Ui.ShowError(player, "Pojazd nie należy do Ciebie.");
return;
}
Dictionary <string, object> offerData = new Dictionary <string, object>
{
{ "Id", vehData.Id }
};
Library.CreateOffer(player, target.PlayerHandle, OfferType.SellCar, (uint)price, offerData,
$"sprzedaż pojazdu {vehData.Name}");
}
else if (offerType == "leczenie")
{
int groupDuty = Groups.Library.GetPlayerGroupDuty(charData);
if (groupDuty == 0)
{
Ui.ShowError(player, "Nie jesteś na duty żadnej grupy.");
return;
}
if (!Groups.Library.DoesGroupHasPerm(groupDuty, Permissions.SharedMedHeal))
{
Ui.ShowError(player, "Grupa nie posiada uprawnień do leczenia.");
return;
}
if (!Groups.Library.DoesPlayerHasPerm(charData, groupDuty, Permissions.SharedMedHeal))
{
Ui.ShowError(player, "Twoja ranga w grupie nie posiada upranień do leczenia.");
return;
}
if (arguments.Length - 1 < 2)
{
Ui.ShowUsage(player, "/o(feruj) leczenie [ID gracza] [cena]");
return;
}
int playerId = Command.GetNumberFromString(arguments[1]);
int price = Command.GetNumberFromString(arguments[2]);
if (playerId == Command.InvalidNumber || price == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne parametry komendy.");
return;
}
if (price < 0)
{
Ui.ShowWarning(player, "Kwota oferty musi być większa lub równa 0.");
return;
}
Character target = Account.GetPlayerDataByServerId(playerId);
if (target == null)
{
Ui.ShowError(player, "Nie znaleziono gracza o podanym ID.");
return;
}
if (Library.DoesPlayerHasActiveOffer(target.PlayerHandle))
{
Ui.ShowError(player, "Gracz posiada już inną aktywną ofertę.");
return;
}
if (Global.GetDistanceBetweenPositions(player.Position, target.PlayerHandle.Position) > 3.0 ||
player.Dimension != target.PlayerHandle.Dimension)
{
Ui.ShowError(player, "Gracz jest za daleko.");
return;
}
Library.CreateOffer(player, target.PlayerHandle, OfferType.Heal, (uint)price, null, "Leczenie");
}
else if (offerType == "naprawe")
{
if (arguments.Length - 1 < 2)
{
Ui.ShowUsage(player, "/o(feruj) naprawe [ID gracza] [cena]");
return;
}
int playerId = Command.GetNumberFromString(arguments[1]);
int price = Command.GetNumberFromString(arguments[2]);
if (playerId == Command.InvalidNumber || price == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne parametry komendy.");
return;
}
if (price < 0)
{
Ui.ShowWarning(player, "Kwota oferty musi być większa lub równa 0.");
return;
}
Character target = Account.GetPlayerDataByServerId(playerId);
if (target == null)
{
Ui.ShowError(player, "Nie znaleziono gracza o podanym ID.");
return;
}
if (Library.DoesPlayerHasActiveOffer(target.PlayerHandle))
{
Ui.ShowError(player, "Gracz posiada już inną aktywną ofertę.");
return;
}
if (Global.GetDistanceBetweenPositions(player.Position, target.PlayerHandle.Position) > 3.0 ||
player.Dimension != target.PlayerHandle.Dimension)
{
Ui.ShowError(player, "Gracz jest za daleko.");
return;
}
if (!target.PlayerHandle.IsInVehicle)
{
Ui.ShowError(player, "Gracz nie jest w pojeździe.");
return;
}
Vehicle vehData = Vehicles.Library.GetVehicleData(target.PlayerHandle.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd nie jest prawidłowy.");
return;
}
Dictionary <string, object> data = new Dictionary <string, object>
{
{ "vehData", vehData }
};
Library.CreateOffer(player, target.PlayerHandle, OfferType.Repair, (uint)price, data,
"Naprawa pojazdu");
}
else if (offerType == "tatuaz")
{
if (arguments.Length - 1 < 3)
{
Ui.ShowUsage(player, "/o(feruj) tatuaz [ID gracza] [ID tatuazu] [cena]");
return;
}
int playerId = Command.GetNumberFromString(arguments[1]);
int tattooId = Command.GetNumberFromString(arguments[2]);
int price = Command.GetNumberFromString(arguments[3]);
if (playerId == Command.InvalidNumber || price == Command.InvalidNumber ||
tattooId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne parametry komendy.");
return;
}
if (price < 0)
{
Ui.ShowWarning(player, "Kwota oferty musi być większa lub równa 0.");
return;
}
Character target = Account.GetPlayerDataByServerId(playerId);
if (target == null)
{
Ui.ShowError(player, "Nie znaleziono gracza o podanym ID.");
return;
}
if (Library.DoesPlayerHasActiveOffer(target.PlayerHandle))
{
Ui.ShowError(player, "Gracz posiada już inną aktywną ofertę.");
return;
}
if (Global.GetDistanceBetweenPositions(player.Position, target.PlayerHandle.Position) > 3.0 ||
player.Dimension != target.PlayerHandle.Dimension)
{
Ui.ShowError(player, "Gracz jest za daleko.");
return;
}
TattooRow tattooInfo = Tattoos.Library.GetTattooData(tattooId);
if (tattooInfo == null)
{
Ui.ShowError(player, "Podano niepoprawne Id tatuażu.");
return;
}
if (tattooInfo.Sex != target.Sex)
{
Ui.ShowError(player,
$"Tatuaż nie zgadza się z płcią postaci dla której chcesz go zrobić. ({(int) target.Sex})");
return;
}
if (target.SyncedTattoos.Contains(tattooId))
{
Ui.ShowError(player, "Gracz posiada już taki tatuaż.");
return;
}
Dictionary <string, object> data = new Dictionary <string, object>
{
{ "tattooId", tattooId }
};
Library.CreateOffer(player, target.PlayerHandle, OfferType.TattooCreate, (uint)price, data,
$"Nałożenie tatuażu [ID: {tattooId}]");
}
}
/// <summary>
/// Wykonuje się w momencie zaakceptowania oferty.
/// </summary>
/// <param name="offerId"></param>
/// <param name="payType"></param>
private static void OnOfferAccept(int offerId, OfferPayType payType)
{
Offer offerData = GetOfferData(offerId);
if (offerData == null)
{
return;
}
if (!offerData.SystemOffer && !NAPI.Entity.DoesEntityExist(offerData.Player) ||
!NAPI.Entity.DoesEntityExist(offerData.Target))
{
offerData.Destroy("Jeden z graczy nie jest zalogowany.");
return;
}
Character charData = Account.GetPlayerData(offerData.Player);
Character targetData = Account.GetPlayerData(offerData.Target);
if (!offerData.SystemOffer && charData == null || targetData == null)
{
offerData.Destroy("Jeden z graczy nie jest zalogowany.");
return;
}
if (payType == OfferPayType.Cash && targetData.Cash < offerData.Price)
{
offerData.Destroy("Kupujący nie ma odpowiedniej ilości gotówki przy sobie.");
return;
}
if (payType == OfferPayType.Card && targetData.AccountBalance < offerData.Price)
{
offerData.Destroy("Kupujący nie ma na koncie bankowym odpowiedniej ilości gotówki.");
return;
}
// Akcje ofert
if (offerData.Type == OfferType.SellItem)
{
if (Global.GetDistanceBetweenPositions(offerData.Player.Position, offerData.Target.Position) > 3.0 ||
offerData.Player.Dimension != offerData.Target.Dimension)
{
offerData.Destroy("Zbyt daleko od celu.");
return;
}
ItemEntity itemData = ItemsManager.Items.FirstOrDefault(t => t.Id == (int)offerData.Data["Id"]);
if (itemData == null)
{
offerData.Destroy("Przedmiot nie został znaleziony.");
return;
}
if (itemData.Used)
{
offerData.Destroy("Przedmiot nie może być używany.");
return;
}
if (offerData.Price == 0 || PayForOffer(charData, targetData, payType, (int)offerData.Price))
{
itemData.SetOwner(OwnerType.Player, targetData.Id);
Chat.Library.SendPlayerMeMessage(charData,
$"podaje przedmiot \"{itemData.Name}\" graczowi {Player.GetPlayerIcName(targetData)}", true);
offerData.Success();
return;
}
}
else if (offerData.Type == OfferType.Rp)
{
if (offerData.Price == 0 || PayForOffer(charData, targetData, payType, (int)offerData.Price))
{
offerData.Success();
return;
}
}
else if (offerData.Type == OfferType.RegisterVehicle)
{
Vehicle vehData = Vehicles.Library.GetVehicleData((int)offerData.Data["Id"]);
if (vehData == null)
{
offerData.Destroy("Wystąpił błąd w trakcie pobierania danych pojazdu.");
return;
}
if (offerData.Price == 0 || PayForOffer(charData, targetData, payType, (int)offerData.Price))
{
vehData.NumberPlate = Vehicles.Library.GeneratePlate();
vehData.Save();
if (vehData.Spawned && NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
vehData.VehicleHandle.NumberPlate = vehData.NumberPlate;
}
// TODO: akcje z botem
offerData.Success();
return;
}
}
else if (offerData.Type == OfferType.SellCar)
{
Vehicle vehData = Vehicles.Library.GetVehicleData((int)offerData.Data["Id"]);
if (vehData == null)
{
offerData.Destroy("Pojazd nie został odnaleziony.");
return;
}
if (offerData.Price == 0 || PayForOffer(charData, targetData, payType, (int)offerData.Price))
{
vehData.OwnerType = Vehicles.OwnerType.Player;
vehData.Owner = targetData.Id;
vehData.Save();
Chat.Library.SendPlayerMeMessage(charData,
$"podaje klucze do pojazdu graczowi {Player.GetPlayerIcName(targetData)}.", true);
offerData.Success();
return;
}
}
else if (offerData.Type == OfferType.Heal)
{
if (offerData.Price == 0 || PayForOffer(charData, targetData, payType, (int)offerData.Price))
{
targetData.Health = 100;
targetData.PlayerHandle.Health = 100;
offerData.Success();
return;
}
}
else if (offerData.Type == OfferType.PdFine)
{
// todo
}
else if (offerData.Type == OfferType.Fuel)
{
// todo
}
else if (offerData.Type == OfferType.GroupGive)
{
using (Database.Database db = new Database.Database())
{
// todo
}
}
else if (offerData.Type == OfferType.BincoCloth)
{
if (offerData.Price == 0 || PayForOffer(null, targetData, payType, (int)offerData.Price))
{
using (Database.Database db = new Database.Database())
{
db.ClothSets.Add((ClothSet)offerData.Data["clothSet"]);
db.SaveChanges();
Player.SendFormattedChatMessage(targetData.PlayerHandle,
"Ubranie zostało zapisane. Możesz je zmienić używając komendy /przebierz.",
Constants.ColorPictonBlue);
offerData.Success();
}
}
}
else if (offerData.Type == OfferType.GasStation)
{
Vehicle vehData = Vehicles.Library.GetVehicleData((GTANetworkAPI.Vehicle)offerData.Data["vehicle"]);
if (vehData != null)
{
if (offerData.Price == 0 || PayForOffer(null, targetData, payType, (int)offerData.Price))
{
vehData.Fuel += Command.GetNumberFromString(offerData.Data["fuel"].ToString());
vehData.Save();
Chat.Library.SendPlayerMeMessage(targetData,
$"wkłada wąż do baku i tankuje auto \"{vehData.Name}\".", true);
offerData.Success();
}
}
}
else if (offerData.Type == OfferType.Repair)
{
Vehicle vehData = (Vehicle)offerData.Data["vehData"];
if (vehData != null)
{
if (charData != null && Progress.Library.DoesPlayerHasActiveProgress(charData) ||
targetData != null && Progress.Library.DoesPlayerHasActiveProgress(targetData))
{
offerData.Destroy("Jeden z graczy posiada już aktywne zadanie.");
return;
}
Dictionary <string, object> data = new Dictionary <string, object>
{
{ "veh", vehData },
{ "price", offerData.Price },
{ "type", payType }
};
Progress.Library.CreateProgress("Naprawa pojazdu", targetData, charData, ProgressType.FixVehicle,
60, data);
offerData.Success(true);
}
}
else if (offerData.Type == OfferType.TattooCreate)
{
if (charData != null && Progress.Library.DoesPlayerHasActiveProgress(charData) ||
targetData != null && Progress.Library.DoesPlayerHasActiveProgress(targetData))
{
offerData.Destroy("Jeden z graczy posiada już aktywne zadanie.");
return;
}
Dictionary <string, object> data = new Dictionary <string, object>
{
{ "tattooId", (int)offerData.Data["tattooId"] },
{ "price", offerData.Price },
{ "type", payType }
};
Progress.Library.CreateProgress("Nakładanie tatuażu", targetData, charData, ProgressType.TattooCreate,
20, data);
offerData.Success(true);
}
offerData.Destroy();
}
public void Command_AdminVehicle(Client player, string args = "")
{
Character charData = Account.GetPlayerData(player);
if (charData == null)
{
return;
}
if (charData.AdminLevel == 0)
{
return;
}
const string legend =
"/av [uid, stworz, edytuj, usun, tm, to, spawn, napraw, kolor1, kolor2, pj, przypisz, przeszukaj, " +
"respawn, parkuj, mods, info, paliwo]";
string[] arguments = Command.GetCommandArguments(args);
if (arguments.Length < 1)
{
Ui.ShowUsage(player, legend);
return;
}
string option = arguments[0].ToLower();
if (option == "uid")
{
Vehicle vehicleFound = Library.GetNearestVehicle(player.Position, player.Dimension);
if (vehicleFound == null)
{
Ui.ShowError(player, "Nie znaleziono żadnego pojazdu obok Ciebie.");
return;
}
Player.SendFormattedChatMessage(player,
$"Znaleziony pojazd: (UID: {vehicleFound.Id}) {vehicleFound.Name}", Constants.ColorDelRio);
}
else if (option == "info")
{
if (player.IsInVehicle)
{
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Nie znaleziono takiego pojazdu.");
return;
}
Library.ShowUi(charData, UiType.VehicleInfo, vehData.Id);
}
else
{
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av info [ID pojazdu]");
return;
}
int vehId = Command.GetNumberFromString(arguments[1]);
if (vehId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano błędne dane.");
return;
}
Vehicle vehData = Library.GetVehicleData(vehId);
if (vehData == null)
{
Ui.ShowError(player, "Nie znaleziono takiego pojazdu.");
return;
}
Library.ShowUi(charData, UiType.VehicleInfo, vehData.Id);
}
}
else if (option == "paliwo")
{
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
vehData.Fuel = vehData.MaxFuel;
vehData.Save();
Ui.ShowInfo(player, "Pojazd został napełniony.");
}
else if (option == "handling")
{
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
if (arguments.Length - 1 < 2)
{
Ui.ShowUsage(player, "/av handling [typ] [wartość]");
}
string type = arguments[1].ToUpper();
double value = Command.GetDoubleFromString(arguments[2]);
if (vehData.TestHandling.ContainsKey(type))
{
vehData.TestHandling.Remove(type);
}
vehData.TestHandling.Add(type, value);
Library.SyncVehicleForPlayer(null, vehData.VehicleHandle.Value);
Ui.ShowInfo(player, $"Zmieniono wartość \"{type}\" na \"{value}\".");
}
else if (option == "mods")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesColor, true))
{
return;
}
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
using (Database.Database db = new Database.Database())
{
List <VehicleMod> mods = db.VehicleMods.Where(t => t.VehicleId == vehData.Id).ToList();
if (mods.Count == 0)
{
Ui.ShowInfo(player, "Pojazd nie posiada żadnych modyfikacji.");
return;
}
List <DialogColumn> dialogColumns = new List <DialogColumn>
{
new DialogColumn("ID Modyfikacji", 40),
new DialogColumn("Wartość modyfikacji", 40)
};
List <DialogRow> dialogRows = new List <DialogRow>();
foreach (VehicleMod entry in mods)
{
dialogRows.Add(new DialogRow(null, new[] { entry.ModId.ToString(), entry.ModVal.ToString() }));
}
string[] dialogButtons = { "Wybierz", "Zamknij" };
Dialogs.Library.CreateDialog(player, DialogId.None, "Zainstalowane modyfikacje", dialogColumns,
dialogRows, dialogButtons);
}
}
else if (option == "rmods")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesColor, true))
{
return;
}
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
for (int i = 0; i < 76; i++)
{
NAPI.Vehicle.SetVehicleMod(vehData.VehicleHandle, i, -1);
}
using (Database.Database db = new Database.Database())
{
List <VehicleMod> vehMods = db.VehicleMods.Where(t => t.VehicleId == vehData.Id).ToList();
foreach (VehicleMod entry in vehMods)
{
NAPI.Vehicle.SetVehicleMod(vehData.VehicleHandle, (int)entry.ModId, entry.ModVal);
}
}
}
else if (option == "stworz")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehicleCreate, true))
{
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av stworz [nazwa pojazdu]");
return;
}
uint?vehicleHash = Library.GetVehicleHashByName(arguments[1].ToLower());
if (vehicleHash == null)
{
Ui.ShowError(player, "Nie znaleziono takiego pojazdu.");
return;
}
Vector3 posInFrontOf = Global.GetPositionInFrontOf(player.Position, player.Heading, 5.0f);
Vehicle vehicle = Library.CreateVehicle((long)vehicleHash, posInFrontOf,
new Vector3(0, 0, player.Heading + 90), 0, 0, OwnerType.Player, (int)player.Dimension, charData.Id,
Command.UpperFirst(arguments[1], false), Player.GetPlayerDebugName(charData));
Player.SendFormattedChatMessage(player, $"Utworzono pojazd \"{vehicle.Name}\" (UID: {vehicle.Id})",
Constants.ColorDarkRed);
}
else if (option == "edytuj")
{
Vehicle vehData;
if (player.IsInVehicle)
{
vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Nie znaleziono pojazdu o podanym ID.");
return;
}
Library.ShowUi(charData, UiType.VehicleEditAdmin, vehData.Id);
return;
}
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehicleCreate, true))
{
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av edytuj [id pojazdu]");
return;
}
int vehId = Command.GetNumberFromString(arguments[1]);
if (vehId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne UID pojazdu.");
return;
}
vehData = Library.GetVehicleData(vehId);
if (vehData == null)
{
Ui.ShowError(player, "Nie znaleziono pojazdu o podanym ID.");
return;
}
Library.ShowUi(charData, UiType.VehicleEditAdmin, vehData.Id);
}
else if (option == "usun")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehicleDelete, true))
{
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av usun [id pojazdu]");
return;
}
int vehId = Command.GetNumberFromString(arguments[1]);
if (vehId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne UID pojazdu");
return;
}
Vehicle vehData = Library.GetVehicleData(vehId);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd o takim UID nie istnieje.");
return;
}
Player.SendFormattedChatMessage(player,
$"Pojazd \"{vehData.Name}\" (UID: {vehData.Id}) został usunięty.", Constants.ColorDarkRed);
Library.DestroyVehicle(vehData.Id);
}
else if (option == "to")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesTeleport, true))
{
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av to [id pojazdu]");
return;
}
int vehId = Command.GetNumberFromString(arguments[1]);
if (vehId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne UID pojazdu.");
return;
}
Vehicle vehData = Library.GetVehicleData(vehId);
if (vehData == null)
{
Ui.ShowError(player, "Nie znaleziono pojazdu o podanym ID.");
return;
}
if (!vehData.Spawned || vehData.VehicleHandle == null ||
!NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
Ui.ShowError(player, "Pojazd nie jest zespawnowany.");
return;
}
player.Position = new Vector3(vehData.VehicleHandle.Position.X - 2.5,
vehData.VehicleHandle.Position.Y - 2.5, vehData.VehicleHandle.Position.Z);
player.Dimension = vehData.VehicleHandle.Dimension;
Player.SendFormattedChatMessage(player,
$"Teleportowałeś się do pojazdu \"{vehData.Name}\" (UID: {vehData.Id}).", Constants.ColorDelRio);
}
else if (option == "tm")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesTeleport, true))
{
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av tm [id pojazdu]");
return;
}
int vehId = Command.GetNumberFromString(arguments[1]);
if (vehId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne UID pojazdu.");
return;
}
Vehicle vehData = Library.GetVehicleData(vehId);
if (vehData == null)
{
Ui.ShowError(player, "Nie znaleziono pojazdu o podanym ID.");
return;
}
if (!vehData.Spawned || vehData.VehicleHandle == null ||
!NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
Ui.ShowError(player, "Pojazd nie jest zespawnowany.");
return;
}
Vector3 newPosition = Global.GetPositionInFrontOf(player.Position, player.Heading, 5.0f);
vehData.VehicleHandle.Position = newPosition;
vehData.VehicleHandle.Rotation = new Vector3(0, 0, player.Heading + 90.0f);
vehData.VehicleHandle.Dimension = player.Dimension;
Player.SendFormattedChatMessage(player,
$"Pojazd \"{vehData.Name}\" (UID: {vehData.Id}) został przeteleportowany do Ciebie.",
Constants.ColorDelRio);
}
else if (option == "spawn")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesSpawn, true))
{
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av spawn [id pojazdu]");
return;
}
int vehId = Command.GetNumberFromString(arguments[1]);
if (vehId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne UID pojazdu.");
return;
}
Vehicle vehData = Library.GetVehicleData(vehId);
if (vehData == null)
{
Ui.ShowError(player, "Nie znaleziono pojazdu o podanym ID.");
return;
}
if (!vehData.Spawned || vehData.VehicleHandle == null ||
!NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
Library.SpawnVehicle(vehData.Id);
Player.SendFormattedChatMessage(player,
$"Pojazd \"{vehData.Name}\" (UID: {vehData.Id}) został zespawnowany.", Constants.ColorDelRio);
}
else
{
Library.UnspawnVehicle(vehData.Id);
Player.SendFormattedChatMessage(player,
$"Pojazd \"{vehData.Name}\" (UID: {vehData.Id}) został odspawnowany.", Constants.ColorDelRio);
}
}
else if (option == "parkuj")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesPark, true))
{
return;
}
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
Library.ParkVehicle(charData.PlayerHandle, vehData, player.Vehicle.Position, player.Vehicle.Rotation,
(int)player.Dimension);
}
else if (option == "napraw")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesFix, true))
{
return;
}
if (player.IsInVehicle)
{
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
vehData.Health = 1000.0f;
vehData.Save();
if (vehData.Spawned && vehData.VehicleHandle != null &&
NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
vehData.VehicleHandle.Repair();
}
Player.SendFormattedChatMessage(player,
$"Pojazd \"{vehData.Name}\" (UID: {vehData.Id}) został naprawiony.", Constants.ColorDelRio);
}
else
{
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av napraw [id pojazdu]");
return;
}
int vehId = Command.GetNumberFromString(arguments[1]);
if (vehId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne UID pojazdu.");
return;
}
Vehicle vehData = Library.GetVehicleData(vehId);
if (vehData == null)
{
Ui.ShowError(player, "Nie znaleziono pojazdu o podanym ID.");
return;
}
vehData.Health = 1000.0f;
vehData.Save();
if (vehData.Spawned && vehData.VehicleHandle != null &&
NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
vehData.VehicleHandle.Repair();
}
Player.SendFormattedChatMessage(player,
$"Pojazd \"{vehData.Name}\" (UID: {vehData.Id}) został naprawiony.", Constants.ColorDelRio);
}
}
else if (option == "kolor1")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesColor, true))
{
return;
}
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av kolor1 [id koloru]");
return;
}
int colorId = Command.GetNumberFromString(arguments[1]);
if (colorId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano nieprawidłowy kolor pojazdu.");
return;
}
vehData.FirstColor = colorId;
if (vehData.Spawned && vehData.VehicleHandle != null &&
NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
vehData.VehicleHandle.PrimaryColor = vehData.FirstColor;
}
Player.SendFormattedChatMessage(player,
$"Pojazd \"{vehData.Name}\" (UID: {vehData.Id}) został przemalowany.", Constants.ColorDelRio);
}
else if (option == "kolor2")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesColor, true))
{
return;
}
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av kolor2 [id koloru]");
return;
}
int colorId = Command.GetNumberFromString(arguments[1]);
if (colorId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano nieprawidłowy kolor pojazdu.");
return;
}
vehData.SecondColor = colorId;
if (vehData.Spawned && vehData.VehicleHandle != null &&
NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
vehData.VehicleHandle.SecondaryColor = vehData.SecondColor;
}
Player.SendFormattedChatMessage(player,
$"Pojazd \"{vehData.Name}\" (UID: {vehData.Id}) został przemalowany.", Constants.ColorDelRio);
}
else if (option == "pj")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesPj, true))
{
return;
}
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av pj [id paintjobu]");
return;
}
int liveryId = Command.GetNumberFromString(arguments[1]);
if (liveryId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano nieprawidłowe id paintjobu.");
return;
}
vehData.Livery = liveryId;
vehData.Save();
if (vehData.Spawned && vehData.VehicleHandle != null &&
NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
vehData.VehicleHandle.Livery = vehData.Livery;
Library.SyncVehicleForPlayer(null, vehData.VehicleHandle.Value, "livery", vehData.Livery);
}
Player.SendFormattedChatMessage(player,
$"Pojazd \"{vehData.Name}\" (UID: {vehData.Id}) został przemalowany.", Constants.ColorDelRio);
}
else if (option == "przypisz")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesAssign, true))
{
return;
}
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
if (arguments.Length - 1 < 2)
{
Ui.ShowUsage(player, "/av przypisz [gracz, grupa] [Id właściciela]");
return;
}
int ownerId = Command.GetNumberFromString(arguments[2]);
if (ownerId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano niepoprawne Id właściciela");
return;
}
string subOption = arguments[1].ToLower();
if (subOption == "gracz")
{
Character targetData = Account.GetPlayerDataByServerId(ownerId);
if (targetData == null)
{
Ui.ShowError(player, "Nie znaleziono gracza o podanym Id.");
return;
}
vehData.OwnerType = OwnerType.Player;
vehData.Owner = targetData.Id;
vehData.Save();
Player.SendFormattedChatMessage(targetData.PlayerHandle,
$"Administrator przypisał Ci pojazd {Library.GetVehicleFormattedName(vehData)}.",
Constants.ColorPictonBlue);
Player.SendFormattedChatMessage(player,
$"Pojazd {Library.GetVehicleFormattedName(vehData)} został przypisany graczowi " +
$"{Player.GetPlayerIcName(targetData, true)}.", Constants.ColorDarkRed);
}
else if (subOption == "grupa")
{
Group groupData = Groups.Library.GetGroupData(ownerId);
if (groupData == null)
{
Ui.ShowError(player, "Nie znaleziono grupy o podanym Id.");
return;
}
vehData.OwnerType = OwnerType.Group;
vehData.Owner = groupData.Id;
vehData.Save();
Player.SendFormattedChatMessage(player,
$"Pojazd {Library.GetVehicleFormattedName(vehData)} został przypisany grupie " +
$"{groupData.Name} (UID: {groupData.Id})", Constants.ColorDarkRed);
}
else
{
Ui.ShowUsage(player, "/av przypisz [gracz, grupa] [Id właściciela]");
}
}
else if (option == "extra")
{
if (!Admin.Library.DoesPlayerHasAdminPerm(charData, Permissions.VehiclesPj, true))
{
return;
}
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Pojazd w którym siedzisz jest nieprawidłowym pojazdem.");
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/av extra [id extrasu]");
return;
}
int extrasId = Command.GetNumberFromString(arguments[1]);
if (extrasId == Command.InvalidNumber)
{
Ui.ShowError(player, "Podano nieprawidłowe id extrasu.");
return;
}
if (vehData.MappedExtras == null)
{
vehData.MappedExtras = new Dictionary <int, bool>();
}
if (vehData.MappedExtras.ContainsKey(extrasId))
{
vehData.MappedExtras[extrasId] = !vehData.MappedExtras[extrasId];
Ui.ShowInfo(player, $"Zmieniono stan extrasu na {vehData.MappedExtras[extrasId].ToString()}.");
}
else
{
vehData.MappedExtras.Add(extrasId, !vehData.VehicleHandle.GetExtra(extrasId));
Ui.ShowInfo(player, $"Zmieniono stan extrasu na {vehData.MappedExtras[extrasId].ToString()}.");
}
vehData.Save();
vehData.RebuildExtras();
}
}
public void Command_Vehicle(Client player, string args = "")
{
Character charData = Account.GetPlayerData(player);
if (charData == null)
{
return;
}
const string legend = "/v [l(ista), z(amknij), (za)parkuj, maska, bagaznik]";
string[] arguments = Command.GetCommandArguments(args);
if (arguments.Length < 1)
{
Ui.ShowUsage(player, legend);
return;
}
string option = arguments[0].ToLower();
if (option == "lista" || option == "l")
{
Library.ShowUi(charData, UiType.VehiclesList, 0);
}
else if (option == "zamknij" || option == "z")
{
Vehicle vehData = Library.GetNearestVehicle(player.Position, player.Dimension);
if (vehData == null)
{
Ui.ShowWarning(player, "Nie znaleziono żadnego pojazdu obok Ciebie.");
return;
}
if (!Library.DoesPlayerHasVehiclePerm(charData, vehData.Id))
{
Ui.ShowError(player, "Nie posiadasz kluczy do tego pojazdu.");
return;
}
if (vehData.Closed)
{
vehData.Closed = false;
vehData.VehicleHandle.Locked = false;
Chat.Library.SendPlayerMeMessage(charData, $"otwiera drzwi pojazdu \"{vehData.Name}\".", true);
}
else
{
vehData.Closed = true;
vehData.VehicleHandle.Locked = true;
Chat.Library.SendPlayerMeMessage(charData, $"zamyka drzwi pojazdu \"{vehData.Name}\".", true);
}
}
else if (option == "zaparkuj" || option == "parkuj")
{
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz być w pojeździe.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Nie znaleziono tego pojazdu.");
return;
}
if (!Library.DoesPlayerHasVehicleOwner(charData, vehData.Id))
{
Ui.ShowError(player, "Nie posiadasz odpowiednich uprawnień.");
return;
}
vehData.X = vehData.VehicleHandle.Position.X;
vehData.Y = vehData.VehicleHandle.Position.Y;
vehData.Z = vehData.VehicleHandle.Position.Z;
vehData.Rx = vehData.VehicleHandle.Rotation.X;
vehData.Ry = vehData.VehicleHandle.Rotation.Y;
vehData.Rz = vehData.VehicleHandle.Rotation.Z;
vehData.Dimension = (int)vehData.VehicleHandle.Dimension;
vehData.Save();
Ui.ShowInfo(player, "Pojazd został zaparkowany pomyślnie.");
}
else if (option == "maska")
{
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
if (player.VehicleSeat != -1)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe jako kierowca.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Niewłaściwy pojazd.");
return;
}
vehData.Hood = !vehData.Hood;
foreach (KeyValuePair <int, Character> entry in Account.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry.Value.PlayerHandle, "client.vehicle.sync.hood",
vehData.VehicleHandle.Value, vehData.Hood);
}
}
else if (option == "bagaznik")
{
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
if (player.VehicleSeat != -1)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe jako kierowca.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Niewłaściwy pojazd.");
return;
}
vehData.Trunk = !vehData.Trunk;
foreach (KeyValuePair <int, Character> entry in Account.GetAllPlayers())
{
NAPI.ClientEvent.TriggerClientEvent(entry.Value.PlayerHandle, "client.vehicle.sync.trunk",
vehData.VehicleHandle.Value, vehData.Trunk);
}
}
else if (option == "opis")
{
if (!player.IsInVehicle)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe.");
return;
}
if (player.VehicleSeat != -1)
{
Ui.ShowError(player, "Musisz siedzieć w pojeździe jako kierowca.");
return;
}
Vehicle vehData = Library.GetVehicleData(player.Vehicle);
if (vehData == null)
{
Ui.ShowError(player, "Niewłaściwy pojazd.");
return;
}
if (arguments.Length - 1 < 1)
{
Ui.ShowUsage(player, "/v opis [tresc opisu] | Aby usunac opis wpisz /v opis usun");
return;
}
if (arguments[1].ToLower() == "usun")
{
Library.SyncVehicleForPlayer(null, player.Vehicle.Value, "descdel", 0);
Ui.ShowInfo(player, "Opis pojazdu usunięty.");
vehData.VehicleDescription = null;
return;
}
vehData.VehicleDescription = Command.GetConcatString(arguments, 1);
Library.SyncVehicleForPlayer(null, player.Vehicle.Value, "desc", vehData.VehicleDescription);
Ui.ShowInfo(player, "Opis pojazdu został ustawiony.");
}
}
/// <summary>
/// Funkcja wykonywująca się w momencie, gdy TimeLeft osiągnie wartość 0.
/// </summary>
private void OnSuccess()
{
// Jeśli jakimś sposobem OnSuccess uruchomi się po raz drugi - niszczymy progress.
if (IsBlocked)
{
Destroy();
return;
}
// Blokujemy progress, aby przypadkiem nie wykonał się drugi raz.
IsBlocked = true;
if (Type == ProgressType.FixVehicle)
{
Vehicle vehData = (Vehicle)Data["veh"];
if (vehData == null)
{
SendMessage("Pojazd nie istnieje.");
Destroy();
return;
}
if (vehData.VehicleHandle == null || !NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
SendMessage("Pojazd nie jest zespawnowany.");
Destroy();
return;
}
if (TargetData == null || TargetData.PlayerHandle == null ||
!NAPI.Entity.DoesEntityExist(TargetData.PlayerHandle))
{
SendMessage("Mechanik wyszedł z gry.");
Destroy();
return;
}
if (Offers.Library.PayForOffer(TargetData, CharData, (OfferPayType)Data["type"],
(int)(uint)Data["price"]))
{
vehData.Health = 1000.0f;
vehData.Save();
if (vehData.Spawned && vehData.VehicleHandle != null &&
NAPI.Entity.DoesEntityExist(vehData.VehicleHandle))
{
vehData.VehicleHandle.Repair();
}
// ReSharper disable once PossibleInvalidCastException
SendMessage($"Pojazd został naprawiony za kwotę ${(uint) Data["price"]}.");
}
else
{
SendMessage("Pojazd nie został naprawiony z powodu błędu podczas pobierania opłaty.");
}
Destroy();
}
else if (Type == ProgressType.TattooCreate)
{
if (Offers.Library.PayForOffer(TargetData, CharData, (OfferPayType)Data["type"],
(int)(uint)Data["price"]))
{
int tattooId = (int)Data["tattooId"];
CharData.SyncedTattoos.Add(tattooId);
using (Database.Database db = new Database.Database())
{
Tattoo newTattoo = new Tattoo
{
CharId = CharData.Id,
TattooId = tattooId
};
db.Tattoos.Add(newTattoo);
db.SaveChanges();
}
Sync.Library.SyncPlayerForPlayer(CharData.PlayerHandle);
// ReSharper disable once PossibleInvalidCastException
SendMessage($"Tatuaż został nałożony za kwotę ${(uint) Data["price"]}.");
}
else
{
SendMessage("Tatuaż nie został nałożony z powodu błędu podczas pobierania opłaty.");
}
Destroy();
}
}
