added auto think time update; added destiation on ui

.idea/.idea.uqac-ia-aspirobot/.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

uqac-ia-aspirobot/Agent/AgAgent.cs

-using System.Linq;
+using System;
+using System.Linq;
 using System.Threading;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
             _state = state;
             _ui = ui;
             _options = options.Value;
-            _state.SleepTime = _options.SleepTime;
+            _state.LastThinkTime = DateTime.MinValue;
+            _state.ThinkTimeInterval = _options.ThinkTimeInterval;
         }
 
         private void Run()
 
             while (running)
             {
-                if (_state.SleepTime > 0)
+                if (_options.SleepTime > 0)
                 {
-                    Thread.Sleep(_state.SleepTime);
+                    Thread.Sleep(_options.SleepTime);
                 }
                 UpdateSensors();
                 _ui.Update();
 
         public void UpdateState()
         {
-            var dustyRooms = _environment.FindDustyRooms();//TODO Compute average on xx last values
-            if (_options.AutoAdjustSleepTime)
+            if (_options.AutoAdjustThinkTimeInterval)
             {
-                if (dustyRooms.Count > _state.DustyRooms.Count)
+                var dustyRooms = _environment.FindDustyRooms();
+                if ((dustyRooms.Count < _state.DustyRooms.Count || !dustyRooms.Any()) && _state.ThinkTimeInterval < 7500)
                 {
-                    _state.SleepTime += _state.SleepTime / 2;
+                    _state.ThinkTimeInterval += _state.ThinkTimeInterval / 2;
                 }
-                else if (dustyRooms.Count < _state.DustyRooms.Count)
+                else if (dustyRooms.Count > _state.DustyRooms.Count && _state.ThinkTimeInterval > 100)
                 {
-                    _state.SleepTime -= _state.SleepTime / 2;
+                    _state.ThinkTimeInterval -= _state.ThinkTimeInterval / 2;
                 }
+                _state.DustyRooms = dustyRooms;
+            }
+            else
+            {
+                _state.DustyRooms = _environment.FindDustyRooms();
             }
-            _state.DustyRooms = dustyRooms;
         }
 
         public void Think()
         {
-            if (_state.Destination == null && _state.DustyRooms.Any())
+            if (_state.LastThinkTime.AddMilliseconds(_state.ThinkTimeInterval) <= DateTime.Now)
             {
-                _state.Destination = _state.DustyRooms.OrderBy(room => room.Distance(_engineEffector)).First();
+                if (_state.Destination == null && _state.DustyRooms.Any())
+                {
+                    _state.Destination = _state.DustyRooms.OrderBy(room => room.Distance(_engineEffector)).First();
+                }
+                _state.LastThinkTime = DateTime.Now;
             }
         }
 

uqac-ia-aspirobot/Agent/AgConfig.cs

 {
     public class AgConfig
     {
-        public bool AutoAdjustSleepTime { get; set; }
+        public bool AutoAdjustThinkTimeInterval { get; set; }
 
         public int SleepTime { get; set; }
 
+        public int ThinkTimeInterval { get; set; }
+
         public int StartX { get; set; }
 
         public int StartY { get; set; }
 
         public void CopyTo(AgConfig other)
         {
+            other.AutoAdjustThinkTimeInterval = AutoAdjustThinkTimeInterval;
             other.SleepTime = SleepTime;
+            other.ThinkTimeInterval = ThinkTimeInterval;
             other.StartX = StartX;
             other.StartY = StartY;
         }

uqac-ia-aspirobot/Agent/AgState.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using uqac_ia_aspirobot.Interfaces;
 
 namespace uqac_ia_aspirobot.Agent
 {
     public class AgState
     {
-        public int SleepTime { get; set; }
+        public int ThinkTimeInterval { get; set; }
+
+        public DateTime LastThinkTime { get; set; }
 
         public IList<IRoom> DustyRooms { get; set; }
 

uqac-ia-aspirobot/Agent/Effectors/AgEngineEffector.cs

-using System;
-using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Options;
 using uqac_ia_aspirobot.Extensions;
 
 namespace uqac_ia_aspirobot.Agent.Effectors

uqac-ia-aspirobot/Common/ArStreamString.cs

 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Text;
 
 {
     public class ArStreamString
     {
-        private readonly Stream ioStream;
-        private readonly UnicodeEncoding streamEncoding;
-        private readonly IList<string> _writtenStrings = new List<string>();
-        private readonly IList<string> _readStrings = new List<string>();
+        private readonly Stream _ioStream;
+        private readonly UnicodeEncoding _streamEncoding;
 
         public ArStreamString(Stream ioStream)
         {
-            this.ioStream = ioStream;
-            streamEncoding = new UnicodeEncoding();
+            _ioStream = ioStream;
+            _streamEncoding = new UnicodeEncoding();
         }
 
         public string ReadString()
         {
-            int len = ioStream.ReadByte() * 256;
-            len += ioStream.ReadByte();
-            byte[] inBuffer = new byte[len];
-            ioStream.Read(inBuffer, 0, len);
+            var len = _ioStream.ReadByte() * 256;
+            len += _ioStream.ReadByte();
+            var inBuffer = new byte[len];
+            _ioStream.Read(inBuffer, 0, len);
 
-            var str = streamEncoding.GetString(inBuffer);
-            _readStrings.Add(str);
+            var str = _streamEncoding.GetString(inBuffer);
             return str;
         }
 
 
         public int Write(string outString)
         {
-            _writtenStrings.Add(outString);
-            byte[] outBuffer = streamEncoding.GetBytes(outString);
-            int len = outBuffer.Length;
-            if (len > UInt16.MaxValue)
+            var outBuffer = _streamEncoding.GetBytes(outString);
+            var len = outBuffer.Length;
+            if (len > ushort.MaxValue)
             {
-                len = (int)UInt16.MaxValue;
+                len = ushort.MaxValue;
             }
-            ioStream.WriteByte((byte)(len / 256));
-            ioStream.WriteByte((byte)(len & 255));
-            ioStream.Write(outBuffer, 0, len);
-            ioStream.Flush();
+            _ioStream.WriteByte((byte)(len / 256));
+            _ioStream.WriteByte((byte)(len & 255));
+            _ioStream.Write(outBuffer, 0, len);
+            _ioStream.Flush();
 
             return outBuffer.Length + 2;
         }

uqac-ia-aspirobot/Extensions/Extensions.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
+using uqac_ia_aspirobot.Agent;
 using uqac_ia_aspirobot.Agent.Effectors;
 using uqac_ia_aspirobot.Common;
 using uqac_ia_aspirobot.Interfaces;
             return engine.X == x && engine.Y == y;
         }
 
+        public static bool IsInPosition(this IRoom room, int x, int y)
+        {
+            return room.X == x && room.Y == y;
+        }
+
         public static bool IsInRoom(this AgEngineEffector engine, IRoom room)
         {
             return engine.IsInPosition(room.X, room.Y);

uqac-ia-aspirobot/Program.cs

                 ActionPropability = 30.0f,
                 AddDustProbability = 50.0f,
                 AddJewelProbability = 50.0f,
-//                RemoveJewelProbability = 50.0f,
-                RemoveJewelProbability = 0,
+                RemoveJewelProbability = 30.0f,
                 SleepTime = 1000
             }, arConfig);
 
                 SleepTime = 1000,
                 StartX = 0,
                 StartY = 0,
-                AutoAdjustSleepTime = false
+                AutoAdjustThinkTimeInterval = true,
+                ThinkTimeInterval = 10000
             }, arConfig);
 
             AgAgent.Join();

uqac-ia-aspirobot/UI/UiConsole.cs

         private readonly AgPickedSensor _agPickedSensor;
         private readonly AgBatterySensor _agBatterySensor;
         private readonly AgVaccumSensor _agVaccumSensor;
+        private readonly AgState _agState;
 
         public UiConsole(IEnvironment environment, AgEngineEffector agEngineEffector, AgPickedSensor agPickedSensor,
-            AgBatterySensor agBatterySensor, AgVaccumSensor agVaccumSensor)
+            AgBatterySensor agBatterySensor, AgVaccumSensor agVaccumSensor, AgState agState)
         {
             _environment = environment;
             _agEngineEffector = agEngineEffector;
             _agPickedSensor = agPickedSensor;
             _agBatterySensor = agBatterySensor;
             _agVaccumSensor = agVaccumSensor;
+            _agState = agState;
         }
 
         public void SetBackgroundColor(ConsoleColor? color)
             }
         }
 
+        public void SetForegroundColor(ConsoleColor? color)
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                Console.ForegroundColor = color.GetValueOrDefault(ConsoleColor.Black);
+            }
+            else
+            {
+                var str = "";
+                if (color == null)
+                {
+                    str = $"{(char)27}[1;39m";
+                }
+                if (color == ConsoleColor.Black)
+                {
+                    str = $"{(char)27}[1;30m";
+                }
+                if (color == ConsoleColor.Red)
+                {
+                    str = $"{(char)27}[1;31m";
+                }
+                if (color == ConsoleColor.Green)
+                {
+                    str = $"{(char)27}[1;32m";
+                }
+                if (color == ConsoleColor.Yellow)
+                {
+                    str = $"{(char)27}[1;33m";
+                }
+                if (color == ConsoleColor.Blue)
+                {
+                    str = $"{(char)27}[1;34m";
+                }
+                if (color == ConsoleColor.Magenta)
+                {
+                    str = $"{(char)27}[1;35m";
+                }
+                if (color == ConsoleColor.Cyan)
+                {
+                    str = $"{(char)27}[1;36m";
+                }
+                if (color == ConsoleColor.Gray)
+                {
+                    str = $"{(char)27}[1;37m";
+                }
+                Console.Write(str);
+            }
+        }
+
         public void Clear()
         {
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                         color = ConsoleColor.Red;
                     }
                     SetBackgroundColor(color);
-                    Console.Write(_agEngineEffector.IsInPosition(x, y) ? "X" : " ");
+                    var isDest = _agState.Destination?.IsInPosition(x, y) ?? false;
+                    if (_agEngineEffector.IsInPosition(x, y))
+                    {
+                        Console.Write("X");
+                    }
+                    else if (isDest)
+                    {
+                        SetForegroundColor(ConsoleColor.Red);
+                        Console.Write("+");
+                    }
+                    else
+                    {
+                        Console.Write(" ");
+                    }
+                    SetForegroundColor(null);
                     SetBackgroundColor(null);
                 }
                 Console.WriteLine("|");
             Console.WriteLine($"Battery: {_agBatterySensor.Spent}");
             Console.WriteLine($"Vaccumed: {_agVaccumSensor.Vaccumed}");
             Console.WriteLine($"Picked: {_agPickedSensor.Picked}");
+            Console.WriteLine($"Think: {_agState.ThinkTimeInterval}ms");
         }
     }
 }