public async void OnResourceStart()
{
NAPI.Server.SetAutoRespawnAfterDeath(false);
NAPI.Server.SetAutoSpawnOnConnect(false);
//NAPI.Server.SetGlobalServerChat(false);
//NAPI.Server.SetCommandErrorMessage("");
ServerUtilities.Initialise();
Database db = new Database();
Connection = db.Connection;
GroupDatabase.InitializeTable();
GroupDatabase.InitializeGroups();
VehicleDatabase.InitializeTable();
PlayerDatabase.InitializeTable();
CharacterDatabase.InitializeTable();
await GroupDatabase.AddCommandsToGroup(Config.GROUP_NAME_ADMIN, Commands.AdminCommands.ToArray());
await GroupDatabase.AddCommandsToGroup(Config.GROUP_NAME_LEAD_ADMIN, Commands.OwnerCommands.ToArray());
await GroupDatabase.AddCommandsToGroup(Config.GROUP_NAME_OWNER, Commands.OwnerCommands.ToArray());
}
public static async void RespawnVehicles()
{
List <Vehicle> vehiclesToDelete = NAPI.Pools.GetAllVehicles();
List <Client> allPlayers = NAPI.Pools.GetAllPlayers();
List <uint> vehiclesToNotRespawn = new List <uint>();
foreach (var player in allPlayers)
{
var vehicle = NAPI.Player.GetPlayerVehicle(player);
if (vehicle == null)
{
continue;
}
vehiclesToDelete.Remove(vehicle);
var vehicleData = vehicle.GetData(VehicleData.VEHICLE_DATA_KEY);
if (vehicleData == null)
{
continue;
}
vehiclesToNotRespawn.Add(vehicleData.Id);
}
//Delete vehicles
foreach (Vehicle vehicle in vehiclesToDelete)
{
NAPI.Task.Run(() =>
{
vehicle.Delete();
});
}
uint[] vehicleIds = await VehicleDatabase.GetVehicles();
VehicleData[] vehiclesToSpawn = await Task.WhenAll(vehicleIds.Where(e => vehiclesToNotRespawn.Contains(e) == false)
.Select(e => VehicleDatabase.GetVehicleData(e)));
foreach (VehicleData vehicleData in vehiclesToSpawn)
{
uint vehicleHash = NAPI.Util.GetHashKey(vehicleData.VehicleName);
float heading = 0;
if (vehicleData.Heading.HasValue)
{
heading = vehicleData.Heading.Value;
}
NAPI.Task.Run(() =>
{
var vehicle = NAPI.Vehicle.CreateVehicle(vehicleHash, vehicleData.GetPosition(), heading, vehicleData.Color1, vehicleData.Color2);
vehicle.SetData(VehicleData.VEHICLE_DATA_KEY, vehicleData);
});
}
NAPI.Chat.SendChatMessageToAll($"All vehicles respawned");
}
private void ConfigurationReader()
{
var data = LoadResourceFile(GetCurrentResourceName(), "config.ini");
if (Configuration.LoadFromString(data).Contains("VehicleSpawner") == true)
{
Configuration loaded = Configuration.LoadFromString(data);
Disabled = loaded["VehicleSpawner"]["DisabledVehicles"].StringValueArray;
MenuCommand(loaded["VehicleSpawner"]["CommandName"].StringValue);
foreach (var setting in loaded)
{
if (setting.Name != "VehicleSpawner")
{
var settingName = setting.Name;
foreach (var item in setting)
{
if (!item.IsEmpty)
{
if (!IsModelValid((uint)GetHashKey(item.Name)))
{
ProcessError($"The spawn code { item.Name } is invalid");
}
else
{
var dictionary = new Dictionary <string, string> {
};
if (!Categories.Contains(setting.Name))
{
Categories.Add(setting.Name);
}
dictionary.Add(item.Name, setting.Name);
if (!VehicleDatabase.ContainsKey(item.StringValue))
{
VehicleDatabase.Add(setting.Name + item.StringValue, dictionary);
}
}
}
else
{
ProcessError();
}
}
}
}
Debug.WriteLine("Vehicle configuration loaded.");
}
else
{
ProcessError();
}
}
static IEnumerable <Route> ServeRequest(Request request)
{
if (!CheckRequest(request))
{
return(null);
}
(IGraphDatabase cars, IGraphDatabase trains) = MockData.InitDatabases();
List <IGraphDatabase> databases = new List <IGraphDatabase>();
databases.Add(cars);
databases.Add(trains);
IGraphDatabase database = new VehicleDatabase(databases, request.Filter.AllowedVehicles);
database = new PopulationDatabase(database, request.Filter.MinPopulation);
database = new HasRestaurantDatabase(database, request.Filter.RestaurantRequired);
List <ISolver> solvers = new List <ISolver>();
solvers.Add(new BFS());
solvers.Add(new DFS());
solvers.Add(new DijkstraCost());
solvers.Add(new DijkstraTime());
IRouteProblem problem = ProblemFactory.MakeProblem(request.Problem, request.From, request.To);
problem.Graph = database;
foreach (ISolver solver in solvers)
{
if (solver.Name == request.Solver && problem.TrySolveBySolver(solver, out IEnumerable <Route> routes))
{
return(routes);
}
}
Console.WriteLine("Cannot find algorithm to solve this problem");
return(null);
}
public async void CMD_ParkVehicle(Client client)
{
Vehicle vehicle = NAPI.Player.GetPlayerVehicle(client);
if (vehicle == null)
{
return;
}
CharacterData characterData = client.GetData(CharacterData.CHARACTER_DATA_KEY);
if (characterData == null)
{
return;
}
VehicleData vehicleData = vehicle.GetData(VehicleData.VEHICLE_DATA_KEY);
//No owner
if (vehicleData == null)
{
client.SendChatMessage("You do not own this vehicle!");
return;
}
if (vehicleData.OwnerId != characterData.Id)
{
client.SendChatMessage("You do not own this vehicle!");
return;
}
vehicleData.SetPosition(vehicle.Position);
vehicleData.Heading = vehicle.Heading;
VehicleDatabase.SaveVehicle(vehicleData);
Main.Logger.LogClient(client, $"({vehicle.DisplayName}) parked at {vehicle.Position}");
}
public async void CMD_TakeOwnershipOfVehicle(Client client, string targetFirstName, string targetSurname = "")
{
if (await ServerUtilities.CanUseCommand(client, COMMAND_VEHICLE_SET_OWNER) == false)
{
return;
}
Client owner = ServerUtilities.GetPlayerIfExists(client, targetFirstName, targetSurname);
if (owner == null)
{
return;
}
Vehicle vehicle = NAPI.Player.GetPlayerVehicle(owner);
if (vehicle == null)
{
Main.Logger.LogClient(client, "You are not in a vehicle!");
return;
}
CharacterData newOwnerCharacterData = owner.GetData(CharacterData.CHARACTER_DATA_KEY);
if (newOwnerCharacterData == null)
{
return;
}
CharacterData clientCharacterData = client.GetData(CharacterData.CHARACTER_DATA_KEY);
//Owner is Client
bool isClientOwner = false;
if (clientCharacterData != null && clientCharacterData.Id == newOwnerCharacterData.Id)
{
isClientOwner = true;
}
VehicleData vehicleData = vehicle.GetData(VehicleData.VEHICLE_DATA_KEY);
if (vehicleData != null)
{
if (vehicleData.OwnerId == newOwnerCharacterData.Id)
{
if (isClientOwner)
{
Main.Logger.LogClient(client, $"You already own ({vehicleData.Id}) {vehicle.DisplayName}.");
}
else
{
Main.Logger.LogClient(client, $"{newOwnerCharacterData.Name} already owns ({vehicleData.Id}) {vehicle.DisplayName}.");
}
return;
}
else
{
vehicleData.OwnerId = newOwnerCharacterData.Id;
VehicleDatabase.SaveVehicle(vehicleData);
}
}
else
{
vehicleData = new VehicleData()
{
VehicleName = ((VehicleHash)vehicle.Model).ToString(),
Color1 = vehicle.PrimaryColor,
Color2 = vehicle.SecondaryColor,
Heading = vehicle.Heading,
OwnerId = newOwnerCharacterData.Id
};
vehicleData.SetPosition(vehicle.Position);
vehicleData = await VehicleDatabase.CreateVehicle(vehicleData);
vehicle.SetData(VehicleData.VEHICLE_DATA_KEY, vehicleData);
}
Main.Logger.LogClient(client, $"Gave {newOwnerCharacterData.Name} ownership of {vehicle.DisplayName}.");
Main.Logger.LogClient(owner, $"{clientCharacterData.Name} gave you ownership of {vehicle.DisplayName}.");
}
