![\"image\"](\"https:\/\/pagan-gerbil.net\/wp-content\/uploads\/2017\/01\/image.png\" "\\"image\\"")
<\/p>\nProgramming uses maths. It\u2019s hard to ignore sometimes, especially when modelling something that is inherently graphical and position based such as a game.<\/p>\n
I\u2019ve decided to give the models three different position indicators \u2013 PositionX, PositionY and PositionZ. This will describe their exact position anywhere on the board \u2013 including on a ladder, a walkway or the ground. When they are given instructions to move, they should change those position variables accordingly \u2013 but not past the maximum move distance.<\/p>\n
My two options are to either pass in a distance and direction (both X direction and Y direction, like an aircraft would need to navigate) or a new set of position points \u2013 in essence, saying precisely \u2018go here\u2019. In the first, the new position would need to be calculated, and in the second the distance would need to be calculated. Either way, I\u2019d need to write both sets of code at some point.<\/p>\n
I think that it will be easier to back-track the distance and directions from a set of positions than it would be the other way around. Transforming a simple co-ordinate of (X, Y, Z) \u2013 where X is East-West, Y is North-South and Z is Up-Down \u2013 such as (1, 2, 1) to a new position of (2, 1, 2) tells me that the model has moved up a slope to the North-East for a distance of… actually, that bit gets harder. But it\u2019s at least easy to work out with trigonometry!<\/p>\n
<\/p>\n
On a two-dimensional plane, it is fairly simple to work out \u2013 as on the (hastily scribbled, not-to-scale) diagram to the left. This brings back distant memories of Pythagoras \u2013 a2<\/sup> + b2<\/sup> = c2<\/sup> \u2013 or, the square root of the difference in X + the difference in Y is the distance between the two points.<\/p>\n On a three-dimensional world, this is a bit more complicated \u2013 it has to be reduced to two different two-dimensional triangles to calculate the distance. The difference between two points is the \u2018difference in X\u2019 value of the second triangle. Another way of putting it would be \u221a (\u221a ((X1<\/sub> \u2013 X2<\/sub>)2<\/sup> + (Y1<\/sub> \u2013 Y2<\/sub>)2<\/sup>) + (Z1<\/sub> \u2013 Z2<\/sub>)2<\/sup>). Excellent.<\/p>\n In my original example then, the answer would be 1.554 arbitrary units. I could work out the directions (angles) by using more of my dusty trigonometric knowledge, but I only need to know the distance at this point. All I need to know are some test values that give a value above a model\u2019s Movement rate and some under, so I can test the outcomes of the MoveModel method. In the case of overshooting a model\u2019s permitted movement, I think I\u2019ll throw a new exception. I can see (a few pages down the line) that the model is going to need to be able to tell it\u2019s distance from other objects anyway, so this could be checked before attempting to move the model.<\/p>\n Time for a test! These values will move the model just a smidgen over 4 units.<\/p>\n The code to pass this in the MovementManager is:<\/p>\n And in the Model itself is:<\/p>\n I can\u2019t help but think that I am still over-designing this, but it feels about right to me. Finally, the test to ensure that the model actually does move:<\/p>\n Which requires a change to MoveModel –<\/p>\n Next, the situation that a model may move in two goes \u2013 and cannot go above it\u2019s movement rate in both chunks. For this, we\u2019ll have to record the distance moved.<\/p>\n Movement of a model is starting to take on several different, inter-related actions so I\u2019m going to move that stuff into the Model class itself. MoveModel in the MovementManager becomes simpler:<\/p>\n And the addition to the Model class is:<\/p>\n Next is to make sure we can make multiple moves without going over the limit and throwing an exception:<\/p>\n This doesn\u2019t need any new code, it just proves that the existing code still works. Finally, there needs to be a check that the TotalDistanceMoved will reset to 0 at the beginning of each turn. What is going to be the trigger for that? Currently, the only place that a new turn is known about is the GameManager, and the IncrementPhase method. The question is, therefore, how should the model be informed of this change? Should the GameManager contain a collection of all the models currently in the game, so the IncrementPhase method can just iterate that collection? Or should models be held elsewhere, and subscribe to a \u2018new turn\u2019 event that is triggered? I think it makes most sense for the models to be stored in the GameManager \u2013 at least at this time \u2013 and for them to expose a \u2018new turn\u2019 method.<\/p>\n I have become aware as I am refactoring this code around that I\u2019m starting to break the isolation of the unit tests \u2013 some tests are calling methods in classes that are not the class under test. This will obviously need to be refactored, but I\u2019d like to finish the current train of thought first. To do that properly though, I need to add a new test class \u2013 ModelTests \u2013 and test the NewTurn method on that as well as making sure the GameManager calls NewTurn on each of it\u2019s (mocked) Models. Testing these two things becomes an integration test, and cannot guarantee which class\/method is actually responsible for failing a test.<\/p>\n In the above test, I am adding a mock model into the GameManager, then verifying that the NewTurn method is called once. I add the Models property, create an IModel interface, change the IncrementPhase code to<\/p>\n And… four tests fail on me!<\/p>\n This is exactly the purpose of unit testing. In this case, I realised that the Models collection (List<IModel>) hadn\u2019t been initialised \u2013 these tests suddenly failing are a result of the turn ending and attempting to iterate through a collection that hasn\u2019t been set up yet \u2013 a NullReferenceException. One quick tweak to the constructor, and they\u2019re all passing again.<\/p>\n Finally, the test on the Model side to make sure that it sets TotalDistanceMoved back to zero.<\/p>\n And the code in Model being insultingly simple:<\/p>\n Thirteen tests so far, and all passing. A quick lesson in how unit tests can quickly point to something going awry \u2013 though I am sure more important lessons will come along as I move through the project \u2013 and we\u2019re almost to the end of page 10 in the rulebook. This has been a long section, and it\u2019s a good point to leave it at.<\/p>\n This is a learning project I am documenting in order to teach myself TDD and unit testing \u2013 as I publish this, I have already written many parts in advance but I want to know what I\u2019m doing wrong! If you see improvements or corrections, either to the code or the process, please leave a comment and let me know! Introduction to this project can be found here<\/a>.<\/em><\/p>\n","protected":false},"excerpt":{"rendered":" Programming uses maths. It\u2019s hard to ignore sometimes, especially when modelling something that is inherently graphical and position based such as a game. I\u2019ve decided to give the models three different position indicators \u2013 PositionX, PositionY and PositionZ. This will describe their exact position anywhere on the board \u2013 including on a ladder, a walkway … <\/p>\n[TestMethod<\/span>]\npublic void <\/span>MoveModel_CannotMoveFurtherThanModelsMovement()\n{\nbool <\/span>correctExceptionThrown = false<\/span>;\ntry\n<\/span>{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMovementManager <\/span>movementManager = new <\/span>MovementManager<\/span>(mockGameManager.Object);\nModel <\/span>testModel = new <\/span>Model<\/span>();\ntestModel.Movement = 4;\ndecimal <\/span>newX = 5;\ndecimal <\/span>newY = 6;\ndecimal <\/span>newZ = 3;\nmovementManager.MoveModel(testModel, newX, newY, newZ);\n}\ncatch <\/span>(ArgumentException <\/span>ex)\n{\ncorrectExceptionThrown = true<\/span>;\n}\nAssert<\/span>.IsTrue(correctExceptionThrown);\n}<\/pre>\npublic void <\/span>MoveModel(Model <\/span>testModel, float <\/span>newX, float <\/span>newY, float <\/span>newZ)\n{\nif <\/span>(testModel.Movement < testModel.GetDistanceFrom(newX, newY, newZ))\n{\nthrow new <\/span>ArgumentException<\/span>(\"The model cannot move further than it's Movement rate.\"<\/span>);\n}\n}<\/pre>\npublic float <\/span>PositionX { get<\/span>; set<\/span>; }\npublic float <\/span>PositionY { get<\/span>; set<\/span>; }\npublic float <\/span>PositionZ { get<\/span>; set<\/span>; }\npublic double <\/span>GetDistanceFrom(float <\/span>positionX, float <\/span>positionY, float <\/span>positionZ)\n{\ndouble <\/span>distance = 0;\ndouble <\/span>differenceX = this<\/span>.PositionX - positionX;\ndouble <\/span>differenceY = this<\/span>.PositionY - positionY;\ndouble <\/span>differenceZ = this<\/span>.PositionZ - positionZ;\ndistance = Math<\/span>.Sqrt(Math<\/span>.Sqrt((differenceX * differenceX) + (differenceY * differenceY)) + (differenceZ * differenceZ));\nreturn <\/span>distance;\n}<\/pre>\n[TestMethod<\/span>]\npublic void <\/span>MoveModel_PositionHasChanged()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMovementManager <\/span>movementManager = new <\/span>MovementManager<\/span>(mockGameManager.Object);\nModel <\/span>testModel = new <\/span>Model<\/span>();\ntestModel.Movement = 4;\ntestModel.PositionX = 0;\ntestModel.PositionY = 0;\ntestModel.PositionZ = 0;\nfloat <\/span>newX = 5;\nfloat <\/span>newY = 4;\nfloat <\/span>newZ = 3;\nmovementManager.MoveModel(testModel, newX, newY, newZ);\nAssert<\/span>.AreEqual(5, testModel.PositionX);\nAssert<\/span>.AreEqual(4, testModel.PositionY);\nAssert<\/span>.AreEqual(3, testModel.PositionZ);\n}<\/pre>\npublic void <\/span>MoveModel(Model <\/span>testModel, float <\/span>newX, float <\/span>newY, float <\/span>newZ)\n{\nif <\/span>(testModel.Movement < testModel.GetDistanceFrom(newX, newY, newZ))\n{\nthrow new <\/span>ArgumentException<\/span>(\"The model cannot move further than it's Movement rate.\"<\/span>);\n}\nelse\n<\/span>{\ntestModel.PositionX = newX;\ntestModel.PositionY = newY;\ntestModel.PositionZ = newZ;\n}\n}<\/pre>\n[TestMethod<\/span>]\npublic void <\/span>MoveModel_TotalMovementInASingleTurnCannotExceedModelMovement_ThrowsArgumentException()\n{\nbool <\/span>correctExceptionThrown = false<\/span>;\ntry\n<\/span>{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMovementManager <\/span>movementManager = new <\/span>MovementManager<\/span>(mockGameManager.Object);\nModel <\/span>testModel = new <\/span>Model<\/span>();\ntestModel.Movement = 4;\ntestModel.PositionX = 0;\ntestModel.PositionY = 0;\ntestModel.PositionZ = 0;\nfloat <\/span>newX = 5;\nfloat <\/span>newY = 4;\nfloat <\/span>newZ = 3;\nmovementManager.MoveModel(testModel, newX, newY, newZ);\nmovementManager.MoveModel(testModel, 0, 0, 0);\n}\ncatch <\/span>(ArgumentException <\/span>ex)\n{\ncorrectExceptionThrown = true<\/span>;\n}\nAssert<\/span>.IsTrue(correctExceptionThrown);\n}<\/pre>\npublic void <\/span>MoveModel(Model <\/span>testModel, float <\/span>newX, float <\/span>newY, float <\/span>newZ)\n{\nif <\/span>(testModel.Movement < testModel.GetDistanceFrom(newX, newY, newZ) + testModel.TotalDistanceMoved)\n{\nthrow new <\/span>ArgumentException<\/span>(\"The model cannot move further than it's Movement rate.\"<\/span>);\n}\nelse\n<\/span>{\ntestModel.MoveModel(newX, newY, newZ);\n}\n}<\/pre>\npublic double <\/span>TotalDistanceMoved { get<\/span>; private set<\/span>; }\npublic void <\/span>MoveModel(float <\/span>positionX, float <\/span>positionY, float <\/span>positionZ)\n{\nthis<\/span>.TotalDistanceMoved += GetDistanceFrom(positionX, positionY, positionZ);\nthis<\/span>.PositionX = positionX;\nthis<\/span>.PositionY = positionY;\nthis<\/span>.PositionZ = positionZ;\n}<\/pre>\n[TestMethod<\/span>]\npublic void <\/span>MoveModel_MakeTwoSmallMovementsWithoutGoingOverMovementRate()\n{\nbool <\/span>correctExceptionThrown = false<\/span>;\ntry\n<\/span>{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMovementManager <\/span>movementManager = new <\/span>MovementManager<\/span>(mockGameManager.Object);\nModel <\/span>testModel = new <\/span>Model<\/span>();\ntestModel.Movement = 4;\ntestModel.PositionX = 0;\ntestModel.PositionY = 0;\ntestModel.PositionZ = 0;\nfloat <\/span>newX = 1;\nfloat <\/span>newY = 1;\nfloat <\/span>newZ = 0;\nmovementManager.MoveModel(testModel, newX, newY, newZ);\nmovementManager.MoveModel(testModel, 0, 0, 0);\n}\ncatch <\/span>(ArgumentException <\/span>ex)\n{\ncorrectExceptionThrown = true<\/span>;\n}\nAssert<\/span>.IsFalse(correctExceptionThrown);\n}<\/pre>\n[TestMethod<\/span>]\npublic void <\/span>IncrementTurnPhase_CallsNewTurnOnModels()\n{\nGameManager <\/span>manager = new <\/span>GameManager<\/span>(2);\nMock<\/span><IModel<\/span>> mockModel = new <\/span>Mock<\/span><IModel<\/span>>();\nmanager.Models.Add(mockModel.Object);\nmanager.IncrementPhase(); \/\/ Go to Shooting\n<\/span>manager.IncrementPhase(); \/\/ Go to Close Combat\n<\/span>manager.IncrementPhase(); \/\/ Go to Recovery\n<\/span>manager.IncrementPhase(); \/\/ Go back to Movement\n<\/span>mockModel.Verify(item => item.NewTurn(), Times<\/span>.Once());\n}<\/pre>\npublic void <\/span>IncrementPhase()\n{\nif <\/span>(CurrentPhase == TurnPhase<\/span>.Recovery)\n{\nCurrentPhase = TurnPhase<\/span>.Movement;\nif <\/span>(CurrentPlayersTurn == NumberOfPlayers)\n{\nCurrentPlayersTurn = 1;\n}\nelse\n<\/span>{\nCurrentPlayersTurn++;\n}\nforeach <\/span>(IModel <\/span>model in this<\/span>.Models)\n{\nmodel.NewTurn();\n}\n}\nelse\n<\/span>{\nCurrentPhase++;\n}\n}<\/pre>\n![\"image_3\"](\"https:\/\/pagan-gerbil.net\/wp-content\/uploads\/2017\/01\/image_3.png\" "\\"image_3\\"")
<\/p>\n[TestClass<\/span>]\npublic class <\/span>ModelTests\n<\/span>{\n[TestMethod<\/span>]\npublic void <\/span>NewTurn_SetsDistanceMovedToZero()\n{\nModel <\/span>testModel = new <\/span>Model<\/span>();\ntestModel.TotalDistanceMoved = 4;\ntestModel.NewTurn();\nAssert<\/span>.AreEqual(0, testModel.TotalDistanceMoved);\n}\n}<\/pre>\npublic void <\/span>NewTurn()\n{\nthis<\/span>.TotalDistanceMoved = 0;\n}<\/pre>\n