public override ItemPropertyModifier GetPropertyModifier(AggregateField field)
{
var modifier = base.GetPropertyModifier(field);
if (Character == Character.None)
{
return(modifier);
}
var characterExtensions = Character.GetExtensions();
var extensions = _extensionReader.GetExtensions();
var extensionBonus = characterExtensions.Select(e => extensions[e.id])
.Where(e => e.aggregateField == field)
.Sum(e => characterExtensions.GetLevel(e.id) * e.bonus);
extensionBonus += ExtensionBonuses.Where(e => e.aggregateField == field).Sum(e => characterExtensions.GetLevel(e.extensionId) * e.bonus);
if (!extensionBonus.IsZero())
{
var m = ItemPropertyModifier.Create(field, extensionBonus);
m.NormalizeExtensionBonus();
m.Modify(ref modifier);
}
return(modifier);
}
protected override double CalculateValue()
{
var optimalRange = ItemPropertyModifier.Create(AggregateField.optimal_range);
var ammo = _module.GetAmmo();
var m = module as MissileWeaponModule;
if (m != null)
{
if (ammo != null)
{
optimalRange = ammo.OptimalRangePropertyModifier;
var missileRangeMod = m.MissileRangeModifier.ToPropertyModifier();
missileRangeMod.Modify(ref optimalRange);
module.ApplyRobotPropertyModifiers(ref optimalRange);
}
}
else
{
optimalRange = module.GetPropertyModifier(AggregateField.optimal_range);
ammo?.ModifyOptimalRange(ref optimalRange);
}
ApplyEffectModifiers(ref optimalRange);
return(optimalRange.Value);
}
public void ApplyRobotPropertyModifiers(ref ItemPropertyModifier modifier)
{
var modifiers = PropertyModifiers.GetOrEmpty(modifier.Field);
foreach (var m in modifiers)
{
ParentRobot?.GetPropertyModifier(m).Modify(ref modifier);
}
}
static EffectHelper()
{
_effectDefaultModifiers = Database.CreateLookupCache <EffectType, ItemPropertyModifier>("effectdefaultmodifiers", "effectid", r =>
{
var field = (AggregateField)r.GetValue <int>("field");
var value = r.GetValue <double>("value");
return(ItemPropertyModifier.Create(field, value));
});
}
protected void ApplyEffectModifiers(ref ItemPropertyModifier m)
{
if (_effectModifiers == null)
{
return;
}
foreach (var effectModifier in _effectModifiers)
{
module.ParentRobot?.ApplyEffectPropertyModifiers(effectModifier, ref m);
}
}
public void ApplyTo(ref ItemPropertyModifier propertyModifier, AggregateField modifierField)
{
if (!EnableModifiers)
{
return;
}
foreach (var modifier in PropertyModifiers.Where(pp => pp.Field == modifierField))
{
modifier.Modify(ref propertyModifier);
}
}
private void ApplyHighwayEffect(bool apply)
{
if (apply)
{
var effectBuilder = NewEffectBuilder().SetType(EffectType.effect_highway)
.WithPropertyModifier(ItemPropertyModifier.Create(AggregateField.effect_speed_highway_modifier, 1.0));
ApplyEffect(effectBuilder);
}
else
{
EffectHandler.RemoveEffectsByType(EffectType.effect_highway);
}
}
public void ApplyMiningAmountModifier(ref ItemPropertyModifier propertyModifier)
{
MiningAmmoModifier modifier;
if (!TryGetMiningAmmoModifier(MaterialType, out modifier))
return;
var parentRobot = GetParentRobot();
if (parentRobot == null)
return;
var amountMod = parentRobot.GetPropertyModifier(modifier.amountModifier);
amountMod.Modify(ref propertyModifier);
}
public EffectBuilder WithPropertyModifier(ItemPropertyModifier propertyModifier)
{
_propertyModifiers.Add(propertyModifier);
return(this);
}
public virtual void ModifyCycleTime(ref ItemPropertyModifier modifier)
{
}
public void ModifyFalloff(ref ItemPropertyModifier falloff)
{
var falloffMod = GetPropertyModifier(AggregateField.falloff_modifier);
falloffMod.Modify(ref falloff);
}
public virtual void ModifyOptimalRange(ref ItemPropertyModifier property)
{
}
public override void ModifyOptimalRange(ref ItemPropertyModifier property)
{
var optimalRangeMod = _optimalRangeModifier.ToPropertyModifier();
optimalRangeMod.Modify(ref property);
}
public override void ModifyCycleTime(ref ItemPropertyModifier modifier)
{
var m = GetPropertyModifier(AggregateField.mining_probe_cycle_time_intrusion_modifier);
m.Modify(ref modifier);
}