public void Run()
        {
            foreach (int i in _damagedPeds)
            {
                GswPedComponent gswPed = _damagedPeds.Components1[i];
                Ped             ped    = gswPed.ThisPed;
                if (!ped.Exists())
                {
                    continue;
                }

                int pedEntity = _damagedPeds.Entities[i];
                if (!ped.IsWearingHelmet)
                {
#if DEBUG
                    _logger.MakeLog($"Ped {ped.Name(pedEntity)} doesn't have Helmet");
#endif
                    continue;
                }

                int bodyPartEntity = _damagedPeds.Components2[i].DamagedBodyPartEntity;
                var bodyArmor      = _ecsWorld.GetComponent <BodyPartArmorComponent>(bodyPartEntity);
                if (bodyArmor == null || !bodyArmor.ProtectedByHelmet)
                {
#if DEBUG
                    var partName = bodyPartEntity.GetEntityName(_ecsWorld);
                    _logger.MakeLog($"Helmet of {ped.Name(pedEntity)} doesn't protect {partName}");
#endif
                    continue;
                }

                int weaponEntity = _damagedPeds.Components3[i].WeaponEntity;
                var weaponStats  = _ecsWorld.GetComponent <ArmorWeaponStatsComponent>(weaponEntity);
                if (weaponStats == null)
                {
#if DEBUG
                    _logger.MakeLog($"This weapon doesn't have {nameof(ArmorWeaponStatsComponent)}");
#endif
                    continue;
                }

                float chance           = weaponStats.ChanceToPenetrateHelmet;
                bool  helmetPenetrated = Random.IsTrueWithProbability(chance);
                if (!helmetPenetrated)
                {
#if DEBUG
                    _logger.MakeLog($"Helmet of {ped.Name(pedEntity)} was not penetrated, when chance was {chance}");
#endif
                    _ecsWorld.RemoveComponent <DamagedByWeaponComponent>(pedEntity);
                    _ecsWorld.RemoveComponent <DamagedBodyPartComponent>(pedEntity);
                    continue;
                }

#if DEBUG
                _logger.MakeLog($"Helmet of {ped.Name(pedEntity)} was penetrated, when chance was {chance}");
#endif
            }
        }
Beispiel #2
0
        public void Run()
        {
            GswWorldComponent gswWorld = _world.Components1[0];
            bool detectingEnabled = gswWorld.MaxPedCountPerFrame > 0 &&
                                    (gswWorld.HumanDetectingEnabled || gswWorld.AnimalDetectingEnabled);

            if (gswWorld.NeedToCheckPeds.Count <= 0)
            {
                foreach (int i in _forceCreateEvents)
                {
                    Ped targetPed = _forceCreateEvents.Components1[i].TargetPed;
                    if (gswWorld.ForceCreatePeds.Contains(targetPed)) continue;

                    gswWorld.ForceCreatePeds.Add(targetPed);
                    gswWorld.NeedToCheckPeds.Enqueue(targetPed);
                    _ecsWorld.RemoveEntity(_forceCreateEvents.Entities[i]);
                }

                foreach (int i in _gswPeds)
                {
                    GswPedComponent gswPed = _gswPeds.Components1[i];

                    Ped ped = gswPed.ThisPed;
                    if (IsExistsAndAlive(ped)) continue;

                    EcsEntity pedEntity = _gswPeds.Entities[i];
                    _ecsWorld.AddComponent<RemovedPedMarkComponent>(pedEntity);
                }

                if (detectingEnabled)
                {
                    NativeFunction.Natives.SET_AI_MELEE_WEAPON_DAMAGE_MODIFIER(0.01f);
                    foreach (Ped ped in World.GetAllPeds())
                    {
                        gswWorld.NeedToCheckPeds.Enqueue(ped);
                    }
                }
            }

            for (int i = 0; i < gswWorld.MaxPedCountPerFrame; i++)
            {
                if(gswWorld.NeedToCheckPeds.Count <= 0) break;
                
                Ped ped = gswWorld.NeedToCheckPeds.Dequeue();
                if (IsNotExistsOrDead(ped)) continue;
                if (GswPedAlreadyExist(ped)) continue;

                bool forceCreatePed = gswWorld.ForceCreatePeds.Contains(ped);
                if (!forceCreatePed && IsNotDamaged(ped)) continue;

                EcsEntity? entity = null;
                if (ped.IsHuman && (forceCreatePed || gswWorld.HumanDetectingEnabled))
                {
                    entity = CreateHuman(gswWorld, ped);
                }
                else if (!ped.IsHuman && (forceCreatePed || gswWorld.AnimalDetectingEnabled))
                {
                    entity = CreateAnimal(gswWorld, ped);
                }

                if (entity == null)
                {
                    throw new Exception($"Ped is not supported! {ped.Model.Name} is not animal or human!");
                }
                
                NativeFunction.Natives.SET_PED_SUFFERS_CRITICAL_HITS(ped, false);
                NativeFunction.Natives.SET_PED_CONFIG_FLAG(ped, 281, true);
                _ecsWorld.AddComponent<NewPedMarkComponent>(entity.Value);
                if (!forceCreatePed) continue;

#if DEBUG
                _logger.MakeLog($"Ped {entity.Value.GetEntityName()} was force created");
#endif
                gswWorld.ForceCreatePeds.Remove(ped);
            }

#if DEBUG
            if (!_debugText.IsEmpty())
            {
                _debugText.Components1[0].UpdateDebugText("Peds", _gswPeds.GetEnumerator().GetCount().ToString());
            }
#endif
        }
Beispiel #3
0
        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;
            }
        }
Beispiel #4
0
        public void Run()
        {
            if (_world.EntitiesCount <= 0)
            {
                throw new Exception("World was not init!");
            }

            GswWorldComponent gswWorld = _world.Components1[0];
            bool detectingEnabled      = gswWorld.HumanDetectingEnabled || gswWorld.AnimalDetectingEnabled;

            _stopwatch.Restart();
            if (gswWorld.NeedToCheckPeds.Count <= 0)
            {
                foreach (int i in _forceCreateEvents)
                {
                    Ped targetPed = _forceCreateEvents.Components1[i].TargetPed;
                    gswWorld.NeedToCheckPeds.Enqueue(targetPed);
                    gswWorld.ForceCreatePeds.Add(targetPed);
                    _ecsWorld.RemoveEntity(_forceCreateEvents.Entities[i]);
                }

                foreach (int i in _gswPeds)
                {
                    GswPedComponent gswPed = _gswPeds.Components1[i];

                    Ped ped = gswPed.ThisPed;
                    if (IsExistsAndAlive(ped))
                    {
                        continue;
                    }

                    int pedEntity = _gswPeds.Entities[i];
                    _ecsWorld.AddComponent <RemovedPedMarkComponent>(pedEntity);
                }

                if (detectingEnabled)
                {
                    foreach (Ped ped in World.GetAllPeds())
                    {
                        gswWorld.NeedToCheckPeds.Enqueue(ped);
                    }
                }
            }

            while (!TimeIsOver() && gswWorld.NeedToCheckPeds.Count > 0)
            {
                Ped ped = gswWorld.NeedToCheckPeds.Dequeue();
                if (IsNotExistsOrDead(ped))
                {
                    continue;
                }
                if (GswPedAlreadyExist(ped))
                {
                    continue;
                }

                bool forceCreatePed = gswWorld.ForceCreatePeds.Contains(ped);
                if (!forceCreatePed && IsNotDamaged(ped))
                {
                    continue;
                }

                int entity;
                if (ped.IsHuman && (forceCreatePed || gswWorld.HumanDetectingEnabled))
                {
                    entity = CreateHuman(gswWorld, ped);
                }
                else if (!ped.IsHuman && (forceCreatePed || gswWorld.AnimalDetectingEnabled))
                {
                    entity = CreateAnimal(gswWorld, ped);
                }
                else
                {
                    entity = -1;
                }

                if (!forceCreatePed)
                {
                    continue;
                }

#if DEBUG
                _logger.MakeLog($"Ped {ped.Name(entity)} was force created");
#endif
                gswWorld.ForceCreatePeds.Remove(ped);
            }

#if DEBUG
            string pedCounter = "Peds: " + _gswPeds.EntitiesCount;
            pedCounter.ShowInGsw(0.165f, 0.94f, 0.25f, Color.White);

            string worldTime = "World Time: " + _stopwatch.ElapsedMilliseconds;
            worldTime.ShowInGsw(0.165f, 0.955f, 0.25f, Color.White);
#endif
            _stopwatch.Stop();
        }