public override void Execute(EffectContext context)
{
List <Player> playersToApply = new List <Player>();
switch (AppliesTo)
{
case EffectApplication.ExecutingPlayer:
ApplyToPlayer(context.ExecutingPlayer, context);
break;
case EffectApplication.ReferenceChain:
Player curPlayer = context.ExecutingPlayer;
foreach (string reference in ReferenceChain)
{
curPlayer = curPlayer.GetReference(reference);
if (curPlayer == null)
{
Debug.LogError("Could not follow reference chain. Reference does not exist: " + reference);
return;
}
}
ApplyToPlayer(curPlayer, context);
break;
case EffectApplication.Target:
if (context.Targets == null)
{
return;
}
if (context.Targets.Count <= Target)
{
return;
}
ApplyToPlayer(context.Targets[Target], context);
break;
case EffectApplication.PlayerQuery:
playersToApply.AddRange(context.Game.Players);
break;
case EffectApplication.TargetQuery:
if (context.Targets == null)
{
return;
}
playersToApply.AddRange(context.Targets);
break;
}
List <Player> queried = Query.Query(playersToApply);
foreach (Player player in queried)
{
ApplyToPlayer(player, context);
}
}
protected override bool Pass(Player player, ConditionContext context)
{
int counterValue = player.GetCounterValue(Counter);
int comparedValue = 0;
switch (CompareTo)
{
case CompareToType.Value:
comparedValue = Value;
break;
case CompareToType.OtherCounter:
Player owningPlayer = player;
foreach (string reference in CounterReferenceChain)
{
owningPlayer = owningPlayer.GetReference(reference);
if (owningPlayer == null)
{
return(false);
}
}
comparedValue = owningPlayer.GetCounterValue(CompareToCounter);
break;
}
switch (Comparison)
{
case Operator.Equal:
return(counterValue == comparedValue);
case Operator.NotEqual:
return(counterValue != comparedValue);
case Operator.GreaterThan:
return(counterValue > comparedValue);
case Operator.GreaterThanOrEqualTo:
return(counterValue >= comparedValue);
case Operator.LessThan:
return(counterValue < comparedValue);
case Operator.LessThanOrEqualTo:
return(counterValue <= comparedValue);
default:
return(false);
}
}
public override bool Check(ConditionContext context)
{
List <Player> playersToApply = new List <Player>();
switch (AppliesTo)
{
// First are single target, we can return right here
case PlayerApplication.Self:
return(Pass(context.Subject, context));
case PlayerApplication.Target:
if (context.Targets == null)
{
return(false);
}
if (context.Targets.Count <= Target)
{
return(false);
}
return(Pass(context.Targets[Target], context));
case PlayerApplication.ReferenceChain:
Player refPlayer = context.Subject;
foreach (string reference in ReferenceChain)
{
refPlayer = refPlayer.GetReference(reference);
if (refPlayer == null)
{
return(false);
}
}
return(Pass(refPlayer, context));
// Rest are multi target, we need another pass over after so break instead of returning
case PlayerApplication.PlayerQuery:
playersToApply.AddRange(context.Game.Players);
break;
case PlayerApplication.TargetQuery:
if (context.Targets == null)
{
return(false);
}
playersToApply.AddRange(context.Targets);
break;
default:
return(false);
}
List <Player> queried = Query.Query(playersToApply);
int passCount = 0;
foreach (Player player in queried)
{
if (Pass(player, context))
{
passCount++;
}
}
switch (Requirement)
{
case ConditionRequirement.Exactly:
return(passCount == NumberOfPlayers);
case ConditionRequirement.AtLeast:
return(passCount >= NumberOfPlayers);
case ConditionRequirement.AtMost:
return(passCount <= NumberOfPlayers);
case ConditionRequirement.All:
return(passCount == queried.Count);
case ConditionRequirement.None:
return(passCount == 0);
default:
return(false);
}
}
