Esempio n. 1
0
        private static void rebindWeaponAttributes(EntityTypeAttributes entityType, WeaponAttributesWrapper weaponAttributesWrapper)
        {
            var unitAttributes = entityType.Get <UnitAttributes>();

            if (unitAttributes != null)
            {
                for (var i = 0; i < unitAttributes.WeaponLoadout.Length; i++)
                {
                    var weaponBinding = unitAttributes.WeaponLoadout[i];
                    if (weaponBinding.Weapon.Name == weaponAttributesWrapper.Name)
                    {
                        unitAttributes.WeaponLoadout[i] = new WeaponBinding(
                            weaponID: weaponBinding.WeaponID,
                            weaponBindingIndex: weaponBinding.WeaponBindingIndex,
                            weapon: weaponAttributesWrapper,
                            ammoID: weaponBinding.AmmoID,
                            turretIndex: weaponBinding.TurretIndex,
                            defaultTurretAngleOffsetRadians: weaponBinding.DefaultTurretAngleOffsetRadians,
                            disabledOnSpawn: weaponBinding.DisabledOnSpawn,
                            weaponOffsetFromUnitOrigin: weaponBinding.OffsetFromUnitCenterInLocalSpace,
                            showAmmoOnHUD: weaponBinding.ShowAmmoOnHUD
                            );
                    }
                }
            }
        }
Esempio n. 2
0
        public void OutputWeaponDPS(AttributeLoader loader, WeaponAttributesWrapper weaponAttributesWrapper)
        {
            using (loader.logger.BeginScope($"DPS info:"))
            {
                loader.logger.Log($"BaseDamagePerRound {weaponAttributesWrapper.BaseDamagePerRound}");
                loader.logger.Log($"RateOfFire {weaponAttributesWrapper.RateOfFire}");
                loader.logger.Log($"Burst: {weaponAttributesWrapper.BurstPeriodMinTimeMS} - {weaponAttributesWrapper.BurstPeriodMaxTimeMS}");
                loader.logger.Log($"NumberOfBursts {weaponAttributesWrapper.NumberOfBursts}");
                loader.logger.Log($"CooldownTimeMS: {weaponAttributesWrapper.CooldownTimeMS}");
                loader.logger.Log($"WindUpTimeMS: {weaponAttributesWrapper.WindUpTimeMS}");
                loader.logger.Log($"WindDownTimeMS: {weaponAttributesWrapper.WindDownTimeMS}");
                loader.logger.Log($"ReloadTimeMS: {weaponAttributesWrapper.ReloadTimeMS}");
                loader.logger.Log($"DamagePacketsPerShot: {weaponAttributesWrapper.DamagePacketsPerShot}");
                loader.logger.Log($"AreaOfEffectFalloffType: {weaponAttributesWrapper.AreaOfEffectFalloffType}");
                loader.logger.Log($"AreaOfEffectRadius: {weaponAttributesWrapper.AreaOfEffectRadius}");

                if (weaponAttributesWrapper.RateOfFire > 0)
                {
                    WeaponDPSInfo weaponDPSInfo = new WeaponDPSInfo(weaponAttributesWrapper);

                    loader.logger.Log("");
                    loader.logger.Log($"AverageShotsPerBurst: {weaponDPSInfo.AverageShotsPerBurst:F4}");
                    loader.logger.Log($"TrueROF: {weaponDPSInfo.TrueROF:F4}");
                    loader.logger.Log($"SequenceDuration: {weaponDPSInfo.SequenceDuration:F4}");
                    loader.logger.Log($"PureDPS: {weaponDPSInfo.PureDPS:F4}");

                    for (int armor = 0; armor <= 18; armor += 6)
                    {
                        using (loader.logger.BeginScope($"Armor{armor}DPS:"))
                        {
                            double armorDPS = weaponDPSInfo.ArmorDPS(armor);
                            Dictionary <WeaponRange, double> rangeDPS = weaponDPSInfo.RangeDPS(armorDPS);
                            loader.logger.Log($"pure: {armorDPS:F4}");
                            foreach (var range in weaponAttributesWrapper.Ranges)
                            {
                                double accuracy = Fixed64.UnsafeDoubleValue(range.Accuracy) * 0.01;
                                loader.logger.Log($"{range.Range,6} ({range.Distance,5:D} /{accuracy*100,3:F2}%): {rangeDPS[range.Range]:F4}");
                            }
                        }
                    }
                }
            }
        }
Esempio n. 3
0
        private void applyRangeAttributes(WeaponRange weaponRange, RangeBasedWeaponAttributesPatch rangePatch, WeaponAttributesWrapper weaponWrapper)
        {
            if (rangePatch == null)
            {
                return;
            }

            var ranges = weaponWrapper.Ranges;

            var newRanges = ranges.Where(r => r.Range < weaponRange);

            var range = ranges.SingleOrDefault(r => r.Range == weaponRange);

            using (logger.BeginScope($"RangeAttributes{weaponRange}:"))
            {
                if (rangePatch.Remove)
                {
                    logger.Log("(removed)");
                }
                else
                {
                    RangeBasedWeaponAttributesWrapper rangeWrapper;

                    if (range != null)
                    {
                        rangeWrapper = new RangeBasedWeaponAttributesWrapper(range);
                    }
                    else
                    {
                        logger.Log("(created)");
                        rangeWrapper = new RangeBasedWeaponAttributesWrapper(weaponRange);
                    }

                    ApplyRangeBasedWeaponAttributesPatch(rangePatch, rangeWrapper);

                    newRanges = newRanges.Concat(new[] { rangeWrapper });
                }
            }

            newRanges = newRanges.Concat(ranges.Where(r => r.Range > weaponRange));

            weaponWrapper.Ranges = newRanges.ToArray();
        }
Esempio n. 4
0
        private void applyEntityTypesToSpawnOnImpact(WeaponAttributesPatch weaponAttributesPatch, WeaponAttributesWrapper weaponAttributesWrapper)
        {
            var wrappers = weaponAttributesWrapper.EntityTypesToSpawnOnImpact.Select(x => new EntityTypeToSpawnAttributesWrapper(x)).ToList();

            applyListPatch(weaponAttributesPatch.EntityTypesToSpawnOnImpact, wrappers, () => new EntityTypeToSpawnAttributesWrapper(), ApplyEntityTypeToSpawnAttributesPatch, nameof(EntityTypeToSpawnAttributes));

            weaponAttributesWrapper.EntityTypesToSpawnOnImpact = wrappers.Where(x => x != null).ToArray();
        }
Esempio n. 5
0
        private void applyWeaponModifiers(WeaponAttributesPatch weaponAttributesPatch, WeaponAttributesWrapper weaponAttributesWrapper)
        {
            var modifiers = weaponAttributesWrapper.Modifiers.Select(x => new WeaponModifierInfoWrapper(x)).ToList();

            applyListPatch(weaponAttributesPatch.Modifiers, modifiers, () => new WeaponModifierInfoWrapper(), ApplyWeaponModifierInfoPatch, nameof(WeaponModifierInfo));

            weaponAttributesWrapper.Modifiers = modifiers.ToArray();
        }
Esempio n. 6
0
        public void ApplyWeaponAttributesPatch(WeaponAttributesPatch weaponAttributesPatch, WeaponAttributesWrapper weaponAttributesWrapper)
        {
            applyPropertyPatch(weaponAttributesPatch.ExcludeFromAutoTargetAcquisition, () => weaponAttributesWrapper.ExcludeFromAutoTargetAcquisition);
            applyPropertyPatch(weaponAttributesPatch.ExcludeFromAutoFire, () => weaponAttributesWrapper.ExcludeFromAutoFire);
            applyPropertyPatch(weaponAttributesPatch.ExcludeFromHeightAdvantage, () => weaponAttributesWrapper.ExcludeFromHeightAdvantage);
            applyPropertyPatch(weaponAttributesPatch.DamageType, () => weaponAttributesWrapper.DamageType);
            applyPropertyPatch(weaponAttributesPatch.IsTracer, () => weaponAttributesWrapper.IsTracer);
            applyPropertyPatch(weaponAttributesPatch.TracerSpeed, () => weaponAttributesWrapper.TracerSpeed, x => Fixed64.UnsafeFromDouble(x));
            applyPropertyPatch(weaponAttributesPatch.TracerLength, () => weaponAttributesWrapper.TracerLength, x => Fixed64.UnsafeFromDouble(x));
            applyPropertyPatch(weaponAttributesPatch.BaseDamagePerRound, () => weaponAttributesWrapper.BaseDamagePerRound, x => Fixed64.UnsafeFromDouble(x));
            applyPropertyPatch(weaponAttributesPatch.BaseWreckDamagePerRound, () => weaponAttributesWrapper.BaseWreckDamagePerRound, x => Fixed64.UnsafeFromDouble(x));
            applyPropertyPatch(weaponAttributesPatch.FiringRecoil, () => weaponAttributesWrapper.FiringRecoil);
            applyPropertyPatch(weaponAttributesPatch.WindUpTimeMS, () => weaponAttributesWrapper.WindUpTimeMS);
            applyPropertyPatch(weaponAttributesPatch.RateOfFire, () => weaponAttributesWrapper.RateOfFire);
            applyPropertyPatch(weaponAttributesPatch.NumberOfBursts, () => weaponAttributesWrapper.NumberOfBursts);
            applyPropertyPatch(weaponAttributesPatch.DamagePacketsPerShot, () => weaponAttributesWrapper.DamagePacketsPerShot);
            applyPropertyPatch(weaponAttributesPatch.BurstPeriodMinTimeMS, () => weaponAttributesWrapper.BurstPeriodMinTimeMS);
            applyPropertyPatch(weaponAttributesPatch.BurstPeriodMaxTimeMS, () => weaponAttributesWrapper.BurstPeriodMaxTimeMS);
            applyPropertyPatch(weaponAttributesPatch.CooldownTimeMS, () => weaponAttributesWrapper.CooldownTimeMS);
            applyPropertyPatch(weaponAttributesPatch.WindDownTimeMS, () => weaponAttributesWrapper.WindDownTimeMS);
            applyPropertyPatch(weaponAttributesPatch.ReloadTimeMS, () => weaponAttributesWrapper.ReloadTimeMS);
            applyPropertyPatch(weaponAttributesPatch.LineOfSightRequired, () => weaponAttributesWrapper.LineOfSightRequired);
            applyPropertyPatch(weaponAttributesPatch.LeadsTarget, () => weaponAttributesWrapper.LeadsTarget);
            applyPropertyPatch(weaponAttributesPatch.KillSkipsUnitDeathSequence, () => weaponAttributesWrapper.KillSkipsUnitDeathSequence);
            applyPropertyPatch(weaponAttributesPatch.RevealTriggers, () => weaponAttributesWrapper.RevealTriggers);
            applyPropertyPatch(weaponAttributesPatch.UnitStatusAttackingTriggers, () => weaponAttributesWrapper.UnitStatusAttackingTriggers);
            applyPropertyPatch(weaponAttributesPatch.TargetStyle, () => weaponAttributesWrapper.TargetStyle);

            applyWeaponModifiers(weaponAttributesPatch, weaponAttributesWrapper);

            applyPropertyPatch(weaponAttributesPatch.AreaOfEffectFalloffType, () => weaponAttributesWrapper.AreaOfEffectFalloffType);
            applyPropertyPatch(weaponAttributesPatch.AreaOfEffectRadius, () => weaponAttributesWrapper.AreaOfEffectRadius, x => Fixed64.UnsafeFromDouble(x));
            applyPropertyPatch(weaponAttributesPatch.ExcludeWeaponOwnerFromAreaOfEffect, () => weaponAttributesWrapper.ExcludeWeaponOwnerFromAreaOfEffect);
            applyPropertyPatch(weaponAttributesPatch.FriendlyFireDamageScalar, () => weaponAttributesWrapper.FriendlyFireDamageScalar, x => Fixed64.UnsafeFromDouble(x));
            applyPropertyPatch(weaponAttributesPatch.WeaponOwnerFriendlyFireDamageScalar, () => weaponAttributesWrapper.WeaponOwnerFriendlyFireDamageScalar, x => Fixed64.UnsafeFromDouble(x));

            if (weaponAttributesPatch.Turret != null)
            {
                using (logger.BeginScope($"Turret:"))
                {
                    var turret        = weaponAttributesWrapper.Turret;
                    var turretWrapper = new TurretAttributesWrapper(turret);

                    ApplyTurretAttributesPatch(weaponAttributesPatch.Turret, turretWrapper);

                    weaponAttributesWrapper.Turret = turretWrapper;
                }
            }

            applyRangeAttributes(WeaponRange.Short, weaponAttributesPatch.RangeAttributesShort, weaponAttributesWrapper);
            applyRangeAttributes(WeaponRange.Medium, weaponAttributesPatch.RangeAttributesMedium, weaponAttributesWrapper);
            applyRangeAttributes(WeaponRange.Long, weaponAttributesPatch.RangeAttributesLong, weaponAttributesWrapper);

            applyPropertyPatch(weaponAttributesPatch.ProjectileEntityTypeToSpawn, () => weaponAttributesWrapper.ProjectileEntityTypeToSpawn);
            applyPropertyPatch(weaponAttributesPatch.StatusEffectsTargetAlignment, () => weaponAttributesWrapper.StatusEffectsTargetAlignment);
            applyPropertyPatch(weaponAttributesPatch.StatusEffectsExcludeTargetType, () => weaponAttributesWrapper.StatusEffectsExcludeTargetType);
            applyPropertyPatch(weaponAttributesPatch.ActiveStatusEffectsIndex, () => weaponAttributesWrapper.ActiveStatusEffectsIndex);

            applyEntityTypesToSpawnOnImpact(weaponAttributesPatch, weaponAttributesWrapper);

            if (weaponAttributesPatch.TargetPrioritizationAttributes != null)
            {
                using (logger.BeginScope($"TargetPrioritizationAttributes:"))
                {
                    var targetPrioritizationWrapper = new TargetPriorizationAttributesWrapper(weaponAttributesWrapper.TargetPriorizationAttributes);

                    ApplyTargetPrioritizationAttributesPatch(weaponAttributesPatch.TargetPrioritizationAttributes, targetPrioritizationWrapper);

                    weaponAttributesWrapper.TargetPriorizationAttributes = targetPrioritizationWrapper;
                }
            }
        }