private bool FilterJamTargets(GenericShip ship)
{
if (ship.Owner.PlayerNo == Selection.ThisShip.Owner.PlayerNo)
{
return(false);
}
if (ship.Tokens.HasToken(typeof(JamToken)))
{
return(false);
}
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(Selection.ThisShip, ship);
if (distanceInfo.Range <= 1)
{
return(true);
}
BoardTools.ShotInfo shotInfo = new BoardTools.ShotInfo(Selection.ThisShip, ship, Selection.ThisShip.PrimaryWeapons);
if (shotInfo.Range <= 2 && shotInfo.InPrimaryArc)
{
return(true);
}
return(false);
}
public override bool IsDiceModificationAvailable()
{
bool result = false;
if (Combat.AttackStep == (RerollType == RerollTypeEnum.AttackDice ? CombatStep.Attack : CombatStep.Defence))
{
var friendlyShip = RerollType == RerollTypeEnum.AttackDice ? Combat.Attacker : Combat.Defender;
if (CanReRollWithWeaponClass())
{
if (CanUseOwnAbility || friendlyShip != Host)
{
if (friendlyShip.Owner == Host.Owner)
{
BoardTools.DistanceInfo positionInfo = new BoardTools.DistanceInfo(Host, friendlyShip);
if (positionInfo.Range <= MaxFriendlyShipRange)
{
result = true;
}
}
}
}
}
return(result);
}
private void SaturationSalvoDamage(object sender, System.EventArgs e)
{
var allShips = Roster.AllShips.Select(x => x.Value).ToList();
foreach (GenericShip ship in allShips)
{
if (ship.ShipId == Combat.Defender.ShipId)
{
continue;
}
BoardTools.DistanceInfo shotInfo = new BoardTools.DistanceInfo(Combat.Defender, ship);
if (shotInfo.Range == 1 && ship.Agility < (Combat.ChosenWeapon as GenericUpgrade).Cost)
{
Triggers.RegisterTrigger(new Trigger()
{
Name = ship.ShipId + ": Saturation Salvo Damage Check",
TriggerType = TriggerTypes.OnAbilityDirect,
TriggerOwner = ship.Owner.PlayerNo,
EventHandler = StartSaturationSalvoCheckSubPhase,
Sender = ship
});
}
}
Triggers.ResolveTriggers(TriggerTypes.OnAbilityDirect, Triggers.FinishTrigger);
}
private void CheckSelflessnessAbility(GenericShip toDamage, DamageSourceEventArgs e)
{
curToDamage = toDamage;
curDamageInfo = e;
// Is this ship the defender in combat?
if (Combat.Defender != curToDamage)
{
return;
}
// Is the damage type a ship attack?
if (curDamageInfo.DamageType != DamageTypes.ShipAttack)
{
return;
}
// Is the defender on our team and not us? If not return.
if (Combat.Defender.Owner.PlayerNo != HostShip.Owner.PlayerNo || Combat.Defender.ShipId == HostShip.ShipId)
{
return;
}
// If the defender is at range one of us we register our trigger to prevent damage.
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(Combat.Defender, HostShip);
if (distanceInfo.Range == 1 && Combat.DiceRollAttack.RegularSuccesses > 0)
{
RegisterAbilityTrigger(TriggerTypes.OnTryDamagePrevention, UseSelflessnessAbility);
}
}
private void DoSplashDamage(GenericShip harpoonedShip, Action callback)
{
Messages.ShowInfo("\"Harpooned!\" condition deals splash damage");
var ships = Roster.AllShips.Select(x => x.Value).ToList();
foreach (GenericShip ship in ships)
{
// Defending ship shouldn't suffer additional damage
if (ship.ShipId == harpoonedShip.ShipId)
{
continue;
}
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(harpoonedShip, ship);
if (distanceInfo.Range == 1)
{
DamageSourceEventArgs harpoonconditionDamage = new DamageSourceEventArgs()
{
Source = "Harpoon Condition",
DamageType = DamageTypes.CardAbility
};
ship.Damage.TryResolveDamage(1, harpoonconditionDamage, callback);
}
}
}
private void AssaultMissilesHitEffect()
{
var ships = Roster.AllShips.Select(x => x.Value).ToList();
foreach (GenericShip ship in ships)
{
// null refs?
if (ship.Model == null || Combat.Defender == null || Combat.Defender.Model == null)
{
continue;
}
// Defending ship shouldn't suffer additional damage
if (ship.Model == Combat.Defender.Model)
{
continue;
}
BoardTools.DistanceInfo shotInfo = new BoardTools.DistanceInfo(Combat.Defender, ship);
if (shotInfo.Range == 1)
{
//Messages.ShowErrorToHuman(string.Format("{0} is within range 1 of {1}; assault missile deals 1 damage!", ship.PilotName, Combat.Defender.PilotName));
DamageSourceEventArgs assaultsplashDamage = new DamageSourceEventArgs()
{
Source = "Assault Missile",
DamageType = DamageTypes.CardAbility
};
ship.Damage.TryResolveDamage(1, assaultsplashDamage, Triggers.FinishTrigger);
}
}
}
public void CanPerformTargetLock(ref bool result, GenericShip attacker, ITargetLockable defender)
{
bool abilityIsActive = false;
if (defender is GenericShip)
{
if ((defender as GenericShip).ShipId != HostShip.ShipId)
{
if ((defender as GenericShip).Owner.PlayerNo == HostShip.Owner.PlayerNo)
{
BoardTools.DistanceInfo positionInfo = new BoardTools.DistanceInfo(attacker, HostShip);
if (positionInfo.Range >= attacker.TargetLockMinRange && positionInfo.Range <= attacker.TargetLockMaxRange)
{
abilityIsActive = true;
}
}
}
if (abilityIsActive)
{
if (Roster.GetPlayer(Phases.CurrentPhasePlayer).GetType() == typeof(Players.HumanPlayer))
{
Messages.ShowErrorToHuman("Captain Kagi: You cannot target lock that ship");
}
result = false;
}
}
}
protected virtual bool IsAvailable()
{
if (Combat.AttackStep != CombatStep.Attack)
{
return(false);
}
if (Combat.Attacker == HostShip)
{
return(false);
}
if (Combat.Attacker.Owner != HostShip.Owner)
{
return(false);
}
if (Combat.ChosenWeapon.GetType() != typeof(PrimaryWeaponClass))
{
return(false);
}
BoardTools.DistanceInfo positionInfo = new BoardTools.DistanceInfo(HostShip, Combat.Attacker);
if (positionInfo.Range > 1)
{
return(false);
}
return(true);
}
protected override bool IsAvailable()
{
if (Combat.AttackStep != CombatStep.Attack)
{
return(false);
}
if (Combat.Attacker.Owner != HostShip.Owner)
{
return(false);
}
if (Combat.ChosenWeapon.WeaponType != WeaponTypes.PrimaryWeapon)
{
return(false);
}
BoardTools.DistanceInfo positionInfo = new BoardTools.DistanceInfo(HostShip, Combat.Attacker);
if (positionInfo.Range > 1)
{
return(false);
}
return(true);
}
public void CanPerformAttack(ref bool result, List <string> stringList)
{
bool shipIsProtected = false;
if (Selection.AnotherShip.ShipId != HostShip.ShipId)
{
if (Selection.AnotherShip.Owner.PlayerNo == HostShip.Owner.PlayerNo)
{
BoardTools.DistanceInfo positionInfo = new BoardTools.DistanceInfo(Selection.AnotherShip, HostShip);
if (positionInfo.Range <= 1)
{
if (!Selection.ThisShip.ShipsBumped.Contains(HostShip))
{
if (Combat.ChosenWeapon.IsShotAvailable(HostShip))
{
shipIsProtected = true;
}
}
}
}
}
if (shipIsProtected)
{
if (Roster.GetPlayer(Phases.CurrentPhasePlayer).GetType() == typeof(Players.HumanPlayer))
{
stringList.Add("Biggs DarkLighter: You cannot attack target ship");
}
result = false;
}
}
private bool FilterTargets(GenericShip ship)
{
//Filter other friendly ships range 1
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(Host, ship);
return(ship.Owner.PlayerNo != Host.Owner.PlayerNo &&
ship != Host &&
distanceInfo.Range == 1);
}
private void CheckSelflessnessAbility()
{
if (Combat.Defender.Owner.PlayerNo == HostShip.Owner.PlayerNo && Combat.Defender.ShipId != HostShip.ShipId)
{
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(Combat.Defender, HostShip);
if (distanceInfo.Range == 1 && Combat.DiceRollAttack.RegularSuccesses > 0)
{
RegisterAbilityTrigger(TriggerTypes.OnTryDamagePrevention, UseSelflessnessAbility);
}
}
}
private void RegisterJanOrsAbility()
{
if (Combat.Attacker.Owner.PlayerNo == HostShip.Owner.PlayerNo && Combat.Attacker.ShipId != HostShip.ShipId)
{
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(Combat.Attacker, HostShip);
if (distanceInfo.Range < 4)
{
RegisterAbilityTrigger(TriggerTypes.OnAttackStart, AskJanOrsAbility);
}
}
}
private void RegisterJanOrsCrewAbility(GenericShip ship, System.Type tokenType)
{
if (tokenType == typeof(Tokens.FocusToken) && ship.Owner == HostShip.Owner && !IsAbilityUsed)
{
BoardTools.DistanceInfo positionInfo = new BoardTools.DistanceInfo(ship, HostShip);
if (positionInfo.Range <= 3)
{
TargetShip = ship;
RegisterAbilityTrigger(TriggerTypes.OnBeforeTokenIsAssigned, ShowDecision);
}
}
}
private void CheckAbility(GenericShip ship)
{
if (!IsAbilityUsed && ship.Owner.PlayerNo == HostShip.Owner.PlayerNo && ship.AssignedManeuver.ColorComplexity == Movement.MovementComplexity.Normal)
{
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(HostShip, ship);
if (distanceInfo.Range < 3)
{
ShipToRemoveStress = ship;
RegisterAbilityTrigger(TriggerTypes.OnMovementFinish, AskKananJarrusAbility);
}
}
}
private void CheckCarnorJaxRestriction(GenericShip ship, ActionsList.GenericAction action, ref bool isAllowed)
{
if (ship.Owner != HostShip.Owner && action.TokensSpend.Any(token => token == typeof(FocusToken) || token == typeof(EvadeToken)))
{
BoardTools.DistanceInfo positionInfo = new BoardTools.DistanceInfo(ship, HostShip);
if (positionInfo.Range <= 1)
{
Messages.ShowErrorToHuman("Carnor Jax: Cannot perform focus or evade actions, or spend focus or evade tokens");
isAllowed = false;
}
}
}
private void CaptainYorrPilotAbility(GenericShip ship, System.Type tokenType)
{
if (tokenType == typeof(Tokens.StressToken) && ship.Owner == HostShip.Owner && ship != HostShip && HostShip.Tokens.CountTokensByType(typeof(Tokens.StressToken)) <= 2)
{
BoardTools.DistanceInfo positionInfo = new BoardTools.DistanceInfo(ship, HostShip);
if (positionInfo.Range <= 2)
{
TargetShip = ship;
RegisterAbilityTrigger(TriggerTypes.OnBeforeTokenIsAssigned, ShowDecision);
}
}
}
private void RegisterTrigger(GenericShip ship)
{
var range = new BoardTools.DistanceInfo(HostShip, Combat.Attacker).Range;
if (Combat.Attacker.Owner == HostShip.Owner &&
Combat.Defender.Owner != HostShip.Owner &&
HostShip.SectorsInfo.IsShipInSector(Combat.Defender, Arcs.ArcType.Front) &&
range >= 1 && range <= 2)
{
RegisterAbilityTrigger(TriggerTypes.OnAttackFinish, AskPerformFocusAction);
}
}
private void CheckPilotAbility()
{
bool IsDifferentPlayer = (HostShip.Owner.PlayerNo != Combat.Attacker.Owner.PlayerNo);
bool HasFocusTokens = HostShip.Tokens.HasToken(typeof(Tokens.FocusToken));
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(HostShip, Combat.Attacker);
if (IsDifferentPlayer && HasFocusTokens && distanceInfo.Range < 3)
{
RegisterAbilityTrigger(TriggerTypes.OnAttackStart, AskDecreaseAttack);
}
}
private void RegisterAbility(GenericShip ship, Type tokenType)
{
if (tokenType == typeof(Tokens.WeaponsDisabledToken) && ship.Owner == HostShip.Owner && !ship.IsStressed && ship != HostShip && HostShip.State.Charges > 0)
{
BoardTools.DistanceInfo positionInfo = new BoardTools.DistanceInfo(ship, HostShip);
if (positionInfo.Range == 1)
{
TargetShip = ship;
RegisterAbilityTrigger(TriggerTypes.OnBeforeTokenIsAssigned, ShowDecision);
}
}
}
private void RegisterScavengerCraneAbility(GenericShip destroyedShip, bool isFled)
{
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(HostShip, destroyedShip);
if (distanceInfo.Range <= 2)
{
var recoverableUpgrades = GetRecoverableUpgrades();
if (recoverableUpgrades.Length > 0)
{
RegisterAbilityTrigger(TriggerTypes.OnShipIsDestroyed, AskUseScavengerCrane);
}
}
}
private void CheckAbility(GenericShip ship)
{
if (ship.IsBumped || BoardTools.Board.IsOffTheBoard(ship) || !HostShip.Tokens.HasToken <ForceToken>())
{
return;
}
if (ship.Owner.PlayerNo == HostShip.Owner.PlayerNo && ship.AssignedManeuver.ColorComplexity == Movement.MovementComplexity.Normal)
{
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(HostShip, ship);
if (distanceInfo.Range < 3)
{
ShipToRemoveStress = ship;
RegisterAbilityTrigger(TriggerTypes.OnMovementFinish, AskKananJarrusAbility);
}
}
}
private void AssaultMissilesHitEffect()
{
var ships = Roster.AllShips.Select(x => x.Value).ToList();
foreach (GenericShip ship in ships)
{
// null refs?
if (ship.Model == null || Combat.Defender == null || Combat.Defender.Model == null)
{
continue;
}
// Defending ship shouldn't suffer additional damage
if (ship.Model == Combat.Defender.Model)
{
continue;
}
BoardTools.DistanceInfo shotInfo = new BoardTools.DistanceInfo(Combat.Defender, ship);
if (shotInfo.Range == 1)
{
//Messages.ShowErrorToHuman(string.Format("{0} is within range 1 of {1}; assault missile deals 1 damage!", ship.PilotName, Combat.Defender.PilotName));
var diceRoll = new DiceRoll(DiceKind.Attack, 0, DiceRollCheckType.Combat);
diceRoll.AddDice(DieSide.Success);
var hitDie = diceRoll.DiceList [0];
ship.AssignedDamageDiceroll.DiceList.Add(hitDie);
Triggers.RegisterTrigger(new Trigger()
{
Name = "Suffer Assault Missile Damage",
TriggerType = TriggerTypes.OnDamageIsDealt,
TriggerOwner = ship.Owner.PlayerNo,
EventHandler = ship.SufferDamage,
Skippable = true,
EventArgs = new DamageSourceEventArgs()
{
Source = "Assault Missile",
DamageType = DamageTypes.CardAbility
}
});
}
}
Triggers.ResolveTriggers(TriggerTypes.OnDamageIsDealt, Triggers.FinishTrigger);
}
private void AssignIonTokens()
{
shipsToAssignIon = new List <GenericShip>();
var ships = Roster.AllShips.Select(x => x.Value).ToList();
foreach (GenericShip ship in ships)
{
BoardTools.DistanceInfo shotInfo = new BoardTools.DistanceInfo(Combat.Defender, ship);
if (shotInfo.Range == 1)
{
shipsToAssignIon.Add(ship);
}
}
AssignIonTokensRecursive();
}
protected bool FilterTargetsByRange(GenericShip ship, int minRange, int maxRange)
{
bool result = true;
if ((Phases.CurrentSubPhase as SelectShipSubPhase) == null || (Phases.CurrentSubPhase as SelectShipSubPhase).CanMeasureRangeBeforeSelection)
{
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(Selection.ThisShip, ship);
if (distanceInfo.Range < minRange)
{
return(false);
}
if (distanceInfo.Range > maxRange)
{
return(false);
}
}
return(result);
}
public Dictionary <GenericShip, float> GetEnemyShipsAndDistance(GenericShip thisShip, bool ignoreCollided = false, bool inArcAndRange = false)
{
Dictionary <GenericShip, float> results = new Dictionary <GenericShip, float>();
foreach (var shipHolder in Roster.GetPlayer(Roster.AnotherPlayer(thisShip.Owner.PlayerNo)).Ships)
{
if (!shipHolder.Value.IsDestroyed)
{
if (ignoreCollided)
{
if (thisShip.LastShipCollision != null)
{
if (thisShip.LastShipCollision.ShipId == shipHolder.Value.ShipId)
{
continue;
}
}
if (shipHolder.Value.LastShipCollision != null)
{
if (shipHolder.Value.LastShipCollision.ShipId == thisShip.ShipId)
{
continue;
}
}
}
if (inArcAndRange)
{
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(thisShip, shipHolder.Value);
if ((distanceInfo.Range > 3))
{
continue;
}
}
float distance = Vector3.Distance(thisShip.GetCenter(), shipHolder.Value.GetCenter());
results.Add(shipHolder.Value, distance);
}
}
results = results.OrderBy(n => n.Value).ToDictionary(n => n.Key, n => n.Value);
return(results);
}
public override bool IsActionEffectAvailable()
{
bool result = true;
foreach (var friendlyShip in Host.Owner.Ships)
{
if (friendlyShip.Value.ShipId != Host.ShipId)
{
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(Host, friendlyShip.Value);
if (distanceInfo.Range < 3)
{
result = false;
break;
}
}
}
return(result);
}
public bool IsDiceModificationAvailable()
{
var noFriendlyShipsInRange0to2 = true;
foreach (var friendlyShip in HostShip.Owner.Ships)
{
if (friendlyShip.Value != HostShip)
{
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(HostShip, friendlyShip.Value);
if (distanceInfo.Range < 3)
{
noFriendlyShipsInRange0to2 = false;
break;
}
}
}
return((HostShip.IsAttacking || HostShip.IsDefending) && noFriendlyShipsInRange0to2 && HostUpgrade.State.Charges > 0);
}
private void DoSplashDamage(GenericShip harpoonedShip, Action callback)
{
Messages.ShowInfo("\"Harpooned!\" condition deals splash damage");
var ships = Roster.AllShips.Select(x => x.Value).ToList();
foreach (GenericShip ship in ships)
{
// Defending ship shouldn't suffer additional damage
if (ship.ShipId == harpoonedShip.ShipId)
{
continue;
}
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(harpoonedShip, ship);
if (distanceInfo.Range == 1)
{
var diceRoll = new DiceRoll(DiceKind.Attack, 0, DiceRollCheckType.Combat);
diceRoll.AddDice(DieSide.Success);
var hitDie = diceRoll.DiceList[0];
ship.AssignedDamageDiceroll.DiceList.Add(hitDie);
Triggers.RegisterTrigger(new Trigger()
{
Name = "Suffer \"Harpooned!\" condition damage",
TriggerType = TriggerTypes.OnDamageIsDealt,
TriggerOwner = ship.Owner.PlayerNo,
EventHandler = ship.SufferDamage,
Skippable = true,
EventArgs = new DamageSourceEventArgs()
{
Source = "\"Harpooned!\" condition",
DamageType = DamageTypes.CardAbility
}
});
}
}
Triggers.ResolveTriggers(TriggerTypes.OnDamageIsDealt, callback);
}
private void CheckIdenVersioAbilitySE(GenericShip toDamage, DamageSourceEventArgs e)
{
curToDamage = toDamage;
// Is the defender on our team? If not return.
if (curToDamage.Owner.PlayerNo != HostShip.Owner.PlayerNo)
{
return;
}
if (!(curToDamage is Ship.SecondEdition.TIELnFighter.TIELnFighter))
{
return;
}
// If the defender is at range one of us we register our trigger to prevent damage.
BoardTools.DistanceInfo distanceInfo = new BoardTools.DistanceInfo(curToDamage, HostShip);
if (distanceInfo.Range <= 1)
{
RegisterAbilityTrigger(TriggerTypes.OnTryDamagePrevention, UseIdenVersioAbilitySE);
}
}
