interfaces; README

README.md

+Aspirobot
+=========
+Aspirobot is a simple(r) AI agent that vaccums dust in your rooms but leaves your jewels.
+
+Build
+-----
+- Command line  
+`cd uqac-ia-aspirobot
+dotnet restore
+dotnet build
+dotnet run`
+
+- Visual Studio  
+Run VS, open solution, wait for package restore, click run (F5)
+
+- Rider  
+Run Rider, open solution, wait for package restore, click run (Shift + F10)
+
+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)
+  
+- 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
+  
+How it works
+------------

uqac-ia-aspirobot/Agent/AgAgent.cs

 using System.Threading;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
-using uqac_ia_aspirobot.Agent.Effectors;
+using uqac_ia_aspirobot.Agent.FakeEnv;
+using uqac_ia_aspirobot.Agent.FakeEnv.Effectors;
+using uqac_ia_aspirobot.Agent.FakeEnv.Sensors;
+using uqac_ia_aspirobot.Agent.Interfaces.Effectors;
+using uqac_ia_aspirobot.Agent.Interfaces.Sensors;
 using uqac_ia_aspirobot.Common;
 using uqac_ia_aspirobot.Extensions;
 using uqac_ia_aspirobot.Interfaces;
 {
     public class AgAgent
     {
-        private readonly AgDustSensor _agDustSensor;
+        private readonly IAgDustSensor _agDustSensor;
+        private readonly IAgBatterySensor _agBatterySensor;
+        private readonly IAgPickedSensor _agPickedSensor;
+        private readonly IAgVaccumSensor _agVaccumSensor;
 
-        private readonly AgEngineEffector _engineEffector;
+        private readonly IAgEngineEffector _engineEffector;
 
-        private readonly AgVaccumEffector _vaccumEffector;
+        private readonly IAgVaccumEffector _vaccumEffector;
 
         private readonly IEnvironment _environment;
 
             agServices.AddSingleton<AgAgent>();
             agServices.AddSingleton<ArClient>();
 
-            agServices.AddSingleton<AgDustSensor>();
-            agServices.AddSingleton<AgBatterySensor>();
-            agServices.AddSingleton<AgVaccumSensor>();
-            agServices.AddSingleton<AgPickedSensor>();
+            agServices.AddSingleton<IAgDustSensor, AgDustSensor>();
+            agServices.AddSingleton<IAgBatterySensor, AgBatterySensor>();
+            agServices.AddSingleton<IAgVaccumSensor, AgVaccumSensor>();
+            agServices.AddSingleton<IAgPickedSensor, AgPickedSensor>();
 
-            agServices.AddSingleton<AgVaccumEffector>();
-            agServices.AddSingleton<AgEngineEffector>();
+            agServices.AddSingleton<IAgVaccumEffector, AgVaccumEffector>();
+            agServices.AddSingleton<IAgEngineEffector, AgEngineEffector>();
 
             agServices.AddSingleton<IUi, UiConsole>();
             agServices.AddSingleton<IEnvironment, AgEnvironment>();
             _thread.Join();
         }
 
-        public AgAgent(IEnvironment environment, IOptions<AgConfig> options, AgState state, IUi ui,
-            AgDustSensor agDustSensor,
-            AgEngineEffector engineEffector, AgVaccumEffector vaccumEffector)
+        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;
+
             _environment = environment;
             _state = state;
             _ui = ui;
+
             _options = options.Value;
             _state.LastThinkTime = DateTime.MinValue;
             _state.ThinkTimeInterval = _options.ThinkTimeInterval;
         public void UpdateSensors()
         {
             _agDustSensor.Update();
+            _agBatterySensor.Update();
+            _agPickedSensor.Update();
+            _agVaccumSensor.Update();
         }
 
         public void UpdateState()

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

 using uqac_ia_aspirobot.Extensions;
 using uqac_ia_aspirobot.Interfaces;
 
-namespace uqac_ia_aspirobot.Agent
+namespace uqac_ia_aspirobot.Agent.FakeEnv
 {
     public class AgEnvironment : IEnvironment
     {

uqac-ia-aspirobot/Agent/AgRoom.cs → uqac-ia-aspirobot/Agent/FakeEnv/AgRoom.cs

 using uqac_ia_aspirobot.Extensions;
 using uqac_ia_aspirobot.Interfaces;
 
-namespace uqac_ia_aspirobot.Agent
+namespace uqac_ia_aspirobot.Agent.FakeEnv
 {
     public class AgRoom : IRoom
     {

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

 using Microsoft.Extensions.Options;
+using uqac_ia_aspirobot.Agent.Interfaces.Effectors;
+using uqac_ia_aspirobot.Agent.Interfaces.Sensors;
 using uqac_ia_aspirobot.Extensions;
 
-namespace uqac_ia_aspirobot.Agent.Effectors
+namespace uqac_ia_aspirobot.Agent.FakeEnv.Effectors
 {
-    public class AgEngineEffector
+    public class AgEngineEffector : IAgEngineEffector
     {
-        private readonly AgBatterySensor _agBatterySensor;
+        private readonly IAgBatterySensor _agBatterySensor;
 
         private readonly AgConfig _options;
 
 
         public int Y { get; protected set; }
 
-        public AgEngineEffector(IOptions<AgConfig> options, AgBatterySensor agBatterySensor)
+        public AgEngineEffector(IOptions<AgConfig> options, IAgBatterySensor agBatterySensor)
         {
             _agBatterySensor = agBatterySensor;
             _options = options.Value;

uqac-ia-aspirobot/Agent/Effectors/AgVaccumEffector.cs → uqac-ia-aspirobot/Agent/FakeEnv/Effectors/AgVaccumEffector.cs

-using uqac_ia_aspirobot.Common;
+using uqac_ia_aspirobot.Agent.Interfaces.Effectors;
+using uqac_ia_aspirobot.Agent.Interfaces.Sensors;
+using uqac_ia_aspirobot.Common;
 using uqac_ia_aspirobot.Extensions;
 using uqac_ia_aspirobot.Interfaces;
 
-namespace uqac_ia_aspirobot.Agent.Effectors
+namespace uqac_ia_aspirobot.Agent.FakeEnv.Effectors
 {
-    public class AgVaccumEffector
+    public class AgVaccumEffector : IAgVaccumEffector
     {
-        private readonly AgEngineEffector _engineEffector;
+        private readonly IAgEngineEffector _engineEffector;
         private readonly ArClient _arClient;
         private readonly IEnvironment _environment;
-        private readonly AgBatterySensor _agBatterySensor;
-        private readonly AgVaccumSensor _agVaccumSensor;
-        private readonly AgPickedSensor _agPickedSensor;
+        private readonly IAgBatterySensor _agBatterySensor;
+        private readonly IAgVaccumSensor _agVaccumSensor;
+        private readonly IAgPickedSensor _agPickedSensor;
 
-        public AgVaccumEffector(AgEngineEffector engineEffector, ArClient arClient, IEnvironment environment,
-            AgBatterySensor agBatterySensor, AgVaccumSensor agVaccumSensor, AgPickedSensor agPickedSensor)
+        public AgVaccumEffector(IAgEngineEffector engineEffector, ArClient arClient, IEnvironment environment,
+            IAgBatterySensor agBatterySensor, IAgVaccumSensor agVaccumSensor, IAgPickedSensor agPickedSensor)
         {
             _engineEffector = engineEffector;
             _arClient = arClient;

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

+using uqac_ia_aspirobot.Agent.Interfaces.Sensors;
+
+namespace uqac_ia_aspirobot.Agent.FakeEnv.Sensors
+{
+    public class AgBatterySensor : IAgBatterySensor
+    {
+        public int Spent { get; protected set; }
+
+        public void Add(int v)
+        {
+            if (v > 0)
+            {
+                Spent += v;
+            }
+        }
+
+        public void Update()
+        {
+        }
+    }
+}

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

-using uqac_ia_aspirobot.Interfaces;
+using uqac_ia_aspirobot.Agent.Interfaces.Sensors;
+using uqac_ia_aspirobot.Interfaces;
 
-namespace uqac_ia_aspirobot.Agent
+namespace uqac_ia_aspirobot.Agent.FakeEnv.Sensors
 {
-    public class AgDustSensor
+    public class AgDustSensor : IAgDustSensor
     {
         private readonly AgEnvironment _environment;
 

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

+using uqac_ia_aspirobot.Agent.Interfaces.Sensors;
+
+namespace uqac_ia_aspirobot.Agent.FakeEnv.Sensors
+{
+    public class AgPickedSensor : IAgPickedSensor
+    {
+        public int Picked { get; protected set; }
+
+        public void Increase()
+        {
+            ++Picked;
+        }
+
+        public void Update()
+        {
+        }
+    }
+}

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

+using uqac_ia_aspirobot.Agent.Interfaces.Sensors;
+
+namespace uqac_ia_aspirobot.Agent.FakeEnv.Sensors
+{
+    public class AgVaccumSensor : IAgVaccumSensor
+    {
+        public int Vaccumed { get; protected set; }
+
+        public void Increase()
+        {
+            ++Vaccumed;
+        }
+
+        public void Update()
+        {
+        }
+    }
+}

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

+namespace uqac_ia_aspirobot.Agent.Interfaces.Effectors
+{
+    public interface IAgEngineEffector
+    {
+
+        int X { get; }
+
+        int Y { get; }
+
+        void MoveTo(int x, int y);
+    }
+}

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

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

uqac-ia-aspirobot/Agent/Interfaces/Sensors/IAgBatterySensor.cs

+namespace uqac_ia_aspirobot.Agent.Interfaces.Sensors
+{
+    public interface IAgBatterySensor : ISensor
+    {
+        int Spent { get; }
+
+        void Add(int v);
+    }
+}

uqac-ia-aspirobot/Agent/Interfaces/Sensors/IAgDustSensor.cs

+namespace uqac_ia_aspirobot.Agent.Interfaces.Sensors
+{
+    public interface IAgDustSensor : ISensor
+    {
+    }
+}

uqac-ia-aspirobot/Agent/Interfaces/Sensors/IAgPickedSensor.cs

+namespace uqac_ia_aspirobot.Agent.Interfaces.Sensors
+{
+    public interface IAgPickedSensor : ISensor
+    {
+        int Picked { get; }
+
+        void Increase();
+    }
+}

uqac-ia-aspirobot/Agent/Interfaces/Sensors/IAgVaccumSensor.cs

+namespace uqac_ia_aspirobot.Agent.Interfaces.Sensors
+{
+    public interface IAgVaccumSensor : ISensor
+    {
+        int Vaccumed { get; }
+
+        void Increase();
+    }
+}

uqac-ia-aspirobot/Agent/Interfaces/Sensors/ISensor.cs

+namespace uqac_ia_aspirobot.Agent.Interfaces.Sensors
+{
+    public interface ISensor
+    {
+        void Update();
+    }
+}

uqac-ia-aspirobot/Agent/Sensors/AgBatterySensor.cs

-namespace uqac_ia_aspirobot.Agent
-{
-    public class AgBatterySensor
-    {
-        public int Spent { get; protected set; }
-
-        public void Add(int v)
-        {
-            if (v > 0)
-            {
-                Spent += v;
-            }
-        }
-    }
-}

uqac-ia-aspirobot/Agent/Sensors/AgPickedSensor.cs

-namespace uqac_ia_aspirobot.Agent
-{
-    public class AgPickedSensor
-    {
-        public int Picked { get; protected set; }
-
-        public void Increase()
-        {
-            ++Picked;
-        }
-    }
-}

uqac-ia-aspirobot/Agent/Sensors/AgVaccumSensor.cs

-namespace uqac_ia_aspirobot.Agent
-{
-    public class AgVaccumSensor
-    {
-        public int Vaccumed { get; protected set; }
-
-        public void Increase()
-        {
-            ++Vaccumed;
-        }
-    }
-}

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.Agent.Interfaces.Effectors;
 using uqac_ia_aspirobot.Common;
 using uqac_ia_aspirobot.Interfaces;
 
             return Math.Abs(room.X - x) + Math.Abs(room.Y - y);
         }
 
-        public static int Distance(this IRoom room, AgEngineEffector effector)
+        public static int Distance(this IRoom room, IAgEngineEffector effector)
         {
             return room.Distance(effector.X, effector.Y);
         }
 
-        public static int Distance(this AgEngineEffector effector, int x, int y)
+        public static int Distance(this IAgEngineEffector effector, int x, int y)
         {
             return Math.Abs(effector.X - x) + Math.Abs(effector.Y - y);
         }
 
-        public static int Distance(this AgEngineEffector effector, IRoom room)
+        public static int Distance(this IAgEngineEffector effector, IRoom room)
         {
             return effector.Distance(room.X, room.Y);
         }
             return state.HasFlag(RoomState.Dust) && !state.HasFlag(RoomState.Jewel);
         }
 
-        public static bool IsInPosition(this AgEngineEffector engine, int x, int y)
+        public static bool IsInPosition(this IAgEngineEffector engine, int x, int y)
         {
             return engine.X == x && engine.Y == y;
         }
             return room.X == x && room.Y == y;
         }
 
-        public static bool IsInRoom(this AgEngineEffector engine, IRoom room)
+        public static bool IsInRoom(this IAgEngineEffector engine, IRoom room)
         {
             return engine.IsInPosition(room.X, room.Y);
         }
 
-        public static void Move(this AgEngineEffector engine, int dx, int dy)
+        public static void Move(this IAgEngineEffector engine, int dx, int dy)
         {
             engine.MoveTo(engine.X + dx, engine.Y + dy);
         }

uqac-ia-aspirobot/UI/UiConsole.cs

 using System;
 using System.Runtime.InteropServices;
 using uqac_ia_aspirobot.Agent;
-using uqac_ia_aspirobot.Agent.Effectors;
+using uqac_ia_aspirobot.Agent.Interfaces.Effectors;
+using uqac_ia_aspirobot.Agent.Interfaces.Sensors;
 using uqac_ia_aspirobot.Extensions;
 using uqac_ia_aspirobot.Interfaces;
 
     public class UiConsole : IUi
     {
         private readonly IEnvironment _environment;
-        private readonly AgEngineEffector _agEngineEffector;
-        private readonly AgPickedSensor _agPickedSensor;
-        private readonly AgBatterySensor _agBatterySensor;
-        private readonly AgVaccumSensor _agVaccumSensor;
+        private readonly IAgEngineEffector _agEngineEffector;
+        private readonly IAgPickedSensor _agPickedSensor;
+        private readonly IAgBatterySensor _agBatterySensor;
+        private readonly IAgVaccumSensor _agVaccumSensor;
         private readonly AgState _agState;
 
-        public UiConsole(IEnvironment environment, AgEngineEffector agEngineEffector, AgPickedSensor agPickedSensor,
-            AgBatterySensor agBatterySensor, AgVaccumSensor agVaccumSensor, AgState agState)
+        public UiConsole(IEnvironment environment, IAgEngineEffector agEngineEffector, IAgPickedSensor agPickedSensor,
+            IAgBatterySensor agBatterySensor, IAgVaccumSensor agVaccumSensor, AgState agState)
         {
             _environment = environment;
             _agEngineEffector = agEngineEffector;