public void Execute(GoBoard goBoard, Coordinate originPoint, int transform, MoveList moves)
{
PatternFunctionParameters<int> lPatternFunctionParameters = new PatternFunctionParameters<int>();
foreach (Coordinate lCoordinate in Parameters)
{
Coordinate lCoordinate2 = originPoint + (lCoordinate - Origin).Transform(transform);
lPatternFunctionParameters.Add(goBoard.Coord.At(lCoordinate2.X, lCoordinate2.Y));
}
Function(moves, lPatternFunctionParameters);
}
public static int SameString(GoBoard goBoard, Color player, PatternFunctionParameters<int> parameters)
{
return goBoard.IsSameString(parameters[0], parameters[1]) ? TRUE : FALSE;
}
public static int LibertyCountAfterMove(GoBoard goBoard, Color player, PatternFunctionParameters<int> parameters)
{
return LibertyCountAfterMove(goBoard, player, parameters[0]);
}
public static int LibertyCount(GoBoard goBoard, Color player, PatternFunctionParameters<int> parameters)
{
return goBoard.GetBlockLibertyCount(parameters[0]);
}
public static int IsSuicideXMove(GoBoard goBoard, Color player, PatternFunctionParameters<int> parameters)
{
return goBoard.IsSuicide(parameters[0], player.Opposite) ? TRUE : FALSE;
}
public static int IsSafeXMove(GoBoard goBoard, Color player, PatternFunctionParameters<int> parameters)
{
Color lPlayer = player.Opposite;
return ((goBoard.IsLegal(parameters[0], lPlayer))
&& (LibertyCountAfterMove(goBoard, lPlayer, parameters[0]) > 1)) ? TRUE : FALSE;
}
public static int IsLegalXMove(GoBoard goBoard, Color player, PatternFunctionParameters<int> parameters)
{
Color lPlayer = player.Opposite;
return (goBoard.IsLegal(parameters[0], lPlayer)) ? TRUE : FALSE;
}
public static void Test(MoveList moves, PatternFunctionParameters<int> patternFunctionParameters)
{
Console.Error.WriteLine("DEBUG: Test Action!");
}
public static int IsKo(GoBoard goBoard, Color player, PatternFunctionParameters<int> parameters)
{
return goBoard.IsKo(parameters[0]) ? TRUE : FALSE;
}
public PatternActionOperand(PatternActionFunctions.PatternActionFunction function, PatternFunctionParameters<Coordinate> parameters, Coordinate origin)
{
Function = function;
Parameters = parameters;
Origin = origin;
}
protected int EvaulateFunction()
{
PatternFunction lFunction = GetCurrentFunction();
NextToken();
NextToken();
PatternFunctionParameters<int> lPatternFunctionParameters = new PatternFunctionParameters<int>();
while (true)
{
PatternToken lToken = GetCurrentToken();
int lInt = GetTokenInteger(); // in case this is needed later
char lVariable = GetTokenVariable(); // in case this is needed later
NextToken();
if (lToken == PatternToken.COMMA)
continue;
if (lToken == PatternToken.CLOSE_PARA)
break;
if (lToken == PatternToken.INTEGER)
lPatternFunctionParameters.Add(lInt);
else if (lToken == PatternToken.VARIABLE)
{
Coordinate lCoordinate = OriginPoint + (Pattern.GetLetterLocation(lVariable) - Pattern.Origin).Transform(Transform);
lPatternFunctionParameters.Add(Board.Coord.At(lCoordinate.X, lCoordinate.Y));
}
else
lPatternFunctionParameters.Add(EvaulateExpression());
}
// Call function
return lFunction(Board, Player, lPatternFunctionParameters);
}
public static bool Execute(string method, MoveList moves, PatternFunctionParameters<int> patternFunctionParameters)
{
PatternActionFunction lFunction = GetFunction(method, patternFunctionParameters.Count);
if (lFunction == null)
return false;
try
{
lFunction(moves, patternFunctionParameters);
return true;
}
catch
{
return false;
}
}
public static void AntiSuji(MoveList moves, PatternFunctionParameters<int> patternFunctionParameters)
{
moves.RemoveMove(patternFunctionParameters[0]);
}
public static int Dead(GoBoard goBoard, Color player, PatternFunctionParameters<int> parameters)
{
return goBoard.GetSafetyStatus(parameters[0]).IsDead ? TRUE : FALSE;
}
public static int IsLegalOMove(GoBoard goBoard, Color player, PatternFunctionParameters<int> parameters)
{
return (goBoard.IsLegal(parameters[0], player)) ? TRUE : FALSE;
}
public static PatternActionCode Compile(PatternActionCode patternActionCode, Pattern pattern, string action)
{
if (string.IsNullOrEmpty(action))
return patternActionCode;
int lOpenParan = action.IndexOf('(');
int lCloseParan = action.IndexOf(')');
if (lOpenParan < 0)
{
patternActionCode.SetErrorMessage("Action line missing an open parentheses");
return patternActionCode;
}
if (lCloseParan < 0)
{
patternActionCode.SetErrorMessage("Action line missing a close parentheses");
return patternActionCode;
}
string lName = action.Substring(0, lOpenParan).Trim();
string lValues = action.Substring(lOpenParan + 1, lCloseParan - lOpenParan - 1).Trim();
PatternFunctionParameters<Coordinate> lPatternFunctionParameters = new PatternFunctionParameters<Coordinate>();
if (!string.IsNullOrEmpty(lValues))
{
string[] lParameters = lValues.Split(',');
foreach (string lParameter in lParameters)
{
if (lParameter.Length != 1)
{
patternActionCode.SetErrorMessage("Invalid action function parameter: " + lParameter);
return patternActionCode;
}
lPatternFunctionParameters.Add(pattern.GetLetterLocation(lParameter[0]));
}
}
PatternActionFunctions.PatternActionFunction lPatternActionFunction = PatternActionFunctions.GetFunction(lName, lPatternFunctionParameters.Count);
if (lPatternActionFunction == null)
{
patternActionCode.SetErrorMessage("Unknown action function: " + lName + " with " + lPatternFunctionParameters.Count + " parameters");
return patternActionCode;
}
patternActionCode.Add(new PatternActionOperand(lPatternActionFunction, lPatternFunctionParameters, pattern.Origin));
return patternActionCode;
}
public static void Replace(MoveList moves, PatternFunctionParameters<int> patternFunctionParameters)
{
double lValue = moves.GetValue(patternFunctionParameters[0]);
moves.RemoveMove(patternFunctionParameters[0]);
moves.SetMinValue(patternFunctionParameters[1], lValue); // redistribution (limited)
}
