Fixed the waiting time calculation and added graphical representation on the checkouts fill

Caisses/Caisses.csproj

@@ -59,7 +59,7 @@
     <Compile Include="GraphicalClient.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Store.cs" />
+    <Compile Include="GraphicalStore.cs" />
     <EmbeddedResource Include="Form1.resx">
       <DependentUpon>Form1.cs</DependentUpon>
     </EmbeddedResource>

Caisses/Checkout.cs

@@ -22,32 +22,16 @@ namespace Caisses
             Clients = new List<Client>();
             Open = false;
         }
-        public void Tick(int averageWaitingTime, int CrossoverTime)
+        public void Tick(int averageWaitingTime, int CrossoverTime, int openedCheckoutsCount)
         {
-            if (!Open && averageWaitingTime > CrossoverTime)
+            if (!Open && averageWaitingTime > CrossoverTime || openedCheckoutsCount == 0)
             {
                 Open = true;
             }
-            if (Open && averageWaitingTime < CrossoverTime && Clients.Count == 0)
+            if (Open && averageWaitingTime < 1 && Clients.Count == 0 && openedCheckoutsCount > 1)
             {
                 Open = false;
             }
-            /*
-            if (Clients.Count != 0)
-            {
-                //This is the first client inline
-                Client client = Clients[0];
-                if (client.State == Client.ClientState.Inline)
-                    client.State = Client.ClientState.Checkout;
-
-                
-                if (client.CheckoutTime <= 0)
-                {
-                    I think we need to do this processing in the store
-                }
-                
-            }
-        */
         }
     }
 }

Caisses/GraphicalCheckout.cs

@@ -28,13 +28,37 @@ namespace Caisses
         }
         public void Draw(Bitmap checkoutAreaImage)
         {
+            int radius = Math.Min(Size.Width, Size.Height / MAX_CAPACITY);
+            Size clientSize = new Size(radius,radius);
+            int xOffset = Size.Width / 2 - radius / 2;
             Graphics g = Graphics.FromImage(checkoutAreaImage);
+            
+
+
+
             //g.DrawRectangle(new Pen(Color.FromArgb(Random.Next(0,255),Random.Next(0,255),Random.Next(0,255))),new Rectangle(Position,Size));
             g.DrawRectangle(new Pen(Color.Black),new Rectangle(Position,Size));
             if (Open)
             {
                 g.FillRectangle(new SolidBrush(Color.Green),new Rectangle(Position, Size));
-                g.DrawString(Clients.Count().ToString(), new Font("Arial", 16), new SolidBrush(Color.White), new PointF(Position.X, Position.Y));
+                //g.DrawString(Clients.Count().ToString(), new Font("Arial", 16), new SolidBrush(Color.White), new PointF(Position.X, Position.Y));
+
+                if(Clients.Count > 0)
+                {
+                    for (int i = 0; i < Clients.Count; i++)
+                    {
+                        Point clientPos = new Point(Position.X + xOffset, (i) * clientSize.Height + Position.Y);
+                        if (i == 0)
+                        {
+                            g.FillEllipse(Brushes.BlueViolet, new Rectangle(clientPos, clientSize));
+                            g.DrawString(Clients[i].CheckoutTime.ToString(), new Font("Arial", 16), new SolidBrush(Color.White), clientPos);
+                        }
+                        else
+                        {
+                            g.FillEllipse(Brushes.Violet, new Rectangle(clientPos, clientSize));
+                        }
+                    }
+                }   
             }
             else
             {

Caisses/GraphicalClient.cs

@@ -60,11 +60,11 @@ namespace Caisses
                     g.DrawString(WaitingTime.ToString(), new Font("Arial", 16), new SolidBrush(Color.White), new PointF(Position.X, Position.Y));
                     break;
                 case ClientState.Inline:
-                    g.FillEllipse(new SolidBrush(Color.Violet), new RectangleF(Position, Size));
+                    //g.FillEllipse(new SolidBrush(Color.Violet), new RectangleF(Position, Size));
                     break;
                 case ClientState.Checkout:
-                    g.FillEllipse(new SolidBrush(Color.Green), new RectangleF(Position, Size));
+                    //g.FillEllipse(new SolidBrush(Color.Green), new RectangleF(Position, Size));
-                    g.DrawString(CheckoutTime.ToString(), new Font("Arial", 16), new SolidBrush(Color.Black), new PointF(Position.X, Position.Y));
+                    //g.DrawString(CheckoutTime.ToString(), new Font("Arial", 16), new SolidBrush(Color.Black), new PointF(Position.X, Position.Y));
                     break;
                 default:
                     break;

Caisses/GraphicalStore.cs

@@ -67,25 +67,13 @@ namespace Caisses
                 FillStore(amountOfNewCLients);
             }
 
-            int cumulatedWaitingTime = 0;
-            int averageWaitingTime = 0;
-
             foreach (GraphicalClient client in Clients)
             {
                 client.Tick();
-                cumulatedWaitingTime += client.WaitingTime;
-            }
-            if (Clients.Count == 0)
-            {
-                averageWaitingTime = 0;
-            }
-            else
-            {
-                averageWaitingTime = cumulatedWaitingTime / Clients.Count;
             }
             foreach (GraphicalCheckout checkout in Checkouts)
             {
-                checkout.Tick(averageWaitingTime,CROSSOVER_TIME);
+                checkout.Tick(GetAverageWaitingTime(),CROSSOVER_TIME,GetAmountOfOpenCheckouts());
             }
 
             //Processing the checkout mechanism
@@ -207,22 +195,40 @@ namespace Caisses
             }
             return result;
         }
+        public int GetAmountOfOpenCheckouts()
+        {
+            int result = 0;
+            foreach (GraphicalCheckout checkout in Checkouts)
+            {
+                if (checkout.Open)
+                {
+                    result++;
+                }
+            }
+            return result;
+        }
         public int GetAverageWaitingTime()
         {
             int cumulatedWaitingTime = 0;
             int averageWaitingTime = 0;
 
+            int waitingClients = 0;
+
             foreach (GraphicalClient client in Clients)
+            {
+                if (client.State == Client.ClientState.Waiting)
                 {
                     cumulatedWaitingTime += client.WaitingTime;
+                    waitingClients += 1;
                 }
-            if (Clients.Count == 0)
+            }
+            if (Clients.Count == 0 || waitingClients == 0)
             {
                 averageWaitingTime = 0;
             }
             else
             { 
-                averageWaitingTime = cumulatedWaitingTime / Clients.Count;
+                averageWaitingTime = cumulatedWaitingTime / waitingClients;
             }
 
             return averageWaitingTime;