static public List <IPartialSnapshotCompression> NewInstancesOfUnitCountTreeCompression(Dictionary <ISensoryUnit, int> unitCountDictonary, ISensationSnapshot partialSnapshot, ISensationSnapshot snapShot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction)
{
var result = new List <IPartialSnapshotCompression>();
// Find 2-7 if 2-7 fields around are marked as Filled or Empty (two pattern with counted units) --> fieldOfVision.ThreeByThree
foreach (KeyValuePair <ISensoryUnit, int> unitCountEntry in unitCountDictonary)
{
var patterns = partialSnapshot.SensoryPatterns.Where(p => p.SensoryUnits.Contains(unitCountEntry.Key)).ToList();
foreach (ISensoryPattern pattern in patterns)
{
ISensationSnapshot partialSnapshot2 = SensationSnapshot.ExtractSnapshot(snapShot, fieldOfVision, PuzzleReferee.Addition(direction, pattern.DirectionType));
var unitCountDictonary2 = SensationSnapshot.CountUnits(partialSnapshot2);
foreach (KeyValuePair <ISensoryUnit, int> unitCountEntry2 in unitCountDictonary2)
{
if (unitCountEntry2.Key.Equals(unitCountEntry.Key) && unitCountEntry2.Value <= 1)
{
// If the same unit found one time in the field of view, it must be the exact same one.
continue;
}
var unitCompression = new PartialSnapshotCompression(CompressionTypes.UnitCountTree, fieldOfVision, DirectionTypes.Undefined);
var node = new PartialSnapshotCompressionNode(unitCountEntry.Key);
for (int i = 0; i < unitCountEntry2.Value; i++)
{
node.ChildNodes.Add(new PartialSnapshotCompressionNode(unitCountEntry2.Key));
}
unitCompression.ChildNodes.Add(node);
if (!result.Contains(unitCompression))
{
result.Add(unitCompression);
}
}
}
}
return(result);
}
static public IPartialSnapshotCompression Parse(string text)
{
if (string.IsNullOrEmpty(text))
{
return(null);
}
string parseText = text.Trim();
if (!parseText.StartsWith("{") || !parseText.EndsWith("}"))
{
return(null);
}
parseText = parseText.Substring(1, parseText.Length - 2);
string[] splits = parseText.Split(new[] { ',' });
if (splits.Length <= 2)
{
return(null);
}
CompressionTypes compressionType = (CompressionTypes)Enum.Parse(typeof(CompressionTypes), splits[0].Trim(), true);
FieldOfVisionTypes fieldOfVision = (FieldOfVisionTypes)Enum.Parse(typeof(FieldOfVisionTypes), splits[1].Trim(), true);
DirectionTypes direction = DirectionTypes.Undefined;
string childNodesText = splits[2].Trim();
if (!childNodesText.Contains("{"))
{
direction = (DirectionTypes)Enum.Parse(typeof(DirectionTypes), childNodesText, true);
childNodesText = splits[3].Trim();
}
var result = new PartialSnapshotCompression(compressionType, fieldOfVision, direction);
if (!childNodesText.Contains("<Empty>"))
{
if (!childNodesText.StartsWith(IdentifierChildNodes))
{
result.ChildNodes.Add(PartialSnapshotCompressionNode.Parse(childNodesText));
}
else
{
// =======================================================================================================================
// ToDo: Check ChildNodeTree also!!! Up to now it's only one single child handled! (Think about regular expressions maybe)
// =======================================================================================================================
childNodesText = childNodesText.Substring(IdentifierChildNodes.Length);
childNodesText = IdentifierChildNodes.Substring(0, childNodesText.Length - 1);
var splitedChildNodesText = childNodesText.Split(new[] { ';' });
foreach (var childNodeText in splitedChildNodesText)
{
result.ChildNodes.Add(PartialSnapshotCompressionNode.Parse(childNodeText));
}
}
}
return(result);
}
static public List <IPartialSnapshotCompression> NewInstancesOfUnitCompression(Dictionary <ISensoryUnit, int> unitCountDictonary, FieldOfVisionTypes fieldOfVision)
{
// Single units for fieldOfVision.Single and fieldOfVision.ThreeByThree allows to find 0 and 9
var result = new List <IPartialSnapshotCompression>();
foreach (var unitCountEntry in unitCountDictonary)
{
var unitCompression = new PartialSnapshotCompression(CompressionTypes.Unit, fieldOfVision, DirectionTypes.Undefined);
var node = new PartialSnapshotCompressionNode(unitCountEntry.Key);
unitCompression.ChildNodes.Add(node);
result.Add(unitCompression);
}
return(result);
}
static public IPartialSnapshotCompressionNode Parse(string text)
{
if (string.IsNullOrEmpty(text))
{
return(null);
}
string parseText = text.Trim();
if (!parseText.StartsWith("{") || !parseText.EndsWith("}"))
{
return(null);
}
parseText = parseText.Substring(1, parseText.Length - 2);
int seperatorIndex = parseText.IndexOf(':');
var unitParseText = seperatorIndex > 0 ? parseText.Substring(0, seperatorIndex) : parseText;
var unit = SensoryUnit.Parse(unitParseText);
var result = new PartialSnapshotCompressionNode(unit);
if (seperatorIndex > 0)
{
string childCountParseText = parseText.Substring(seperatorIndex + 1).Trim();
if (childCountParseText.Length > 2)
{
childCountParseText = childCountParseText.Substring(1, childCountParseText.Length - 2);
int multiplierIndex = childCountParseText.IndexOf('*');
int childCount = int.Parse(childCountParseText.Substring(0, multiplierIndex));
string childParseText = childCountParseText.Substring(multiplierIndex + 1);
var child = Parse(childParseText);
for (int i = 0; i < childCount; i++)
{
result.ChildNodes.Add(new PartialSnapshotCompressionNode(child.Unit));
}
}
}
return(result);
}
static public List <IPartialSnapshotCompression> NewInstancesOfMultiUnitCountTreeCompression(Dictionary <ISensoryUnit, int> unitCountDictonary, ISensationSnapshot partialSnapshot, ISensationSnapshot snapShot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction)
{
var result = new List <IPartialSnapshotCompression>();
// Find 2-7 if 2-7 fields around are marked as Filled or Empty (two pattern with counted units) --> fieldOfVision.ThreeByThree
foreach (KeyValuePair <ISensoryUnit, int> unitCountEntry in unitCountDictonary)
{
var patterns = partialSnapshot.SensoryPatterns.Where(p => p.SensoryUnits.Contains(unitCountEntry.Key)).ToList();
foreach (ISensoryPattern pattern in patterns)
{
ISensationSnapshot partialSnapshot2 = SensationSnapshot.ExtractSnapshot(snapShot, fieldOfVision, PuzzleReferee.Addition(direction, pattern.DirectionType));
var unitCountDictonary2 = SensationSnapshot.CountUnits(partialSnapshot2);
List <ISensoryUnit> sortedUnits = new List <ISensoryUnit>();
sortedUnits.AddRange(unitCountDictonary2.Keys.ToList());
sortedUnits.Sort();
for (int i = 0; i < sortedUnits.Count - 1; i++)
{
var unitKey1 = sortedUnits[i];
int unitValue1 = unitCountDictonary2[unitKey1];
if (unitKey1.Equals(unitCountEntry.Key))
{
unitValue1--;
if (unitValue1 < 1)
{
// If the same unit found one time in the field of view, it must be the exact same one.
continue;
}
}
for (int j = i + 1; j < sortedUnits.Count; j++)
{
var unitKey2 = sortedUnits[j];
var unitValue2 = unitCountDictonary2[unitKey2];
if (unitKey2.Equals(unitCountEntry.Key))
{
unitValue2--;
if (unitValue2 < 1)
{
// If the same unit found one time in the field of view, it must be the exact same one.
continue;
}
}
var unitCompression = new PartialSnapshotCompression(CompressionTypes.MultiUnitCountTree, fieldOfVision, DirectionTypes.Undefined);
var node = new PartialSnapshotCompressionNode(unitCountEntry.Key);
for (int q = 0; q < unitValue1; q++)
{
node.ChildNodes.Add(new PartialSnapshotCompressionNode(unitKey1));
}
for (int q = 0; q < unitValue2; q++)
{
node.ChildNodes.Add(new PartialSnapshotCompressionNode(unitKey2));
}
unitCompression.ChildNodes.Add(node);
if (!result.Contains(unitCompression))
{
result.Add(unitCompression);
}
}
}
}
}
return(result);
}
