public void Run()
{
foreach (int i in _damagedPeds)
{
Ped ped = _damagedPeds.Components1[i].ThisPed;
if (!ped.Exists())
{
continue;
}
EcsEntity pedEntity = _damagedPeds.Entities[i];
if (!ped.IsWearingHelmet)
{
#if DEBUG
_logger.MakeLog($"{pedEntity.GetEntityName()} doesn't have helmet");
#endif
continue;
}
EcsEntity bodyPartEntity = _damagedPeds.Components2[i].DamagedBodyPartEntity;
var bodyArmor = _ecsWorld.GetComponent <BodyPartArmorComponent>(bodyPartEntity);
if (bodyArmor == null || !bodyArmor.ProtectedByHelmet)
{
#if DEBUG
string partName = bodyPartEntity.GetEntityName();
_logger.MakeLog($"Helmet of {pedEntity.GetEntityName()} doesn't protect {partName}");
#endif
continue;
}
EcsEntity weaponEntity = _damagedPeds.Components3[i].WeaponEntity;
var weaponStats = _ecsWorld.GetComponent <ArmorWeaponStatsComponent>(weaponEntity);
if (weaponStats == null)
{
#if DEBUG
_logger.MakeLog($"Weapon {weaponEntity.GetEntityName()} doesn't have {nameof(ArmorWeaponStatsComponent)}");
#endif
continue;
}
float chance = weaponStats.ChanceToPenetrateHelmet;
bool helmetPenetrated = _random.IsTrueWithProbability(chance);
if (!helmetPenetrated)
{
#if DEBUG
_logger.MakeLog($"Helmet of {pedEntity.GetEntityName()} was not penetrated, " +
$"when chance was {chance:0.00}");
#endif
_ecsWorld.RemoveComponent <DamagedByWeaponComponent>(pedEntity);
_ecsWorld.RemoveComponent <DamagedBodyPartComponent>(pedEntity);
continue;
}
#if DEBUG
_logger.MakeLog($"Helmet of {pedEntity.GetEntityName()} was penetrated, when chance was {chance:0.00}");
#endif
}
}
public void Run()
{
if (_playerConfig.EntitiesCount <= 0)
{
throw new Exception("Player system was not init!");
}
var config = _playerConfig.Components1[0];
foreach (int i in _playerPeds)
{
Ped ped = _playerPeds.Components1[i].ThisPed;
int entity = _playerPeds.Entities[i];
if (Game.LocalPlayer.Character.Equals(ped))
{
continue;
}
_ecsWorld.RemoveComponent <PlayerMarkComponent>(entity);
#if DEBUG
_logger.MakeLog($"PlayerMark removed from ped {ped.Name(entity)}, 'cause different characters");
#endif
}
foreach (int i in _newPeds)
{
Ped ped = _newPeds.Components1[i].ThisPed;
int entity = _newPeds.Entities[i];
if (!ped.IsLocalPlayer)
{
continue;
}
if (config.PlayerEnabled)
{
_ecsWorld.AddComponent <PlayerMarkComponent>(entity);
NativeFunction.Natives.SET_PLAYER_HEALTH_RECHARGE_MULTIPLIER(Game.LocalPlayer, 0f);
#if DEBUG
_logger.MakeLog($"Ped {ped.Name(entity)} was marked as player");
#endif
}
else
{
_ecsWorld.RemoveComponent <NewPedMarkComponent>(entity);
#if DEBUG
_logger.MakeLog($"NewPedMark removed from ped {ped.Name(entity)}, 'cause player is disabled");
#endif
}
}
_ecsWorld.ProcessDelayedUpdates();
if (config.PlayerEnabled && _playerPeds.EntitiesCount <= 0)
{
_ecsWorld.CreateEntityWith <ForceCreateGswPedEvent>().TargetPed = Game.LocalPlayer.Character;
}
}
public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(HitCleanSystem);
#endif
for (int i = 0; i < _requestsToClean.EntitiesCount; i++)
{
int pedEntity = _requestsToClean.Components1[i].Entity;
var ped = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity).ThisPed;
if (ped != null)
{
Function.Call(Hash.CLEAR_PED_LAST_WEAPON_DAMAGE, ped);
Function.Call(Hash.CLEAR_PED_LAST_DAMAGE_BONE, ped);
}
_ecsWorld.RemoveEntity(_requestsToClean.Entities[i]);
}
for (int i = 0; i < _peds.EntitiesCount; i++)
{
_ecsWorld.RemoveComponent <HaveDamageMarkComponent>(_peds.Entities[i]);
}
}
public void Run()
{
foreach (int i in _pedsToRemove)
{
PedBleedingInfoComponent info = _pedsToRemove.Components1[i];
EcsEntity pedEntity = _pedsToRemove.Entities[i];
foreach (EcsEntity entity in info.BleedingEntities)
{
_ecsWorld.RemoveEntity(entity);
}
_ecsWorld.RemoveComponent <PedBleedingInfoComponent>(pedEntity);
}
_ecsWorld.ProcessDelayedUpdates();
foreach (int i in _healedEntities)
{
PedBleedingInfoComponent info = _healedEntities.Components1[i];
foreach (EcsEntity bleedingEntity in info.BleedingEntities)
{
if (!_ecsWorld.IsEntityExists(bleedingEntity))
{
continue;
}
_ecsWorld.RemoveEntity(bleedingEntity);
}
}
}
private void RemovePeds()
{
for (var pedIndex = 0; pedIndex < _npcs.EntitiesCount; pedIndex++)
{
var woundedPed = _npcs.Components1[pedIndex];
if (woundedPed.IsPlayer)
{
return;
}
var ped = woundedPed.ThisPed;
if (ped.IsAlive && !OutRemoveRange(ped))
{
continue;
}
_world.Data.GswPeds.Remove(ped);
woundedPed.ThisPed = null;
_ecsWorld.RemoveComponent <PainComponent>(_npcs.Entities[pedIndex], true);
_ecsWorld.RemoveEntity(_npcs.Entities[pedIndex]);
#if DEBUG
ped.AttachedBlip.Delete();
#endif
}
}
protected override void ProcessWound(Ped ped, EcsEntity pedEntity, EcsEntity woundEntity)
{
var permanent = EcsWorld.GetComponent <PermanentRagdollComponent>(pedEntity);
var enable = EcsWorld.GetComponent <EnableRagdollComponent>(woundEntity);
if (permanent == null && enable != null)
{
if (enable.Permanent)
{
var create = EcsWorld.EnsureComponent <CreatePermanentRagdollComponent>(pedEntity, out _);
create.DisableOnlyOnHeal = enable.DisableOnlyOnHeal;
create.Type = enable.Type;
}
else
{
int length = enable.LengthInMs;
NativeFunction
.Natives
.SET_PED_TO_RAGDOLL(ped, length, length, enable.Type, 0, 0, 0);
#if DEBUG
Logger.MakeLog($"{pedEntity.GetEntityName()} got ragdoll for {length} ms");
#endif
}
}
var disable = EcsWorld.GetComponent <DisablePermanentRagdollComponent>(woundEntity);
if (permanent != null && !permanent.DisableOnlyOnHeal && disable != null)
{
NativeFunction.Natives.SET_PED_TO_RAGDOLL(ped, 1, 1, 1, 0, 0, 0);
EcsWorld.RemoveComponent <PermanentRagdollComponent>(pedEntity);
#if DEBUG
Logger.MakeLog($"{pedEntity.GetEntityName()} was restored from permanent ragdoll");
#endif
}
}
public void OnPointerUp(PointerEventData eventData)
{
captured = false;
ToggleCapture(captured);
DuplicatePlayer();
for (int i = 0; i < frameSelectionFilter.EntitiesCount; i++)
{
var entity = frameSelectionFilter.Entities[i];
world.RemoveComponent <FrameSelection>(entity);
var replay = world.AddComponent <Replay>(entity);
replay.startFrame = frameSelectionFilter.Components1[i].frame;
releasedFrame = Time.frameCount - replay.startFrame;
replay.currentFrame = releasedFrame;
}
}
public void Run()
{
foreach (int i in _damagedPeds)
{
DamagedByWeaponComponent damagedComponent = _damagedPeds.Components1[i];
EcsEntity weaponEntity = damagedComponent.WeaponEntity;
EcsEntity pedEntity = _damagedPeds.Entities[i];
var woundRandomizer = _ecsWorld.GetComponent <WoundRandomizerComponent>(weaponEntity);
if (woundRandomizer == null || woundRandomizer.WoundRandomizer.Count <= 0)
{
_logger.MakeLog($"!!!WARNING!!! Weapon {weaponEntity.GetEntityName()} " +
$"doesn't have {nameof(WoundRandomizerComponent)}");
_ecsWorld.RemoveComponent <DamagedByWeaponComponent>(pedEntity);
continue;
}
EcsEntity woundEntity = woundRandomizer.WoundRandomizer.NextWithReplacement();
damagedComponent.MainWoundEntity = woundEntity;
var wounded = _ecsWorld.EnsureComponent <WoundedComponent>(pedEntity, out _);
wounded.WoundEntities.Add(woundEntity);
#if DEBUG
_logger.MakeLog($"{pedEntity.GetEntityName()} have got wound {woundEntity.GetEntityName()}");
#endif
}
}
public void Run()
{
if (_notifications.IsEmpty() || _gameService.GameIsPaused)
{
return;
}
float delta = GswExtensions.GetDeltaTime();
NotificationSettingsComponent settings = _settings.Components1[0];
if (settings.CombineToOne)
{
string finalMessage = "";
foreach (int i in _notifications)
{
NotificationComponent notification = _notifications.Components1[i];
notification.Delay -= delta;
if (notification.Delay <= 0)
{
finalMessage += notification.Message + "~n~";
_ecsWorld.RemoveComponent <NotificationComponent>(_notifications.Entities[i]);
}
}
if (!string.IsNullOrEmpty(finalMessage))
{
Game.DisplayNotification(finalMessage);
}
}
else
{
foreach (int i in _notifications)
{
NotificationComponent notification = _notifications.Components1[i];
notification.Delay -= delta;
if (notification.Delay <= 0)
{
if (!string.IsNullOrEmpty(notification.Message))
{
Game.DisplayNotification(notification.Message);
}
_ecsWorld.RemoveComponent <NotificationComponent>(_notifications.Entities[i]);
}
}
}
}
sealed protected override void RunReactive()
{
foreach (var i in _reactiveFilter)
{
_world.RemoveComponent <EcsUpdateReactiveFlag <Inc1> > (_reactiveFilter.Entities[i]);
}
RunUpdateReactive();
}
public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(PlayerSystem);
#endif
if (!_config.Data.PlayerConfig.WoundedPlayerEnabled)
{
return;
}
for (var i = 0; i < _players.EntitiesCount; i++)
{
var woundedPed = _players.Components1[i];
var playerEntity = _players.Entities[i];
if (!woundedPed.ThisPed.Position.Equals(Game.Player.Character.Position))
{
SwitchGswPed(Game.Player.Character, woundedPed, playerEntity);
}
var pedHealth = woundedPed.PedHealth;
if (pedHealth > _config.Data.PlayerConfig.MaximalHealth)
{
_ecsWorld.CreateEntityWith <InstantHealEvent>().Entity = playerEntity;
}
else if (pedHealth < _config.Data.PlayerConfig.MinimalHealth && !woundedPed.IsDead)
{
woundedPed.Health = pedHealth;
woundedPed.IsDead = true;
Game.Player.WantedLevel = 0;
Game.Player.IgnoredByEveryone = false;
Function.Call(Hash.ANIMPOSTFX_STOP_ALL);
var ragdollEvent = _ecsWorld.CreateEntityWith <SetPedToRagdollEvent>();
ragdollEvent.RagdollState = RagdollStates.PERMANENT;
ragdollEvent.Entity = playerEntity;
_ecsWorld.RemoveComponent <PainComponent>(_players.Entities[i], true);
_ecsWorld.CreateEntityWith <ShowHealthStateEvent>().Entity = playerEntity;
}
}
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
var permanent = EcsWorld.GetComponent <PermanentFacialAnimationComponent>(pedEntity);
if (permanent == null)
{
return;
}
EcsWorld.RemoveComponent <PermanentFacialAnimationComponent>(pedEntity);
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
if (!isPlayer)
{
return;
}
NativeFunction.Natives.xB4EDDC19532BFB85();
EcsWorld.RemoveComponent <MainScreenEffectComponent>(pedEntity, true);
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
if (!isPlayer)
{
return;
}
NativeFunction.Natives.STOP_GAMEPLAY_CAM_SHAKING(true);
EcsWorld.RemoveComponent <PermanentCameraShakeComponent>(pedEntity, true);
}
void IEcsRunSystem.Run()
{
foreach (var resEntity in _resFilter.Entities)
{
var res = _world.GetComponent <ResComponent>(resEntity, _resId);
if (res.type == ResType.none)
{
_world.RemoveComponent <ResViewComponent>(resEntity, _viewId);
_world.RemoveComponent <ResMoveComponent>(resEntity, _moveId);
}
}
foreach (var moveEntity in _moveFilter.Entities)
{
var move = _world.GetComponent <ResMoveComponent>(moveEntity, _moveId);
if (move.curcycle > move.cyclemove)
{
_world.RemoveComponent <ResMoveComponent>(moveEntity, _moveId);
}
}
}
public void Run()
{
foreach (int i in _pedsToRemove)
{
BleedingInfoComponent info = _pedsToRemove.Components1[i];
int pedEntity = _pedsToRemove.Entities[i];
foreach (int entity in info.BleedingEntities)
{
_ecsWorld.RemoveEntity(entity);
}
_ecsWorld.RemoveComponent <BleedingInfoComponent>(pedEntity);
}
}
protected override void ProcessReceivedComponent(ReceivedNetworkComponentEvent received)
{
TComponent oldComponent;
long networkEntity = received.NetworkEntityUid;
bool localEntityExist = NetworkConfig.Data.NetworkEntitiesToLocal.ContainsKey(networkEntity);
int localEntity;
bool componentWasRemoved = received.ComponentFlags.HasFlag(EcsNetComponentFlags.WAS_REMOVED);
if (componentWasRemoved && !localEntityExist)
{
#if DEBUG
throw new Exception(string.Format("Attempt to remove {0} for non exist local entity", typeof(TComponent).Name));
#endif
return;
}
if (localEntityExist)
{
localEntity = NetworkConfig.Data.NetworkEntitiesToLocal[received.NetworkEntityUid];
bool isNew;
oldComponent = EcsWorld.EnsureComponent <TComponent>(localEntity, out isNew);
}
else
{
localEntity = EcsWorld.CreateEntityWith(out oldComponent);
EcsWorld.CreateEntityWith <NewEntityReceivedEvent>().LocalEntity = localEntity;
AddNetworkToLocalEntity(received.NetworkEntityUid, localEntity);
}
if (componentWasRemoved)
{
EcsWorld.RemoveComponent <TComponent>(localEntity);
if (EcsWorld.IsEntityExists(localEntity))
{
return;
}
RemoveNetworkToLocalEntity(networkEntity, localEntity);
}
else
{
var newComponent =
NetworkConfig.Data.Serializator.GetComponentFromBytes <TComponent>(received.ComponentBytes);
NewToOldConverter(newComponent, oldComponent);
}
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
var disabled = EcsWorld.GetComponent <DisabledVehicleControlComponent>(pedEntity);
if (disabled == null)
{
return;
}
EcsWorld.RemoveComponent <DisabledVehicleControlComponent>(pedEntity);
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
if (!isPlayer)
{
ped.BlockPermanentEvents = false;
}
}
protected override void PreExecuteActions()
{
foreach (int i in _needRagdollPeds)
{
Ped ped = _needRagdollPeds.Components1[i].ThisPed;
EcsEntity pedEntity = _needRagdollPeds.Entities[i];
if (!ped.Exists() || EcsWorld.GetComponent <PermanentRagdollComponent>(pedEntity) != null)
{
EcsWorld.RemoveComponent <CreatePermanentRagdollComponent>(pedEntity);
continue;
}
if (ped.IsRagdoll)
{
continue;
}
CreatePermanentRagdollComponent createRagdoll = _needRagdollPeds.Components2[i];
NativeFunction.Natives.SET_PED_TO_RAGDOLL(ped, -1, -1, createRagdoll.Type, 0, 0, 0);
var permanentRagdoll = EcsWorld.EnsureComponent <PermanentRagdollComponent>(pedEntity, out _);
permanentRagdoll.DisableOnlyOnHeal = createRagdoll.DisableOnlyOnHeal;
permanentRagdoll.Type = createRagdoll.Type;
EcsWorld.RemoveComponent <CreatePermanentRagdollComponent>(pedEntity);
#if DEBUG
Logger.MakeLog($"{pedEntity.GetEntityName()} have got permanent ragdoll");
#endif
}
foreach (int i in _permanentRagdollPeds)
{
Ped ped = _permanentRagdollPeds.Components1[i].ThisPed;
if (!ped.Exists() || ped.IsRagdoll)
{
continue;
}
PermanentRagdollComponent ragdoll = _permanentRagdollPeds.Components2[i];
NativeFunction.Natives.SET_PED_TO_RAGDOLL(ped, -1, -1, ragdoll.Type, 0, 0, 0);
}
}
protected override void ProcessWound(Ped ped, EcsEntity pedEntity, EcsEntity woundEntity)
{
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
var disabled = EcsWorld.GetComponent <DisabledVehicleControlComponent>(pedEntity);
var disable = EcsWorld.GetComponent <DisableVehicleControlComponent>(woundEntity);
if (disable != null && ped.CurrentVehicle.Exists())
{
if (disabled == null)
{
EcsWorld
.AddComponent <DisabledVehicleControlComponent>(pedEntity)
.EnableOnlyOnHeal = disable.EnableOnlyOnHeal;
if (!isPlayer)
{
ped.Tasks.Clear();
ped.BlockPermanentEvents = true;
ped.Tasks.PerformDrivingManeuver(VehicleManeuver.Wait);
}
}
else
{
disabled.EnableOnlyOnHeal |= disable.EnableOnlyOnHeal;
}
}
var enable = EcsWorld.GetComponent <EnableVehicleControlComponent>(woundEntity);
if (disabled == null || disabled.EnableOnlyOnHeal || enable == null)
{
return;
}
EcsWorld.RemoveComponent <DisabledVehicleControlComponent>(pedEntity);
if (!isPlayer)
{
ped.BlockPermanentEvents = false;
}
}
protected override void ProcessWound(Ped ped, EcsEntity pedEntity, EcsEntity woundEntity)
{
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
if (!isPlayer)
{
return;
}
var mainEffect = EcsWorld.GetComponent <MainScreenEffectComponent>(pedEntity);
var start = EcsWorld.GetComponent <StartScreenEffectComponent>(woundEntity);
if (start != null)
{
if (mainEffect != null && (!start.Main || mainEffect.Name.Equals(start.Name)))
{
return;
}
NativeFunction.Natives.x2206BF9A37B7F724(start.Name, start.Duration, start.Loop);
EcsWorld.EnsureComponent <MainScreenEffectComponent>(pedEntity, out _).Name = start.Name;
#if DEBUG
Logger.MakeLog($"Start Effect {start.Name}, duration {start.Duration}, loop {start.Loop}");
#endif
}
var stop = EcsWorld.GetComponent <StopScreenEffectComponent>(woundEntity);
if (stop != null)
{
NativeFunction.Natives.x068E835A1D0DC0E3(stop.Name);
if (mainEffect != null && mainEffect.Name.Equals(stop.Name))
{
EcsWorld.RemoveComponent <MainScreenEffectComponent>(pedEntity);
}
#if DEBUG
Logger.MakeLog($"Stop Effect {stop.Name}");
#endif
}
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
var permanentRate = EcsWorld.GetComponent <PermanentMovementRateComponent>(pedEntity);
if (permanentRate != null)
{
NativeFunction.Natives.SET_PED_MOVE_RATE_OVERRIDE(ped, 1.0f);
EcsWorld.RemoveComponent <PermanentMovementRateComponent>(pedEntity);
#if DEBUG
Logger.MakeLog($"Permanent move rate for {pedEntity.GetEntityName()} was reset");
#endif
}
var player = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity);
if (player == null)
{
return;
}
NativeFunction.Natives.SET_PLAYER_SPRINT(Game.LocalPlayer, true);
EcsWorld.RemoveComponent <PermanentDisabledSprintComponent>(pedEntity, true);
}
protected override void ProcessWound(Ped ped, EcsEntity pedEntity, EcsEntity woundEntity)
{
var enable = EcsWorld.GetComponent <EnableFacialAnimationComponent>(woundEntity);
if (enable != null)
{
string animationName = _random.NextFromList(enable.Animations);
string dict = ped.IsMale
? enable.MaleDict
: enable.FemaleDict;
if (enable.Permanent)
{
var permanent = EcsWorld.EnsureComponent <PermanentFacialAnimationComponent>(pedEntity, out _);
permanent.Name = animationName;
permanent.Dict = dict;
#if DEBUG
Logger.MakeLog($"{pedEntity.GetEntityName()} got permanent facial animation {animationName}");
#endif
}
else
{
NativeFunction.Natives.PLAY_FACIAL_ANIM(ped, animationName, dict);
#if DEBUG
Logger.MakeLog($"{pedEntity.GetEntityName()} got short facial animation {animationName}");
#endif
}
}
var disable = EcsWorld.GetComponent <DisableFacialAnimationComponent>(woundEntity);
if (disable != null)
{
EcsWorld.RemoveComponent <PermanentFacialAnimationComponent>(pedEntity, true);
#if DEBUG
Logger.MakeLog($"{pedEntity.GetEntityName()} clean facial animation");
#endif
}
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
if (!ped.IsRagdoll)
{
return;
}
NativeFunction.Natives.SET_PED_TO_RAGDOLL(ped, 1, 1, 1, 0, 0, 0);
#if DEBUG
Logger.MakeLog($"{pedEntity.GetEntityName()} was restored from ragdoll");
#endif
var permanent = EcsWorld.GetComponent <PermanentRagdollComponent>(pedEntity);
if (permanent == null)
{
return;
}
EcsWorld.RemoveComponent <PermanentRagdollComponent>(pedEntity);
#if DEBUG
Logger.MakeLog($"{pedEntity.GetEntityName()} was restored from permanent ragdoll");
#endif
}
public void Run()
{
for (var i = 0; i < _requestEvents.EntitiesCount; i++)
{
var pedEntity = _requestEvents.Components1[i].Entity;
if (!_ecsWorld.IsEntityExists(pedEntity))
{
continue;
}
var woundedPed = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed?.MostDangerBleedingEntity == null)
{
continue;
}
if (woundedPed.InPermanentRagdoll)
{
continue;
}
var progress = _ecsWorld.EnsureComponent <BandageInProgressComponent>(pedEntity, out var isNew);
if (!isNew)
{
SendMessage(_localeConfig.Data.AlreadyBandaging, pedEntity);
continue;
}
if (woundedPed.IsPlayer)
{
if (Game.Player.Money < _config.Data.WoundConfig.BandageCost)
{
SendMessage(_localeConfig.Data.DontHaveMoneyForBandage, pedEntity);
continue;
}
Game.Player.Money -= _config.Data.WoundConfig.BandageCost;
}
var timeToBandage = _config.Data.WoundConfig.ApplyBandageTime;
progress.EstimateTime = timeToBandage;
SendMessage(string.Format(_localeConfig.Data.YouTryToBandage, timeToBandage.ToString("F1")), pedEntity);
}
_requestEvents.CleanFilter();
var frameTimeInSec = Game.LastFrameTime;
for (var i = 0; i < _pedsWithBandageInProgress.EntitiesCount; i++)
{
var woundedPed = _pedsWithBandageInProgress.Components1[i];
var thisPed = woundedPed.ThisPed;
var progress = _pedsWithBandageInProgress.Components2[i];
var pedEntity = _pedsWithBandageInProgress.Entities[i];
if (woundedPed.InPermanentRagdoll || thisPed.IsWalking || thisPed.IsRunning ||
thisPed.IsSprinting || thisPed.IsShooting || thisPed.IsRagdoll ||
thisPed.IsJumping || thisPed.IsReloading || thisPed.IsSwimming)
{
SendMessage($"~r~{_localeConfig.Data.BandageFailed}", pedEntity);
_ecsWorld.RemoveComponent <BandageInProgressComponent>(pedEntity);
continue;
}
progress.EstimateTime -= frameTimeInSec;
if (progress.EstimateTime > 0)
{
continue;
}
_ecsWorld.RemoveComponent <BandageInProgressComponent>(pedEntity);
_ecsWorld.CreateEntityWith <SuccessfulBandageEvent>().Entity = pedEntity;
}
for (var i = 0; i < _successfulEvents.EntitiesCount; i++)
{
var pedEntity = _successfulEvents.Components1[i].Entity;
if (!_ecsWorld.IsEntityExists(pedEntity))
{
continue;
}
var woundedPed = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed?.MostDangerBleedingEntity == null)
{
continue;
}
var bleedingEntity = woundedPed.MostDangerBleedingEntity.Value;
if (!_ecsWorld.IsEntityExists(bleedingEntity))
{
continue;
}
var bleeding = _ecsWorld.GetComponent <BleedingComponent>(woundedPed.MostDangerBleedingEntity.Value);
if (bleeding == null)
{
continue;
}
bleeding.BleedSeverity = bleeding.BleedSeverity / 2;
UpdateMostDangerWound(woundedPed, pedEntity);
SendMessage(string.Format("~g~" + _localeConfig.Data.BandageSuccess, bleeding.Name), pedEntity);
}
_successfulEvents.CleanFilter();
}
public void Run()
{
GhostConfigComponent ghostConfig = _ghostConfig.Components1[0];
WorldComponent world = _world.Components1[0];
if (_enableEvents.EntitiesCount > 0)
{
foreach (int i in _ghosts)
{
GameObject ghost = _ghosts.Components2[i].Transform.gameObject;
int ghostEntity = _ghosts.Entities[i];
bool isNew;
_ecsWorld
.EnsureComponent <GhostInFearStateComponent>(ghostEntity, out isNew)
.EstimateTime = ghostConfig.FearStateInSec;
if (isNew)
{
ghost.GetComponent <MeshRenderer>().material.color = ghostConfig.FearState;
}
}
}
foreach (int i in _fearStateGhosts)
{
GhostComponent ghostComponent = _fearStateGhosts.Components1[i];
GhostInFearStateComponent fearState = _fearStateGhosts.Components2[i];
GameObject ghost = _fearStateGhosts.Components3[i].Transform.gameObject;
int ghostEntity = _fearStateGhosts.Entities[i];
fearState.EstimateTime -= Time.deltaTime;
if (fearState.EstimateTime <= 0)
{
_ecsWorld.RemoveComponent <GhostInFearStateComponent>(ghostEntity);
var material = ghost.GetComponent <MeshRenderer>().material;
switch (ghostComponent.GhostType)
{
case GhostTypes.BLINKY:
material.color = ghostConfig.Blinky;
break;
case GhostTypes.PINKY:
material.color = ghostConfig.Pinky;
break;
case GhostTypes.INKY:
material.color = ghostConfig.Inky;
break;
case GhostTypes.CLYDE:
material.color = ghostConfig.Clyde;
break;
default:
throw new ArgumentOutOfRangeException();
}
return;
}
Vector2Int currentPosition = _ecsWorld.GetComponent <PositionComponent>(ghostEntity).Position;
foreach (int entity in world.WorldField[currentPosition.x][currentPosition.y])
{
var player = _ecsWorld.GetComponent <PlayerComponent>(entity);
if (player == null)
{
continue;
}
player.Scores += ghostConfig.ScoresPerGhost;
_ecsWorld.CreateEntityWith <UpdateScoreTableEvent>();
_ecsWorld.AddComponent <DestroyedWorldObjectComponent>(ghostEntity);
}
}
}
public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(PainRecoverySystem);
#endif
float frameTimeInSeconds = Game.LastFrameTime;
for (int i = 0; i < _pedsWithPain.EntitiesCount; i++)
{
WoundedPedComponent woundedPed = _pedsWithPain.Components1[i];
PainComponent pain = _pedsWithPain.Components2[i];
int pedEntity = _pedsWithPain.Entities[i];
if (pain.CurrentPain <= 0f || woundedPed.IsDead)
{
_ecsWorld.RemoveComponent <PainComponent>(pedEntity, true);
continue;
}
pain.CurrentPain -= woundedPed.PainRecoverSpeed * frameTimeInSeconds;
var painPercent = pain.CurrentPain / woundedPed.MaximalPain;
var backPercent = painPercent > 1
? 0
: 1 - painPercent;
if (painPercent > 3f)
{
if (woundedPed.PainState == PainStates.DEADLY)
{
continue;
}
_ecsWorld.CreateEntityWith(out DeadlyPainChangeStateEvent deadlyPainEvent);
deadlyPainEvent.Entity = pedEntity;
deadlyPainEvent.ForceUpdate = false;
}
else if (painPercent > 1f)
{
if (woundedPed.IsMale)
{
Function.Call(Hash.PLAY_FACIAL_ANIM, woundedPed.ThisPed, "dead_1", "facials@gen_male@base");
}
else
{
Function.Call(Hash.PLAY_FACIAL_ANIM, woundedPed.ThisPed, "dead_1", "facials@gen_female@base");
}
if (woundedPed.PainState == PainStates.UNBEARABLE)
{
continue;
}
_ecsWorld.CreateEntityWith(out UnbearablePainChangeStateEvent unbearablePainEvent);
unbearablePainEvent.Entity = pedEntity;
unbearablePainEvent.ForceUpdate = false;
}
else if (painPercent > 0.8f)
{
if (woundedPed.IsMale)
{
Function.Call(Hash.PLAY_FACIAL_ANIM, woundedPed.ThisPed, "mood_injured_1", "facials@gen_male@base");
}
else
{
Function.Call(Hash.PLAY_FACIAL_ANIM, woundedPed.ThisPed, "mood_injured_1", "facials@gen_female@base");
}
if (woundedPed.PainState == PainStates.INTENSE)
{
continue;
}
_ecsWorld.CreateEntityWith(out IntensePainChangeStateEvent intensePainEvent);
intensePainEvent.Entity = pedEntity;
intensePainEvent.ForceUpdate = false;
}
else if (painPercent > 0.3f)
{
if (woundedPed.PainState == PainStates.AVERAGE)
{
continue;
}
_ecsWorld.CreateEntityWith(out AveragePainChangeStateEvent averagePainEvent);
averagePainEvent.Entity = pedEntity;
averagePainEvent.ForceUpdate = false;
}
else if (painPercent > 0.01f)
{
if (woundedPed.PainState == PainStates.MILD)
{
continue;
}
_ecsWorld.CreateEntityWith(out MildPainChangeStateEvent mildPainEvent);
mildPainEvent.Entity = pedEntity;
mildPainEvent.ForceUpdate = false;
}
else
{
if (woundedPed.PainState == PainStates.NONE)
{
continue;
}
_ecsWorld.CreateEntityWith(out NoPainChangeStateEvent noPainEvent);
noPainEvent.Entity = pedEntity;
noPainEvent.ForceUpdate = false;
if (!_config.Data.PlayerConfig.CameraIsShaking)
{
Function.Call(Hash._SET_CAM_EFFECT, 0);
Function.Call(Hash._STOP_ALL_SCREEN_EFFECTS);
}
}
if (woundedPed.Crits.HasFlag(CritTypes.LEGS_DAMAGED))
{
continue;
}
var adjustable = 1f - _config.Data.WoundConfig.MoveRateOnFullPain;
var moveRate = 1f - adjustable * backPercent;
Function.Call(Hash.SET_PED_MOVE_RATE_OVERRIDE, woundedPed.ThisPed, moveRate);
}
}
public void Run()
{
foreach (int i in _pedsWithArmor)
{
GswPedComponent gswPed = _pedsWithArmor.Components1[i];
PedArmorComponent armor = _pedsWithArmor.Components2[i];
Ped ped = gswPed.ThisPed;
if (!ped.Exists())
{
continue;
}
if (ped.Armor > armor.Armor)
{
armor.Armor = ped.Armor;
}
#if DEBUG
if (armor.Armor <= 0)
{
continue;
}
Vector3 position = ped.AbovePosition;
float maxArmor = ped.IsLocalPlayer
? NativeFunction.Natives.GET_PLAYER_MAX_ARMOUR <int>(Game.LocalPlayer)
: 100;
Debug.DrawWireBoxDebug(position, ped.Orientation, new Vector3(1.05f, 0.15f, 0.1f), Color.LightSkyBlue);
Debug.DrawWireBoxDebug(position, ped.Orientation, new Vector3(armor.Armor / maxArmor, 0.1f, 0.1f), Color.MediumBlue);
#endif
}
foreach (int i in _damagedPedsWithArmor)
{
GswPedComponent gswPed = _damagedPedsWithArmor.Components1[i];
PedArmorComponent armor = _damagedPedsWithArmor.Components4[i];
Ped ped = gswPed.ThisPed;
if (!ped.Exists())
{
continue;
}
EcsEntity pedEntity = _damagedPedsWithArmor.Entities[i];
if (armor.Armor <= 0)
{
#if DEBUG
_logger.MakeLog($"{pedEntity.GetEntityName()} doesn't have armor");
#endif
ped.Armor = armor.Armor;
continue;
}
EcsEntity bodyPartEntity = _damagedPedsWithArmor.Components2[i].DamagedBodyPartEntity;
var bodyArmor = _ecsWorld.GetComponent <BodyPartArmorComponent>(bodyPartEntity);
if (bodyArmor == null || !bodyArmor.ProtectedByBodyArmor)
{
#if DEBUG
var partName = bodyPartEntity.GetEntityName();
_logger.MakeLog($"{partName} of {pedEntity.GetEntityName()} is not protected by armor");
#endif
ped.Armor = armor.Armor;
continue;
}
EcsEntity weaponEntity = _damagedPedsWithArmor.Components3[i].WeaponEntity;
var weaponStats = _ecsWorld.GetComponent <ArmorWeaponStatsComponent>(weaponEntity);
if (weaponStats == null)
{
#if DEBUG
_logger.MakeLog($"Weapon {weaponEntity.GetEntityName()} " +
$"doesn't have {nameof(ArmorWeaponStatsComponent)}");
#endif
ped.Armor = armor.Armor;
continue;
}
armor.Armor -= weaponStats.ArmorDamage;
var newPain = _ecsWorld.EnsureComponent <AdditionalPainComponent>(pedEntity, out bool _);
newPain.AdditionalPain = weaponStats.ArmorDamage;
#if DEBUG
_logger.MakeLog($"Added pain {newPain.AdditionalPain:0.00} " +
$"by armor hit for {pedEntity.GetEntityName()}");
#endif
if (armor.Armor <= 0)
{
#if DEBUG
_logger.MakeLog($"Armor of {pedEntity.GetEntityName()} was destroyed");
#endif
ped.Armor = armor.Armor;
continue;
}
float maxArmor = ped.IsLocalPlayer
? NativeFunction.Natives.GET_PLAYER_MAX_ARMOUR <int>(Game.LocalPlayer)
: 100;
float armorPercent = armor.Armor / maxArmor;
if (!weaponStats.CanPenetrateArmor || weaponStats.MinArmorPercentForPenetration < armorPercent)
{
#if DEBUG
_logger.MakeLog($"Armor of {pedEntity.GetEntityName()} was not penetrated");
#endif
_ecsWorld.RemoveComponent <DamagedByWeaponComponent>(pedEntity);
_ecsWorld.RemoveComponent <DamagedBodyPartComponent>(pedEntity);
ped.Armor = armor.Armor;
continue;
}
float chanceToPenetrate = 1 - armorPercent / weaponStats.MinArmorPercentForPenetration;
bool wasPenetrated = _random.IsTrueWithProbability(chanceToPenetrate);
if (!wasPenetrated)
{
#if DEBUG
_logger.MakeLog($"Armor of {pedEntity.GetEntityName()} was not penetrated, " +
$"when chance was {chanceToPenetrate:0.00}");
#endif
_ecsWorld.RemoveComponent <DamagedByWeaponComponent>(pedEntity);
_ecsWorld.RemoveComponent <DamagedBodyPartComponent>(pedEntity);
ped.Armor = armor.Armor;
continue;
}
#if DEBUG
_logger.MakeLog($"Armor of {pedEntity.GetEntityName()} was penetrated, " +
$"when chance was {chanceToPenetrate:0.00}");
#endif
ped.Armor = armor.Armor;
}
}
public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(InstantHealSystem);
#endif
for (var i = 0; i < _events.EntitiesCount; i++)
{
var pedEntity = _events.Components1[i].Entity;
if (!_ecsWorld.IsEntityExists(pedEntity))
{
continue;
}
var woundedPed = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed != null)
{
if (woundedPed.IsPlayer)
{
_ecsWorld.CreateEntityWith <AddCameraShakeEvent>().Length = CameraShakeLength.CLEAR;
Function.Call(Hash.SET_PLAYER_SPRINT, Game.Player, true);
Function.Call(Hash._SET_CAM_EFFECT, 0);
Function.Call(Hash.ANIMPOSTFX_STOP_ALL);
woundedPed.Health = _mainConfig.Data.PlayerConfig.MaximalHealth;
Game.Player.IgnoredByEveryone = false;
}
else
{
woundedPed.Health = GunshotWound2.Random.Next(50, _mainConfig.Data.NpcConfig.MaxStartHealth);
woundedPed.ThisPed.Accuracy = woundedPed.DefaultAccuracy;
}
woundedPed.IsDead = false;
woundedPed.Crits = 0;
woundedPed.PedHealth = woundedPed.Health;
woundedPed.Armor = woundedPed.ThisPed.Armor;
woundedPed.BleedingCount = 0;
woundedPed.MostDangerBleedingEntity = null;
_ecsWorld.RemoveComponent <PainComponent>(pedEntity, true);
Function.Call(Hash.CLEAR_PED_BLOOD_DAMAGE, woundedPed.ThisPed);
Function.Call(Hash.SET_PED_MOVE_RATE_OVERRIDE, woundedPed.ThisPed, 1f);
_ecsWorld.CreateEntityWith(out NoPainChangeStateEvent noPainEvent);
noPainEvent.Entity = pedEntity;
noPainEvent.ForceUpdate = true;
}
for (var bleedIndex = 0; bleedIndex < _bleedingComponents.EntitiesCount; bleedIndex++)
{
if (_bleedingComponents.Components1[bleedIndex].Entity != pedEntity)
{
continue;
}
_ecsWorld.RemoveEntity(_bleedingComponents.Entities[bleedIndex]);
}
}
_events.CleanFilter();
}
public void Run()
{
foreach (int i in _entities)
{
Ped ped = _entities.Components1[i].ThisPed;
if (!ped.Exists())
{
continue;
}
HealthComponent health = _entities.Components2[i];
if (health.Health <= 0)
{
continue;
}
BleedingInfoComponent info = _entities.Components3[i];
int pedEntity = _entities.Entities[i];
float bleedingDamage = 0;
for (int bleedingIndex = info.BleedingEntities.Count - 1; bleedingIndex >= 0; bleedingIndex--)
{
int bleedingEntity = info.BleedingEntities[bleedingIndex];
if (!_ecsWorld.IsEntityExists(bleedingEntity))
{
info.BleedingEntities.RemoveAt(bleedingIndex);
continue;
}
var bleeding = _ecsWorld.GetComponent <BleedingComponent>(bleedingEntity);
if (bleeding == null)
{
info.BleedingEntities.RemoveAt(bleedingIndex);
continue;
}
float delta = GswExtensions.GetDeltaTime();
if (delta <= 0)
{
continue;
}
bleedingDamage += bleeding.Severity * delta;
bleeding.Severity -= info.BleedingHealRate / HEAL_RATE_SLOWER * delta;
if (bleeding.Severity > 0)
{
continue;
}
#if DEBUG
_logger.MakeLog($"Bleeding {bleedingEntity} on Entity ({pedEntity}) was healed");
#endif
_ecsWorld.RemoveComponent <BleedingComponent>(bleedingEntity);
info.BleedingEntities.RemoveAt(bleedingIndex);
}
if (bleedingDamage <= 0)
{
continue;
}
health.Health -= bleedingDamage;
ped.SetHealth(health.Health);
}
}
