codingpirates-maze 0.1.0__py3-none-any.whl

maze/bee.py

@@ -0,0 +1,184 @@
+from enum import Enum
+import random
+from .maze import SquareType, MazeType, Cell, Player, Maze
+from .farmer import FarmerMazeType
+
+
+class BeeMazeType(MazeType):
+
+    def __init__(self):
+        super().__init__()
+        self.cellClass = BeeCell
+        self.playerClass = BeePlayer
+        self.subfolder = "bee"
+
+    def setup(self, level, maze):
+        super().setup(level, maze)
+        screen = maze.screen
+        screen.bgpic(Maze.shapefile("background", ".png"))
+        screen.register_shape(Maze.shapefile("cloud"))
+        screen.register_shape(Maze.shapefile("path"))
+        screen.register_shape(Maze.shapefile("purple_flower"))
+        screen.register_shape(Maze.shapefile("red_flower"))
+        screen.register_shape(Maze.shapefile("honeycomb"))
+
+    def parse_cell_from_old_values(self, map_cell, initial_dirt_cell):
+        map_cell = str(map_cell)
+        initial_dirt_cell = int(initial_dirt_cell)
+        tileType = featureType = value = cloudType = flowerColor = None
+
+        if initial_dirt_cell != 0 and any(substring in map_cell for substring in ['1', 'R', 'P', 'FC']):
+            tileType = SquareType.OPEN
+            featureType = BeeFeatureType.FLOWER if initial_dirt_cell > 0 else BeeFeatureType.HIVE
+            value = abs(initial_dirt_cell)
+            cloudType = CloudType.STATIC if map_cell == 'FC' else CloudType.NONE
+            if map_cell == 'R':
+                flowerColor = FlowerColor.RED
+            elif map_cell == 'P':
+                flowerColor = FlowerColor.PURPLE
+            else:
+                flowerColor = FlowerColor.DEFAULT
+        else:
+            tileType = int(map_cell)
+
+        return dict(tileType=tileType, featureType=featureType, value=value, cloudType=cloudType,
+                    flowerColor=flowerColor)
+
+
+BEE_SHAPE = ((0, -22), (-4, -20), (-7, -13), (7, -13), (-7, -13), (-7.6, -5.6), (7.6, -5.6), (-7.6, -5.6), (-2.6, 7.4),
+             (-13.1, -10.5), (-18, -13), (-23, -11), (-25, -6), (-23, -1), (-2.6, 7.5), (-7, 9), (-6, 15), (-4, 17),
+             (-7, 20), (-11, 22), (-7, 20), (-4, 17), (0, 18), (4, 17), (7, 20), (11, 22), (7, 20), (4, 17), (6, 15),
+             (7, 9), (2.6, 7.5), (23, -1), (25, -6), (23, -11), (18, -13), (13.1, -10.5), (2.6, 7.4), (7.6, -5.6),
+             (7, -13), (4, -20))
+
+
+class BeeFeatureType(Enum):
+    NONE = None
+    HIVE = 0
+    FLOWER = 1
+    VARIABLE = 2
+
+
+class CloudType(Enum):
+    NONE = None
+    STATIC = 0
+    HIVE_OR_FLOWER = 1
+    FLOWER_OR_NOTHING = 2
+    HIVE_OR_NOTHING = 3
+    ANY = 4
+
+
+class FlowerColor(Enum):
+    DEFAULT = None
+    RED = 0
+    PURPLE = 1
+
+
+class BeeCell(Cell):
+
+    def __init__(self, tileType=0, value=0, range=0, featureType=None, flowerColor=None, cloudType=None):
+        super().__init__(tileType=tileType, value=value, range=range)
+        self.featureType = BeeFeatureType(featureType)
+        self.flowerColor = FlowerColor(flowerColor)
+        self.cloudType = CloudType(cloudType)
+
+    def is_variable_range(self):
+        return False
+
+    def draw(self, x, y):
+        if not self.isCloud() and self.featureType in (BeeFeatureType.NONE, BeeFeatureType.VARIABLE):
+            self.value = 0
+        super().draw(x, y)
+
+    def isFlower(self):
+        return self.featureType == BeeFeatureType.FLOWER
+
+    def isHive(self):
+        return self.featureType == BeeFeatureType.HIVE
+
+    def redraw(self):
+        if self.isCloud() or self.featureType not in (BeeFeatureType.NONE, BeeFeatureType.VARIABLE):
+            self.showturtle()
+        else:
+            self.hideturtle()
+
+        if self.cloudType != CloudType.NONE:
+            self.shape(Maze.shapefile("cloud"))
+        elif self.isFlower():
+            if self.flowerColor != FlowerColor.RED:
+                self.shape(Maze.shapefile("purple_flower"))
+            else:
+                self.shape(Maze.shapefile("red_flower"))
+            self.draw_value()
+        elif self.isHive():
+            self.shape(Maze.shapefile("honeycomb"))
+            self.draw_value()
+
+    def isCloud(self):
+        return self.cloudType != CloudType.NONE
+
+    def needs_visit(self):
+        return self.isCloud() or self.isFlower() or self.isHive()
+
+    def reveal(self):
+        possibilities = None
+        if self.isCloud():
+            if self.cloudType == CloudType.HIVE_OR_FLOWER:
+                possibilities = [BeeFeatureType.HIVE, BeeFeatureType.FLOWER]
+            elif self.cloudType == CloudType.FLOWER_OR_NOTHING:
+                possibilities = [BeeFeatureType.FLOWER, BeeFeatureType.FLOWER, BeeFeatureType.NONE]
+            elif self.cloudType == CloudType.HIVE_OR_NOTHING:
+                possibilities = [BeeFeatureType.HIVE, BeeFeatureType.HIVE, BeeFeatureType.NONE]
+            elif self.cloudType == CloudType.ANY:
+                possibilities = [BeeFeatureType.NONE, BeeFeatureType.HIVE, BeeFeatureType.FLOWER]
+
+            if possibilities:
+                self.featureType = random.choice(possibilities)
+
+            if self.featureType == BeeFeatureType.NONE:
+                # When there is no feature type, set the value to 0 so that 
+                # we can detect the win condition properly
+                self.value = 0
+            elif self.value == 0:
+                self.value = 1
+
+            self.cloudType = CloudType.NONE
+            self.redraw()
+
+
+class BeePlayer(Player):
+
+    def __init__(self, maze):
+        super().__init__(maze)
+
+        screen = self._turtle.getscreen()
+
+        screen.register_shape("bee", BEE_SHAPE)
+
+        self._turtle.color("black", "yellow")
+        self._turtle.shape("bee")
+
+    def at_flower(self):
+        return self._get_current_cell().isFlower()
+
+    def at_honeycomb(self):
+        return self._get_current_cell().isHive()
+
+    def nectar(self):
+        return self._get_value_if(lambda cell: cell.isFlower())
+
+    def honey(self):
+        return self._get_value_if(lambda cell: cell.isHive())
+
+    def get_nectar(self):
+        self._process(lambda cell: cell.isFlower())
+
+    def make_honey(self):
+        self._process(lambda cell: cell.isHive())
+
+    at_hive = at_honeycomb
+
+    def _check(self):
+        if self.maze.maze_type.detect_win_scenario(self.maze):
+            self._success()
+        super()._check()

maze/beeshape.py

@@ -0,0 +1,115 @@
+import turtle
+
+# Define the coordinates for the bee shape (a simple polygon)
+bee_shape = (
+    (-4, 0),   
+    (-3, -1),   
+    (-1.9, -1.5),  
+    (-0.8, -1.5), 
+    (1.9, -0.5), # Start of top wing
+    (-1.8, -2.7), 
+    (-2.1, -3.5), 
+    (-1.9, -4.3), 
+    (-1.9, -4.3)
+)
+
+lg_bee_shape = (
+    (-22, 0),   
+    (-20, -4),   
+    (-13, -7),  
+    (-5.6, -7.6), 
+    (7.4, -2.6), # Start of top wing
+    (-10.5, -13.1), 
+    (-13, -18), 
+    (-11, -23), 
+    (-6, -25), 
+    (-1, -23), 
+    (7.5, -2.6), # End of top wing
+    (9, -7), 
+    (15, -6), 
+    (17, -4), # Start of top antenna
+    (20, -7), 
+    (22, -11),  # Tip of top antenna
+    (20, -7), 
+    (17, -4), # End of top antenna
+    (18, 0), 
+    (17, 4), # Start of bottom antenna
+    (20, 7), 
+    (22, 11), # Tip of bottom antenna
+    (20, 7),
+    (17, 4), # End of bottom antenna
+    (15, 6),
+    (9, 7), 
+    (7.5, 2.6), # Start of bottom wing
+    (-1, 23), 
+    (-6, 25), 
+    (-11, 23), 
+    (-13, 18), 
+    (-10.5, 13.1), 
+    (7.4, 2.6), # End of bottom wing
+    (-5.6, 7.6), 
+    (-13, 7),  
+    (-20, 4)
+#    (-22, 0),   
+)
+
+
+lg_bee_shape2 = (
+    (0    , -22   ),   
+    (-4   , -20   ),   
+    (-7   , -13   ),  
+    ( 7   , -13   ),  
+    (-7   , -13   ),  
+    (-7.6 , -5.6  ), 
+    ( 7.6 , -5.6  ), 
+    (-7.6 , -5.6  ), 
+    (-2.6 , 7.4   ), # Start of top wing
+    (-13.1, -10.5 ), 
+    (-18  , -13   ), 
+    (-23  , -11   ), 
+    (-25  , -6    ), 
+    (-23  , -1    ), 
+    (-2.6 , 7.5   ), # End of top wing
+    (-7   , 9     ), 
+    (-6   , 15    ), 
+    (-4   , 17    ), # Start of top antenna
+    (-7   , 20    ), 
+    (-11  , 22    ),  # Tip of top antenna
+    (-7   , 20    ), 
+    (-4   , 17    ), # End of top antenna
+    (0    , 18    ), 
+    (4    , 17    ), # Start of bottom antenna
+    (7    , 20    ), 
+    (11   , 22    ), # Tip of bottom antenna
+    (7    , 20    ),
+    (4    , 17    ), # End of bottom antenna
+    (6    , 15    ),
+    (7    , 9     ), 
+    (2.6  , 7.5   ), # Start of bottom wing
+    (23   , -1    ), 
+    (25   , -6    ), 
+    (23   , -11   ), 
+    (18   , -13   ), 
+    (13.1 , -10.5 ), 
+    (2.6  , 7.4   ), # End of bottom wing
+    (7.6  , -5.6  ), 
+    (7    , -13   ),  
+    (4    , -20   )
+)
+
+
+# Register the bee shape with the name "bee"
+turtle.register_shape("bee", lg_bee_shape2)
+
+# Create a turtle using our custom bee shape
+bee_turtle = turtle.Turtle()
+bee_turtle.shape("bee")
+bee_turtle.fillcolor("yellow")  # Optional: Fill the bee shape with color
+
+# Move the bee forward (you can add more movements here)
+for i in range(50):
+    bee_turtle.forward(5 + 2 * i)
+    bee_turtle.right(45)
+
+# Keep the turtle window open
+turtle.done()

maze/birds.py

@@ -0,0 +1,69 @@
+from enum import Enum
+import random
+from .maze import SquareType, MazeType, Cell, Player, Maze
+
+
+BIRD_SHAPE = ((0,-12),(-1,-12),(-2,-10),(-3,-3),(-4,-1),(-10,3),(-20,3),(-24,4),(-11,9),(-8,9),(-3,7),(0,10),(0,10),
+              (3,7),(8,9),(11,9),(24,4),(20,3),(10,3),(4,-1),(3,-3),(2,-10),(1,-12),(0,-12))
+
+
+class BirdsMazeType(MazeType):
+  
+    def __init__(self):
+        super().__init__()
+        self.cellClass = BirdsCell
+        self.playerClass = Bird
+        self.subfolder = "birds"
+
+    def setup(self, level, maze):
+        super().setup(level, maze)
+        screen = maze.screen
+
+        screen.bgpic(Maze.shapefile("background", ".png"))
+        screen.register_shape(Maze.shapefile("path"))
+        screen.register_shape(Maze.shapefile("tnt"))
+        screen.register_shape(Maze.shapefile("monster"))
+
+        screen.register_shape(Maze.shapefile("wall_1"))
+        screen.register_shape(Maze.shapefile("wall_2"))
+        screen.register_shape(Maze.shapefile("wall_3"))
+        screen.register_shape(Maze.shapefile("wall_4"))
+        screen.register_shape(Maze.shapefile("wall_5"))
+
+        self.path()._stamp = False
+
+
+class BirdsCell(Cell):
+
+    def __init__(self,tileType=0, value=0, range=0):
+        super().__init__(tileType=tileType, value=value, range=range)
+
+    def redraw(self):
+        if self.is_obstacle():
+            self.shape(Maze.shapefile("tnt"))
+        elif self.is_finish():
+            self.shape(Maze.shapefile("monster"))
+        elif self.is_wall():
+            tile = random.randint(1, 5)
+            self.shape(Maze.shapefile(f"wall_{tile}"))
+
+        if self.tileType in [SquareType.OPEN, SquareType.START]:
+            self.hideturtle()
+        else:
+            self.showturtle()
+
+    def needs_visit(self):
+        return self.is_finish()
+
+
+class Bird(Player):
+
+    def __init__(self, maze):
+        super().__init__(maze)
+
+        screen = self._turtle.getscreen()
+
+        screen.register_shape("bird", BIRD_SHAPE)
+
+        self._turtle.color("black","red")
+        self._turtle.shape("bird")

maze/collector.py

@@ -0,0 +1,106 @@
+import turtle
+from enum import Enum
+import random
+from .maze import SquareType, MazeType, Cell, Player, Maze
+
+
+COLLECTOR_SHAPE = (
+    (0, -15), (-5, -13), (-9, -8), (-9, 0), (-7, 5), (-9, 0), (-9, -8), (-5, -13), (-15, -12), (-19, -9), (-19, 0),
+    (-16, 9), (-7, 5), (-16, 9), (-15, 13), (-9, 13), (-7, 11), (-7, 5), (0, 8), (7, 5), (7, 11), (9, 13), (15, 13),
+    (16, 9), (7, 5), (16, 9), (19, 0), (19, -9), (15, -12), (5, -13), (9, -8), (9, 0), (7, 5), (9, 0), (9, -8),
+    (5, -13), (0, -15))
+
+class CollectorMazeType(MazeType):
+  
+    def __init__(self):
+        super().__init__()
+        self.cellClass = CollectorCell
+        self.pathClass = CollectorPath
+        self.playerClass = Collector
+        self.subfolder = "collector"
+        self.min_collected = -1
+
+    def setup(self, level, maze: Maze):
+        super().setup(level, maze)
+        screen = maze.screen
+
+        screen.bgcolor("dark grey")
+        screen.register_shape(Maze.shapefile("crystal"))
+
+        screen.register_shape(Maze.shapefile("wall_1"))
+        screen.register_shape(Maze.shapefile("wall_2"))
+
+        screen.register_shape(Maze.shapefile("floor_1"))
+        screen.register_shape(Maze.shapefile("floor_2"))
+        screen.register_shape(Maze.shapefile("floor_3"))
+        screen.register_shape(Maze.shapefile("floor_4"))
+
+        level_props = level['properties']
+        min_col = level_props.get("min_collected")
+        if min_col:
+            self.min_collected = int(min_col)
+
+    def detect_win_scenario(self, maze):
+        return maze.player._gems_collected >= self.min_collected
+
+
+
+class CollectorPath(turtle.Turtle):
+    def __init__(self):
+        turtle.Turtle.__init__(self)
+        self.setheading(90)
+        self.penup()
+        self.speed(0)
+
+    def draw(self, x, y):
+        self.x = x
+        self.y = y
+        self.goto(x, y)
+        tile = random.randint(1, 4)
+        self.shape(Maze.shapefile(f"floor_{tile}"))
+        self.stamp()
+
+class CollectorCell(Cell):
+
+    def __init__(self,tileType=0, value=0, range=0, featureType=None):
+        super().__init__(tileType=tileType, value=value, range=range)
+        # Some levels have featureType in the serialized_maze field, even though Collector does not use it for anything
+
+    def redraw(self):
+        if self.is_wall():
+            tile = random.randint(1, 2)
+            self.showturtle()
+            self.shape(Maze.shapefile(f"wall_{tile}"))
+
+        if self.value != 0:
+            self.shape(Maze.shapefile("crystal"))
+            self.showturtle()
+            self.draw_value()
+        elif not self.is_wall():
+            self.hideturtle()
+
+        if self.originalValue != 0 and self.value == 0:
+            # Clear any value that might have been previously written
+            self.clear()
+
+    def needs_visit(self):
+        return self.originalValue > 0
+
+
+class Collector(Player):
+
+    def __init__(self, maze):
+        super().__init__(maze)
+
+        screen = self._turtle.getscreen()
+
+        screen.register_shape("collector", COLLECTOR_SHAPE)
+
+        self._turtle.color("black", "navajo white")
+        self._turtle.shape("collector")
+
+        self._gems_collected = 0
+
+    def collect(self):
+        self._process(lambda cell: cell.value > 0)
+        self._gems_collected += 1

maze/farmer.py

@@ -0,0 +1,95 @@
+from enum import Enum
+import random
+from .maze import SquareType, MazeType, Cell, Player, Maze
+
+FARMER_SHAPE = (
+    (0, -15), (-5, -13), (-9, -8), (-9, 0), (-7, 5), (-9, 0), (-9, -8), (-5, -13), (-15, -12), (-19, -9), (-19, 0),
+    (-16, 9), (-7, 5), (-16, 9), (-15, 13), (-9, 13), (-7, 11), (-7, 5), (0, 8), (7, 5), (7, 11), (9, 13), (15, 13),
+    (16, 9), (7, 5), (16, 9), (19, 0), (19, -9), (15, -12), (5, -13), (9, -8), (9, 0), (7, 5), (9, 0), (9, -8),
+    (5, -13), (0, -15))
+
+
+class FarmerMazeType(MazeType):
+
+    def __init__(self):
+        super().__init__()
+        self.cellClass = FarmerCell
+        self.playerClass = Farmer
+        self.subfolder = "farmer"
+
+    def setup(self, level, maze):
+        super().setup(level, maze)
+        screen = maze.screen
+        screen.bgpic(Maze.shapefile("background", ".png"))
+        screen.register_shape(Maze.shapefile("path"))
+        screen.register_shape(Maze.shapefile("hole"))
+        screen.register_shape(Maze.shapefile("pile"))
+
+    def success(self, maze, player):
+        self.path().clear()
+        super().success(maze, player)
+
+
+class FarmerCell(Cell):
+
+    def __init__(self, tileType=0, value=0, range=0, featureType=0, possibleFeatures: list = None, startsHidden=False):
+        super().__init__(tileType=tileType, value=value, range=range)
+
+    def redraw(self):
+        if self.value != 0:
+            if self.is_hole():
+                self.shape(Maze.shapefile("hole"))
+            else:
+                self.shape(Maze.shapefile("pile"))
+            self.showturtle()
+        else:
+            self.hideturtle()
+
+        if self.value != 0:
+            self.draw_value()
+
+        if self.originalValue != 0 and self.value == 0:
+            # Clear any value that might have been previously written
+            self.clear()
+
+    def is_hole(self):
+        return self.value < 0
+
+    def is_pile(self):
+        return self.value > 0
+
+    def needs_visit(self):
+        return self.originalValue != 0
+
+
+class Farmer(Player):
+
+    def __init__(self, maze):
+        super().__init__(maze)
+
+        screen = self._turtle.getscreen()
+
+        screen.register_shape("farmer", FARMER_SHAPE)
+
+        self._turtle.color("black", "steel blue")
+        self._turtle.shape("farmer")
+
+    def remove(self):
+        """
+        Removes dirt from a pile
+        :return:
+        """
+        self._process(lambda cell: cell.is_pile())
+
+    def fill(self):
+        """
+        Fills the hole with dirt
+        :return:
+        """
+        self._process(lambda cell: cell.is_hole(), -1)
+
+    def at_pile(self):
+        return self._get_current_cell().is_pile()
+
+    def at_hole(self):
+        return self._get_current_cell().is_hole()

maze/harvester.py

@@ -0,0 +1,141 @@
+from enum import Enum
+import random
+from .maze import SquareType, MazeType, Cell, Player, Maze
+from .farmer import Farmer
+
+
+class HarvesterFeatureType(Enum):
+    NONE = 0
+    CORN = 1
+    PUMPKIN = 2
+    LETTUCE = 3
+
+
+class HarvesterMazeType(MazeType):
+
+    def __init__(self):
+        super().__init__()
+        self.cellClass = HarvesterCell
+        self.playerClass = Harvester
+        self.subfolder = "farmer"
+
+    def setup(self, level, maze):
+        super().setup(level, maze)
+        screen = maze.screen
+        screen.bgpic(Maze.shapefile("background", ".png"))
+        screen.register_shape(Maze.shapefile("path"))
+        screen.register_shape(Maze.shapefile("sprout"))
+        screen.register_shape(Maze.shapefile("lettuce"))
+        screen.register_shape(Maze.shapefile("corn"))
+        screen.register_shape(Maze.shapefile("pumpkin"))
+
+    def success(self, maze, player):
+        self.path().clear()
+        super().success(maze, player)
+
+
+class HarvesterCell(Cell):
+
+    def __init__(self, tileType=0, value=0, range=0, featureType=0, possibleFeatures: list = None, startsHidden=False):
+        super().__init__(tileType=tileType, value=value, range=range)
+
+        self.feature_type = HarvesterFeatureType(featureType)
+
+        if type(possibleFeatures) is list:
+            self.possible_features = list(map(lambda feature: HarvesterFeatureType(feature), possibleFeatures))
+        else:
+            self.possible_features = [HarvesterFeatureType.NONE]
+
+        self.feature_type = random.choice(self.possible_features)
+        if self.feature_type == HarvesterFeatureType.NONE:
+            self.value = 0
+
+        if len(self.possible_features) > 1:
+            startsHidden = True
+
+        self.starts_hidden = startsHidden
+
+    def redraw(self):
+        if self.starts_hidden:
+            self.shape(Maze.shapefile("sprout"))
+            self.showturtle()
+        elif self.is_crop() and self.value > 0:
+            self.shape(Maze.shapefile(self.feature_type.name.lower()))
+            self.showturtle()
+        else:
+            self.hideturtle()
+
+        if self.value != 0 and not self.starts_hidden:
+            self.draw_value()
+
+        if self.originalValue != 0 and self.value == 0:
+            # Clear any value that might have been previously written
+            self.clear()
+
+    def reveal(self):
+        if self.starts_hidden:
+            self.starts_hidden = False
+            self.redraw()
+
+    def is_corn(self):
+        return self.feature_type == HarvesterFeatureType.CORN
+
+    def is_lettuce(self):
+        return self.feature_type == HarvesterFeatureType.LETTUCE
+
+    def is_pumpkin(self):
+        return self.feature_type == HarvesterFeatureType.PUMPKIN
+
+    def is_crop(self):
+        return self.feature_type is not HarvesterFeatureType.NONE
+
+    def needs_visit(self):
+        return self.originalValue != 0
+
+
+class Harvester(Farmer):
+
+    def __init__(self, maze):
+        super().__init__(maze)
+
+    def pick_pumpkin(self):
+        """
+        Pick a pumpkin ripe for the taking
+        :return:
+        """
+        self._process(lambda cell: cell.is_pumpkin())
+
+    def pick_corn(self):
+        """
+        Pick the corn
+        :return:
+        """
+        self._process(lambda cell: cell.is_corn())
+
+    def pick_lettuce(self):
+        """
+        Pick the corn
+        :return:
+        """
+        self._process(lambda cell: cell.is_lettuce())
+
+    def at_corn(self):
+        return self._get_current_cell().is_corn()
+
+    def at_pumpkin(self):
+        return self._get_current_cell().is_pumpkin()
+
+    def at_lettuce(self):
+        return self._get_current_cell().is_lettuce()
+
+    def has_corn(self):
+        cell: FarmerCell = self._get_current_cell()
+        return cell.is_corn() and cell.value > 0
+
+    def has_pumpkin(self):
+        cell: FarmerCell = self._get_current_cell()
+        return cell.is_pumpkin() and cell.value > 0
+
+    def has_lettuce(self):
+        cell: FarmerCell = self._get_current_cell()
+        return cell.is_lettuce() and cell.value > 0