public BondSpreadCalculator(BondSpreadServiceModel bondSpreadServiceModel, CurveBuilder curveBuilder,
FutureBuilder futureBuilder, FutureEnrichment futureEnricher, ForwardBuilder forwardBuilder,
InterestCurves curves)
{
this.bondSpreadServiceModel = bondSpreadServiceModel;
this.curveBuilder = curveBuilder;
this.futureBuilder = futureBuilder;
this.futureEnricher = futureEnricher;
this.forwardBuilder = forwardBuilder;
this.curves = curves;
carbonFieldMap = CarbonModel.GetEnumToFieldMapping(new[] { "bid", "ask", "primAct1", "secAct1" });
dataObserver = new DataObserver(bondPriceCache, carbonFieldMap, FutureCache);
dataObserver.Subscribe(dataObserveSubject);
}
/// <summary>The compose.</summary>
/// <param name="skill">The skill.</param>
public override void Compose(IAbilitySkill skill)
{
base.Compose(skill);
var skillAddedObserver = new DataObserver <IAbilitySkill>(
add =>
{
if (add.IsItem && add.SourceItem.Id == AbilityId.item_ultimate_scepter)
{
skill.AddPart <IModifierGenerator>(
abilitySkill =>
new ModifierGenerator(skill)
{
Workers =
new List <ModifierGeneratorWorker>
{
new ModifierGeneratorWorker(
"modifier_centaur_stampede",
modifier =>
modifier.AssignModifierEffectApplier(
new ModifierEffectApplier(modifier)
{
Workers =
new List <IEffectApplierWorker>
{
new DamageReductionEffectApplierWorker
(
modifier,
false,
abilityModifier => 0.6)
}
}),
false,
true,
true)
}
});
}
});
skillAddedObserver.Subscribe(skill.Owner.SkillBook.SkillAdded);
skill.DisposeNotifier.Subscribe(() => skillAddedObserver.Dispose());
}
protected override void RealTestOutPut()
{
var tracker = new DataTracker();
var tracker1 = new DataObserver("tracker1");
var tracker2 = new DataObserver("tracker2");
tracker1.Subscribe(tracker);
tracker2.Subscribe(tracker);
tracker.Track(new DataSource()
{
a = 888
});
tracker1.UnSubscribe();
tracker.Track(new DataSource()
{
a = 233
});
tracker.Track(null);
}
public virtual void Initialize()
{
if (this.Skill.AbilityInfo.DamageString != null)
{
if (this.Skill.AbilityInfo.DamageScepterString != null)
{
if (this.Skill.Owner.SourceUnit.HasModifier("modifier_item_ultimate_scepter_consumed"))
{
this.RawDamageWorkerAssign =
unit =>
new StringDataAghaDamageCalculatorWorker(
this.Skill,
unit,
this.DamageWorkerAssign(unit));
}
else if (this.Skill.Owner.SourceUnit.HasModifier("modifier_item_ultimate_scepter"))
{
this.RawDamageWorkerAssign =
unit =>
new StringDataAghaDamageCalculatorWorker(
this.Skill,
unit,
this.DamageWorkerAssign(unit));
var observer = new DataObserver <IAbilitySkill>();
observer.OnNextAction = remove =>
{
if (remove.IsItem && remove.SourceItem.Id == AbilityId.item_ultimate_scepter)
{
this.RawDamageWorkerAssign =
unit =>
new StringDataDamageCalculatorWorker(
this.Skill,
unit,
this.DamageWorkerAssign(unit));
observer.Dispose();
}
};
observer.Subscribe(this.Skill.Owner.SkillBook.SkillRemoved);
this.Skill.DisposeNotifier.Subscribe(() => observer.Dispose());
}
}
else
{
this.RawDamageWorkerAssign =
unit => new StringDataDamageCalculatorWorker(this.Skill, unit, this.DamageWorkerAssign(unit));
}
}
else
{
this.RawDamageWorkerAssign =
unit => new GetDamageCalculatorWorker(this.Skill, unit, this.DamageWorkerAssign(unit));
}
if (this.DamageType == DamageType.Magical)
{
this.DamageWorkerAssign = unit => new MagicalSkillDamageCalculatorWorker(this.Skill, unit);
}
else if (this.DamageType == DamageType.Physical)
{
this.DamageWorkerAssign = unit => new PhysicalSkillDamageCalculatorWorker(this.Skill, unit);
}
else if (this.DamageType == DamageType.Pure)
{
this.DamageWorkerAssign = unit => new PureSkillDamageCalculatorWorker(this.Skill, unit);
}
else
{
this.DamageWorkerAssign = unit => new HealthRemovalSkillDamageCalculatorWorker(this.Skill, unit);
}
}
public virtual void Initialize()
{
this.castPointUpdate = new LevelUpdater <IAbilitySkill, double>(
this.Skill,
() => Math.Max(this.Skill.SourceAbility.FindCastPoint(), 0.1));
this.speedUpdate = new LevelUpdater <IAbilitySkill, float>(
this.Skill,
() => this.Skill.SourceAbility.GetProjectileSpeed());
var manaSub = false;
if (this.Skill.SourceAbility.ManaCost > 0)
{
manaSub = true;
this.manaObserver = new DataObserver <IMana>(
mana =>
{
if (this.Skill.SourceAbility.IsValid)
{
this.EnoughMana = mana.Current > this.Skill.SourceAbility.ManaCost;
}
else
{
Console.WriteLine(
"SkillCastData: receiving mana data for invalid skill " + this.Skill.Name);
}
});
this.manaObserver.Subscribe(this.Skill.Owner.Mana);
}
else
{
DataObserver <ISkillLevel> levelObserver = null;
levelObserver = new DataObserver <ISkillLevel>(
level =>
{
if (manaSub)
{
return;
}
if (this.Skill.SourceAbility.ManaCost > 0)
{
manaSub = true;
this.manaObserver = new DataObserver <IMana>(
mana =>
{
if (this.Skill.SourceAbility.IsValid)
{
this.EnoughMana = mana.Current > this.Skill.SourceAbility.ManaCost;
}
else
{
Console.WriteLine(
"SkillCastData: receiving mana data for invalid skill "
+ this.Skill.Name);
}
});
this.manaObserver.Subscribe(this.Skill.Owner.Mana);
}
});
levelObserver.Subscribe(this.Skill.Level);
}
if (this.Skill.Cooldown != null)
{
this.cooldownObserver = new DataObserver <ICooldown>(
cooldown =>
{
this.Cooldown = cooldown.Current;
this.IsOnCooldown = this.Cooldown > 0;
});
this.cooldownObserver.Subscribe(this.Skill.Cooldown);
}
}
