public SensationSnapshot(DirectionTypes directionType, FieldOfVisionTypes fieldOfVisionType, List <ISensoryPattern> sensoryPatterns, bool saveable = true) { Id = -1; Direction = directionType; FieldOfVision = fieldOfVisionType; SensoryPatterns.AddRange(sensoryPatterns); }
public PartialSnapshotCompression(CompressionTypes compressionType, FieldOfVisionTypes fieldOfVision, DirectionTypes direction) { Id = -1; CompressionType = compressionType; FieldOfVision = fieldOfVision; Direction = direction; }
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 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 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); }
private void FillPartialBoard(PuzzleBoard patialBoard, FieldOfVisionTypes fieldOfVisionType, Point position) { switch (fieldOfVisionType) { case FieldOfVisionTypes.Single: SetValueAndState(position, new Point(0, 0), patialBoard); break; case FieldOfVisionTypes.ThreeByThree: FillPartialBoard(patialBoard, FieldOfVisionTypes.Single, position); SetValueAndState(position, new Point(-1, 0), patialBoard); SetValueAndState(position, new Point(1, 0), patialBoard); SetValueAndState(position, new Point(0, -1), patialBoard); SetValueAndState(position, new Point(0, 1), patialBoard); SetValueAndState(position, new Point(-1, -1), patialBoard); SetValueAndState(position, new Point(-1, 1), patialBoard); SetValueAndState(position, new Point(1, 1), patialBoard); SetValueAndState(position, new Point(1, -1), patialBoard); break; case FieldOfVisionTypes.FiveByFive: FillPartialBoard(patialBoard, FieldOfVisionTypes.ThreeByThree, position); SetValueAndState(position, new Point(-2, 0), patialBoard); SetValueAndState(position, new Point(2, 0), patialBoard); SetValueAndState(position, new Point(0, 2), patialBoard); SetValueAndState(position, new Point(0, -2), patialBoard); SetValueAndState(position, new Point(-2, -1), patialBoard); SetValueAndState(position, new Point(-2, 1), patialBoard); SetValueAndState(position, new Point(2, -1), patialBoard); SetValueAndState(position, new Point(2, 1), patialBoard); SetValueAndState(position, new Point(-1, 2), patialBoard); SetValueAndState(position, new Point(1, 2), patialBoard); SetValueAndState(position, new Point(-1, -2), patialBoard); SetValueAndState(position, new Point(1, -2), patialBoard); SetValueAndState(position, new Point(-2, -2), patialBoard); SetValueAndState(position, new Point(-2, 2), patialBoard); SetValueAndState(position, new Point(2, -2), patialBoard); SetValueAndState(position, new Point(2, 2), patialBoard); break; } }
private PuzzleBoard CreatePartialBoard(FieldOfVisionTypes fieldOfVisionType, Point position) { PuzzleBoard partialBoard; switch (fieldOfVisionType) { case FieldOfVisionTypes.Single: partialBoard = new PuzzleBoard(1, 1); break; case FieldOfVisionTypes.ThreeByThree: partialBoard = new PuzzleBoard(3, 3); break; case FieldOfVisionTypes.FiveByFive: partialBoard = new PuzzleBoard(5, 5); break; default: return(null); } FillPartialBoard(partialBoard, fieldOfVisionType, position); return(partialBoard); }
private void DrawFieldOfVision(FieldOfVisionTypes fieldOfVisionType, Point position) { PuzzleBoard partialBoard = CreatePartialBoard(fieldOfVisionType, position); if (partialBoard == null) { return; } int width = partialBoard.Columns; int height = partialBoard.Rows; int drawCellSize = Math.Min(_pbxLookResult.Width, _pbxLookResult.Height); int maxFieldDimension = Math.Max(width, height); drawCellSize = drawCellSize / maxFieldDimension; int drawWidth = width * drawCellSize; int drawHeight = height * drawCellSize; Bitmap playGround = new Bitmap(drawWidth + 1, drawHeight + 1); Bitmap playGroundBackground = new Bitmap(drawWidth + 1, drawHeight + 1); Font font = new Font(Font.FontFamily, (int)Math.Round(drawCellSize * 0.55)); using (Graphics graphics = Graphics.FromImage(playGround)) { using (Graphics graphicsBackground = Graphics.FromImage(playGroundBackground)) { graphics.Clear(Color.Transparent); graphicsBackground.Clear(Color.White); for (int y = 0; y <= partialBoard.Rows; y++) { graphics.DrawLine(new Pen(Color.Gray), 0, y * drawCellSize, drawWidth, y * drawCellSize); } for (int x = 0; x <= partialBoard.Columns; x++) { graphics.DrawLine(new Pen(Color.Gray), x * drawCellSize, 0, x * drawCellSize, drawHeight); } for (int y = 0; y < partialBoard.Rows; y++) { for (int x = 0; x < partialBoard.Columns; x++) { Point cellPos = new Point(x, y); int drawX = x * drawCellSize; int drawY = y * drawCellSize; int number = partialBoard.GetValue(cellPos); if (number >= 0 && number <= 9) { Brush fontBrush = partialBoard.GetState(cellPos) == PuzzleCellStateTypes.Filled ? Brushes.White : Brushes.Black; graphics.DrawString(number.ToString(), font, fontBrush, new Rectangle(drawX + (30 / maxFieldDimension), drawY + (10 / maxFieldDimension), drawCellSize, drawCellSize)); } switch (partialBoard.GetState(cellPos)) { case PuzzleCellStateTypes.Undefined: graphicsBackground.FillRectangle(Brushes.Yellow, drawX, drawY, drawCellSize, drawCellSize); break; case PuzzleCellStateTypes.Filled: graphicsBackground.FillRectangle(Brushes.Black, drawX, drawY, drawCellSize, drawCellSize); break; case PuzzleCellStateTypes.Empty: graphicsBackground.FillRectangle(Brushes.Gainsboro, drawX, drawY, drawCellSize, drawCellSize); graphicsBackground.DrawLine(new Pen(Color.Gray), drawX, drawY, drawX + drawCellSize, drawY + drawCellSize); graphicsBackground.DrawLine(new Pen(Color.Gray), drawX, drawY + drawCellSize, drawX + drawCellSize, drawY); break; case PuzzleCellStateTypes.Outside: graphicsBackground.FillRectangle(Brushes.DarkBlue, drawX, drawY, drawCellSize, drawCellSize); graphicsBackground.DrawLine(new Pen(Color.White), drawX, drawY, drawX + drawCellSize, drawY + drawCellSize); graphicsBackground.DrawLine(new Pen(Color.White), drawX, drawY + drawCellSize, drawX + drawCellSize, drawY); break; } } } } } _pbxLookResult.Image = playGround; _pbxLookResult.BackgroundImage = playGroundBackground; }
public Dictionary <ISensoryPattern, int> GetNoDifferencePattern(FieldOfVisionTypes fieldOfVision) { return(_noDifferencePatternDictonary[fieldOfVision]); }
static public List <IPartialSnapshotCompression> NewInstances(ISensationSnapshot snapshot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction, CompressionTypes maximumCompression) { var result = new List <IPartialSnapshotCompression>(); ISensationSnapshot partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, direction); // Single units for fieldOfVision.Single and fieldOfVision.ThreeByThree allows to find 0 and 9 var unitCountDictonary = SensationSnapshot.CountUnits(partialSnapshot); result.AddRange(NewInstancesOfUnitCompression(unitCountDictonary, fieldOfVision)); if (maximumCompression >= CompressionTypes.UnitSimpleTree) { // Find 1 and 8 if a field around is marked as Filled or Empty (two pattern with single unit) --> fieldOfVision.ThreeByThree result.AddRange(NewInstancesOfUnitSimpleTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction)); } if (maximumCompression >= CompressionTypes.UnitCountTree) { // ToDo: Find 2-7 if 2-7 fields around are marked as Filled or Empty (two pattern with counted units) --> fieldOfVision.ThreeByThree result.AddRange(NewInstancesOfUnitCountTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction)); } if (maximumCompression >= CompressionTypes.MultiUnitCountTree) { // ToDo: Find 1-5 fields at the boarder with combination of Empty and Outside --> fieldOfVision.ThreeByThree result.AddRange(NewInstancesOfMultiUnitCountTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction)); } return(result); }
static public List <IPartialSnapshotCompression> NewInstancesOfMultiUnitCountTreeCompression(ISensationSnapshot snapshot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction) { var result = new List <IPartialSnapshotCompression>(); ISensationSnapshot partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, direction); var unitCountDictonary = SensationSnapshot.CountUnits(partialSnapshot); result.AddRange(NewInstancesOfMultiUnitCountTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction)); 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); }
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); }
public void RememberDifference(bool isDifferent, ISensationSnapshot snapshot) { FieldOfVisionTypes fieldOfVision = GetFieldOfVisionsForDifferences().Last(); var partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, Action.Direction); // Handles counter and single units if (isDifferent) { DifferenceCount++; var singleUnits = SplitUnits(partialSnapshot); foreach (var unit in singleUnits) { if (!DifferentUnits.ContainsKey(unit) && NoDifferentUnits.ContainsKey(unit)) { DifferentUnits.Add(unit, 0); } if (DifferentUnits.ContainsKey(unit)) { DifferentUnits[unit]++; } } List <ISensoryUnit> unitsToRemove = new List <ISensoryUnit>(); foreach (var entry in DifferentUnits) { if (!NoDifferentUnits.ContainsKey(entry.Key)) { unitsToRemove.Add(entry.Key); } } foreach (var unit in unitsToRemove) { DifferentUnits.Remove(unit); } } else { NoDifferenceCount++; var singleUnits = SplitUnits(partialSnapshot); foreach (var unit in singleUnits) { if (!NoDifferentUnits.ContainsKey(unit)) { NoDifferentUnits.Add(unit, 0); } NoDifferentUnits[unit]++; } } if (NoDifferenceCount > MINIMUM_CALL_COUNT_FOR_DIFFERENT_PATTERN && DifferenceCount > 0) { if (isDifferent) { // Look for pattern in No-Difference-Dictionary, which have brought about a change foreach (var pattern in SplitPattern(partialSnapshot, 1)) { if (GetNoDifferencePattern(fieldOfVision).ContainsKey(pattern)) { GetNoDifferencePattern(fieldOfVision).Remove(pattern); } } } else { // Looking for pattern that probably show, that there is no effect by handling this action foreach (var pattern in SplitPattern(partialSnapshot, 1)) { bool patternFound = true; foreach (var unit in pattern.SensoryUnits) { if (!NoDifferentUnits.ContainsKey(unit)) { patternFound = false; break; } } if (patternFound) { if (!GetNoDifferencePattern(fieldOfVision).ContainsKey(pattern)) { GetNoDifferencePattern(fieldOfVision).Add(pattern, 0); } GetNoDifferencePattern(fieldOfVision)[pattern]++; } } } } }
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); }
public void RememberFeedback(int feedbackValue, ISensationSnapshot snapshot) { FieldOfVisionTypes fieldOfVision = GetFieldOfVisionsForFeedback().Last(); List <IPartialSnapshotCompression> partialSnapshotCompressions = PartialSnapshotCompression.NewInstances(snapshot, fieldOfVision, Action.Direction, GetMaximumCompression()); if (feedbackValue < 0) { NegativeFeedbackCount++; // ########### PartialSnapshotCompression ############# foreach (IPartialSnapshotCompression pscEntry in partialSnapshotCompressions) { if (PositveDictPartialSnapshotCompressions.ContainsKey(pscEntry)) { PositveDictPartialSnapshotCompressions.Remove(pscEntry); } bool containingEntryExists = false; foreach (IPartialSnapshotCompression negativePsc in NegativeDictPartialSnapshotCompressions.Keys) { if (GetNegativeFeedbackPercentage(negativePsc) >= 0.99 && pscEntry.Contains(negativePsc)) { containingEntryExists = true; break; } } if (containingEntryExists) { continue; } if (!NegativeDictPartialSnapshotCompressions.ContainsKey(pscEntry)) { NegativeDictPartialSnapshotCompressions.Add(pscEntry, new FeedbackCounter(PositiveFeedbackCount, NegativeFeedbackCount)); } else if (GetNegativeFeedbackPercentage(pscEntry) >= 0.99) { var entriesToRemove = new List <IPartialSnapshotCompression>(); foreach (IPartialSnapshotCompression existingPsc in NegativeDictPartialSnapshotCompressions.Keys.Where(p => p.CompressionType != pscEntry.CompressionType)) { if (existingPsc.Contains(pscEntry)) { entriesToRemove.Add(existingPsc); } } if (entriesToRemove.Any()) { foreach (IPartialSnapshotCompression existingPsc in entriesToRemove) { NegativeDictPartialSnapshotCompressions.Remove(existingPsc); } } } else { NegativeDictPartialSnapshotCompressions[pscEntry].NegativeLifeCycleStamp = NegativeFeedbackCount; NegativeDictPartialSnapshotCompressions[pscEntry].NegativeCount++; } } } else if (feedbackValue > 0) { PositiveFeedbackCount++; // ########### PartialSnapshotCompression ############# foreach (IPartialSnapshotCompression pscEntry in partialSnapshotCompressions) { if (NegativeDictPartialSnapshotCompressions.ContainsKey(pscEntry)) { NegativeDictPartialSnapshotCompressions.Remove(pscEntry); } if (OverallNegativePartialSnapshotCompressions.Contains(pscEntry)) { if (!PositveDictPartialSnapshotCompressions.ContainsKey(pscEntry)) { PositveDictPartialSnapshotCompressions.Add(pscEntry, new FeedbackCounter(PositiveFeedbackCount, NegativeFeedbackCount)); } else { PositveDictPartialSnapshotCompressions[pscEntry].PositiveLifeCycleStamp = PositiveFeedbackCount; PositveDictPartialSnapshotCompressions[pscEntry].PositiveCount++; } } } } if (feedbackValue != 0) { List <IPartialSnapshotCompression> sortedKeys = NegativeDictPartialSnapshotCompressions.Keys.ToList(); sortedKeys.Sort(); var keysToRemove = new List <IPartialSnapshotCompression>(); for (int i = 0; i < sortedKeys.Count - 1; i++) { for (int j = i + 1; j < sortedKeys.Count; j++) { var a = sortedKeys[i]; var b = sortedKeys[j]; if (a.Contains(b) && NegativeDictPartialSnapshotCompressions[a].NegativeCount < NegativeDictPartialSnapshotCompressions[b].NegativeCount) { keysToRemove.Add(a); } else if (b.Contains(a) && NegativeDictPartialSnapshotCompressions[b].NegativeCount < NegativeDictPartialSnapshotCompressions[a].NegativeCount) { keysToRemove.Add(b); } } } foreach (var key in keysToRemove) { NegativeDictPartialSnapshotCompressions.Remove(key); } } }
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); }
static public ISensationSnapshot ExtractSnapshot(ISensationSnapshot sensationSnapshot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction) { if (fieldOfVision == FieldOfVisionTypes.Single) { Point centerPos = PuzzleReferee.ConvertToPoint(direction); var resultPatterns = new List <ISensoryPattern>(); foreach (ISensoryPattern pattern in sensationSnapshot.SensoryPatterns) { if (direction.Equals(pattern.DirectionType)) { var newPattern = new SensoryPattern(pattern); Point oldPatternPos = PuzzleReferee.ConvertToPoint(newPattern.DirectionType); var newPatternPos = new Point(oldPatternPos.X - centerPos.X, oldPatternPos.Y - centerPos.Y); newPattern.DirectionType = PuzzleReferee.ConvertToDirectionType(newPatternPos); resultPatterns.Add(newPattern); } } return(new SensationSnapshot(PuzzleReferee.ConvertToDirectionType(centerPos), FieldOfVisionTypes.Single, resultPatterns, false)); } else if (fieldOfVision == FieldOfVisionTypes.ThreeByThree) { Point centerPos = PuzzleReferee.ConvertToPoint(direction); List <DirectionTypes> fieldOfVisionDirections = new List <DirectionTypes>(); for (int sy = -1; sy < 2; sy++) { for (int sx = -1; sx < 2; sx++) { fieldOfVisionDirections.Add(PuzzleReferee.ConvertToDirectionType(new Point(sx + centerPos.X, sy + centerPos.Y))); } } var resultPatterns = new List <ISensoryPattern>(); foreach (ISensoryPattern pattern in sensationSnapshot.SensoryPatterns) { if (fieldOfVisionDirections.Contains(pattern.DirectionType)) { var newPattern = new SensoryPattern(pattern); Point oldPatternPos = PuzzleReferee.ConvertToPoint(newPattern.DirectionType); var newPatternPos = new Point(oldPatternPos.X - centerPos.X, oldPatternPos.Y - centerPos.Y); newPattern.DirectionType = PuzzleReferee.ConvertToDirectionType(newPatternPos); resultPatterns.Add(newPattern); } } return(new SensationSnapshot(PuzzleReferee.ConvertToDirectionType(centerPos), FieldOfVisionTypes.ThreeByThree, resultPatterns, false)); } throw new NotImplementedException(); }