602 lines
21 KiB
C#
602 lines
21 KiB
C#
using GTA;
|
|
using GTA.Native;
|
|
using RageCoop.Client.Scripting;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Security.Cryptography;
|
|
using Lidgren.Network;
|
|
|
|
namespace RageCoop.Client
|
|
{
|
|
internal class EntityPool
|
|
{
|
|
public static object PedsLock = new object();
|
|
public static int CharactersCount { get { return PedsByID.Count; } }
|
|
#if BENCHMARK
|
|
private static Stopwatch PerfCounter=new Stopwatch();
|
|
private static Stopwatch PerfCounter2=Stopwatch.StartNew();
|
|
#endif
|
|
#region ACTIVE INSTANCES
|
|
|
|
private static Dictionary<int, SyncedPed> PedsByID = new Dictionary<int, SyncedPed>();
|
|
private static Dictionary<int, SyncedPed> PedsByHandle = new Dictionary<int, SyncedPed>();
|
|
|
|
|
|
private static Dictionary<int, SyncedVehicle> VehiclesByID = new Dictionary<int, SyncedVehicle>();
|
|
private static Dictionary<int, SyncedVehicle> VehiclesByHandle = new Dictionary<int, SyncedVehicle>();
|
|
|
|
private static Dictionary<int, SyncedProjectile> ProjectilesByID = new Dictionary<int, SyncedProjectile>();
|
|
private static Dictionary<int, SyncedProjectile> ProjectilesByHandle = new Dictionary<int, SyncedProjectile>();
|
|
|
|
public static Dictionary<int, SyncedProp> ServerProps = new Dictionary<int, SyncedProp>();
|
|
public static Dictionary<int, Blip> ServerBlips = new Dictionary<int, Blip>();
|
|
|
|
#endregion
|
|
|
|
#region LOCKS
|
|
|
|
public static object VehiclesLock = new object();
|
|
public static object ProjectilesLock = new object();
|
|
public static object PropsLock = new object();
|
|
public static object BlipsLock = new object();
|
|
|
|
#endregion
|
|
public static void Cleanup(bool keepPlayer = true, bool keepMine = true)
|
|
{
|
|
foreach (int id in new List<int>(PedsByID.Keys))
|
|
{
|
|
if (keepPlayer && (id==Main.LocalPlayerID)|| keepMine && (PedsByID[id].OwnerID == Main.LocalPlayerID)) { continue; }
|
|
RemovePed(id);
|
|
}
|
|
PedsByID.Clear();
|
|
PedsByHandle.Clear();
|
|
|
|
foreach (int id in new List<int>(VehiclesByID.Keys))
|
|
{
|
|
if (keepMine&&(VehiclesByID[id].OwnerID==Main.LocalPlayerID)) { continue; }
|
|
RemoveVehicle(id);
|
|
}
|
|
VehiclesByID.Clear();
|
|
VehiclesByHandle.Clear();
|
|
|
|
foreach (var p in ProjectilesByID.Values)
|
|
{
|
|
if (p.ShooterID!=Main.LocalPlayerID && p.MainProjectile!=null && p.MainProjectile.Exists())
|
|
{
|
|
p.MainProjectile.Delete();
|
|
}
|
|
}
|
|
ProjectilesByID.Clear();
|
|
ProjectilesByHandle.Clear();
|
|
|
|
foreach (var p in ServerProps.Values)
|
|
{
|
|
p?.MainProp?.Delete();
|
|
}
|
|
ServerProps.Clear();
|
|
|
|
foreach (var b in ServerBlips.Values)
|
|
{
|
|
if (b.Exists())
|
|
{
|
|
b.Delete();
|
|
}
|
|
}
|
|
ServerBlips.Clear();
|
|
}
|
|
|
|
#region PEDS
|
|
public static SyncedPed GetPedByID(int id) => PedsByID.TryGetValue(id, out var p) ? p : null;
|
|
public static SyncedPed GetPedByHandle(int handle) => PedsByHandle.TryGetValue(handle, out var p) ? p : null;
|
|
public static List<int> GetPedIDs() => new List<int>(PedsByID.Keys);
|
|
public static bool AddPlayer()
|
|
{
|
|
Ped p = Game.Player.Character;
|
|
SyncedPed player = GetPedByID(Main.LocalPlayerID);
|
|
if (player==null)
|
|
{
|
|
Main.Logger.Debug($"Creating SyncEntity for player, handle:{p.Handle}");
|
|
SyncedPed c = new SyncedPed(p);
|
|
Main.LocalPlayerID = c.OwnerID = c.ID;
|
|
Add(c);
|
|
Main.Logger.Debug($"Local player ID is:{c.ID}");
|
|
PlayerList.SetPlayer(c.ID, Main.Settings.Username);
|
|
return true;
|
|
}
|
|
|
|
if (player.MainPed != p)
|
|
{
|
|
// Player model changed
|
|
player.MainPed = p;
|
|
|
|
// Remove it from Handle_Characters
|
|
var pairs = PedsByHandle.Where(x => x.Value == player);
|
|
if (pairs.Any())
|
|
{
|
|
var pair = pairs.First();
|
|
|
|
// Re-add
|
|
PedsByHandle.Remove(pair.Key);
|
|
if (PedsByHandle.ContainsKey(p.Handle))
|
|
{
|
|
RemovePed(PedsByHandle[p.Handle].ID);
|
|
}
|
|
PedsByHandle.Add(p.Handle, player);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
public static void Add(SyncedPed c)
|
|
{
|
|
if (PedsByID.ContainsKey(c.ID))
|
|
{
|
|
PedsByID[c.ID]=c;
|
|
}
|
|
else
|
|
{
|
|
PedsByID.Add(c.ID, c);
|
|
}
|
|
if (c.MainPed==null) { return; }
|
|
if (PedsByHandle.ContainsKey(c.MainPed.Handle))
|
|
{
|
|
PedsByHandle[c.MainPed.Handle]=c;
|
|
}
|
|
else
|
|
{
|
|
PedsByHandle.Add(c.MainPed.Handle, c);
|
|
}
|
|
if (c.IsLocal)
|
|
{
|
|
API.Events.InvokePedSpawned(c);
|
|
}
|
|
}
|
|
public static void RemovePed(int id, string reason = "Cleanup")
|
|
{
|
|
if (PedsByID.ContainsKey(id))
|
|
{
|
|
SyncedPed c = PedsByID[id];
|
|
var p = c.MainPed;
|
|
if (p!=null)
|
|
{
|
|
if (PedsByHandle.ContainsKey(p.Handle))
|
|
{
|
|
PedsByHandle.Remove(p.Handle);
|
|
}
|
|
// Main.Logger.Debug($"Removing ped {c.ID}. Reason:{reason}");
|
|
p.AttachedBlip?.Delete();
|
|
p.Kill();
|
|
p.Model.MarkAsNoLongerNeeded();
|
|
p.MarkAsNoLongerNeeded();
|
|
p.Delete();
|
|
}
|
|
c.PedBlip?.Delete();
|
|
c.ParachuteProp?.Delete();
|
|
PedsByID.Remove(id);
|
|
if (c.IsLocal)
|
|
{
|
|
API.Events.InvokePedDeleted(c);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region VEHICLES
|
|
public static SyncedVehicle GetVehicleByID(int id) => VehiclesByID.TryGetValue(id,out var v) ? v : null;
|
|
public static SyncedVehicle GetVehicleByHandle(int handle) => VehiclesByHandle.TryGetValue(handle,out var v) ? v : null;
|
|
public static List<int> GetVehicleIDs() => new List<int>(VehiclesByID.Keys);
|
|
public static void Add(SyncedVehicle v)
|
|
{
|
|
if (VehiclesByID.ContainsKey(v.ID))
|
|
{
|
|
VehiclesByID[v.ID]=v;
|
|
}
|
|
else
|
|
{
|
|
VehiclesByID.Add(v.ID, v);
|
|
}
|
|
if (v.MainVehicle==null) { return; }
|
|
if (VehiclesByHandle.ContainsKey(v.MainVehicle.Handle))
|
|
{
|
|
VehiclesByHandle[v.MainVehicle.Handle]=v;
|
|
}
|
|
else
|
|
{
|
|
VehiclesByHandle.Add(v.MainVehicle.Handle, v);
|
|
}
|
|
if (v.IsLocal)
|
|
{
|
|
API.Events.InvokeVehicleSpawned(v);
|
|
}
|
|
}
|
|
public static void RemoveVehicle(int id, string reason = "Cleanup")
|
|
{
|
|
if (VehiclesByID.ContainsKey(id))
|
|
{
|
|
SyncedVehicle v = VehiclesByID[id];
|
|
var veh = v.MainVehicle;
|
|
if (veh!=null)
|
|
{
|
|
if (VehiclesByHandle.ContainsKey(veh.Handle))
|
|
{
|
|
VehiclesByHandle.Remove(veh.Handle);
|
|
}
|
|
// Main.Logger.Debug($"Removing vehicle {v.ID}. Reason:{reason}");
|
|
veh.AttachedBlip?.Delete();
|
|
veh.Model.MarkAsNoLongerNeeded();
|
|
veh.MarkAsNoLongerNeeded();
|
|
veh.Delete();
|
|
}
|
|
VehiclesByID.Remove(id);
|
|
if (v.IsLocal) { API.Events.InvokeVehicleDeleted(v); }
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PROJECTILES
|
|
public static SyncedProjectile GetProjectileByID(int id)
|
|
{
|
|
return ProjectilesByID.TryGetValue(id,out var p) ? p : null;
|
|
}
|
|
public static void Add(SyncedProjectile p)
|
|
{
|
|
if (!p.IsValid) { return; }
|
|
if (ProjectilesByID.ContainsKey(p.ID))
|
|
{
|
|
ProjectilesByID[p.ID]=p;
|
|
}
|
|
else
|
|
{
|
|
ProjectilesByID.Add(p.ID, p);
|
|
}
|
|
if (p.MainProjectile==null) { return; }
|
|
if (ProjectilesByHandle.ContainsKey(p.MainProjectile.Handle))
|
|
{
|
|
ProjectilesByHandle[p.MainProjectile.Handle]=p;
|
|
}
|
|
else
|
|
{
|
|
ProjectilesByHandle.Add(p.MainProjectile.Handle, p);
|
|
}
|
|
}
|
|
public static void RemoveProjectile(int id, string reason)
|
|
{
|
|
if (ProjectilesByID.ContainsKey(id))
|
|
{
|
|
SyncedProjectile sp = ProjectilesByID[id];
|
|
var p = sp.MainProjectile;
|
|
if (p!=null)
|
|
{
|
|
if (ProjectilesByHandle.ContainsKey(p.Handle))
|
|
{
|
|
ProjectilesByHandle.Remove(p.Handle);
|
|
}
|
|
Main.Logger.Debug($"Removing projectile {sp.ID}. Reason:{reason}");
|
|
p.Explode();
|
|
}
|
|
ProjectilesByID.Remove(id);
|
|
}
|
|
}
|
|
|
|
public static bool PedExists(int id) => PedsByID.ContainsKey(id);
|
|
public static bool VehicleExists(int id) => VehiclesByID.ContainsKey(id);
|
|
public static bool ProjectileExists(int id) => ProjectilesByID.ContainsKey(id);
|
|
#endregion
|
|
static int vehStateIndex;
|
|
static int pedStateIndex;
|
|
static int vehStatesPerFrame;
|
|
static int pedStatesPerFrame;
|
|
static int i;
|
|
public static Ped[] allPeds = new Ped[0];
|
|
public static Vehicle[] allVehicles = new Vehicle[0];
|
|
public static Projectile[] allProjectiles = new Projectile[0];
|
|
|
|
public static void DoSync()
|
|
{
|
|
UpdateTargets();
|
|
#if BENCHMARK
|
|
PerfCounter.Restart();
|
|
Debug.TimeStamps[TimeStamp.CheckProjectiles]=PerfCounter.ElapsedTicks;
|
|
#endif
|
|
allPeds = World.GetAllPeds();
|
|
allVehicles=World.GetAllVehicles();
|
|
allProjectiles=World.GetAllProjectiles();
|
|
vehStatesPerFrame=allVehicles.Length*2/(int)Game.FPS+1;
|
|
pedStatesPerFrame=allPeds.Length*2/(int)Game.FPS+1;
|
|
/*
|
|
if (Main.Ticked%50==0)
|
|
{
|
|
bool flag1 = allVehicles.Length>Main.Settings.WorldVehicleSoftLimit && Main.Settings.WorldVehicleSoftLimit>-1;
|
|
bool flag2 = allPeds.Length>Main.Settings.WorldPedSoftLimit && Main.Settings.WorldPedSoftLimit>-1;
|
|
if ((flag1||flag2) && _trafficSpawning)
|
|
{ SetBudget(0); _trafficSpawning=false; }
|
|
else if(!_trafficSpawning)
|
|
{ SetBudget(1); _trafficSpawning=true; }
|
|
}
|
|
*/
|
|
#if BENCHMARK
|
|
|
|
Debug.TimeStamps[TimeStamp.GetAllEntities]=PerfCounter.ElapsedTicks;
|
|
#endif
|
|
|
|
lock (ProjectilesLock)
|
|
{
|
|
|
|
foreach (Projectile p in allProjectiles)
|
|
{
|
|
if (!ProjectilesByHandle.ContainsKey(p.Handle))
|
|
{
|
|
Add(new SyncedProjectile(p));
|
|
}
|
|
}
|
|
|
|
foreach (SyncedProjectile p in ProjectilesByID.Values.ToArray())
|
|
{
|
|
// Outgoing sync
|
|
if (p.IsLocal)
|
|
{
|
|
if (p.MainProjectile.AttachedEntity==null)
|
|
{
|
|
// Prevent projectiles from exploding next to vehicle
|
|
if (WeaponUtil.VehicleProjectileWeapons.Contains((VehicleWeaponHash)p.MainProjectile.WeaponHash) &&
|
|
p.MainProjectile.WeaponHash != (WeaponHash)VehicleWeaponHash.Tank && p.Origin.DistanceTo(p.MainProjectile.Position) < 2)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Networking.SendProjectile(p);
|
|
}
|
|
}
|
|
else // Incoming sync
|
|
{
|
|
if (p.Exploded || p.IsOutOfSync)
|
|
{
|
|
RemoveProjectile(p.ID, "OutOfSync | Exploded");
|
|
}
|
|
else
|
|
{
|
|
p.Update();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
i=-1;
|
|
|
|
lock (PedsLock)
|
|
{
|
|
EntityPool.AddPlayer();
|
|
|
|
foreach (Ped p in allPeds)
|
|
{
|
|
SyncedPed c = EntityPool.GetPedByHandle(p.Handle);
|
|
if (c==null && (p!=Game.Player.Character))
|
|
{
|
|
if (allPeds.Length>Main.Settings.WorldPedSoftLimit && p.PopulationType != EntityPopulationType.RandomAmbient)
|
|
{
|
|
p.Delete();
|
|
continue;
|
|
}
|
|
// Main.Logger.Trace($"Creating SyncEntity for ped, handle:{p.Handle}");
|
|
c=new SyncedPed(p);
|
|
|
|
EntityPool.Add(c);
|
|
}
|
|
}
|
|
#if BENCHMARK
|
|
|
|
Debug.TimeStamps[TimeStamp.AddPeds]=PerfCounter.ElapsedTicks;
|
|
#endif
|
|
var ps = PedsByID.Values.ToArray();
|
|
pedStateIndex+=pedStatesPerFrame;
|
|
if (pedStateIndex>=ps.Length)
|
|
{
|
|
pedStateIndex=0;
|
|
}
|
|
|
|
foreach (SyncedPed c in ps)
|
|
{
|
|
i++;
|
|
if ((c.MainPed!=null)&&(!c.MainPed.Exists()))
|
|
{
|
|
EntityPool.RemovePed(c.ID, "non-existent");
|
|
continue;
|
|
}
|
|
|
|
// Outgoing sync
|
|
if (c.IsLocal)
|
|
{
|
|
#if BENCHMARK
|
|
var start = PerfCounter2.ElapsedTicks;
|
|
#endif
|
|
// event check
|
|
SyncEvents.Check(c);
|
|
|
|
Networking.SendPed(c, (i-pedStateIndex)<pedStatesPerFrame);
|
|
#if BENCHMARK
|
|
Debug.TimeStamps[TimeStamp.SendPed]=PerfCounter2.ElapsedTicks-start;
|
|
#endif
|
|
}
|
|
else // Incoming sync
|
|
{
|
|
#if BENCHMARK
|
|
var start = PerfCounter2.ElapsedTicks;
|
|
#endif
|
|
c.Update();
|
|
if (c.IsOutOfSync)
|
|
{
|
|
RemovePed(c.ID, "OutOfSync");
|
|
}
|
|
#if BENCHMARK
|
|
Debug.TimeStamps[TimeStamp.UpdatePed]=PerfCounter2.ElapsedTicks-start;
|
|
#endif
|
|
}
|
|
}
|
|
#if BENCHMARK
|
|
Debug.TimeStamps[TimeStamp.PedTotal]=PerfCounter.ElapsedTicks;
|
|
#endif
|
|
}
|
|
|
|
i=-1;
|
|
|
|
lock (VehiclesLock)
|
|
{
|
|
foreach (Vehicle veh in allVehicles)
|
|
{
|
|
if (!VehiclesByHandle.ContainsKey(veh.Handle))
|
|
{
|
|
if (allVehicles.Length>Main.Settings.WorldVehicleSoftLimit)
|
|
{
|
|
var type = veh.PopulationType;
|
|
if (type==EntityPopulationType.RandomAmbient || type==EntityPopulationType.RandomParked)
|
|
{
|
|
foreach (var p in veh.Occupants)
|
|
{
|
|
p.Delete();
|
|
var c = EntityPool.GetPedByHandle(p.Handle);
|
|
if (c!=null)
|
|
{
|
|
EntityPool.RemovePed(c.ID, "ThrottleTraffic");
|
|
}
|
|
}
|
|
veh.Delete();
|
|
continue;
|
|
}
|
|
}
|
|
// Main.Logger.Debug($"Creating SyncEntity for vehicle, handle:{veh.Handle}");
|
|
|
|
Add(new SyncedVehicle(veh));
|
|
}
|
|
}
|
|
#if BENCHMARK
|
|
Debug.TimeStamps[TimeStamp.AddVehicles]=PerfCounter.ElapsedTicks;
|
|
#endif
|
|
var vs = VehiclesByID.Values.ToArray();
|
|
vehStateIndex+=vehStatesPerFrame;
|
|
if (vehStateIndex>=vs.Length)
|
|
{
|
|
vehStateIndex=0;
|
|
}
|
|
|
|
foreach (SyncedVehicle v in vs)
|
|
{
|
|
i++;
|
|
if ((v.MainVehicle!=null)&&(!v.MainVehicle.Exists()))
|
|
{
|
|
EntityPool.RemoveVehicle(v.ID, "non-existent");
|
|
continue;
|
|
}
|
|
|
|
// Outgoing sync
|
|
if (v.IsLocal)
|
|
{
|
|
if (!v.MainVehicle.IsVisible) { continue; }
|
|
SyncEvents.Check(v);
|
|
|
|
Networking.SendVehicle(v, (i-vehStateIndex)<vehStatesPerFrame);
|
|
}
|
|
else // Incoming sync
|
|
{
|
|
v.Update();
|
|
if (v.IsOutOfSync)
|
|
{
|
|
RemoveVehicle(v.ID, "OutOfSync");
|
|
}
|
|
}
|
|
}
|
|
|
|
#if BENCHMARK
|
|
Debug.TimeStamps[TimeStamp.VehicleTotal]=PerfCounter.ElapsedTicks;
|
|
#endif
|
|
}
|
|
Networking.Peer.FlushSendQueue();
|
|
}
|
|
static void UpdateTargets()
|
|
{
|
|
Networking.Targets=new List<NetConnection>(PlayerList.Players.Count) { Networking.ServerConnection };
|
|
foreach (var p in PlayerList.Players.Values.ToArray())
|
|
{
|
|
if (p.HasDirectConnection && p.Position.DistanceTo(Main.PlayerPosition)<500)
|
|
{
|
|
Networking.Targets.Add(p.Connection);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void RemoveAllFromPlayer(int playerPedId)
|
|
{
|
|
foreach (SyncedPed p in PedsByID.Values.ToArray())
|
|
{
|
|
if (p.OwnerID==playerPedId)
|
|
{
|
|
RemovePed(p.ID);
|
|
}
|
|
}
|
|
|
|
foreach (SyncedVehicle v in VehiclesByID.Values.ToArray())
|
|
{
|
|
if (v.OwnerID==playerPedId)
|
|
{
|
|
RemoveVehicle(v.ID);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int RequestNewID()
|
|
{
|
|
int ID = 0;
|
|
while ((ID==0) || PedsByID.ContainsKey(ID) || VehiclesByID.ContainsKey(ID) || ProjectilesByID.ContainsKey(ID))
|
|
{
|
|
byte[] rngBytes = new byte[4];
|
|
|
|
RandomNumberGenerator.Create().GetBytes(rngBytes);
|
|
|
|
// Convert the bytes into an integer
|
|
ID = BitConverter.ToInt32(rngBytes, 0);
|
|
}
|
|
return ID;
|
|
}
|
|
private static void SetBudget(int b)
|
|
{
|
|
Function.Call(Hash.SET_PED_POPULATION_BUDGET, b); // 0 - 3
|
|
Function.Call(Hash.SET_VEHICLE_POPULATION_BUDGET, b); // 0 - 3
|
|
}
|
|
public static string DumpDebug()
|
|
{
|
|
return $"\nID_Peds: {PedsByID.Count}" +
|
|
$"\nHandle_Peds: {PedsByHandle.Count}" +
|
|
$"\nID_Vehicles: {VehiclesByID.Count}" +
|
|
$"\nHandle_vehicles: {VehiclesByHandle.Count}" +
|
|
$"\nID_Projectiles: {ProjectilesByID.Count}" +
|
|
$"\nHandle_Projectiles: {ProjectilesByHandle.Count}" +
|
|
$"\npedStatesPerFrame: {pedStatesPerFrame}" +
|
|
$"\nvehStatesPerFrame: {vehStatesPerFrame}";
|
|
}
|
|
public static class ThreadSafe
|
|
{
|
|
public static void Add(SyncedVehicle v)
|
|
{
|
|
lock (EntityPool.VehiclesLock)
|
|
{
|
|
EntityPool.Add(v);
|
|
}
|
|
}
|
|
public static void Add(SyncedPed p)
|
|
{
|
|
lock (EntityPool.PedsLock)
|
|
{
|
|
EntityPool.Add(p);
|
|
}
|
|
}
|
|
public static void Add(SyncedProjectile sp)
|
|
{
|
|
lock (EntityPool.ProjectilesLock)
|
|
{
|
|
EntityPool.Add(sp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|