re init

.gitignore

+*.swp
+*.*~
+project.lock.json
+.DS_Store
+*.pyc
+
+# Visual Studio Code
+.vscode
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+build/
+bld/
+[Bb]in/
+[Oo]bj/
+msbuild.log
+msbuild.err
+msbuild.wrn
+
+# Visual Studio 2015
+.vs/
+
+
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff:
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+
+# Sensitive or high-churn files:
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.xml
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+
+# Gradle:
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Mongo Explorer plugin:
+.idea/**/mongoSettings.xml
+
+## File-based project format:
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties

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

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RiderRiderContentModelStore">
+    <excludedPaths />
+  </component>
+</project>

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

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.uqac-ia-aspirobot/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.uqac-ia-aspirobot/riderModule.iml" />
+    </modules>
+  </component>
+</project>

.idea/.idea.uqac-ia-aspirobot/riderModule.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RIDER_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$/../..">
+      <sourceFolder url="file://$MODULE_DIR$/../../uqac-ia-aspirobot" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/../../packages" />
+      <excludeFolder url="file://$MODULE_DIR$/../../uqac-ia-aspirobot/bin" />
+      <excludeFolder url="file://$MODULE_DIR$/../../uqac-ia-aspirobot/obj" />
+    </content>
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

uqac-ia-aspirobot.sln

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.0.0
+MinimumVisualStudioVersion = 10.0.0.1
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "uqac_ia_aspirobot", "uqac-ia-aspirobot/uqac-ia-aspirobot.xproj", "{2A192A8A-B6F4-4752-A622-04C7A4AF0EE5}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2A192A8A-B6F4-4752-A622-04C7A4AF0EE5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2A192A8A-B6F4-4752-A622-04C7A4AF0EE5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2A192A8A-B6F4-4752-A622-04C7A4AF0EE5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2A192A8A-B6F4-4752-A622-04C7A4AF0EE5}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

uqac-ia-aspirobot/Agent/AgAgent.cs

+using System.Linq;
+using System.Threading;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using uqac_ia_aspirobot.Agent.Effectors;
+using uqac_ia_aspirobot.Common;
+using uqac_ia_aspirobot.Extensions;
+using uqac_ia_aspirobot.Interfaces;
+using uqac_ia_aspirobot.UI;
+
+namespace uqac_ia_aspirobot.Agent
+{
+    public class AgAgent
+    {
+        private readonly AgDustSensor _agDustSensor;
+
+        private readonly AgEngineEffector _engineEffector;
+
+        private readonly AgVaccumEffector _vaccumEffector;
+
+        private readonly IEnvironment _environment;
+
+        private readonly AgConfig _options;
+
+        private readonly AgState _state;
+        private readonly IUi _ui;
+
+        private static Thread _thread;
+
+        public static void Start(AgConfig agConfig, ArConfig arConfig)
+        {
+            var agServices = new ServiceCollection();
+            agServices.AddOptions();
+            agServices.AddSingleton<AgState>();
+            agServices.AddSingleton<AgAgent>();
+            agServices.AddSingleton<ArClient>();
+
+            agServices.AddSingleton<AgDustSensor>();
+            agServices.AddSingleton<AgBatterySensor>();
+            agServices.AddSingleton<AgVaccumSensor>();
+            agServices.AddSingleton<AgPickedSensor>();
+
+            agServices.AddSingleton<AgVaccumEffector>();
+            agServices.AddSingleton<AgEngineEffector>();
+
+            agServices.AddSingleton<IUi, UiConsole>();
+            agServices.AddSingleton<IEnvironment, AgEnvironment>();
+            agServices.AddTransient<IRoom, AgRoom>();
+            agServices.Configure<AgConfig>(agConfig.CopyTo);
+            agServices.Configure<ArConfig>(arConfig.CopyTo);
+            var agProvider = agServices.BuildServiceProvider();
+            var agThread = agProvider.GetService<AgAgent>();
+            _thread = new Thread(agThread.Run)
+            {
+                Name = nameof(AgAgent)
+            };
+            _thread.Start();
+        }
+
+        public static void Join()
+        {
+            _thread.Join();
+        }
+
+        public AgAgent(IEnvironment environment, IOptions<AgConfig> options, AgState state, IUi ui,
+            AgDustSensor agDustSensor,
+            AgEngineEffector engineEffector, AgVaccumEffector vaccumEffector)
+        {
+            _agDustSensor = agDustSensor;
+            _engineEffector = engineEffector;
+            _vaccumEffector = vaccumEffector;
+            _environment = environment;
+            _state = state;
+            _ui = ui;
+            _options = options.Value;
+            _state.SleepTime = _options.SleepTime;
+        }
+
+        private void Run()
+        {
+            var running = true;
+
+            _environment.Setup();
+            _state.DustyRooms = _environment.FindDustyRoomsWithoutJewel();
+
+            while (running)
+            {
+                if (_state.SleepTime > 0)
+                {
+                    Thread.Sleep(_state.SleepTime);
+                }
+                UpdateSensors();
+                _ui.Update();
+                UpdateState();
+                Think();
+                Work();
+            }
+        }
+
+        public void UpdateSensors()
+        {
+            _agDustSensor.Update();
+        }
+
+        public void UpdateState()
+        {
+            var dustyRooms = _environment.FindDustyRooms();//TODO Compute average on xx last values
+            if (_options.AutoAdjustSleepTime)
+            {
+                if (dustyRooms.Count > _state.DustyRooms.Count)
+                {
+                    _state.SleepTime += _state.SleepTime / 2;
+                }
+                else if (dustyRooms.Count < _state.DustyRooms.Count)
+                {
+                    _state.SleepTime -= _state.SleepTime / 2;
+                }
+            }
+            _state.DustyRooms = dustyRooms;
+        }
+
+        public void Think()
+        {
+            if (_state.Destination == null && _state.DustyRooms.Any())
+            {
+                _state.Destination = _state.DustyRooms.OrderBy(room => room.Distance(_engineEffector)).First();
+            }
+        }
+
+        public void Work()
+        {
+            if (_environment.GetRoomState(_engineEffector.X, _engineEffector.Y).HasFlag(RoomState.Jewel))
+            {
+                _vaccumEffector.Pick();
+            }
+            if (_environment.GetRoomState(_engineEffector.X, _engineEffector.Y).HasFlag(RoomState.Dust))
+            {
+                _vaccumEffector.Vaccum();
+            }
+            if (_state.Destination != null && _engineEffector.IsInRoom(_state.Destination))
+            {
+                _state.Destination = null;
+            }
+            if (_state.Destination != null)
+            {
+                if (_state.Destination.X < _engineEffector.X)
+                {
+                    _engineEffector.Move(-1, 0);
+                }
+                else if (_state.Destination.X > _engineEffector.X)
+                {
+                    _engineEffector.Move(1, 0);
+                }
+                else if (_state.Destination.Y < _engineEffector.Y)
+                {
+                    _engineEffector.Move(0, -1);
+                }
+                else if (_state.Destination.Y > _engineEffector.Y)
+                {
+                    _engineEffector.Move(0, 1);
+                }
+            }
+        }
+    }
+}

uqac-ia-aspirobot/Agent/AgConfig.cs

+namespace uqac_ia_aspirobot.Agent
+{
+    public class AgConfig
+    {
+        public bool AutoAdjustSleepTime { get; set; }
+
+        public int SleepTime { get; set; }
+
+        public int StartX { get; set; }
+
+        public int StartY { get; set; }
+
+        public void CopyTo(AgConfig other)
+        {
+            other.SleepTime = SleepTime;
+            other.StartX = StartX;
+            other.StartY = StartY;
+        }
+    }
+}

uqac-ia-aspirobot/Agent/AgEnvironment.cs

+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.DependencyInjection;
+using uqac_ia_aspirobot.Common;
+using uqac_ia_aspirobot.Extensions;
+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Agent
+{
+    public class AgEnvironment : IEnvironment
+    {
+        private readonly IServiceProvider _serviceProvider;
+
+        private readonly ArClient _arClient;
+
+        protected int _width;
+
+        protected int _height;
+
+        protected readonly IDictionary<string, IRoom> _rooms = new Dictionary<string, IRoom>();
+
+        public AgEnvironment(IServiceProvider serviceProvider, ArClient arClient)
+        {
+            _serviceProvider = serviceProvider;
+            _arClient = arClient;
+        }
+
+        public void Setup()
+        {
+            _arClient.Setup();
+            _width = _arClient.GetEnvWidth();
+            _height = _arClient.GetEnvWidth();
+            for (var x = 0; x < _width; ++x)
+            {
+                for (var y = 0; y < _height; ++y)
+                {
+                    var room = _serviceProvider.GetService<IRoom>();
+                    room.X = x;
+                    room.Y = y;
+                    _rooms.Add(GetKey(x, y), room);
+                }
+            }
+        }
+
+        public void Update()
+        {
+            this.ForeachRoom<AgRoom>(room =>
+            {
+                room.Update();
+                return true;
+            });
+        }
+
+        protected string GetKey(int x, int y)
+        {
+            return $"{x},{y}";
+        }
+
+        public int GetWidth()
+        {
+            return _width;
+        }
+
+        public int GetHeight()
+        {
+            return _height;
+        }
+
+        public IRoom GetRoom(int x, int y)
+        {
+            return _rooms[GetKey(x, y)];
+        }
+    }
+}

uqac-ia-aspirobot/Agent/AgRoom.cs

+using uqac_ia_aspirobot.Common;
+using uqac_ia_aspirobot.Extensions;
+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Agent
+{
+    public class AgRoom : IRoom
+    {
+        private readonly ArClient _arClient;
+
+        public int X { get; set; }
+
+        public int Y { get; set; }
+
+        public RoomState State { get; protected set; }
+
+        public AgRoom(ArClient arClient)
+        {
+            _arClient = arClient;
+            State = RoomState.Unknown;
+        }
+
+        public void AddDust()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public void RemoveDust()
+        {
+            _arClient.RemoveDust(this);
+        }
+
+        public void AddJewel()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public void RemoveJewel()
+        {
+            _arClient.RemoveJewel(this);
+        }
+
+        public void Update()
+        {
+            State = _arClient.GetRoomState(this);
+        }
+    }
+}

uqac-ia-aspirobot/Agent/AgState.cs

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

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

+using System;
+using Microsoft.Extensions.Options;
+using uqac_ia_aspirobot.Extensions;
+
+namespace uqac_ia_aspirobot.Agent.Effectors
+{
+    public class AgEngineEffector
+    {
+        private readonly AgBatterySensor _agBatterySensor;
+
+        private readonly AgConfig _options;
+
+        public int X { get; protected set; }
+
+        public int Y { get; protected set; }
+
+        public AgEngineEffector(IOptions<AgConfig> options, AgBatterySensor agBatterySensor)
+        {
+            _agBatterySensor = agBatterySensor;
+            _options = options.Value;
+            X = _options.StartX;
+            Y = _options.StartY;
+        }
+
+        public void MoveTo(int x, int y)
+        {
+            _agBatterySensor.Add(this.Distance(x, y));
+            X = x;
+            Y = y;
+        }
+    }
+}

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

+using uqac_ia_aspirobot.Common;
+using uqac_ia_aspirobot.Extensions;
+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Agent.Effectors
+{
+    public class AgVaccumEffector
+    {
+        private readonly AgEngineEffector _engineEffector;
+        private readonly ArClient _arClient;
+        private readonly IEnvironment _environment;
+        private readonly AgBatterySensor _agBatterySensor;
+        private readonly AgVaccumSensor _agVaccumSensor;
+        private readonly AgPickedSensor _agPickedSensor;
+
+        public AgVaccumEffector(AgEngineEffector engineEffector, ArClient arClient, IEnvironment environment,
+            AgBatterySensor agBatterySensor, AgVaccumSensor agVaccumSensor, AgPickedSensor agPickedSensor)
+        {
+            _engineEffector = engineEffector;
+            _arClient = arClient;
+            _environment = environment;
+            _agBatterySensor = agBatterySensor;
+            _agVaccumSensor = agVaccumSensor;
+            _agPickedSensor = agPickedSensor;
+        }
+
+        public void Vaccum()
+        {
+            _agBatterySensor.Add(1);
+            _agVaccumSensor.Increase();
+            _environment.RemoveDust(_engineEffector.X, _engineEffector.Y);
+        }
+
+        public void Pick()
+        {
+            _agBatterySensor.Add(1);
+            _agPickedSensor.Increase();
+            _arClient.RemoveJewel(_engineEffector.X, _engineEffector.Y);
+        }
+    }
+}

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/AgDustSensor.cs

+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Agent
+{
+    public class AgDustSensor
+    {
+        private readonly AgEnvironment _environment;
+
+        public AgDustSensor(IEnvironment environment)
+        {
+            _environment = environment as AgEnvironment;
+        }
+
+        public void Update()
+        {
+            _environment.Update();
+        }
+    }
+}

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/Common/ArClient.cs

+using System.IO.Pipes;
+using Microsoft.Extensions.Options;
+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Common
+{
+    public class ArClient
+    {
+        private readonly ArConfig _options;
+
+        private NamedPipeClientStream _client;
+
+        private ArStreamString _stream;
+
+        public ArClient(IOptions<ArConfig> options)
+        {
+            _options = options.Value;
+        }
+
+        public void Setup()
+        {
+            _client = new NamedPipeClientStream(_options.PipeServer, _options.PipeName, PipeDirection.InOut);
+            _client.Connect();
+            _stream = new ArStreamString(_client);
+        }
+
+        public int GetEnvWidth()
+        {
+            _stream.Write(ArServer.ArCommands.EnvGetWidth);
+            return _stream.ReadInt();
+        }
+
+        public RoomState GetRoomState(int x, int y)
+        {
+            _stream.Write(ArServer.ArCommands.RoomGetState);
+            _stream.Write(x);
+            _stream.Write(y);
+            return _stream.ReadEnum<RoomState>();
+        }
+
+        public void RemoveDust(int x, int y)
+        {
+            _stream.Write(ArServer.ArCommands.RoomRemoveDust);
+            _stream.Write(x);
+            _stream.Write(y);
+        }
+
+        public void RemoveJewel(int x, int y)
+        {
+            _stream.Write(ArServer.ArCommands.RoomRemoveJewel);
+            _stream.Write(x);
+            _stream.Write(y);
+        }
+    }
+}

uqac-ia-aspirobot/Common/ArConfig.cs

+namespace uqac_ia_aspirobot.Common
+{
+    public class ArConfig
+    {
+        public string PipeName { get; set; }
+
+        public string PipeServer { get; set; }
+
+        public int ServerThreadCount { get; set; }
+
+        public void CopyTo(ArConfig other)
+        {
+            other.PipeName = PipeName;
+            other.PipeServer = PipeServer;
+            other.ServerThreadCount = ServerThreadCount;
+        }
+    }
+}

uqac-ia-aspirobot/Common/ArServer.cs

+using System;
+using Microsoft.Extensions.Options;
+using System.IO.Pipes;
+using System.Threading;
+using uqac_ia_aspirobot.Extensions;
+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Common
+{
+    public class ArServer
+    {
+        private readonly IEnvironment _environment;
+
+        public enum ArCommands
+        {
+            EnvGetWidth,
+            EnvGetHeight,
+            RoomGetState,
+            RoomRemoveDust,
+            RoomRemoveJewel
+        }
+
+        private readonly ArConfig _options;
+
+        private Thread[] _servers;
+
+        public ArServer(IOptions<ArConfig> options, IEnvironment environment)
+        {
+            _environment = environment;
+            _options = options.Value;
+        }
+
+        public void Setup()
+        {
+            _servers = new Thread[_options.ServerThreadCount];
+            for (var i = 0; i < _servers.Length; i++)
+            {
+                _servers[i] = new Thread(ServerThread)
+                {
+                    Name = $"ArServer-{i}"
+                };
+                _servers[i].Start();
+            }
+        }
+
+        private void ServerThread()
+        {
+            var server = new NamedPipeServerStream(_options.PipeName, PipeDirection.InOut, _servers.Length);
+            server.WaitForConnection();
+
+            var stream = new ArStreamString(server);
+
+            while (true)
+            {
+                var command = stream.ReadEnum<ArCommands>();
+                if (command == ArCommands.EnvGetWidth)
+                {
+                    stream.Write(_environment.GetWidth());
+                }
+                else if (command == ArCommands.EnvGetHeight)
+                {
+                    stream.Write(_environment.GetHeight());
+                }
+                else if (command == ArCommands.RoomGetState)
+                {
+                    var x = stream.ReadInt();
+                    var y = stream.ReadInt();
+                    stream.Write(_environment.GetRoomState(x, y));
+                }
+                else if (command == ArCommands.RoomRemoveDust)
+                {
+                    var x = stream.ReadInt();
+                    var y = stream.ReadInt();
+                    _environment.GetRoom(x, y).RemoveDust();
+                }
+                else if (command == ArCommands.RoomRemoveJewel)
+                {
+                    var x = stream.ReadInt();
+                    var y = stream.ReadInt();
+                    _environment.GetRoom(x, y).RemoveJewel();
+                }
+            }
+        }
+    }
+}

uqac-ia-aspirobot/Common/ArStreamString.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace uqac_ia_aspirobot.Common
+{
+    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>();
+
+        public ArStreamString(Stream ioStream)
+        {
+            this.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 str = streamEncoding.GetString(inBuffer);
+            _readStrings.Add(str);
+            return str;
+        }
+
+        public int ReadInt()
+        {
+            var str = ReadString();
+            return int.Parse(str);
+        }
+
+        public T ReadEnum<T>()
+        {
+            var str = ReadString();
+            return (T)Enum.Parse(typeof(T), str);
+        }
+
+        public int Write(string outString)
+        {
+            _writtenStrings.Add(outString);
+            byte[] outBuffer = streamEncoding.GetBytes(outString);
+            int len = outBuffer.Length;
+            if (len > UInt16.MaxValue)
+            {
+                len = (int)UInt16.MaxValue;
+            }
+            ioStream.WriteByte((byte)(len / 256));
+            ioStream.WriteByte((byte)(len & 255));
+            ioStream.Write(outBuffer, 0, len);
+            ioStream.Flush();
+
+            return outBuffer.Length + 2;
+        }
+
+        public int Write(int outInt)
+        {
+            return Write(outInt.ToString());
+        }
+
+        public int Write(Enum outEnum)
+        {
+            return Write(outEnum.ToString());
+        }
+    }
+}

uqac-ia-aspirobot/Environment/EnvConfig.cs

+namespace uqac_ia_aspirobot.Environment
+{
+    public class EnvConfig
+    {
+        public int Width { get; set; }
+
+        public int Height { get; set; }
+
+        public float ActionPropability { get; set; }
+
+        public float AddJewelProbability { get; set; }
+
+        public float RemoveJewelProbability { get; set; }
+
+        public float AddDustProbability { get; set; }
+
+        public int SleepTime { get; set; }
+
+        public void CopyTo(EnvConfig other)
+        {
+            other.Width = Width;
+            other.Height = Height;
+            other.ActionPropability = ActionPropability;
+            other.AddJewelProbability = AddJewelProbability;
+            other.RemoveJewelProbability = RemoveJewelProbability;
+            other.AddDustProbability = AddDustProbability;
+            other.SleepTime = SleepTime;
+        }
+    }
+}

uqac-ia-aspirobot/Environment/EnvEnvironment.cs

+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Environment
+{
+    public class EnvEnvironment : IEnvironment
+    {
+        private readonly IServiceProvider _serviceProvider;
+        private readonly EnvConfig _options;
+
+        protected readonly IDictionary<string, IRoom> _rooms = new Dictionary<string, IRoom>();
+
+        protected string GetKey(int x, int y)
+        {
+            return $"{x},{y}";
+        }
+
+        public EnvEnvironment(IServiceProvider serviceProvider, IOptions<EnvConfig> options)
+        {
+            _serviceProvider = serviceProvider;
+            _options = options.Value;
+        }
+
+        public void Setup()
+        {
+            for (var x = 0; x < _options.Width; ++x)
+            {
+                for (var y = 0; y < _options.Height; ++y)
+                {
+                    var room = _serviceProvider.GetService<IRoom>();
+                    room.X = x;
+                    room.Y = y;
+                    _rooms.Add(GetKey(x, y), room);
+                }
+            }
+        }
+
+        public int GetWidth()
+        {
+            return _options.Width;
+        }
+
+        public int GetHeight()
+        {
+            return _options.Height;
+        }
+
+        public IRoom GetRoom(int x, int y)
+        {
+            return _rooms[GetKey(x, y)];
+        }
+    }
+}

uqac-ia-aspirobot/Environment/EnvRoom.cs

+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Environment
+{
+    public class EnvRoom : IRoom
+    {
+        public int X { get; set; }
+
+        public int Y { get; set; }
+
+        public RoomState State { get; protected set; }
+
+        public void AddDust()
+        {
+            State |= RoomState.Dust;
+        }
+
+        public void RemoveDust()
+        {
+            State &= ~RoomState.Dust;
+        }
+
+        public void AddJewel()
+        {
+            State |= RoomState.Jewel;
+        }
+
+        public void RemoveJewel()
+        {
+            State &= ~RoomState.Jewel;
+        }
+    }
+}

uqac-ia-aspirobot/Environment/EnvThread.cs

+using System;
+using System.Threading;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using uqac_ia_aspirobot.Common;
+using uqac_ia_aspirobot.Extensions;
+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Environment
+{
+    public class EnvThread
+    {
+        private readonly IEnvironment _environment;
+
+        private readonly ArServer _server;
+
+        private readonly EnvConfig _config;
+
+        private readonly Random _rand;
+
+        private enum Actions
+        {
+            NoAction = 0,
+            AddDust = 1,
+            AddJewel = 2,
+            RemoveJewel = 3
+        }
+
+        private static Thread _thread;
+
+        public static void Start(EnvConfig envConfig, ArConfig arConfig)
+        {
+            var envServices = new ServiceCollection();
+            envServices.AddOptions();
+            envServices.AddSingleton<EnvThread>();
+            envServices.AddSingleton<ArServer>();
+            envServices.AddSingleton<IEnvironment, EnvEnvironment>();
+            envServices.AddTransient<IRoom, EnvRoom>();
+            envServices.Configure<EnvConfig>(envConfig.CopyTo);
+            envServices.Configure<ArConfig>(arConfig.CopyTo);
+            var envProvider = envServices.BuildServiceProvider();
+            var envThread = envProvider.GetService<EnvThread>();
+            _thread = new Thread(envThread.Run)
+            {
+                Name = nameof(EnvThread)
+            };
+            _thread.Start();
+        }
+
+        public static void Join()
+        {
+            _thread.Join();
+        }
+
+        public EnvThread(IOptions<EnvConfig> config, IEnvironment environment, ArServer server)
+        {
+            _environment = environment;
+            _server = server;
+            _config = config.Value;
+            _rand = new Random();
+        }
+
+        private bool GenerateProba(float proba)
+        {
+            return _rand.NextDouble() * 100.0 <= proba;
+        }
+
+        private Actions GenerateAction()
+        {
+            if (GenerateProba(_config.ActionPropability))
+            {
+                if (GenerateProba(_config.AddDustProbability))
+                {
+                    return Actions.AddDust;
+                }
+                if (GenerateProba(_config.RemoveJewelProbability))
+                {
+                    return Actions.RemoveJewel;
+                }
+                if (GenerateProba(_config.AddJewelProbability))
+                {
+                    return Actions.AddJewel;
+                }
+            }
+            return Actions.NoAction;
+        }
+
+        private void Run()
+        {
+            var running = true;
+
+            _environment.Setup();
+            _server.Setup();
+
+            while (running)
+            {
+                Thread.Sleep(_config.SleepTime);
+                var action = GenerateAction();
+                if (action == Actions.AddDust || action == Actions.AddJewel)
+                {
+                    var x = _rand.Next(0, _environment.GetWidth());
+                    var y = _rand.Next(0, _environment.GetWidth());
+                    if (action == Actions.AddDust)
+                    {
+                        _environment.AddDust(x, y);
+                    }
+                    else if (action == Actions.AddJewel)
+                    {
+                        _environment.AddJewel(x, y);
+                    }
+                }
+                else if (action == Actions.RemoveJewel)
+                {
+                    _environment.ForeachRoom(room =>
+                    {
+                        if (room.State.HasFlag(RoomState.Jewel))
+                        {
+                            room.RemoveJewel();
+                            return false;
+                        }
+                        return true;
+                    });
+                }
+            }
+        }
+    }
+}

uqac-ia-aspirobot/Extensions/Extensions.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using uqac_ia_aspirobot.Agent.Effectors;
+using uqac_ia_aspirobot.Common;
+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.Extensions
+{
+    public static class Extensions
+    {
+        public static void AddDust(this IEnvironment env, int x, int y)
+        {
+            env.GetRoom(x, y).AddDust();
+        }
+
+        public static void RemoveDust(this IEnvironment env, int x, int y)
+        {
+            env.GetRoom(x, y).RemoveDust();
+        }
+
+        public static void AddJewel(this IEnvironment env, int x, int y)
+        {
+            env.GetRoom(x, y).AddJewel();
+        }
+
+        public static void RemoveJewel(this IEnvironment env, int x, int y)
+        {
+            env.GetRoom(x, y).RemoveJewel();
+        }
+
+        public static RoomState GetRoomState(this IEnvironment env, int x, int y)
+        {
+            return env.GetRoom(x, y).State;
+        }
+
+        public static bool ForeachRoom<T>(this IEnvironment env, Func<T, bool> action)
+            where T : IRoom
+        {
+            for (var x = 0; x < env.GetWidth(); ++x)
+            {
+                for (var y = 0; y < env.GetHeight(); ++y)
+                {
+                    if (!action((T) env.GetRoom(x, y)))
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        public static bool ForeachRoom(this IEnvironment env, Func<IRoom, bool> action)
+        {
+            return env.ForeachRoom<IRoom>(action);
+        }
+
+        public static IList<T> FindDustyRooms<T>(this IEnvironment env)
+            where T : IRoom
+        {
+            var rooms = new List<T>();
+            ForeachRoom<T>(env, room =>
+            {
+                if (room.State.HasFlag(RoomState.Dust))
+                {
+                    rooms.Add(room);
+                }
+                return true;
+            });
+            return rooms;
+        }
+
+        public static IList<IRoom> FindDustyRooms(this IEnvironment env)
+        {
+            return env.FindDustyRooms<IRoom>();
+        }
+
+        public static IList<T> FindDustyRoomsWithoutJewel<T>(this IEnvironment env)
+            where T : IRoom
+        {
+            var rooms = new List<T>();
+            ForeachRoom<T>(env, room =>
+            {
+                if (room.State.CanBeVaccumed())
+                {
+                    rooms.Add(room);
+                }
+                return true;
+            });
+            return rooms;
+        }
+
+        public static IList<IRoom> FindDustyRoomsWithoutJewel(this IEnvironment env)
+        {
+            return env.FindDustyRoomsWithoutJewel<IRoom>();
+        }
+
+        public static RoomState GetRoomState(this ArClient client, IRoom room)
+        {
+            return client.GetRoomState(room.X, room.Y);
+        }
+
+        public static void RemoveDust(this ArClient client, IRoom room)
+        {
+            client.RemoveDust(room.X, room.Y);
+        }
+
+        public static void RemoveJewel(this ArClient client, IRoom room)
+        {
+            client.RemoveJewel(room.X, room.Y);
+        }
+
+        public static int Distance(this IRoom room, int x, int y)
+        {
+            return Math.Abs(room.X - x) + Math.Abs(room.Y - y);
+        }
+
+        public static int Distance(this IRoom room, AgEngineEffector effector)
+        {
+            return room.Distance(effector.X, effector.Y);
+        }
+
+        public static int Distance(this AgEngineEffector 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)
+        {
+            return effector.Distance(room.X, room.Y);
+        }
+
+        public static bool CanBeVaccumed(this RoomState state)
+        {
+            return state.HasFlag(RoomState.Dust) && !state.HasFlag(RoomState.Jewel);
+        }
+
+        public static bool IsInPosition(this AgEngineEffector engine, int x, int y)
+        {
+            return engine.X == x && engine.Y == y;
+        }
+
+        public static bool IsInRoom(this AgEngineEffector engine, IRoom room)
+        {
+            return engine.IsInPosition(room.X, room.Y);
+        }
+
+        public static void Move(this AgEngineEffector engine, int dx, int dy)
+        {
+            engine.MoveTo(engine.X + dx, engine.Y + dy);
+        }
+    }
+}

uqac-ia-aspirobot/Interfaces/IEnvironment.cs

+using System;
+
+namespace uqac_ia_aspirobot.Interfaces
+{
+    [Flags]
+    public enum RoomState
+    {
+        Unknown = -1,
+        Clean = 0,
+        Dust = 1,
+        Jewel = 2
+    }
+
+    public interface IEnvironment
+    {
+        void Setup();
+
+        int GetWidth();
+
+        int GetHeight();
+
+        IRoom GetRoom(int x, int y);
+    }
+}

uqac-ia-aspirobot/Interfaces/IRoom.cs

+namespace uqac_ia_aspirobot.Interfaces
+{
+    public interface IRoom
+    {
+        int X { get; set; }
+
+        int Y { get; set; }
+
+        RoomState State { get; }
+
+        void AddDust();
+
+        void RemoveDust();
+
+        void AddJewel();
+
+        void RemoveJewel();
+    }
+}

uqac-ia-aspirobot/Interfaces/IUi.cs

+namespace uqac_ia_aspirobot.Interfaces
+{
+    public interface IUi
+    {
+        void Update();
+    }
+}

uqac-ia-aspirobot/Program.cs

+using System.Threading;
+using uqac_ia_aspirobot.Agent;
+using uqac_ia_aspirobot.Common;
+using uqac_ia_aspirobot.Environment;
+
+namespace uqac_ia_aspirobot
+{
+    internal class Program
+    {
+        public static void Main(string[] args)
+        {
+            Thread.CurrentThread.Name = "Main";
+            var arConfig = new ArConfig
+            {
+                PipeName = "aspirobot-1.0",
+                PipeServer = ".",
+                ServerThreadCount = 1
+            };
+
+            EnvThread.Start(new EnvConfig
+            {
+                Height = 5,
+                Width = 5,
+                ActionPropability = 30.0f,
+                AddDustProbability = 50.0f,
+                AddJewelProbability = 50.0f,
+//                RemoveJewelProbability = 50.0f,
+                RemoveJewelProbability = 0,
+                SleepTime = 1000
+            }, arConfig);
+
+            Thread.Sleep(2);
+
+            AgAgent.Start(new AgConfig
+            {
+                SleepTime = 1000,
+                StartX = 0,
+                StartY = 0,
+                AutoAdjustSleepTime = false
+            }, arConfig);
+
+            AgAgent.Join();
+            EnvThread.Join();
+        }
+    }
+}

uqac-ia-aspirobot/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("uqac_ia_aspirobot")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("uqac_ia_aspirobot")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly: Guid("2A192A8A-B6F4-4752-A622-04C7A4AF0EE5")]

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.Extensions;
+using uqac_ia_aspirobot.Interfaces;
+
+namespace uqac_ia_aspirobot.UI
+{
+    public class UiConsole : IUi
+    {
+        private readonly IEnvironment _environment;
+        private readonly AgEngineEffector _agEngineEffector;
+        private readonly AgPickedSensor _agPickedSensor;
+        private readonly AgBatterySensor _agBatterySensor;
+        private readonly AgVaccumSensor _agVaccumSensor;
+
+        public UiConsole(IEnvironment environment, AgEngineEffector agEngineEffector, AgPickedSensor agPickedSensor,
+            AgBatterySensor agBatterySensor, AgVaccumSensor agVaccumSensor)
+        {
+            _environment = environment;
+            _agEngineEffector = agEngineEffector;
+            _agPickedSensor = agPickedSensor;
+            _agBatterySensor = agBatterySensor;
+            _agVaccumSensor = agVaccumSensor;
+        }
+
+        public void SetBackgroundColor(ConsoleColor? color)
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                Console.BackgroundColor = color.GetValueOrDefault(ConsoleColor.Black);
+            }
+            else
+            {
+                var str = "";
+                if (color == null)
+                {
+                    str = $"{(char)27}[1;49m";
+                }
+                if (color == ConsoleColor.Black)
+                {
+                    str = $"{(char)27}[1;40m";
+                }
+                if (color == ConsoleColor.Red)
+                {
+                    str = $"{(char)27}[1;41m";
+                }
+                if (color == ConsoleColor.Green)
+                {
+                    str = $"{(char)27}[1;42m";
+                }
+                if (color == ConsoleColor.Yellow)
+                {
+                    str = $"{(char)27}[1;43m";
+                }
+                if (color == ConsoleColor.Blue)
+                {
+                    str = $"{(char)27}[1;44m";
+                }
+                if (color == ConsoleColor.Magenta)
+                {
+                    str = $"{(char)27}[1;45m";
+                }
+                if (color == ConsoleColor.Cyan)
+                {
+                    str = $"{(char)27}[1;46m";
+                }
+                if (color == ConsoleColor.Gray)
+                {
+                    str = $"{(char)27}[1;47m";
+                }
+                Console.Write(str);
+            }
+        }
+
+        public void Clear()
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                Console.Clear();
+            }
+            else
+            {
+                Console.WriteLine();
+            }
+        }
+
+        public void Update()
+        {
+            Clear();
+            var bgColor = Console.BackgroundColor;
+            for (var x = 0; x < _environment.GetWidth(); ++x)
+            {
+                Console.Write("|");
+                for (var y = 0; y < _environment.GetHeight(); ++y)
+                {
+                    var state = _environment.GetRoomState(x, y);
+                    ConsoleColor? color = null;
+                    if (state == RoomState.Clean)
+                    {
+                        color = null;
+                    }
+                    else if (state == RoomState.Dust)
+                    {
+                        color = ConsoleColor.Gray;
+                    }
+                    else if (state == RoomState.Jewel)
+                    {
+                        color = ConsoleColor.Cyan;
+                    }
+                    else if (state == RoomState.Unknown)
+                    {
+                        color = ConsoleColor.Yellow;
+                    }
+                    else if (state == (RoomState.Jewel | RoomState.Dust))
+                    {
+                        color = ConsoleColor.Red;
+                    }
+                    SetBackgroundColor(color);
+                    Console.Write(_agEngineEffector.IsInPosition(x, y) ? "X" : " ");
+                    SetBackgroundColor(null);
+                }
+                Console.WriteLine("|");
+            }
+            SetBackgroundColor(bgColor);
+            Console.WriteLine($"Battery: {_agBatterySensor.Spent}");
+            Console.WriteLine($"Vaccumed: {_agVaccumSensor.Vaccumed}");
+            Console.WriteLine($"Picked: {_agPickedSensor.Picked}");
+        }
+    }
+}

uqac-ia-aspirobot/project.json

+{
+  "version": "1.0.0-*",
+  "buildOptions": {
+    "debugType": "portable",
+    "emitEntryPoint": true
+  },
+  "dependencies": {
+      "Microsoft.Extensions.DependencyInjection": "1.1.0",
+      "Microsoft.Extensions.Options": "1.1.0",
+      "System.IO.Pipes": "4.3.0"
+  },
+  "frameworks": {
+    "netcoreapp1.0": {
+      "dependencies": {
+        "Microsoft.NETCore.App": {
+          "type": "platform",
+          "version": "1.0.1"
+        }
+      },
+      "imports": "dnxcore50"
+
+    }
+  }
+}

uqac-ia-aspirobot/uqac-ia-aspirobot.xproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.Props" Condition="'$(VSToolsPath)' != ''"  />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{2A192A8A-B6F4-4752-A622-04C7A4AF0EE5}</ProjectGuid>
+    <ProjectTypeGuids>{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}</ProjectTypeGuids>
+    <RootNamespace>uqac_ia_aspirobot</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">.\obj</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">.\bin\</OutputPath>
+    <TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.targets" Condition="'$(VSToolsPath)' != ''" />
+</Project>