public void Experience(FieldOfVisionTypes fieldOfVisionType, PuzzleBoard partialBoard)
{
Point centerPos = new Point();
switch (fieldOfVisionType)
{
case FieldOfVisionTypes.Single:
centerPos = new Point(0, 0);
break;
case FieldOfVisionTypes.ThreeByThree:
centerPos = new Point(1, 1);
break;
case FieldOfVisionTypes.FiveByFive:
centerPos = new Point(2, 2);
break;
}
List <ISensoryPattern> sensoryPatterns = new List <ISensoryPattern>();
for (int y = 0; y < partialBoard.Rows; y++)
{
for (int x = 0; x < partialBoard.Columns; x++)
{
Point pos = new Point(x, y);
DirectionTypes directionType = PuzzleReferee.ConvertToDirectionType(new Point(pos.X - centerPos.X, pos.Y - centerPos.Y));
PuzzleCellStateTypes state = partialBoard.GetState(pos);
int value = partialBoard.GetValue(pos);
string valueString = value >= 0 ? value.ToString() : " ";
if (state != PuzzleCellStateTypes.Undefined)
{
ISensoryUnit sensoryUnitState = GetOrCreateSensoryUnit(SensoryTypes.FieldState, state.ToString());
ISensoryUnit sensoryUnitValue = GetOrCreateSensoryUnit(SensoryTypes.FieldValue, valueString);
List <ISensoryUnit> sensoryUnits = new List <ISensoryUnit>();
sensoryUnits.Add(sensoryUnitState);
sensoryUnits.Add(sensoryUnitValue);
ISensoryPattern sensoryPattern = new SensoryPattern(directionType, sensoryUnits);
if (_kownSensoryPatterns.Contains(sensoryPattern))
{
sensoryPattern = _kownSensoryPatterns[_kownSensoryPatterns.IndexOf(sensoryPattern)];
}
else
{
_kownSensoryPatterns.Add(sensoryPattern);
_kownSensoryPatterns.Sort();
}
sensoryPatterns.Add(sensoryPattern);
}
}
}
_lastSensationSnapshot = new SensationSnapshot(DirectionTypes.Center, fieldOfVisionType, sensoryPatterns, IS_SAVEABLE_SNAPSHOT);
}
static public bool Contains(Dictionary <Tuple <FieldOfVisionTypes, DirectionTypes>, ISensationSnapshot> dictDirectionToSnapshot, IPartialSnapshotCompression partialSnapshotCompression)
{
ISensoryUnit baseUnit = partialSnapshotCompression.ChildNodes.FirstOrDefault().Unit;
var baseDirection = DirectionTypes.Center;
FieldOfVisionTypes fieldOfVision = partialSnapshotCompression.FieldOfVision;
ISensationSnapshot basePartialSnapshot = dictDirectionToSnapshot[new Tuple <FieldOfVisionTypes, DirectionTypes>(fieldOfVision, baseDirection)];
switch (partialSnapshotCompression.CompressionType)
{
case CompressionTypes.Unit:
return(basePartialSnapshot.SensoryPatterns.Any(p => p.SensoryUnits.Contains(baseUnit)));
case CompressionTypes.UnitSimpleTree:
case CompressionTypes.UnitCountTree:
case CompressionTypes.MultiUnitCountTree:
IEnumerable <ISensoryPattern> patterns = basePartialSnapshot.SensoryPatterns.Where(p => p.SensoryUnits.Contains(baseUnit));
IEnumerable <ISensoryUnit> childUnits = partialSnapshotCompression.ChildNodes.FirstOrDefault().ChildNodes.Select(p => p.Unit);
foreach (var direction in patterns.Select(p => p.DirectionType))
{
var childPartialSnapshot = dictDirectionToSnapshot[new Tuple <FieldOfVisionTypes, DirectionTypes>(fieldOfVision, direction)];
bool areChildNodesIncluded = false;
foreach (var childUnit in childUnits.Distinct())
{
var minCount = childUnits.Count(u => u.Equals(childUnit));
if (baseUnit.Equals(childUnit))
{
minCount++;
}
areChildNodesIncluded = childPartialSnapshot.SensoryPatterns.Count(p => p.SensoryUnits.Contains(childUnit)) >= minCount;
if (!areChildNodesIncluded)
{
break;
}
}
if (areChildNodesIncluded)
{
return(true);
}
}
break;
default:
throw new NotImplementedException();
}
return(false);
}
static public int GetNegativeCountOfSensoryUnit(IEnumerable <KeyValuePair <IPartialSnapshotCompression, IFeedbackCounter> > dictPartialSnapshotCompressions, ISensoryUnit sensoryUnit)
{
int result = 0;
foreach (var feedbackCount in GetFeedbackCounters(dictPartialSnapshotCompressions, sensoryUnit))
{
result += feedbackCount.NegativeCount;
}
return(result);
}
static public IEnumerable <IFeedbackCounter> GetFeedbackCounters(IEnumerable <KeyValuePair <IPartialSnapshotCompression, IFeedbackCounter> > dictPartialSnapshotCompressions, ISensoryUnit sensoryUnit)
{
var result = new List <IFeedbackCounter>();
foreach (KeyValuePair <IPartialSnapshotCompression, IFeedbackCounter> entry in dictPartialSnapshotCompressions.Where(e => e.Key.CompressionType == CompressionTypes.Unit))
{
foreach (var node in entry.Key.ChildNodes)
{
if (node is PartialSnapshotCompressionNode pscUnit && pscUnit.Unit.Equals(sensoryUnit))
{
result.Add(entry.Value);
break;
}
}
}
return(result);
}
static public IList <IActionMemory> Parse(IList <string> lines)
{
if (lines == null)
{
return(null);
}
IList <IActionMemory> result = new List <IActionMemory>();
IPuzzleAction action = null;
FileActionMemory fileActionMemory = null;
int parseType = 0;
FieldOfVisionTypes fieldOfVision = FieldOfVisionTypes.Single;
foreach (var line in lines)
{
if (line.StartsWith(IdentifierIPuzzleAction))
{
action = PuzzleAction.Parse(line.Substring(IdentifierIPuzzleAction.Length));
fileActionMemory = _fileActionMemories.Where(e => e.Action.Equals(action))?.FirstOrDefault();
if (fileActionMemory == null)
{
fileActionMemory = new FileActionMemory(action);
_fileActionMemories.Add(fileActionMemory);
}
result.Add(fileActionMemory);
continue;
}
if (fileActionMemory == null)
{
continue;
}
if (line.StartsWith(IdentifierDifferenceCount))
{
fileActionMemory.DifferenceCount += int.Parse(line.Substring(IdentifierDifferenceCount.Length));
}
else if (line.StartsWith(IdentifierNoDifferenceCount))
{
fileActionMemory.NoDifferenceCount += int.Parse(line.Substring(IdentifierNoDifferenceCount.Length));
}
else if (line.StartsWith(IdentifierPositiveFeedbackCount))
{
fileActionMemory.PositiveFeedbackCount += int.Parse(line.Substring(IdentifierPositiveFeedbackCount.Length));
}
else if (line.StartsWith(IdentifierNegativeFeedbackCount))
{
fileActionMemory.NegativeFeedbackCount += int.Parse(line.Substring(IdentifierNegativeFeedbackCount.Length));
}
else if (line.StartsWith(IdentifierDifferentUnits))
{
parseType = 1;
}
else if (line.StartsWith(IdentifierNoDifferentUnits))
{
parseType = 2;
}
else if (line.StartsWith(IdentifierNGetNoDifferencePattern))
{
fieldOfVision = (FieldOfVisionTypes)Enum.Parse(typeof(FieldOfVisionTypes), line.Substring(IdentifierNGetNoDifferencePattern.Length));
parseType = 3;
}
else if (line.StartsWith(IdentifierPositveDictPartialSnapshotCompressions))
{
parseType = 4;
}
else if (line.StartsWith(IdentifierNegativeDictPartialSnapshotCompressions))
{
parseType = 5;
}
else
{
var splitedLine = line.Split(new[] { '\t' });
if (splitedLine.Length < 4)
{
continue;
}
switch (parseType)
{
case 1: // DifferentUnits
ISensoryUnit differentUnit = SensoryUnit.Parse(splitedLine[2]);
int differentUnitCount = int.Parse(splitedLine[3]);
if (!fileActionMemory.DifferentUnits.ContainsKey(differentUnit))
{
fileActionMemory.DifferentUnits.Add(differentUnit, 0);
}
fileActionMemory.DifferentUnits[differentUnit] += differentUnitCount;
break;
case 2: // NoDifferentUnits
ISensoryUnit noDifferentUnit = SensoryUnit.Parse(splitedLine[2]);
int noDifferentUnitCount = int.Parse(splitedLine[3]);
if (!fileActionMemory.NoDifferentUnits.ContainsKey(noDifferentUnit))
{
fileActionMemory.NoDifferentUnits.Add(noDifferentUnit, 0);
}
fileActionMemory.NoDifferentUnits[noDifferentUnit] += noDifferentUnitCount;
break;
case 3: // DifferentUnits
Dictionary <ISensoryPattern, int> dictionarySensoryPatternCount = fileActionMemory.GetNoDifferencePattern(fieldOfVision);
ISensoryPattern noDifferentPattern = SensoryPattern.Parse(splitedLine[2]);
int noDifferentPatternCount = int.Parse(splitedLine[3]);
if (!dictionarySensoryPatternCount.ContainsKey(noDifferentPattern))
{
dictionarySensoryPatternCount.Add(noDifferentPattern, 0);
}
dictionarySensoryPatternCount[noDifferentPattern] += noDifferentPatternCount;
break;
case 4: // PositveDictPartialSnapshotCompressions
IPartialSnapshotCompression positveDictPartialSnapshotCompression = PartialSnapshotCompression.Parse(splitedLine[2]);
FeedbackCounter positiveFeedback = FeedbackCounter.Parse(splitedLine[3]) as FeedbackCounter;
if (!fileActionMemory.PositveDictPartialSnapshotCompressions.ContainsKey(positveDictPartialSnapshotCompression))
{
fileActionMemory.PositveDictPartialSnapshotCompressions.Add(positveDictPartialSnapshotCompression, new FeedbackCounter(0, 0));
}
positiveFeedback += fileActionMemory.PositveDictPartialSnapshotCompressions[positveDictPartialSnapshotCompression] as FeedbackCounter;
fileActionMemory.PositveDictPartialSnapshotCompressions[positveDictPartialSnapshotCompression] = positiveFeedback;
break;
case 5: // NegativeDictPartialSnapshotCompressions
IPartialSnapshotCompression negativeDictPartialSnapshotCompression = PartialSnapshotCompression.Parse(splitedLine[2]);
FeedbackCounter negativeFeedback = FeedbackCounter.Parse(splitedLine[3]) as FeedbackCounter;
if (!fileActionMemory.NegativeDictPartialSnapshotCompressions.ContainsKey(negativeDictPartialSnapshotCompression))
{
fileActionMemory.NegativeDictPartialSnapshotCompressions.Add(negativeDictPartialSnapshotCompression, new FeedbackCounter(0, 0));
}
negativeFeedback += fileActionMemory.NegativeDictPartialSnapshotCompressions[negativeDictPartialSnapshotCompression] as FeedbackCounter;
fileActionMemory.NegativeDictPartialSnapshotCompressions[negativeDictPartialSnapshotCompression] = negativeFeedback;
break;
}
}
}
return(result);
}
public SensoryUnit(ISensoryUnit sensoryUnit)
{
Id = sensoryUnit.Id;
Type = sensoryUnit.Type;
Value = sensoryUnit.Value;
}
public PartialSnapshotCompressionNode(ISensoryUnit unit)
{
Unit = unit;
}
