public override void ProcessExitZone(TileMoveData moveData)
{
base.ProcessExitZone(moveData);
if (this._data.Source != null && moveData.DoAttackOfOpportunity)
{
if (moveData.Target.Proxy.LParty != this._data.Source.Proxy.LParty)
{
var data = new ActionData();
data.Ability = EAbility.Attack_Of_Opportunity;
data.DisplayDefended = false;
data.Source = this._data.Source;
data.Target = moveData.Target.Tile;
data.WpnAbility = false;
this._action = new MAction(data);
moveData.ParentEvent.AddChildAction(this._action);
this._action.TryProcessNoDisplay();
foreach (var hit in this._action.Data.Hits)
{
if (!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Block) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Parry))
{
moveData.Callback(this);
this._action.AddCallback(moveData.ParentEvent.TryDone);
}
}
this._action.DisplayAction();
}
}
}
public void DoBash(object o)
{
var script = o as SAttackerJolt;
var a = script.GetObjectList()[0] as MAction;
foreach (var hit in a.Data.Hits)
{
var tgt = hit.Data.Target.Current as CChar;
if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Push))
{
var tgtTile = hit.Data.Source.Tile.Model.GetPushTile(tgt.Tile.Model);
if (tgtTile != null)
{
var data = new EvTileMoveData();
data.Char = tgt;
data.Cost = 0;
data.DoAttackOfOpportunity = false;
data.StamCost = 0;
data.Source = tgt.Tile;
data.Target = tgtTile.Controller;
var e = new EvTileMove(data);
e.AddCallback(hit.CallbackHandler);
e.TryProcess();
}
else
{
hit.CallbackHandler(null);
}
}
else
{
hit.CallbackHandler(null);
}
}
}
public override void Process(MHit hit)
{
if (hit.Data.Ability.Data.IsHeal)
{
// TODO:
}
else if (hit.Data.Ability.Data.ProcessDamage)
{
var src = hit.Data.Source.Proxy;
var targetController = hit.Data.Target.Current as CChar;
var tgt = targetController.Proxy;
double dmgToApply = this.GetCritDamage(hit, (double)hit.Data.Dmg);
double dmgReduction = tgt.GetStat(ESecondaryStat.Damage_Reduction);
double flatDmgNegate = src.GetStat(ESecondaryStat.Damage_Ignore);
if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Head))
{
flatDmgNegate += this.GetArmorNegation(hit, src, tgt, flatDmgNegate, true);
dmgReduction = this.GetDmgReduction(hit, src, tgt, dmgReduction, true);
}
else
{
flatDmgNegate += this.GetArmorNegation(hit, src, tgt, flatDmgNegate, false);
dmgReduction = this.GetDmgReduction(hit, src, tgt, dmgReduction, false);
}
dmgToApply -= flatDmgNegate;
dmgToApply *= dmgReduction;
hit.Data.Dmg = (int)dmgToApply;
}
}
public void DoScatter(object o)
{
var hit = o as MHit;
var tgt = hit.Data.Target.Current as CChar;
if (tgt != null &&
FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Push) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Parry))
{
CTile randomController = null;
var tgtTile = hit.Data.Source.Tile.Model.GetPushTile(tgt.Tile.Model);
if (tgtTile == null)
{
randomController = hit.Data.Source.Tile.GetNearestEmptyTile();
}
if (randomController != null)
{
tgtTile = randomController.Model;
}
if (tgtTile != null)
{
var data = new EvTileMoveData();
data.Char = tgt;
data.Cost = 0;
data.DoAttackOfOpportunity = false;
data.StamCost = 0;
data.Source = tgt.Tile;
data.Target = tgtTile.Controller;
var e = new EvTileMove(data);
e.AddCallback(hit.CallbackHandler);
e.TryProcess();
}
}
}
public override void Process(MHit hit)
{
var roll = RNG.Instance.NextDouble();
if (roll > LogicParams.BASE_HEAD_CHANCE)
{
FHit.SetHeadTrue(hit.Data.Flags);
}
}
public override void Process(MHit hit)
{
this.Predict(hit);
var roll = RNG.Instance.NextDouble();
if (hit.Data.Chances.Parry > roll)
{
FHit.SetParryTrue(hit.Data.Flags);
}
}
public override void Process(MHit hit)
{
this.Predict(hit);
if (hit.Data.Ability.Data.Resist != EResistType.None)
{
var roll = RNG.Instance.NextDouble();
if (roll < hit.Data.Chances.Resist)
{
FHit.SetResistTrue(hit.Data.Flags);
}
}
}
private double GetCritDamage(MHit hit, double dmgIn)
{
double dmgOut = dmgIn;
if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Critical))
{
dmgOut *=
(LogicParams.BASE_CRIT_SCALAR +
(hit.Data.Source.Proxy.GetStat(ESecondaryStat.Critical_Multiplier) /
LogicParams.BASE_SCALAR));
}
return(dmgOut);
}
private bool IsHitFatal(MHit hit)
{
var target = hit.Data.Target.Current as CChar;
if (target.Proxy.GetPoints(ESecondaryStat.HP) - hit.Data.Dmg <= 0)
{
if (!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Parry))
{
return(true);
}
}
return(false);
}
public override void TryProcessHit(MHit hit, bool prediction)
{
base.TryProcessHit(hit, prediction);
if (base.CheckConditions(hit))
{
var calc = new ResistCalculator();
var tgt = hit.Data.Target.Current as CChar;
var offense = hit.Data.Source.Proxy.GetStat(this.Data.OffensiveResist);
if (!prediction && !calc.DidResist(tgt, this.Data.Resist, offense))
{
FHit.SetPushTrue(hit.Data.Flags);
tgt.Proxy.AddEffect(this);
}
}
}
private void HandleHitCounters()
{
foreach (var hit in this._data.Hits)
{
var target = hit.Data.Target.Current;
if (target != null && target.GetType().Equals(typeof(CChar)))
{
var tgt = target as CChar;
if (FActionStatus.HasFlag(tgt.Proxy.GetActionFlags().CurFlags, FActionStatus.Flags.Riposting))
{
if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Block) ||
FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge) ||
FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Parry))
{
this.HandleHitCounterHelper(hit, tgt);
}
}
}
}
}
public override void TryProcessHit(MHit hit, bool prediction)
{
base.TryProcessHit(hit, prediction);
if (base.CheckConditions(hit))
{
var calc = new ResistCalculator();
var tgt = hit.Data.Target.Current as CChar;
var offense = hit.Data.Source.Proxy.GetStat(this.Data.OffensiveResist);
if (!prediction && !calc.DidResist(tgt, this.Data.Resist, offense))
{
FCharacterStatus.SetStunnedTrue(tgt.Proxy.GetStatusFlags());
FHit.SetStunTrue(hit.Data.Flags);
hit.AddEffect(this);
tgt.Proxy.AddEffect(this);
}
else if (!prediction)
{
VCombatController.Instance.DisplayText("Resist", tgt, CombatGUIParams.WHITE);
}
}
}
public override void ProcessEnterZone(TileMoveData moveData)
{
this.FirstSpearWallHit = false;
this.SpearWallHit = false;
base.ProcessEnterZone(moveData);
if (this._spearWallData.Source != null)
{
if (moveData.Target.Proxy.LParty != this._spearWallData.Source.Proxy.LParty)
{
moveData.Callback(this);
var data = new ActionData();
data.Ability = EAbility.Pierce;
data.LWeapon = this._spearWallData.LWeapon;
data.ParentWeapon = this._spearWallData.ParentWeapon;
data.Source = this._spearWallData.Source;
data.Target = moveData.Target.Tile;
data.WpnAbility = true;
this._action = new MAction(data);
this._action.AddCallback(moveData.ParentEvent.TryDone);
moveData.ParentEvent.AddChildAction(this._action);
var staminaCalc = new StaminaCalculator();
var cost = staminaCalc.Process(this._action);
if (FActionStatus.HasFlag(this._action.Data.Source.Proxy.GetActionFlags().CurFlags, FActionStatus.Flags.Spearwalling) &&
cost <= this._action.Data.Source.Proxy.GetPoints(ESecondaryStat.Stamina))
{
this._action.TryProcessNoDisplay();
foreach (var hit in this._action.Data.Hits)
{
if (!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Block) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Parry))
{
this.SpearWallHit = true;
}
}
this.HandleSpeared(null);
}
}
}
}
private void DisplayDamage(CChar target, MHit hit)
{
var dmgData = new HitDisplayData();
dmgData.Color = CombatGUIParams.RED;
dmgData.Hit = hit;
dmgData.Priority = ViewParams.DMG_PRIORITY;
dmgData.Text = hit.Data.Dmg.ToString();
dmgData.Target = target.GameHandle;
dmgData.YOffset = CombatGUIParams.FLOAT_OFFSET;
dmgData.Hit.AddDataDisplay(dmgData);
if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Critical))
{
var critData = new HitDisplayData();
critData.Color = CombatGUIParams.RED;
critData.Hit = hit;
critData.Priority = ViewParams.CRIT_PRIORITY;
critData.Text = "CRIT!";
critData.Target = target.GameHandle;
critData.YOffset = CombatGUIParams.FLOAT_OFFSET;
critData.Hit.AddDataDisplay(critData);
}
}
public void ModifyDmgViaDefender(MHit hit)
{
if (hit.Data.Ability.Data.IsHeal)
{
// TODO:
}
else if (!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Parry))
{
if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Block))
{
this.ProcessShieldBlock(hit);
}
else
{
this.Process(hit);
}
}
else
{
hit.Data.Dmg = 0;
}
}
private void ProcessDefenderHitsHelper(CChar target, MHit hit)
{
if (hit.Data.IsHeal)
{
this.DisplayHeal(target, hit);
}
else if (hit.Data.Action.Data.DisplayDefended)
{
if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge))
{
this.DisplayDodge(target, hit);
}
else if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Block))
{
this.DisplayBlock(target, hit);
}
else if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Parry))
{
this.DisplayParry(target, hit);
}
else
{
this.DisplayFlinch(target, hit);
}
}
else if (!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Block) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge) &&
!FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Parry))
{
this.DisplayFlinch(target, hit);
}
else
{
hit.CallbackHandler(this);
}
}
private List <GameObject> GetEmbedBulletTargets(MHit hit)
{
var tgts = new List <GameObject>();
if (hit.Data.Target.Current != null &&
hit.Data.Target.Current.GetType().Equals(typeof(CChar)))
{
var tgt = hit.Data.Target.Current as CChar;
if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge))
{
tgts.Add(tgt.Tile.Handle);
}
else if (FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Block))
{
if (tgt.Proxy.GetLWeapon() != null &&
tgt.Proxy.GetLWeapon().IsTypeOfShield())
{
tgts.Add(tgt.SubComponents[SortingLayers.CHAR_L_WEAPON]);
}
if (tgt.Proxy.GetRWeapon() != null &&
tgt.Proxy.GetRWeapon().IsTypeOfShield())
{
tgts.Add(tgt.SubComponents[SortingLayers.CHAR_R_WEAPON]);
}
}
else
{
if (tgt.Proxy.Type != ECharType.Critter)
{
if (tgt.SubComponents.ContainsKey(SortingLayers.CHAR_ARMOR))
{
tgts.Add(tgt.SubComponents[SortingLayers.CHAR_ARMOR]);
}
else
{
tgts.Add(tgt.SubComponents[SortingLayers.CHAR_TORSO]);
}
if (tgt.SubComponents.ContainsKey(SortingLayers.CHAR_HELM))
{
tgts.Add(tgt.SubComponents[SortingLayers.CHAR_HELM]);
}
else
{
tgts.Add(tgt.SubComponents[SortingLayers.CHAR_HEAD]);
}
if (tgt.SubComponents.ContainsKey(SortingLayers.CHAR_MOUNT))
{
tgts.Add(tgt.SubComponents[SortingLayers.CHAR_MOUNT]);
}
}
else
{
tgts.Add(tgt.SubComponents[SortingLayers.CHAR_MAIN]);
}
}
}
else
{
tgts.Add(hit.Data.Target.Handle);
}
return(tgts);
}
