cleanup; README

README.md

 Aspirobot
 =========
-Aspirobot is a simple(r) AI agent that vaccums dust in your rooms but leaves your jewels.
+Aspirobot is a simple(r) AI agent that vaccums dust in your rooms but pick up your jewels.
 
 Build
 -----
 - Command line  
-`cd uqac-ia-aspirobot
+```shell
+cd uqac-ia-aspirobot
 dotnet restore
 dotnet build
-dotnet run`
+dotnet run
+```
 
 - Visual Studio  
 Run VS, open solution, wait for package restore, click run (F5)
 Configuration
 -------------
 Some behaviors can be configured in Program.cs file:  
-- EnvConfig (Environment configuration)
-  - Height: Map height
-  - Width: Map width
-  - ActionPropability: Probability that an action occurs in the enviromnent, once per SleepTime (>=0, <=100)
-  - AddDustProbability: Probability that a dust is added on the map, only when an action is to be taken (>=0, <=100)
-  - AddJewelProbability: Probability that a jewel is added on the map, only when an action is to be taken, and AddDustProbability does not occur (>=0, <=100)
-  - RemoveJewelProbability: Probability that a jewel is removed from the map, only when an action is to be taken, and neither AddDustProbability nor AddJewelProbability occur (>=0, <=100)
-  - SleepTime: Time between each iteration in ms (>=0)
+- `EnvConfig` (Environment configuration)
+  - `Height`: Map height
+  - `Width`: Map width
+  - `ActionPropability`: Probability that an action occurs in the enviromnent, once per `EnvConfig.SleepTime` (>=0, <=100)
+  - `AddDustProbability`: Probability that a dust is added on the map, only when an action is to be taken (>=0, <=100)
+  - `AddJewelProbability`: Probability that a jewel is added on the map, only when an action is to be taken,
+  and `AddDustProbability` does not occur (>=0, <=100)
+  - `RemoveJewelProbability`: Probability that a jewel is removed from the map, only when an action is to be taken,
+  and neither `EnvConfig.AddDustProbability` nor `EnvConfig.AddJewelProbability` occur (>=0, <=100)
+  - `SleepTime`: Time between each iteration in ms (>=0)
   
-- AgConfig (Agent configuration)
-  - SleepTime: Time between each iteration in ms (>=0)
-  - StartX: Agent start X position (>=0, <EnvConfig.Width)
-  - StartY: Agent start Y position (>=0, <EnvConfig.Height)
-  - AutoAdjustThinkTimeInterval: Indicate if agent should try to auto adjust think time interval 
-  - ThinkTimeInterval: Default think time interval in ms (>=0). This variable controls how often the agent will re-evaluate the situation
+- `AgConfig` (Agent configuration)
+  - `SleepTime`: Time between each iteration in ms (>=0)
+  - `StartX`: Agent start X position (>=0, <`EnvConfig.Width`)
+  - `StartY`: Agent start Y position (>=0, <`EnvConfig.Height`)
+  - `AutoAdjustThinkTimeInterval`: Indicate if agent should try to auto adjust think time interval (`AgConfig.ThinkTimeInterval`)
+  - `ThinkTimeInterval`: Default think time interval in ms (>=0). This variable controls how often the agent will re-evaluate the situation
   
 How it works
 ------------
+Agent will loop forever (until killed) peforming the following operations:
+- Environment update: this action will force all sensors to update their data, so that the environment can be updated.
+  - In the FakeEnv implementation, the environment update itself from remote virtual environment, so the sensors updates do nothing.
+  - In a real robot implementation, the update methods of sensors would gather data and push them to the environment.
+- UI update: this will update the user interface.
+  - In the FakeEnv implementation, it draw in the standard output.
+  - In a real robot implementation, it would either do nothing, or update a web interface (for example)
+- Internal state update: Prepare internal state to be able to choose an action to do.
+- Choose an action: Choose the most appropriate action to do by analysing the gathered data and current internal state.
+- Act: Execute choosen action (go to room, vaccum, pick)
+- Sleep: Sleep for `AgConfig.SleepTime`ms
+
+FakeEnv implementation will loop forever (until killed) peforming the following operations:
+- Sleep: Sleep for `EnvConfig.SleepTime`ms
+- May do something: Randomly choose to do something or not using `EnvConfig.ActionPropability`
+    - May add dust on a random location: Randomly choose to do it or not using `EnvConfig.AddDustProbability`
+    - May add a jewel on a random location: Randomly choose to do it or not using `EnvConfig.AddJewelProbability`.
+    Can only happen if no previous action has been done.
+    - May remove a jewel from the first room that contains a jewel: Randomly choose to do it or not using `EnvConfig.RemoveJewelProbability`.
+    Can only happen if no previous action has been done.
+
+Code
+----
+This agent is coded in .NET Core (C#) using DI (Dependency Injection) and interfaces to abstract implementation
+and allow to run a virtual environment or a real one without changing anything in the agent implementation
+
+FakeEnv implementation starts one thread for the environment and another one for the agent.
+
+Agent logic is in `Agent/*.cs`  
+Agent sensors and effectors interfaces are in `Agent/Interfaces/*`  
+Agent FakeEnv client implementation is in `Agent/FakeEnv/*`  
+FakeEnv client, server, protocol and configuration are defined in `Common/*.cs`  
+FakeEnv server implementation is in `Environment/*.cs`  
+Some helper methods are defined in `Extensions/Extensions.cs`  
+Shared interfaces are in `Interfaces/*.cs`  
+Console user interface is in `UI/UiConsole.cs`

uqac-ia-aspirobot/Agent/AgAgent.cs

 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using Microsoft.Extensions.DependencyInjection;
 {
     public class AgAgent
     {
-        private readonly IAgDustSensor _agDustSensor;
-        private readonly IAgBatterySensor _agBatterySensor;
-        private readonly IAgPickedSensor _agPickedSensor;
-        private readonly IAgVaccumSensor _agVaccumSensor;
 
         private readonly IAgEngineEffector _engineEffector;
 
 
         public AgAgent(IOptions<AgConfig> options,
             IEnvironment environment, AgState state, IUi ui,
-            IAgDustSensor agDustSensor, IAgBatterySensor agBatterySensor, IAgPickedSensor agPickedSensor, IAgVaccumSensor agVaccumSensor,
             IAgEngineEffector engineEffector, IAgVaccumEffector vaccumEffector)
         {
-            _agDustSensor = agDustSensor;
-            _agBatterySensor = agBatterySensor;
-            _agPickedSensor = agPickedSensor;
-            _agVaccumSensor = agVaccumSensor;
-
             _engineEffector = engineEffector;
             _vaccumEffector = vaccumEffector;
 
             var running = true;
 
             _environment.Setup();
-            _state.DustyRooms = _environment.FindDustyRoomsWithoutJewel();
+            _state.DustyRooms = new List<IRoom>();
 
             while (running)
             {
-                if (_options.SleepTime > 0)
-                {
-                    Thread.Sleep(_options.SleepTime);
-                }
-                UpdateSensors();
+                _environment.Update();
                 _ui.Update();
                 UpdateState();
                 Think();
                 Work();
+                if (_options.SleepTime > 0)
+                {
+                    Thread.Sleep(_options.SleepTime);
+                }
             }
         }
 
-        public void UpdateSensors()
-        {
-            _agDustSensor.Update();
-            _agBatterySensor.Update();
-            _agPickedSensor.Update();
-            _agVaccumSensor.Update();
-        }
-
         public void UpdateState()
         {
             if (_options.AutoAdjustThinkTimeInterval)

uqac-ia-aspirobot/Agent/FakeEnv/AgEnvironment.cs

 using System;
 using System.Collections.Generic;
 using Microsoft.Extensions.DependencyInjection;
+using uqac_ia_aspirobot.Agent.Interfaces.Sensors;
 using uqac_ia_aspirobot.Common;
 using uqac_ia_aspirobot.Extensions;
 using uqac_ia_aspirobot.Interfaces;
 {
     public class AgEnvironment : IEnvironment
     {
+        private readonly IAgDustSensor _agDustSensor;
+        private readonly IAgBatterySensor _agBatterySensor;
+        private readonly IAgPickedSensor _agPickedSensor;
+        private readonly IAgVaccumSensor _agVaccumSensor;
+
         private readonly IServiceProvider _serviceProvider;
 
         private readonly ArClient _arClient;
 
-        protected int _width;
+        private int _width;
 
-        protected int _height;
+        private int _height;
 
-        protected readonly IDictionary<string, IRoom> _rooms = new Dictionary<string, IRoom>();
+        private readonly IDictionary<string, IRoom> _rooms = new Dictionary<string, IRoom>();
 
-        public AgEnvironment(IServiceProvider serviceProvider, ArClient arClient)
+        public AgEnvironment(IServiceProvider serviceProvider, ArClient arClient,
+            IAgDustSensor agDustSensor, IAgBatterySensor agBatterySensor, IAgPickedSensor agPickedSensor, IAgVaccumSensor agVaccumSensor)
         {
             _serviceProvider = serviceProvider;
             _arClient = arClient;
+            _agDustSensor = agDustSensor;
+            _agBatterySensor = agBatterySensor;
+            _agPickedSensor = agPickedSensor;
+            _agVaccumSensor = agVaccumSensor;
         }
 
         public void Setup()
                 room.Update();
                 return true;
             });
+
+            _agDustSensor.Update();
+            _agBatterySensor.Update();
+            _agPickedSensor.Update();
+            _agVaccumSensor.Update();
         }
 
         protected string GetKey(int x, int y)

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

     {
         private readonly IAgBatterySensor _agBatterySensor;
 
-        private readonly AgConfig _options;
-
         public int X { get; protected set; }
 
         public int Y { get; protected set; }
         public AgEngineEffector(IOptions<AgConfig> options, IAgBatterySensor agBatterySensor)
         {
             _agBatterySensor = agBatterySensor;
-            _options = options.Value;
-            X = _options.StartX;
-            Y = _options.StartY;
+            X = options.Value.StartX;
+            Y = options.Value.StartY;
         }
 
         public void MoveTo(int x, int y)

uqac-ia-aspirobot/Agent/FakeEnv/Sensors/AgDustSensor.cs

 
         public void Update()
         {
-            _environment.Update();
         }
     }
 }

uqac-ia-aspirobot/Agent/Interfaces/Effectors/IAgEngineEffector.cs

 namespace uqac_ia_aspirobot.Agent.Interfaces.Effectors
 {
-    public interface IAgEngineEffector
+    public interface IAgEngineEffector : IEffector
     {
 
         int X { get; }

uqac-ia-aspirobot/Agent/Interfaces/Effectors/IAgVaccumEffector.cs

 namespace uqac_ia_aspirobot.Agent.Interfaces.Effectors
 {
-    public interface IAgVaccumEffector
+    public interface IAgVaccumEffector : IEffector
     {
         void Vaccum();
         void Pick();

uqac-ia-aspirobot/Agent/Interfaces/Effectors/IEffector.cs

+namespace uqac_ia_aspirobot.Agent.Interfaces.Effectors
+{
+    public interface IEffector
+    {
+
+    }
+}

uqac-ia-aspirobot/Common/ArServer.cs

-using System;
-using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Options;
 using System.IO.Pipes;
 using System.Threading;
 using uqac_ia_aspirobot.Extensions;

uqac-ia-aspirobot/Environment/EnvEnvironment.cs

         private readonly IServiceProvider _serviceProvider;
         private readonly EnvConfig _options;
 
-        protected readonly IDictionary<string, IRoom> _rooms = new Dictionary<string, IRoom>();
+        private readonly IDictionary<string, IRoom> _rooms = new Dictionary<string, IRoom>();
 
-        protected string GetKey(int x, int y)
+        private string GetKey(int x, int y)
         {
             return $"{x},{y}";
         }
         {
             return _rooms[GetKey(x, y)];
         }
+
+        public void Update()
+        {
+        }
     }
 }

uqac-ia-aspirobot/Environment/EnvThread.cs

 
             while (running)
             {
-                Thread.Sleep(_config.SleepTime);
+                if (_config.SleepTime > 0)
+                {
+                    Thread.Sleep(_config.SleepTime);
+                }
                 var action = GenerateAction();
                 if (action == Actions.AddDust || action == Actions.AddJewel)
                 {

uqac-ia-aspirobot/Interfaces/IEnvironment.cs

         int GetHeight();
 
         IRoom GetRoom(int x, int y);
+
+        void Update();
     }
 }

uqac-ia-aspirobot/UI/UiConsole.cs

                 {
                     var state = _environment.GetRoomState(x, y);
                     ConsoleColor? color = null;
-                    if (state == RoomState.Clean)
-                    {
-                        color = null;
-                    }
-                    else if (state == RoomState.Dust)
+                    if (state == RoomState.Dust)
                     {
                         color = ConsoleColor.Gray;
                     }