{"id":185,"date":"2011-02-19T08:00:00","date_gmt":"2011-02-19T08:00:00","guid":{"rendered":"https:\/\/pagan-gerbil.net\/?p=185"},"modified":"2011-02-19T08:00:00","modified_gmt":"2011-02-19T08:00:00","slug":"learning-unit-testing-ix-moving-on-with-movement","status":"publish","type":"post","link":"https:\/\/www.pagan-gerbil.net\/?p=185","title":{"rendered":"Learning Unit Testing IX – Moving On With Movement"},"content":{"rendered":"

Having gotten those knotty problems with world management, distances, directions, etc all out of the way I can finally move off of page 10. So what\u2019s next? Page 11! Hooray!<\/p>\n

It begins with a description of a charge move. A charge works like a run, at double-move rate, with the model (hopefully) ending up in contact with an enemy, or with a low wall that is also in contact with the enemy. The movement side of things should be fairly easy, but describing \u2018base contact\u2019 might be slightly more difficult.<\/p>\n

In the real game, a model\u2019s base is usually a circle 25mm in diameter. This is close enough to one inch to be treated as one of the arbitrary units I\u2019m using for movement and measurement, so a model can be described as having a width of 1. If I choose the location to describe the centre-point of a model\u2019s base, then \u2018base contact\u2019 would be a point equal to half the charger\u2019s width plus half the target\u2019s width, to allow for future models that may be bigger or smaller than a normal one (I\u2019m fondly thinking of Ogryns!)<\/p>\n

I started skirting around the issue slightly in the last post, but I need to seriously consider scenery and models as things with width and height, more than points on a virtual graph. The scenery will also need a different method of determining base contact, since it won\u2019t often have a circular base.<\/p>\n

It\u2019s taking me a while to work out exactly which direction (no pun intended) to go with this. A charge sounds exactly like a regular run move, except you can (and are expected to!) get within 8\u201d of an enemy model without stopping, and it declares that the model \u201cCan do nothing for the rest of the turn.\u201d To that end, I believe that only three new tests are needed, on a \u2018charge\u2019 method \u2013 one that makes sure a charging model can approach within 8\u201d of an enemy, one that checks that an \u2018isCharging\u2019 flag is set so that the model can\u2019t take any more actions this turn, and one that checks that that flag is removed at the beginning of a turn.<\/p>\n

The first test \u2013 that the model doesn\u2019t stop moving close to an enemy \u2013 is almost identical to the one that checks that it does<\/em> stop moving close to an enemy, but with a different expected final position and no exception thrown.<\/p>\n

[TestMethod<\/span>]\npublic void <\/span>Charge_CanGetWithin8InchesOfEnemy()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nModel <\/span>enemyModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\nenemyModel.Location.X = 9;\nenemyModel.Location.Y = 0;\nenemyModel.Location.Z = 0;\nmockGameManager.Setup(item => item.Models).Returns(new <\/span>List<\/span><IModel<\/span>>() { enemyModel });\nModel <\/span>testModel = new <\/span>Model<\/span>(2, mockGameManager.Object, mockObjectManager.Object);\ntestModel.Movement = 4;\ntestModel.Location.X = 0;\ntestModel.Location.Y = 0;\ntestModel.Location.Z = 0;\nbool <\/span>exceptionThrown = false<\/span>;\ntry\n<\/span>{\nmockObjectManager.Setup(item => item.GetDistanceBetween(testModel.Location, It<\/span>.IsAny<float<\/span>>(), It<\/span>.IsAny<float<\/span>>(), It<\/span>.IsAny<float<\/span>>())).Returns(8);\nmockObjectManager.Setup(item => item.GetPointOfIntersection(testModel.Location, It<\/span>.IsAny<LocationPoint<\/span>>(), enemyModel.Location, 8)).Returns(new <\/span>LocationPoint<\/span>(1, 0, 0));\nmockObjectManager.Setup(item => item.GetLineOfSight(testModel, enemyModel)).Returns(1);\ntestModel.Charge(8, 0, 0);\n}\ncatch <\/span>(MovementException <\/span>ex)\n{\nexceptionThrown = true<\/span>;\n}\nAssert<\/span>.IsFalse(exceptionThrown);\nAssert<\/span>.AreEqual(8, testModel.Location.X);\nAssert<\/span>.AreEqual(0, testModel.Location.Y);\nAssert<\/span>.AreEqual(0, testModel.Location.Z);\n}<\/pre>\n
The code to pass this test is extremely simple:<\/p>\n
private bool <\/span>_isCharging = false<\/span>;\npublic void <\/span>Charge(float <\/span>positionX, float <\/span>positionY, float <\/span>positionZ)\n{\n_isCharging = true<\/span>;\nMoveModel(positionX, positionY, positionZ);\n}<\/pre>\n
And a quick change to the ValidateMove method to check if the model is charging before validating the \u2018within 8\u201d of an enemy\u2019 rule:<\/p>\n
if <\/span>(this<\/span>.TotalDistanceMoved + distanceToPoint > this<\/span>.Movement && _isCharging == false<\/span>)<\/pre>\n
I almost feel silly for thinking it would be any harder than that, but then I was originally worrying about the base sizes, low wall restriction, etc, that is all part of \u2018being in base contact\u2019 \u2013 as far as Movement is concerned, it doesn\u2019t matter if the models are in base contact after a charge, only that a charge was attempted. The next test, then, checks that the flag is set:<\/p>\n
[TestMethod<\/span>]\npublic void <\/span>Charge_SetsIsChargingFlag()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nModel <\/span>testModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\ntestModel.Movement = 4;\ntestModel.Location.X = 0;\ntestModel.Location.Y = 0;\ntestModel.Location.Z = 0;\nmockObjectManager.Setup(item => item.GetDistanceBetween(testModel.Location, It<\/span>.IsAny<float<\/span>>(), It<\/span>.IsAny<float<\/span>>(), It<\/span>.IsAny<float<\/span>>())).Returns(8);\ntestModel.Charge(8, 0, 0);\nAssert<\/span>.IsTrue(testModel.IsCharging);\n}<\/pre>\n
The code only needed to change the private _isCharging to a public IsCharging property, and again \u2013 straight into the pass. To make sure the NewTurn method resets the charging flag:<\/p>\n
[TestMethod<\/span>]\npublic void <\/span>NewTurn_SetsIsChargingToFalse()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nModel <\/span>testModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\ntestModel.Movement = 4;\ntestModel.Charge(8, 0, 0);\nAssert<\/span>.IsTrue(testModel.IsCharging);\ntestModel.NewTurn();\nAssert<\/span>.IsFalse(testModel.IsCharging);\n}<\/pre>\n
Code to pass that test is just insultingly simple. At this time, I realised that the IsRunning flag might not have been set back to false at the beginning of a new turn \u2013 there\u2019s no test for it, so I\u2019ll add that in now.<\/p>\n
[TestMethod<\/span>]\npublic void <\/span>NewTurn_SetsIsRunningToFalse()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nmockGameManager.Setup(item => item.Models).Returns(new <\/span>List<\/span><IModel<\/span>>());\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nModel <\/span>testModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\ntestModel.Movement = 4;\ntestModel.MoveModel(8, 0, 0);\nAssert<\/span>.IsTrue(testModel.IsRunning);\ntestModel.NewTurn();\nAssert<\/span>.IsFalse(testModel.IsRunning);\n}<\/pre>\n
And as I predicted \u2013 it fails! The passing code should, again, be fairly easy to figure out. So I now have all the basics of charging, without the \u2018is in base contact\u2019 checks which will mostly be mathematical functions, and abstracted out without really implementing them (as I decided earlier).<\/p>\n
The next challenge is Hiding, then we can move away from page 11 \u2013 much faster than getting away from page 10 was, at any rate! As I see it, the following things are necessary to check for hiding:<\/p>\n
    \n
  • A model can choose to hide if it ends it\u2019s turn in \u2018reasonable\u2019 cover\n
  • A model can move about and stay hidden, as long as it doesn\u2019t leave the \u2018reasonable\u2019 cover.\n
  • A model cannot run or charge and hide in the same turn.\n
  • If an enemy model moves to a position it can see the hiding model, it ceases to be hidden.\n
  • A model ceases to be hidden if an enemy is within it\u2019s Initiative value in inches of the model. <\/li>\n<\/ul>\n
    I will define \u2018reasonable\u2019 cover as being in at least 40% cover \u2013 this value could easily be tweaked later. I had decided while brainstorming before that line-of-sight shouldn\u2019t return a boolean value, rather a percentage of the target that is visible. In systems that can determine only \u2018visible\u2019 and \u2018not visible\u2019, the IObjectManager would obviously return 0 and 1 and nothing in between. More subtle systems would give a range of values, meaning that cover saves (when I get to shooting) will take account of partial cover, heavy cover, etc. The first test then will check line of sight from every enemy, to make sure that it is not more than 60% visible to any of them.<\/p>\n
    [TestMethod<\/span>]\npublic void <\/span>Hide_SetsFlagIfInReasonableCover()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nModel <\/span>enemyModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\nmockGameManager.Setup(item => item.Models).Returns(new <\/span>List<\/span><IModel<\/span>>() { enemyModel });\nModel <\/span>testModel = new <\/span>Model<\/span>(2, mockGameManager.Object, mockObjectManager.Object);\nbool <\/span>exceptionThrown = false<\/span>;\ntry\n<\/span>{\nmockObjectManager.Setup(item => item.GetLineOfSight(It<\/span>.IsAny<IModel<\/span>>(), It<\/span>.IsAny<IModel<\/span>>())).Returns(0.5f);\ntestModel.Hide();\n}\ncatch <\/span>(HidingException ex)\n{\nexceptionThrown = true<\/span>;\n}\nAssert<\/span>.IsFalse(exceptionThrown);
        Assert<\/span>.IsTrue(testModel.IsHiding);\n}<\/pre>\n
    Code to pass this test:<\/p>\n
    public void <\/span>Hide()\n{\nList<\/span><IModel<\/span>> enemyModels = (from <\/span>models in this<\/span>._gameManager.Models\nwhere <\/span>models.Player != this<\/span>.Player\n&& this<\/span>._objectManager.GetLineOfSight(models, this<\/span>) > 0.6\nselect <\/span>models).ToList();\nif <\/span>(enemyModels.Count > 0)\n{\nHidingException <\/span>ex = new <\/span>HidingException<\/span>();\nex.EnemyModels = enemyModels;\nthrow <\/span>ex;\n}\nelse\n<\/span>{\nthis<\/span>.IsHiding = true<\/span>;\n}\n}<\/pre>\n
    Using some lovely LINQy goodness! The next test:<\/p>\n
    [TestMethod<\/span>]\npublic void <\/span>Hide_ThrowsExceptionIfInSight()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nModel <\/span>enemyModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\nmockGameManager.Setup(item => item.Models).Returns(new <\/span>List<\/span><IModel<\/span>>() { enemyModel });\nModel <\/span>testModel = new <\/span>Model<\/span>(2, mockGameManager.Object, mockObjectManager.Object);\nbool <\/span>exceptionThrown = false<\/span>;\ntry\n<\/span>{\nmockObjectManager.Setup(item => item.GetLineOfSight(It<\/span>.IsAny<IModel<\/span>>(), It<\/span>.IsAny<IModel<\/span>>())).Returns(1);\ntestModel.Hide();\n}\ncatch <\/span>(HidingException <\/span>ex)\n{\nexceptionThrown = true<\/span>;\nAssert<\/span>.AreEqual(enemyModel, ex.EnemyModels[0]);\n}\nAssert<\/span>.IsTrue(exceptionThrown);\n}<\/pre>\n
    Needs no modification. Maybe I went a bit too far with the code writing, since I knew what the test would be in advance? I played with the figures to make sure that the test fails when it should.<\/p>\n
    The following tests should prevent the Hiding flag staying set when running or charging:<\/p>\n
    [TestMethod<\/span>]\npublic void <\/span>Hide_RemoveHidingFlagWhenRunning()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nmockGameManager.Setup(item => item.Models).Returns(new <\/span>List<\/span><IModel<\/span>>());\nModel <\/span>testModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\ntestModel.IsHiding = true<\/span>;\ntestModel.Movement = 4;\ntestModel.MoveModel(6, 0, 0);\nAssert<\/span>.IsFalse(testModel.IsHiding);\n}\n[TestMethod<\/span>]\npublic void <\/span>Hide_RemoveHidingFlagWhenCharging()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nmockGameManager.Setup(item => item.Models).Returns(new <\/span>List<\/span><IModel<\/span>>());\nModel <\/span>testModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\ntestModel.IsHiding = true<\/span>;\ntestModel.Movement = 4;\ntestModel.Charge(6, 0, 0);\nAssert<\/span>.IsFalse(testModel.IsHiding);\n}<\/pre>\n
    The code for both these tests is simple \u2013 change MoveModel and Charge to look like:<\/p>\n
    public void <\/span>MoveModel(float <\/span>positionX, float <\/span>positionY, float <\/span>positionZ)\n{\ntry\n<\/span>{\nValidateMove(ref <\/span>positionX, ref <\/span>positionY, ref <\/span>positionZ);\n}\ncatch <\/span>(Exception <\/span>ex)\n{\nthrow<\/span>;\n}\nfinally\n<\/span>{\nthis<\/span>.TotalDistanceMoved += GetDistanceFrom(positionX, positionY, positionZ);\nthis<\/span>.Location.X = positionX;\nthis<\/span>.Location.Y = positionY;\nthis<\/span>.Location.Z = positionZ;\nif <\/span>(this<\/span>.TotalDistanceMoved > this<\/span>.Movement)\n{\nthis<\/span>.IsHiding = false<\/span>;\nthis<\/span>.IsRunning = true<\/span>;\n}\n}\n}\npublic void <\/span>Charge(float <\/span>positionX, float <\/span>positionY, float <\/span>positionZ)\n{\nIsHiding = false<\/span>;\nIsCharging = true<\/span>;\nMoveModel(positionX, positionY, positionZ);\n}<\/pre>\n
    The next two tests check that a model can\u2019t hide if it charged or ran this turn:<\/p>\n
    [TestMethod<\/span>]\npublic void <\/span>Hide_CannotHideIfRanInSameTurn()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nmockGameManager.Setup(item => item.Models).Returns(new <\/span>List<\/span><IModel<\/span>>());\nModel <\/span>testModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\ntestModel.IsRunning = true<\/span>;\nbool <\/span>correctExceptionThrown = false<\/span>;\ntry\n<\/span>{\ntestModel.Hide();\n}\ncatch <\/span>(HidingException <\/span>ex)\n{\ncorrectExceptionThrown = true<\/span>;\n}\nAssert<\/span>.IsFalse(testModel.IsHiding);\nAssert<\/span>.IsTrue(correctExceptionThrown);\n}\n[TestMethod<\/span>]\npublic void <\/span>Hide_CannotHideIfChargedInSameTurn()\n{\nMock<\/span><IGameManager<\/span>> mockGameManager = new <\/span>Mock<\/span><IGameManager<\/span>>();\nMock<\/span><IObjectManager<\/span>> mockObjectManager = new <\/span>Mock<\/span><IObjectManager<\/span>>();\nmockGameManager.Setup(item => item.Models).Returns(new <\/span>List<\/span><IModel<\/span>>());\nModel <\/span>testModel = new <\/span>Model<\/span>(1, mockGameManager.Object, mockObjectManager.Object);\ntestModel.IsCharging = true<\/span>;\nbool <\/span>correctExceptionThrown = false<\/span>;\ntry\n<\/span>{\ntestModel.Hide();\n}\ncatch <\/span>(HidingException <\/span>ex)\n{\ncorrectExceptionThrown = true<\/span>;\n}\nAssert<\/span>.IsFalse(testModel.IsHiding);\nAssert<\/span>.IsTrue(correctExceptionThrown);\n}<\/pre>\n
    I\u2019m really liking how simple these tests are to pass at the moment. The code to solve both of those tests goes at the top of the Hide method, and is just a quick check:<\/p>\n
    if <\/span>(this<\/span>.IsCharging || this<\/span>.IsRunning)\n{\nHidingException <\/span>ex = new <\/span>HidingException<\/span>(\"Cannot hide if charged or ran this turn.\"<\/span>);\nthrow <\/span>ex;\n}<\/pre>\n
    This is getting a bit too long (I\u2019m thinking that 2000 words, including code, should be a maximum limit on these). I\u2019ll continue more Hiding tests next time!<\/p>\n","protected":false},"excerpt":{"rendered":"
    Having gotten those knotty problems with world management, distances, directions, etc all out of the way I can finally move off of page 10. So what\u2019s next? Page 11! Hooray! It begins with a description of a charge move. A charge works like a run, at double-move rate, with the model (hopefully) ending up in … <\/p>\n
    Continue reading “Learning Unit Testing IX – Moving On With Movement”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[14],"tags":[43,62,63,64],"series":[73],"_links":{"self":[{"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=\/wp\/v2\/posts\/185"}],"collection":[{"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=185"}],"version-history":[{"count":0,"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=\/wp\/v2\/posts\/185\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=185"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=185"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=185"},{"taxonomy":"series","embeddable":true,"href":"https:\/\/www.pagan-gerbil.net\/index.php?rest_route=%2Fwp%2Fv2%2Fseries&post=185"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}