public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(BodyHitSystem);
#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)
{
continue;
}
var bodyPart = GetDamagedBodyPart(woundedPed.ThisPed);
var bodyDamage = _ecsWorld.CreateEntityWith <BodyPartWasHitEvent>();
bodyDamage.Entity = pedEntity;
bodyDamage.DamagedPart = bodyPart;
}
}
private void ReceiveConnects()
{
for (int i = 0; i < _connectedClients.EntitiesCount; i++)
{
_connectedClients.Components1[i].ConnectedClient = null;
_ecsWorld.RemoveEntity(_connectedClients.Entities[i]);
}
foreach (ClientInfo clientInfo in _config.Data.EcsNetworkListener.GetConnectedClients())
{
_ecsWorld.CreateEntityWith <ClientConnectedEvent>().ConnectedClient = clientInfo;
}
for (int i = 0; i < _disconnectedClients.EntitiesCount; i++)
{
_disconnectedClients.Components1[i].DisconnectedClient = null;
_ecsWorld.RemoveEntity(_disconnectedClients.Entities[i]);
}
foreach (ClientInfo clientInfo in _config.Data.EcsNetworkListener.GetDisconnectedClients())
{
_ecsWorld.CreateEntityWith <ClientDisconnectedEvent>().DisconnectedClient = clientInfo;
}
for (int i = 0; i < _connectEvents.EntitiesCount; i++)
{
ConnectToEvent connectEvent = _connectEvents.Components1[i];
_config.Data.EcsNetworkListener.Connect(connectEvent.Address, connectEvent.Port);
_ecsWorld.RemoveEntity(_connectEvents.Entities[i]);
}
}
public void Run()
{
GunshotWound2.LastSystem = nameof(BodyHitSystem);
for (int i = 0; i < _requests.EntitiesCount; i++)
{
int pedEntity = _requests.Components1[i].PedEntity;
var woundedPed = _ecsWorld
.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed == null)
{
continue;
}
var bodyPart = GetDamagedBodyPart(woundedPed.ThisPed);
if (bodyPart == BodyParts.NOTHING)
{
continue;
}
var bodyDamage = _ecsWorld.CreateEntityWith <BodyHitComponent>();
bodyDamage.PedEntity = pedEntity;
bodyDamage.DamagedPart = bodyPart;
}
}
public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(DebugInfoSystem);
#endif
for (int i = 0; i < _events.EntitiesCount; i++)
{
#if DEBUG
int pedEntity = _events.Components1[i].Entity;
if (!_ecsWorld.IsEntityExists(pedEntity))
{
continue;
}
var woundedPed = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed == null)
{
continue;
}
SendDebug($"{woundedPed}");
_ecsWorld.CreateEntityWith <ShowHealthStateEvent>().Entity = pedEntity;
#endif
}
_events.RemoveAllEntities();
}
public void Run()
{
for (int i = 0; i < _deathComponents.EntitiesCount; i++)
{
int playerEntity = _deathComponents.Components1[i].PlayerEntity;
var targetPlayer = _ecsWorld.GetComponent <PlayerComponent>(playerEntity);
var deadMoveComponent = _ecsWorld.GetComponent <MoveComponent>(playerEntity);
if (--targetPlayer.Lifes <= 0)
{
targetPlayer.IsDead = true;
if (deadMoveComponent != null)
{
deadMoveComponent.Transform.gameObject.SetActive(false);
}
}
Vector3 respawnVector = targetPlayer.Lifes > 0
? targetPlayer.StartPosition
: Vector3.zero;
var teleportComponent = _ecsWorld.CreateEntityWith <TeleportComponent>();
teleportComponent.MoveEntity = playerEntity;
teleportComponent.TargetPosition = respawnVector;
_ecsWorld.CreateEntityWith <UpdateGuiComponent>();
RemoveEntitiesWith(playerEntity);
}
}
public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(IncreasePainSystem);
#endif
var woundConfig = _config.Data.WoundConfig;
for (var i = 0; i < _events.EntitiesCount; i++)
{
var component = _events.Components1[i];
var pedEntity = component.Entity;
if (!_ecsWorld.IsEntityExists(pedEntity))
{
_ecsWorld.RemoveEntity(_events.Entities[i]);
continue;
}
var woundedPed = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed != null && component.PainAmount > 0f)
{
var pain = _ecsWorld.EnsureComponent <PainComponent>(pedEntity, out var firstPain);
if (firstPain)
{
pain.CurrentPain = 0f;
}
var newPain = component.PainAmount;
var painDeviation = GunshotWound2.Random.NextFloat(
-woundConfig.PainDeviation * newPain,
woundConfig.PainDeviation * newPain);
pain.CurrentPain += woundConfig.PainMultiplier * newPain + painDeviation;
var painAnimIndex = GunshotWound2.Random.Next(1, 6);
PainRecoverySystem.PlayFacialAnim(woundedPed, $"pain_{painAnimIndex.ToString()}");
var painfulWound = woundConfig.PainfulWoundPercent * woundedPed.MaximalPain;
if (woundedPed.IsPlayer && newPain > painfulWound / 2f)
{
_ecsWorld.CreateEntityWith <AddCameraShakeEvent>().Length = CameraShakeLength.ONE_TIME;
}
if (newPain > painfulWound)
{
if (woundConfig.RagdollOnPainfulWound)
{
_ecsWorld.CreateEntityWith(out SetPedToRagdollEvent ragdoll);
ragdoll.Entity = pedEntity;
ragdoll.RagdollState = RagdollStates.SHORT;
}
if (woundedPed.IsPlayer)
{
_ecsWorld.CreateEntityWith <AddFlashEvent>();
}
}
}
_ecsWorld.RemoveEntity(_events.Entities[i]);
}
}
protected void SendMessage(string message, NotifyLevels level = NotifyLevels.COMMON)
{
var notification = EcsWorld.CreateEntityWith <NotificationComponent>();
notification.Level = level;
notification.StringToShow = message;
}
public void Run()
{
for (int i = 0; i < _players.EntitiesCount; i++)
{
int playerNum = _players.Components1[i].Num;
float yAxis = Input.GetAxis(string.Format("Player{0}Y", playerNum));
float xAxis = Input.GetAxis(string.Format("Player{0}X", playerNum));
if (yAxis > 0)
{
SendCommand(Directions.UP, playerNum);
}
else if (yAxis < 0)
{
SendCommand(Directions.DOWN, playerNum);
}
else if (xAxis > 0)
{
SendCommand(Directions.RIGHT, playerNum);
}
else if (xAxis < 0)
{
SendCommand(Directions.LEFT, playerNum);
}
if (Input.GetKeyUp(KeyCode.Escape))
{
_ecsWorld.CreateEntityWith <GameStateComponent>().State = Time.timeScale < 1
? GameStates.START
: GameStates.PAUSE;
}
}
}
private void OnKeyUp(object sender, KeyEventArgs eventArgs)
{
if (_mainConfig.HelmetKey != null && eventArgs.KeyCode == _mainConfig.HelmetKey)
{
_ecsWorld.CreateEntityWith <HelmetRequestComponent>();
return;
}
if (_mainConfig.CheckKey != null && eventArgs.KeyCode == _mainConfig.CheckKey)
{
CheckPlayer();
return;
}
if (_mainConfig.HealKey != null && eventArgs.KeyCode == _mainConfig.HealKey)
{
HealPlayer();
return;
}
switch (eventArgs.KeyCode)
{
case Keys.PageDown:
ReduceRange(5);
break;
case Keys.PageUp:
IncreaseRange(5);
break;
}
}
public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(WoundSystem);
#endif
for (int i = 0; i < _components.EntitiesCount; i++)
{
ProcessWoundEvent component = _components.Components1[i];
int pedEntity = component.Entity;
if (!_ecsWorld.IsEntityExists(pedEntity))
{
continue;
}
var woundedPed = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed == null)
{
continue;
}
float damageDeviation = component.Damage > 0
? _config.Data.WoundConfig.DamageDeviation * component.Damage
: 0;
float bleedingDeviation = component.BleedSeverity > 0
? _config.Data.WoundConfig.BleedingDeviation * component.BleedSeverity
: 0;
if (!woundedPed.IsDead)
{
woundedPed.Health -= _config.Data.WoundConfig.DamageMultiplier * component.Damage +
Random.NextFloat(-damageDeviation, damageDeviation);
woundedPed.ThisPed.Health = (int)woundedPed.Health;
}
CreateBleeding(woundedPed, pedEntity, component.BleedSeverity +
Random.NextFloat(-bleedingDeviation, bleedingDeviation), component.Name);
woundedPed.BleedingCount++;
CreatePain(pedEntity, component.Pain);
CreateCritical(pedEntity, component.Crits);
if (component.ArterySevered)
{
CreateBleeding(woundedPed, pedEntity, 1f, _locale.Data.SeveredArtery);
woundedPed.BleedingCount++;
}
#if DEBUG
_ecsWorld.CreateEntityWith <ShowDebugInfoEvent>().Entity = pedEntity;
#endif
SendWoundInfo(component, woundedPed);
}
_components.RemoveAllEntities();
}
public void Initialize()
{
const string CheckPointTag = "CheckPoint";
foreach (var unityObject in GameObject.FindGameObjectsWithTag(CheckPointTag))
{
var tr = unityObject.transform;
var checkPoint = _world.CreateEntityWith <CheckPoint>();
checkPoint.Coords = tr.localPosition;
}
}
void IEcsInitSystem.Initialize()
{
foreach (var unityObject in GameObject.FindGameObjectsWithTag(FoodTag))
{
var tr = unityObject.transform;
var food = _world.CreateEntityWith <Food> ();
food.Coords.X = (int)tr.localPosition.x;
food.Coords.Y = (int)tr.localPosition.y;
food.Transform = tr;
}
}
public void Initialize()
{
var scoreTables = Object.FindObjectsOfType <ScoreTableBehaviour>();
foreach (ScoreTableBehaviour behaviour in scoreTables)
{
_ecsWorld.CreateEntityWith <ScoreTableComponent>().ScoreText = behaviour.GetComponent <Text>();
}
_ecsWorld.CreateEntityWith <UpdateScoreTableEvent>();
}
public void Initialize()
{
var menus = Object.FindObjectsOfType <PauseMenuBehaviour>();
foreach (PauseMenuBehaviour behaviour in menus)
{
_ecsWorld.CreateEntityWith <PauseMenuComponent>().GameObject = behaviour.gameObject;
}
_ecsWorld.CreateEntityWith <ChangeGameStateEvent>().State = GameStates.START;
}
public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(BaseWeaponHitSystem);
#endif
var config = _config.Data;
for (var i = 0; i < _peds.EntitiesCount; i++)
{
var ped = _peds.Components1[i].ThisPed;
if (!ped.IsAlive)
{
continue;
}
var pedEntity = _peds.Entities[i];
if (CheckDamageAndSendIfNeed <LightImpactHitEvent>(config.LightImpactHashes, ped, pedEntity))
{
continue;
}
if (CheckDamageAndSendIfNeed <CuttingHitEvent>(config.CuttingHashes, ped, pedEntity))
{
continue;
}
if (CheckDamageAndSendIfNeed <HeavyImpactHitEvent>(config.HeavyImpactHashes, ped, pedEntity))
{
continue;
}
if (CheckDamageAndSendIfNeed <SmallCaliberHitEvent>(config.SmallCaliberHashes, ped, pedEntity))
{
continue;
}
if (CheckDamageAndSendIfNeed <ShotgunHitEvent>(config.ShotgunHashes, ped, pedEntity))
{
continue;
}
if (CheckDamageAndSendIfNeed <MediumCaliberHitEvent>(config.MediumCaliberHashes, ped, pedEntity))
{
continue;
}
if (CheckDamageAndSendIfNeed <HighCaliberHitEvent>(config.HighCaliberHashes, ped, pedEntity))
{
continue;
}
if (CheckDamageAndSendIfNeed <ExplosionHitEvent>(config.ExplosiveHashes, ped, pedEntity))
{
continue;
}
_ecsWorld.CreateEntityWith <ShowNotificationEvent>().StringToShow = "~r~Ped damaged by unknown weapon! Please, update weapon hashes.";
}
}
public static void SendComponentToNetwork <TComponent>(this EcsWorld ecsWorld, int entity)
where TComponent : class, new()
{
PrepareComponentToSendEvent <TComponent> prepare;
ecsWorld.CreateEntityWith(out prepare);
prepare.LocalEntityUid = entity;
prepare.ComponentFlags = 0;
#if DEBUG
ecsWorld.CreateEntityWith <PrepareToSendCountEvent>();
#endif
}
protected void SendMessage(string message, NotifyLevels level = NotifyLevels.COMMON)
{
#if !DEBUG
if (level == NotifyLevels.DEBUG)
{
return;
}
#endif
var notification = EcsWorld.CreateEntityWith <ShowNotificationEvent>();
notification.Level = level;
notification.StringToShow = message;
}
public void Run()
{
GunshotWound2.LastSystem = nameof(InstantHealSystem);
for (int i = 0; i < _components.EntitiesCount; i++)
{
int pedEntity = _components.Components1[i].PedEntity;
var woundedPed = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed != null)
{
if (woundedPed.IsPlayer)
{
Function.Call(Hash._SET_CAM_EFFECT, 0);
Function.Call(Hash.SET_PLAYER_SPRINT, Game.Player, true);
Function.Call(Hash._STOP_ALL_SCREEN_EFFECTS);
woundedPed.Health = _mainConfig.Data.PlayerConfig.MaximalHealth;
_ecsWorld.CreateEntityWith <AdrenalineComponent>().Revert = true;
Game.Player.IgnoredByEveryone = false;
}
else
{
woundedPed.Health = _random.Next(50, _mainConfig.Data.NpcConfig.MaximalStartHealth);
woundedPed.ThisPed.Accuracy = woundedPed.DefaultAccuracy;
}
woundedPed.IsDead = false;
woundedPed.DamagedParts = 0;
woundedPed.PainMeter = 0;
Function.Call(Hash.CLEAR_PED_BLOOD_DAMAGE, woundedPed.ThisPed);
Function.Call(Hash.SET_PED_MOVE_RATE_OVERRIDE, woundedPed.ThisPed, 1f);
woundedPed.ThisPed.Health = (int)woundedPed.Health;
woundedPed.Armor = woundedPed.ThisPed.Armor;
_ecsWorld.CreateEntityWith <NoPainStateComponent>().PedEntity = pedEntity;
}
for (int bleedIndex = 0; bleedIndex < _bleedingComponents.EntitiesCount; bleedIndex++)
{
if (_bleedingComponents.Components1[bleedIndex].PedEntity != pedEntity)
{
continue;
}
_ecsWorld.RemoveEntity(_bleedingComponents.Entities[bleedIndex]);
}
_ecsWorld.RemoveEntity(_components.Entities[i]);
}
}
private void OnTriggerEnter2D(Collider2D other)
{
//Debug.Log("TOUCH");
if (other.CompareTag(Utils.BackgroundTag))
{
TriggerBackgroundEvent triggerEvent = _world.CreateEntityWith <TriggerBackgroundEvent>();
triggerEvent.ObstacleTransform = other.transform;
}
else
{
TriggerForegroundEvent triggerEvent = _world.CreateEntityWith <TriggerForegroundEvent>();
triggerEvent.ObstacleTransform = other.transform;
}
}
void IEcsInitSystem.Initialize()
{
foreach (var unityObject in GameObject.FindGameObjectsWithTag(SnakeTag))
{
var tr = unityObject.transform;
var snake = _world.CreateEntityWith <Snake> ();
var head = _world.CreateEntityWith <SnakeSegment> ();
head.Coords.X = (int)tr.localPosition.x;
head.Coords.Y = (int)tr.localPosition.y;
head.Transform = tr;
snake.Body.Add(head);
}
}
public void Initialize()
{
worldEntity = _world.CreateEntityWith <WorldComponent>();
worldEntity.Width = 320;
worldEntity.Height = 240;
LoadMap(Resources.Birb);
var ballEntity = MakeBall();
BuildWalls();
BuildPaddle();
}
public void Initialize()
{
PlayerConfigComponent playerConfig = _playerConfig.Components1[0];
GameObject[] playerObjects = GameObject.FindGameObjectsWithTag("Player");
foreach (GameObject player in playerObjects)
{
PlayerComponent playerComponent;
MoveComponent moveComponent;
int playerEntity = _ecsWorld.CreateEntityWith(out playerComponent, out moveComponent);
Vector2Int startPosition = player.transform.position.ToVector2Int();
moveComponent.Heading = playerConfig.PlayerCount % 2 != 0
? Directions.RIGHT
: Directions.LEFT;
moveComponent.DesiredPosition = startPosition;
moveComponent.Speed = playerConfig.StartSpeed;
playerComponent.Lives = playerConfig.StartLives;
playerComponent.Num = ++playerConfig.PlayerCount;
playerComponent.StartPosition = startPosition;
_ecsWorld.AddComponent <CreateWorldObjectEvent>(playerEntity).Transform = player.transform;
}
}
public void Run()
{
if (_takenEnergizers.EntitiesCount > 0)
{
_ecsWorld.CreateEntityWith <EnableGhostFearStateEvent>();
}
}
void IEcsInitSystem.Initialize()
{
for (var i = 0; i < ITERATIONS; i++)
{
_world.CreateEntityWith <EcsComponent1> (_componentId);
}
}
public void Run()
{
#if DEBUG
GunshotWound2.LastSystem = nameof(HelmetRequestSystem);
#endif
if (_requests.EntitiesCount <= 0)
{
return;
}
var player = Game.Player;
var ped = player.Character;
if (ped.IsWearingHelmet)
{
ped.RemoveHelmet(false);
}
else if (!ped.IsRagdoll)
{
if (player.Money > _config.Data.PlayerConfig.MoneyForHelmet)
{
player.Money -= _config.Data.PlayerConfig.MoneyForHelmet;
ped.GiveHelmet(false, Helmet.RegularMotorcycleHelmet, GunshotWound2.Random.Next(0, 15));
}
else
{
var message = _ecsWorld.CreateEntityWith <ShowNotificationEvent>();
message.StringToShow = _locale.Data.DontHaveMoneyForHelmet;
message.Level = NotifyLevels.COMMON;
}
}
_requests.CleanFilter();
}
protected override void ExecuteState(WoundedPedComponent woundedPed, int pedEntity)
{
base.ExecuteState(woundedPed, pedEntity);
SendPedToRagdoll(pedEntity, RagdollStates.PERMANENT);
if (woundedPed.IsPlayer && Config.Data.PlayerConfig.CanDropWeapon)
{
woundedPed.ThisPed.Weapons.Drop();
}
else if (!woundedPed.IsPlayer)
{
woundedPed.ThisPed.Weapons.Drop();
}
if (!woundedPed.IsPlayer)
{
return;
}
Game.Player.IgnoredByEveryone = true;
EcsWorld.CreateEntityWith <ChangeSpecialAbilityEvent>().Lock = true;
if (Config.Data.PlayerConfig.PoliceCanForgetYou)
{
Game.Player.WantedLevel = 0;
}
if (woundedPed.Crits.HasFlag(CritTypes.NERVES_DAMAGED) || woundedPed.IsDead)
{
return;
}
SendMessage(Locale.Data.UnbearablePainMessage, NotifyLevels.WARNING);
}
private void TriggerStartGameEvent(bool isActive)
{
GameStartEvent eventData;
var entity = _world.CreateEntityWith <GameStartEvent>(out eventData);
eventData.IsActive = isActive;
}
protected override void ExecuteState(WoundedPedComponent woundedPed, int pedEntity)
{
base.ExecuteState(woundedPed, pedEntity);
SendPedToRagdoll(pedEntity, RagdollStates.WAKE_UP);
ChangeWalkingAnimation(pedEntity, woundedPed.IsPlayer
? Config.Data.PlayerConfig.NoPainAnim
: Config.Data.NpcConfig.NoPainAnim);
if (woundedPed.IsMale)
{
Function.Call(Hash.PLAY_FACIAL_ANIM, woundedPed.ThisPed, "mood_happy_1", "facials@gen_male@base");
}
else
{
Function.Call(Hash.PLAY_FACIAL_ANIM, woundedPed.ThisPed, "mood_happy_1", "facials@gen_female@base");
}
if (!woundedPed.IsPlayer)
{
return;
}
if (!woundedPed.Crits.HasFlag(CritTypes.ARMS_DAMAGED))
{
EcsWorld.CreateEntityWith <AddCameraShakeEvent>().Length = CameraShakeLength.CLEAR;
}
EcsWorld.CreateEntityWith <ChangeSpecialAbilityEvent>().Lock = false;
}
protected override void ExecuteState(WoundedPedComponent woundedPed, int pedEntity)
{
base.ExecuteState(woundedPed, pedEntity);
SwitchAnimationComponent anim;
EcsWorld.CreateEntityWith(out anim);
anim.PedEntity = pedEntity;
anim.AnimationName = woundedPed.IsPlayer
? Config.Data.PlayerConfig.IntensePainAnim
: Config.Data.NpcConfig.IntensePainAnim;
if (woundedPed.DamagedParts.HasFlag(DamageTypes.ARMS_DAMAGED))
{
return;
}
var backPercent = 1f - woundedPed.PainMeter / woundedPed.MaximalPain;
if (woundedPed.IsPlayer)
{
Function.Call(Hash._SET_CAM_EFFECT, 2);
}
else
{
woundedPed.ThisPed.Accuracy = (int)(backPercent * woundedPed.DefaultAccuracy);
}
}
public void Run()
{
GunshotWound2.LastSystem = nameof(HelmetRequestSystem);
if (_requests.EntitiesCount == 0)
{
return;
}
var player = Game.Player;
if (player.Character.IsWearingHelmet)
{
player.Character.RemoveHelmet(false);
}
else
{
if (player.Money > _config.Data.PlayerConfig.MoneyForHelmet)
{
player.Money -= _config.Data.PlayerConfig.MoneyForHelmet;
player.Character.GiveHelmet(false, HelmetType.RegularMotorcycleHelmet, Random.Next(0, 20));
}
else
{
var message = _ecsWorld.CreateEntityWith <NotificationComponent>();
message.StringToShow = "You don't have enough money to buy helmet";
message.Level = NotifyLevels.COMMON;
}
}
for (int i = 0; i < _requests.EntitiesCount; i++)
{
_ecsWorld.RemoveEntity(_requests.Entities[i]);
}
}
