public static bool isPlayRuleOK(HREngine.Private.Rule rule, Playfield p)
{
bool retval = true;
RuleEntity entity = (RuleEntity)rule.Entity;
RuleMethod method = (RuleMethod)rule.Method;
// wrong target
if (entity == RuleEntity.PlayerMinionField)
{
List <int> values = new List <int>();
foreach (Minion m in p.ownMinions)
{
if (method == RuleMethod.GetAttack)
{
values.Add(m.Angr);
}
if (method == RuleMethod.GetHealth)
{
values.Add(m.Hp);
}
if (method == RuleMethod.GetMana)
{
values.Add(m.Hp);
}
}
}
if (entity == RuleEntity.EnemyMinionField)
{
return(false);
}
return(retval);
}
/**
* To make it simple for the user, we can figure out the rule name
* from the calling method or class
*/
private string setMethodName(RuleMethod method, string ruleName)
{
/**
* A Rule method may not be set in constructor, so it can be null
*/
if (method != null)
{
// If no rule name, set the method name itself as the rule name
if (ruleName == null)
{
return(method.GetMethodInfo().Name);
}
}
else
{
/**
* For classes implementing Rule, their ctor will call the Rule constructor
* In which case the method will not be null, but .ctor
*
* In that case, find out the class name of the constructor and set it as ruleName
*/
if (ruleName == null)
{
string name;
int m = 1;
name = new StackFrame(1).GetMethod().DeclaringType.Name;
while (name == "Rule")
{
name = new StackFrame(++m).GetMethod().DeclaringType.Name;
}
return(name);
}
}
return(ruleName);
}
internal void Add(RuleMethod rule)
{
Remove(rule);
IsReadOnly = false;
Add(new BrokenRule(rule));
IsReadOnly = true;
}
internal void Remove(RuleMethod rule)
{
// we loop through using a numeric counter because
// removing items within a foreach isn't reliable
IsReadOnly = false;
for (int index = 0; index < Count; index++)
{
if (this[index].RuleName == rule.RuleName)
{
RemoveAt(index);
break;
}
}
IsReadOnly = true;
}
/**
* Remove Rule by method from the RulesList
*/
public bool RemoveRule(RuleMethod ruleMethod)
{
return(1 == RulesList.RemoveAll(rule => rule.RuleMethod == ruleMethod));
}
/**
* Spread parametrize constructor, making it easy for caller
* so that they don't have to create an object of RuleAttributes just to create a rule
*/
public Rule(RuleMethod ruleMethod = null, string ruleName = null, string ruleGroupName = "default", bool ruleEnabled = true, bool stopOnException = true, bool stopOnRuleFailure = false)
: this(ruleMethod, new RuleAttributes(ruleName, ruleGroupName, ruleEnabled, stopOnException, stopOnRuleFailure))
{
}
/**
* Core constructor which takes method and attributes
* Other constructors will call this
*/
public Rule(RuleMethod method, RuleAttributes ruleAttributes)
{
RuleMethod = method;
ruleAttributes.Name = setMethodName(RuleMethod, ruleAttributes.Name);
RuleAttributes = ruleAttributes;
}
