public ExtensionBonus(IDataRecord record)
{
extensionId = record.GetValue <int>("extension");
bonus = record.GetValue <double>("bonus");
aggregateField = record.GetValue <AggregateField>("targetpropertyID");
isEffectEnhancer = record.GetValue <bool>(k.effectEnhancer);
}
/// <summary>
/// Formats the field to a valid string appendable to a query
/// </summary>
/// <param name="aggregateField">The <see cref="AggregateField"/> to be formatted</param>
/// <returns>A <see cref="string"/> with the formatted field.</returns>
public virtual string FormatField(AggregateField aggregateField)
{
// Checks if the aggregate field is valid
ValidateField(aggregateField);
// Retrieve Aggregate Function Name
if (AggregateFunctionMapping == null)
{
throw new NullReferenceException($"There is no definition for the default {nameof(AggregateFunctionMapping)}. Unable to process aggregate fields.");
}
if (!AggregateFunctionMapping.TryGetValue(aggregateField.Function, out string aggregateFunctionString))
{
throw new Exception($"There is no mapping for the Aggregate Function '{Enum.GetName(typeof(AggregateFunctions), aggregateField.Function)}'. Unable to process aggregate field.");
}
// The Count Aggregation Function accepts "0" and "*", verify that
if (aggregateField.Function == AggregateFunctions.Count)
{
// Look for "Zero" or "*" on the Name of the Field
if ((aggregateField.Name == "0") ||
(aggregateField.Name == "*"))
{
return($"{aggregateFunctionString}({aggregateField.Name})");
}
}
else if (aggregateField.Function == AggregateFunctions.CountDistinct)
{
// Replace the word "DISTINCT" for "DISTINCT [field]"
return(aggregateFunctionString.Replace("DISTINCT", $"DISTINCT {FormatFieldAfterValidation((Field)aggregateField)}"));
}
// Return the formatted field
return($"{aggregateFunctionString}({FormatFieldAfterValidation((Field)aggregateField)})");
}
public ExtensionBonus(int extensionId, double bonus, AggregateField aggregateField)
{
this.extensionId = extensionId;
this.bonus = bonus;
this.aggregateField = aggregateField;
isEffectEnhancer = false;
}
public void UpdateIfRelated(AggregateField field)
{
if (IsRelated(field))
{
Update();
}
}
public override ItemPropertyModifier GetPropertyModifier(AggregateField field)
{
var modifier = base.GetPropertyModifier(field);
ApplyRobotPropertyModifiers(ref modifier);
return(modifier);
}
public virtual void UpdateRelatedProperties(AggregateField field)
{
foreach (var property in _properties)
{
property.UpdateIfRelated(field);
}
}
public void Visit(AggregateField component)
{
sql.Append($"{GetAggregateFunctionName(component.Function)}({(component.IsDistinct ? "DISTINCT " : "")}");
component.Field.Accept(this);
sql.Append(")");
if (component.PartitionBy.Count + component.OrderBy.Count > 0)
{
sql.Append(" OVER (");
if (component.PartitionBy.Count > 0)
{
sql.Append("PARTITION BY ");
component.PartitionBy.First().Accept(this);
foreach (var item in component.PartitionBy.Skip(1))
{
sql.Append(", ");
item.Accept(this);
}
}
if (component.OrderBy.Count > 0)
{
sql.Append((component.PartitionBy.Count > 0 ? " " : "") + "ORDER BY ");
component.OrderBy.First().Accept(this);
foreach (var item in component.OrderBy.Skip(1))
{
sql.Append(", ");
item.Accept(this);
}
}
sql.Append(")");
}
}
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);
}
public override void UpdateRelatedProperties(AggregateField field)
{
var ammo = GetAmmo();
ammo?.UpdateRelatedProperties(field);
base.UpdateRelatedProperties(field);
}
public GangModule(EffectType effectType, AggregateField effectModifier)
{
_effectType = effectType;
_effectEnhancerAuraRadiusModifier = new ModuleProperty(this, AggregateField.effect_enhancer_aura_radius_modifier);
AddProperty(_effectEnhancerAuraRadiusModifier);
_effectModifier = new ModuleProperty(this, effectModifier);
AddProperty(_effectModifier);
}
public override void UpdateRelatedProperties(AggregateField field)
{
foreach (var component in RobotComponents)
{
component.UpdateRelatedProperties(field);
}
base.UpdateRelatedProperties(field);
}
public void AddEffectModifier(AggregateField field)
{
if (_effectModifiers == null)
{
_effectModifiers = new List <AggregateField>();
}
_effectModifiers.Add(field);
}
public override void UpdateRelatedProperties(AggregateField field)
{
foreach (var module in Modules)
{
module.UpdateRelatedProperties(field);
}
base.UpdateRelatedProperties(field);
}
public ItemPropertyModifier GetPropertyModifier(AggregateField field)
{
if (TryGetPropertyModifier(field, out ItemPropertyModifier m))
{
return(m);
}
return(ItemPropertyModifier.Create(field));
}
public static AggregateFormula GetFormula(this AggregateField field)
{
AggregateFormula formula;
if (!_formulas.TryGetValue(field, out formula))
{
formula = AggregateFormula.Add;
}
return(formula);
}
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);
}
}
public void AggregateFieldConstructorSetsProperties()
{
const string expectedName = "Kryten";
const string expectedOperation = "Head Rotation";
var expectedToken = JToken.Parse("{ \"scheduled\":1 }");
var actual = new AggregateField(expectedName, expectedOperation, expectedToken);
Assert.Same(expectedName, actual.Name);
Assert.Same(expectedOperation, actual.Operation);
Assert.Same(expectedToken, actual.Token);
}
public override ItemPropertyModifier GetPropertyModifier(AggregateField field)
{
var modifier = base.GetPropertyModifier(field);
foreach (var component in RobotComponents)
{
var m = component.GetPropertyModifier(field);
m.Modify(ref modifier);
}
return(modifier);
}
protected override bool IsRelated(AggregateField field)
{
if (_effectModifiers != null)
{
if (_effectModifiers.Contains(field))
{
return(true);
}
}
return(base.IsRelated(field));
}
public override ItemPropertyModifier GetPropertyModifier(AggregateField field)
{
var modifier = base.GetPropertyModifier(field);
foreach (var module in Modules.Where(m => m.IsPassive))
{
var m = module.GetBasePropertyModifier(field);
m.Modify(ref modifier);
}
return(modifier);
}
public override void UpdateProperty(AggregateField field)
{
switch (field)
{
case AggregateField.shield_absorbtion:
case AggregateField.shield_absorbtion_modifier:
case AggregateField.effect_shield_absorbtion_modifier:
_shieldAbsorbtion.Update();
break;
}
base.UpdateProperty(field);
}
public override void UpdateProperty(AggregateField field)
{
base.UpdateProperty(field);
switch (field)
{
case AggregateField.harvesting_amount_modifier:
case AggregateField.effect_harvesting_amount_modifier:
{
_harverstingAmountModifier.Update();
break;
}
}
}
protected override bool IsRelated(AggregateField field)
{
switch (field)
{
case AggregateField.speed_max:
case AggregateField.speed_max_modifier:
case AggregateField.effect_speed_max_modifier:
case AggregateField.effect_massivness_speed_max_modifier:
case AggregateField.effect_speed_highway_modifier:
return(true);
}
return(false);
}
public override void UpdateProperty(AggregateField field)
{
switch (field)
{
case AggregateField.mining_amount_modifier:
case AggregateField.effect_mining_amount_modifier:
{
_miningAmountModifier.Update();
return;
}
}
base.UpdateProperty(field);
}
protected override bool IsRelated(AggregateField field)
{
if (_modifierField == field)
{
return(true);
}
if (_effectModifiers != null)
{
return(_effectModifiers.Any(m => m == field));
}
return(base.IsRelated(field));
}
public static bool IsPublic(this AggregateField field)
{
switch (field)
{
case AggregateField.armor_max:
case AggregateField.armor_current:
case AggregateField.speed_max:
case AggregateField.speed_current:
case AggregateField.core_max:
case AggregateField.core_current:
return(true);
}
return(false);
}
/// <summary>
/// Tries to Format the Aggregate Field
/// </summary>
/// <param name="aggregateField">The <see cref="AggregateField"/> to be formatted</param>
/// <param name="formattedAggregateField">Reference to the string where the formmatted <see cref="AggregateField"/> will be stored</param>
/// <returns>A <see cref="bool">Boolean</see> value to define whether the formatting succeeded or failed</returns>
public bool TryFormatField(AggregateField aggregateField, out string formattedAggregateField)
{
// Initialize Return String
formattedAggregateField = "";
try
{
formattedAggregateField = FormatField(aggregateField);
return(true);
}
catch
{
return(false);
}
}
public ExtensionInfo(IDataRecord record)
{
id = record.GetValue <int>("extensionid");
name = record.GetValue <string>("extensionname");
category = record.GetValue <int>("category");
rank = record.GetValue <int>("rank");
learningAttributePrimary = record.GetValue <string>("learningattributeprimary");
learningAttributeSecondary = record.GetValue <string>("learningattributesecondary");
bonus = record.GetValue <double>("bonus");
price = record.GetValue <int>("price");
_description = record.GetValue <string>("description");
aggregateField = (AggregateField)(record.GetValue <int?>("targetpropertyID") ?? 0);
hidden = record.GetValue <bool>("hidden");
freezeLimit = record.GetValue <int?>("freezelimit");
}
public override void UpdateProperty(AggregateField field)
{
switch (field)
{
case AggregateField.mining_probe_accuracy:
case AggregateField.mining_probe_accuracy_modifier:
case AggregateField.effect_mining_probe_accuracy_modifier:
{
_miningProbeAccuracy.Update();
break;
}
}
base.UpdateProperty(field);
}
public override void UpdateProperty(AggregateField field)
{
switch (field)
{
case AggregateField.armor_repair_amount:
case AggregateField.armor_repair_amount_modifier:
case AggregateField.effect_repair_amount_modifier:
{
armorRepairAmount.Update();
return;
}
}
base.UpdateProperty(field);
}
