dev

GameHandler.UnitTests/Extensions/PinThrowExtensionTests.cs

@@ -0,0 +1,71 @@
+using GameHandler.Extensions;
+using GameModel;
+using GameModel.Mocks;
+using NUnit.Framework.Legacy;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameHandler.UnitTests.Extensions
+{
+    [TestFixture]
+    internal class PinThrowExtensionTests
+    {
+        
+        [Test]
+        public void GetExpenseTriggers_SinkReturnsSinkTrigger() 
+        {
+            var bs = BoardState.Create();
+            var pt = PinThrow.Create(PinPicture.Create(1,PinState.Down),false,true);
+            var tirgger = pt.GetExpenseTriggers(bs);
+            CollectionAssert.AreEqual(tirgger, new[] {ExpenseTrigger.Sink});
+        }
+
+        [Test]
+        public void GetExpenseTriggers_SinkAndBellReturnsSinkAndBellTrigger()
+        {
+            var bs = BoardState.Create();
+            var pt = PinThrow.Create(PinPicture.Create(1, PinState.Down), true, true);
+            var tirgger = pt.GetExpenseTriggers(bs);
+            CollectionAssert.AreEqual(tirgger, new[] { ExpenseTrigger.Sink, ExpenseTrigger.Bell });
+        }
+
+        [Test]
+        public void GetExpenseTriggers_NoWoodReturnsNoWoodTrigger()
+        {
+            var bs = BoardState.Create();
+            var pt = PinThrow.Create(PinPicture.Create(), false, false);
+            var tirgger = pt.GetExpenseTriggers(bs);
+            CollectionAssert.AreEqual(tirgger, new[] { ExpenseTrigger.NoWood });
+        }
+
+        [Test]
+        public void GetExpenseTriggers_CircleReturnsCircleTrigger()
+        {
+            var bs = BoardState.Create();
+            var pt = PinThrow.Create(PinPicture.CreateCircle(), false, false);
+            var tirgger = pt.GetExpenseTriggers(bs);
+            CollectionAssert.AreEqual(tirgger, new[] { ExpenseTrigger.Circle });
+        }
+
+        [Test]
+        public void GetExpenseTriggers_NineReturnsNineTrigger()
+        {
+            var bs = BoardState.Create();
+            var pt = PinThrow.Create(PinPicture.CreateAllPins(), false, false);
+            var tirgger = pt.GetExpenseTriggers(bs);
+            CollectionAssert.AreEqual(tirgger, new[] { ExpenseTrigger.NinePins });
+        }
+
+        [Test]
+        public void GetExpenseTriggers_SinkAtStartReturnsSinkAtStartTrigger()
+        {
+            var bs = BoardState.Create(ThrowMode.Decrease);
+            var pt = PinThrow.Create(PinPicture.CreateAllPins(), false, true);
+            var tirgger = pt.GetExpenseTriggers(bs);
+            CollectionAssert.AreEqual(tirgger, new[] { ExpenseTrigger.FullSink });
+        }
+    }
+}

GameHandler.UnitTests/PinPictureTests.cs

@@ -113,7 +113,7 @@ namespace GameHandler.UnitTests
         public void PicturePlusSinkIsSamePicture()
         {
             var p = PinPicture.Create();
-            var p2 = p + new PinThrow(null, false, true);
+            var p2 = p + PinThrow.Create(null, false, true);
             Assert.That(p,Is.EqualTo(p2));
         }
 
@@ -135,31 +135,31 @@ namespace GameHandler.UnitTests
         {
             var p1 = PinPicture.Create();
             var throwPic1 = PinPicture.Create(1, PinState.Down);
-            var pinThrow1 = new PinThrow(throwPic1, false, false);
+            var pinThrow1 = PinThrow.Create(throwPic1, false, false);
 
             var throwPic2 = PinPicture.Create(2, PinState.Down);
-            var pinThrow2 = new PinThrow(throwPic2, false, false);
+            var pinThrow2 = PinThrow.Create(throwPic2, false, false);
 
             var throwPic3 = PinPicture.Create(3, PinState.Down);
-            var pinThrow3 = new PinThrow(throwPic3, false, false);
+            var pinThrow3 = PinThrow.Create(throwPic3, false, false);
 
             var throwPic4 = PinPicture.Create(4, PinState.Down);
-            var pinThrow4 = new PinThrow(throwPic4, false, false);
+            var pinThrow4 = PinThrow.Create(throwPic4, false, false);
 
             var throwPic5 = PinPicture.Create(5, PinState.Down);
-            var pinThrow5 = new PinThrow(throwPic5, false, false);
+            var pinThrow5 = PinThrow.Create(throwPic5, false, false);
 
             var throwPic6 = PinPicture.Create(6, PinState.Down);
-            var pinThrow6 = new PinThrow(throwPic6, false, false);
+            var pinThrow6 = PinThrow.Create(throwPic6, false, false);
 
             var throwPic7 = PinPicture.Create(7, PinState.Down);
-            var pinThrow7 = new PinThrow(throwPic7, false, false);
+            var pinThrow7 = PinThrow.Create(throwPic7, false, false);
 
             var throwPic8 = PinPicture.Create(8, PinState.Down);
-            var pinThrow8 = new PinThrow(throwPic8, false, false);
+            var pinThrow8 = PinThrow.Create(throwPic8, false, false);
 
             var throwPic9 = PinPicture.Create(9, PinState.Down);
-            var pinThrow9 = new PinThrow(throwPic9, false, false);
+            var pinThrow9 = PinThrow.Create(throwPic9, false, false);
 
             var p2 = p1 + pinThrow1;
             var p3 = p2 + pinThrow2;

GameHandler.UnitTests/PinThrowTests.cs

@@ -14,7 +14,7 @@ namespace GameHandler.UnitTests
         public void AllNineThrow_IsNotIsNotCircle()
         {
             var pic = new PinPicture(PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down);
-            var t = new PinThrow(pic,false,false);
+            var t = PinThrow.Create(pic,false,false);
 
             Assert.That(t.IsSink, Is.False);
             Assert.That(t.IsNinePins, Is.True);
@@ -27,7 +27,7 @@ namespace GameHandler.UnitTests
         public void SinkThrow_IsNothing()
         {
             var pic = new PinPicture(PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down);
-            var t = new PinThrow(pic, false, true);
+            var t = PinThrow.Create(pic, false, true);
 
             Assert.That(t.IsSink, Is.True);
             Assert.That(t.IsNinePins, Is.False);
@@ -40,7 +40,7 @@ namespace GameHandler.UnitTests
         public void Circle_IsNotAllNine()
         {
             var pic = new PinPicture(PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Up, PinState.Down, PinState.Down, PinState.Down, PinState.Down);
-            var t = new PinThrow(pic, false, false);
+            var t = PinThrow.Create(pic, false, false);
 
             Assert.That(t.IsSink, Is.False);
             Assert.That(t.IsNinePins, Is.False);
@@ -53,7 +53,7 @@ namespace GameHandler.UnitTests
         public void NoWood_IsNotSink()
         {
             var pic = new PinPicture(PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up);
-            var t = new PinThrow(pic, false, false);
+            var t = PinThrow.Create(pic, false, false);
             Assert.That(t.IsSink, Is.False);
             Assert.That(t.IsNinePins, Is.False);
             Assert.That(t.IsCircle, Is.False);

GameHandler.UnitTests/ThrowHandlerTests.cs

@@ -23,7 +23,7 @@ namespace GameHandler.UnitTests
         {
             var bs = _th.Init(ThrowMode.Reposition);
 
-            var bs2 = _th.Update(bs, new PinThrow(PinPicture.Create(2,PinState.Down),false,false));
+            var bs2 = _th.Update(bs, new PinThrow(1, PinPicture.Create(2,PinState.Down),false,false));
 
             Assert.That(bs.PinPicture.UpCount, Is.EqualTo(9));
         }
@@ -33,8 +33,8 @@ namespace GameHandler.UnitTests
         {
             var bs = _th.Init(ThrowMode.Reposition);
 
-            var bs2 = _th.Update(bs, new PinThrow(PinPicture.Create(2, PinState.Down), false, false));
+            var bs2 = _th.Update(bs, new PinThrow(1, PinPicture.Create(2, PinState.Down), false, false));
-            var bs3 = _th.Update(bs, new PinThrow(PinPicture.Create(2, PinState.Down), false, true));
+            var bs3 = _th.Update(bs, new PinThrow(1, PinPicture.Create(2, PinState.Down), false, true));
 
             Assert.That(bs2, Is.EqualTo(bs3));
         }
@@ -44,10 +44,10 @@ namespace GameHandler.UnitTests
         {
             var bs = _th.Init(ThrowMode.Decrease);
 
-            var bs2 = _th.Update(bs, new PinThrow(PinPicture.Create(2, PinState.Down), false, false));
+            var bs2 = _th.Update(bs, new PinThrow(1, PinPicture.Create(2, PinState.Down), false, false));
             Assert.That(bs2.PinPicture.DownCount, Is.EqualTo(1));
 
-            var bs3 = _th.Update(bs, new PinThrow(PinPicture.CreateAllPins(), false, false));
+            var bs3 = _th.Update(bs, new PinThrow(1, PinPicture.CreateAllPins(), false, false));
             Assert.That(bs3.PinPicture.DownCount, Is.EqualTo(0));
         }
     }

GameHandler/ExpenseHandler.cs

@@ -1,8 +1,11 @@
 using GameContract;
+using GameHandler.Extensions;
+using GameModel;
 using GameModel.DeathGame;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Numerics;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -19,5 +22,48 @@ namespace GameHandler
             _expenseRepository = expenseRepository;
         }
 
+        private int[] PlayersAtGameStart;
+        private int[] PlayersInGame;
+
+        public void StartGame(int[] playerIds) 
+        {
+            PlayersAtGameStart = playerIds;
+        }
+
+        private ExpenseModel _expenseModel = new ExpenseModel(Array.Empty<MemberExpense>());
+
+        public ExpenseModel CheckThrow(BoardState currentState, PinThrow pinThrow)
+        {
+            var memberExpenses = new List<MemberExpense>(_expenseModel.MemberExpenses);
+
+            var triggers = pinThrow.GetExpenseTriggers(currentState);
+            if (currentState.ThrowMode == ThrowMode.Decrease && currentState.PinPicture.AllUp)
+            {
+                
+            }
+
+            if (pinThrow.IsCircle)
+            {
+                var inversePlayers = PlayersAtGameStart.Where(_ => _ != pinThrow.PlayerId);
+                var destExpenses = _expenseRepository.GetAll().Where(_ => _.ExpenseTriggers.Any(tr => tr == ExpenseTrigger.Circle));
+                foreach (var expense in destExpenses)
+                {
+                    if (expense.IsInverse)
+                    {
+                        foreach (var player in inversePlayers)
+                        {
+                            memberExpenses.Add(MemberExpense.Create(player, expense));
+                        }
+                    }
+                    else
+                    {
+                        memberExpenses.Add(MemberExpense.Create(pinThrow.PlayerId, expense));
+                    }
+
+                }
+            }
+
+            return _expenseModel with { MemberExpenses = memberExpenses.ToArray() };
+        }
     }
 }

GameHandler/Extensions/PinThrowExtension.cs

@@ -0,0 +1,47 @@
+using GameModel;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameHandler.Extensions
+{
+    public static class PinThrowExtension
+    {
+        public static ExpenseTrigger[] GetExpenseTriggers(this PinThrow pinThrow, BoardState boardState)
+        {
+            var res = new List<ExpenseTrigger>();
+            if (pinThrow.IsSink)
+            {
+                if (boardState.PinPicture.AllUp && boardState.ThrowMode == ThrowMode.Decrease)
+                {
+                    res.Add(ExpenseTrigger.FullSink);
+                }
+                else
+                {
+                    res.Add(ExpenseTrigger.Sink);
+                }
+            }
+            if (pinThrow.IsNoWood)
+            {
+                res.Add(ExpenseTrigger.NoWood);
+            }
+            if (pinThrow.IsBell)
+            {
+                res.Add(ExpenseTrigger.Bell);
+            }
+            if (pinThrow.IsCircle)
+            {
+                res.Add(ExpenseTrigger.Circle);
+            }
+            if (pinThrow.IsNinePins)
+            {
+                res.Add(ExpenseTrigger.NinePins);
+            }
+            return res.ToArray();
+        }
+    }
+}

GameModel/BoardState.cs

@@ -6,5 +6,16 @@ using System.Threading.Tasks;
 
 namespace GameModel
 {
-    public record BoardState(ThrowMode ThrowMode, PinPicture PinPicture );
+    public record BoardState(ThrowMode ThrowMode, PinPicture PinPicture)
+    {
+        public static BoardState Create()
+        {
+            return new BoardState(ThrowMode.Reposition,PinPicture.Create());    
+        }
+
+        public static BoardState Create(ThrowMode ThrowMode)
+        {
+            return new BoardState(ThrowMode, PinPicture.Create());
+        }
+    }
 }

GameModel/ExpenseModel.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameModel
+{
+    public record ExpenseModel(MemberExpense[] MemberExpenses)
+    {
+    }
+}

GameModel/MemberExpense.cs

@@ -6,7 +6,11 @@ using System.Threading.Tasks;
 
 namespace GameModel
 {
-    public record MemberExpense(Guid ExpenseGuid, int MemberId, ExpenseType ExpenseType)
+    public record MemberExpense(Guid ExpenseGuid, int MemberId, ExpenseType ExpenseType, DateTime Created)
     {
+        public static MemberExpense Create(int MemberId, Expense Expense)
+        {
+            return new MemberExpense(Guid.NewGuid(), MemberId, Expense.ExpenseType, DateTime.Now);
+        }
     }
 }

GameModel/PinPicture.cs

@@ -184,5 +184,11 @@ namespace GameModel
             var states = new List<PinState>(new[] { PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Down }).ToArray();            
             return PinPicture.Create(states);
         }
+
+        public static PinPicture CreateCircle()
+        {
+            var states = new List<PinState>(new[] { PinState.Down, PinState.Down, PinState.Down, PinState.Down, PinState.Up, PinState.Down, PinState.Down, PinState.Down, PinState.Down }).ToArray();
+            return PinPicture.Create(states);
+        }
     }
 }

GameModel/PinThrow.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace GameModel
 {
-    public record PinThrow(PinPicture PicPicture, bool IsBell, bool IsSink)
+    public record PinThrow(int PlayerId, PinPicture PicPicture, bool IsBell, bool IsSink)
     {
         public bool IsCircle => !IsSink && PicPicture.DownCount == 8 && (PicPicture[5] ==  PinState.Up);
 
@@ -18,5 +18,15 @@ namespace GameModel
         public int PinCount => IsSink ? 0 : PicPicture.DownCount;
 
         public bool IsNoWood => PicPicture.DownCount == 0 && !IsSink;
+
+        public static PinThrow Create(int PlayerId, PinPicture PicPicture, bool IsBell, bool IsSink)
+        {
+            return new PinThrow(PlayerId, PicPicture, IsBell, IsSink);
+        }
+
+        public static PinThrow Create(PinPicture PicPicture, bool IsBell, bool IsSink)
+        {
+            return Create(1, PicPicture, IsBell, IsSink);
+        }
     }
 }