Example #1
0
    def test_is_facing(self):
        self.begin_for_testing()

        self.assertEqual(block.PISTON.FACING_SOUTH, is_facing())
        right(90)
        self.assertEqual(block.PISTON.FACING_WEST, is_facing())
        right(90)
        self.assertEqual(block.PISTON.FACING_NORTH, is_facing())
        right(90)
        self.assertEqual(block.PISTON.FACING_EAST, is_facing())
        right(90)
        self.assertEqual(block.PISTON.FACING_SOUTH, is_facing())
        right(180)
        self.assertEqual(block.PISTON.FACING_NORTH, is_facing())
        left(90)
        self.assertEqual(block.PISTON.FACING_WEST, is_facing())
Example #2
0
 def test_some_more_turning(self):
     self.begin_for_testing()
     forward(2)
     right(90)
     forward(2)
     down(90)
     forward(2)
     self.assertEqual(
         {
             (100, 200, 300): "gold_block",
             (100, 200, 301): "gold_block",
             (100, 200, 302): "gold_block",
             (99, 200, 302): "gold_block",
             (98, 200, 302): "gold_block",
             (98, 199, 302): "gold_block",
             (98, 198, 302): ("piston", {
                 "facing": "down"
             })
         }, self.game.tiles)
Example #3
0
    def test_turn_methods_take_valid_degrees(self):
        self.begin_for_testing()

        with self.assertRaisesRegexp(
                AssertionError,
                "Oops, right\(abc\) won't work. Degrees must be a number."):
            right('abc')

        with self.assertRaisesRegexp(
                AssertionError,
                "Oops, left\(abc\) won't work. Degrees must be a number."):
            left('abc')

        with self.assertRaisesRegexp(
                AssertionError,
                "Oops, up\(abc\) won't work. Degrees must be a number."):
            up('abc')

        with self.assertRaisesRegexp(
                AssertionError,
                "Oops, down\(abc\) won't work. Degrees must be a number."):
            down('abc')
Example #4
0
    def test_show_that_turtle_wont_turn_right_when_going_down_or_up(self):
        self.begin_for_testing()
        forward(2)
        down(90)
        forward(2)
        right(90)
        forward(2)
        self.assertEqual(
            {
                (100, 200, 300): "gold_block",
                (100, 200, 301): "gold_block",
                (100, 200, 302): "gold_block",
                (100, 199, 302): "gold_block",

                # turtle should have gone right but it didn't.
                (100, 198, 302): "gold_block",
                (100, 197, 302): "gold_block",
                (100, 196, 302): ("piston", {
                    "facing": "down"
                })
            },
            self.game.tiles)
Example #5
0
    def test_right_over_360(self):
        self.begin_for_testing()
        forward(1)
        right(3690)

        self.assertEqual(
            {
                (100, 200, 300): "gold_block",
                (100, 200, 301): ("piston", {
                    "facing": "west"
                })
            }, self.game.tiles)

        forward(2)

        self.assertEqual(
            {
                (100, 200, 300): "gold_block",
                (100, 200, 301): "gold_block",
                (99, 200, 301): "gold_block",
                (98, 200, 301): ("piston", {
                    "facing": "west"
                })
            }, self.game.tiles)
Example #6
0
    def test_turns_and_piston_facing(self):
        self.begin_for_testing()
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "south"
                          })}, self.game.tiles)
        right(30)
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "south"
                          })}, self.game.tiles)
        right(30)  # yaw 60
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "west"
                          })}, self.game.tiles)
        right(30)  # yaw 90 - due west
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "west"
                          })}, self.game.tiles)
        right(30)  # yaw 120
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "west"
                          })}, self.game.tiles)
        right(30)  # yaw 150
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "north"
                          })}, self.game.tiles)
        right(30)  # yaw 180 - due north
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "north"
                          })}, self.game.tiles)
        right(30)  # yaw 210
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "north"
                          })}, self.game.tiles)
        right(30)  # yaw 240
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "east"
                          })}, self.game.tiles)
        right(30)  # yaw 270 - due east
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "east"
                          })}, self.game.tiles)
        right(30)  # yaw 300
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "east"
                          })}, self.game.tiles)
        right(30)  # yaw 330
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "south"
                          })}, self.game.tiles)
        right(30)  # yaw 360
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "south"
                          })}, self.game.tiles)

        up(30)  # pitch 60
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "south"
                          })}, self.game.tiles)
        up(30)  # pitch 30
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "up"
                          })}, self.game.tiles)
        up(30)  # pitch 0 - straight up
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "up"
                          })}, self.game.tiles)
        up(30)  # pitch 330
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "up"
                          })}, self.game.tiles)
        up(30)  # pitch 300
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "north"
                          })}, self.game.tiles)
        up(30)  # pitch 270
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "north"
                          })}, self.game.tiles)
        up(30)  # pitch 240
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "north"
                          })}, self.game.tiles)
        up(30)  # pitch 210
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "down"
                          })}, self.game.tiles)
        up(30)  # pitch 180 - straight down
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "down"
                          })}, self.game.tiles)
        up(30)  # pitch 150
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "down"
                          })}, self.game.tiles)
        up(30)  # pitch 120
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "south"
                          })}, self.game.tiles)
        up(30)  # pitch 90
        self.assertEqual({(100, 200, 300): ("piston", {
                              "facing": "south"
                          })}, self.game.tiles)