public void When_Two_Group_Do_It()
{
var target = GroupParser.NobiGroupParser();
var grpA = new BitPlane(10);
grpA.Add(new Coords(1, 1));
grpA.Add(new Coords(1, 2));
grpA.Add(new Coords(1, 3));
grpA.Add(new Coords(1, 4));
var grpB = new BitPlane(10);
grpB.Add(new Coords(4, 1));
grpB.Add(new Coords(4, 2));
grpB.Add(new Coords(4, 3));
grpB.Add(new Coords(4, 4));
var data = new BitPlane(10);
data.Or(grpA);
data.Or(grpB);
var actual = target.Parse(data.Copy());
Assert.AreEqual(2, actual.Count);
BitPlaneTestHelper.AssertBitPlane(grpA, actual[0], "Group A"); //Todo Algorithm : Make to Order Tolerance
BitPlaneTestHelper.AssertBitPlane(grpB, actual[1], "Group B");
}
public void When_Empty_BitPlane_Do_EmptyList()
{
var target = GroupParser.NobiGroupParser();
var data = new BitPlane(19);
var actual = target.Parse(data);
Assert.AreEqual(0, actual.Count);
}
public static void TraceBitPlane(BitPlane plane, string name)
{
Trace.WriteLine(name);
for (byte i = 0; i < plane.Width; i++)
{
for (byte j = 0; j < plane.Height; j++)
{
Trace.Write(plane[i, j] ? "X" : "O");
}
Trace.WriteLine($"|{i}");
}
}
private GoPlayerStat Build(BitPlane me, BitPlane all)
{
var ret = new GoPlayerStat();
var groups = _groupParser.Parse(me);
foreach (var group in groups)
{
var liberties = _libertiesParser.Parse(group, all);
ret.Groups.Add(new GroupStat(group, liberties));
}
return(ret);
}
private void DecompilePlaneValue(string key, BitPlane plane)
{
for (byte i = 0; i < plane.Width; i++)
{
for (byte j = 0; j < plane.Height; j++)
{
if (plane[i, j])
{
b.p(key, DecompilePointValue(i, j));
}
}
}
}
public void When_Singleton_Stones_Do_It()
{
var target = GroupParser.NobiGroupParser();
var data = new BitPlane(19);
data.Add(new Coords(1, 1));
data.Add(new Coords(2, 2));
data.Add(new Coords(3, 3));
data.Add(new Coords(4, 4));
data.Add(new Coords(5, 5));
var actual = target.Parse(data);
Assert.AreEqual(5, actual.Count);
}
public BitPlane Parse(BitPlane group, BitPlane allStones)
{
var ret = new BitPlane(allStones.Width, allStones.Height);
foreach (var coords in group.Unabled)
{
var liberties = AnalyticHelper.HortogonalCoord(coords).Where(
x => allStones.InOfRange(x) && !allStones[x]
);
ret.AddRange(liberties);
}
return(ret);
}
public void When_One_Group_Do_It()
{
var target = GroupParser.NobiGroupParser();
var grpA = new BitPlane(10);
grpA.Add(new Coords(1, 1));
grpA.Add(new Coords(1, 2));
grpA.Add(new Coords(1, 3));
grpA.Add(new Coords(1, 4));
var actual = target.Parse(grpA.Copy());
Assert.AreEqual(1, actual.Count);
BitPlaneTestHelper.AssertBitPlane(grpA, actual[0], "Group A");
}
public List <BitPlane> Parse(BitPlane stones)
{
var ret = new List <BitPlane>();
var scope = stones.Copy();
while (scope.Unabled.Any())
{
var grp = GroupWalker(scope, scope.Unabled.First());
var bp = new BitPlane(stones.Width, stones.Height);
bp.AddRange(grp);
ret.Add(bp);
}
return(ret);
}
private IEnumerable <ICoords> GroupWalker(BitPlane scope, ICoords fuse)
{
var todo = new List <ICoords>();
todo.Add(fuse);
while (todo.Any())
{
var target = todo.First();
yield return(target);
scope.Remove(target);
todo.Remove(target);
todo.AddRange(_walk(scope, target));
}
}
public void When_Corner_Do_Two()
{
var target = new LibertiesParser();
var data = new BitPlane(11);
data.Add(new Coords(0, 0));
var actual = target.Parse(data, data);
var excepted = new BitPlane(11);
excepted.Add(new Coords(0, 1));
excepted.Add(new Coords(1, 0));
BitPlaneTestHelper.AssertBitPlane(excepted, actual, "Corner");
}
public void When_Tengen_Do_Four()
{
var target = new LibertiesParser();
var data = new BitPlane(11);
data.Add(new Coords(5, 5));
var actual = target.Parse(data, data);
var excepted = new BitPlane(11);
excepted.Add(new Coords(4, 5));
excepted.Add(new Coords(6, 5));
excepted.Add(new Coords(5, 4));
excepted.Add(new Coords(5, 6));
BitPlaneTestHelper.AssertBitPlane(excepted, actual, "Tengen");
}
private static string DecompilePlaneValue(BitPlane plane)
{
var result = new StringBuilder();
for (byte i = 0; i < plane.Width; i++)
{
for (byte j = 0; j < plane.Height; j++)
{
if (plane[i, j])
{
result.Append('[');
result.Append(Convert.ToChar(i + 'a').ToString());
result.Append(Convert.ToChar(j + 'a').ToString());
result.Append(']');
}
}
}
return(result.ToString());
}
public static void AssertBitPlane(BitPlane excepted, BitPlane actual, string message)
{
var compare = excepted.Copy();
compare.Xor(actual);
if (!compare.Empty())
{
Trace.WriteLine(message);
TraceBitPlane(actual, "actual :");
TraceBitPlane(excepted, "excepted :");
TraceBitPlane(compare, "Errors :");
Assert.Fail("See Trace");
}
else
{
TraceBitPlane(actual, "Ok!");
}
}
public void When_Atari_Do_Zero()
{
var target = new LibertiesParser();
var grp = new BitPlane(11);
grp.Add(new Coords(5, 5));
var all = new BitPlane(11);
all.Add(new Coords(5, 5));
all.Add(new Coords(4, 5));
all.Add(new Coords(6, 5));
all.Add(new Coords(5, 4));
all.Add(new Coords(5, 6));
var actual = target.Parse(grp, all);
var excepted = new BitPlane(11);
BitPlaneTestHelper.AssertBitPlane(excepted, actual, "Atari");
}
public GroupStat(BitPlane stones, BitPlane liberties)
{
Stones = stones;
Liberties = liberties;
}
public static IEnumerable <ICoords> NobiWalk(BitPlane scope, ICoords target)
{
return(HortogonalCoord(target).Where(x => scope.InOfRange(x) && scope[x]));
}
