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; }