Pseudo Code Generator

Maze Game Pseudo Code Overview

This pseudo code outlines the structure for a maze game using turtle graphics, detailing game initialization, class definitions for player, enemies, and treasures, maze setup, and game loop logic for movements and collisions.

Prompt

import turtle
import math
import random

wn = turtle.Screen()
wn.bgcolor("black")
wn.title("A Maze Game")
wn.setup(700,700)
wn.tracer(0)


#register shapes
images = ["wizzr.gif", "wizzl.gif", "loot.gif", "wall.gif", "enemyl.gif", "enemyr.gif"]
for image in images:
        turtle.register_shape(image)


class Pen(turtle.Turtle):
    def __init__(self):
        turtle.Turtle.__init__(self)
        self.shape("square")
        self.color("white")
        self.penup()
        self.speed(0)

        
class Player(turtle.Turtle):
    def __init__(self):
        turtle.Turtle.__init__(self)
        self.shape("wizzr.gif")
        self.color("blue")
        self.penup()
        self.speed(0)
        self.gold = 0

    def go_up(self):
        move_to_x = player.xcor()
        move_to_y = player.ycor() + 24



        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)

    def go_down(self):
        move_to_x = player.xcor()
        move_to_y = player.ycor() - 24



        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)


    def go_left(self):
        move_to_x = player.xcor() - 24
        move_to_y = player.ycor()

        self.shape("wizzl.gif")



        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)


    def go_right(self):
        move_to_x = player.xcor() + 24
        move_to_y = player.ycor()

        self.shape("wizzr.gif")



        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)

    def is_collision(self, other):
        a = self.xcor()-other.xcor()
        b = self.ycor()-other.ycor()
        distance = math.sqrt((a ** 2) + (b ** 2) )

        if distance < 5:
            return True
        else:
            return False

class Treasure(turtle.Turtle):
    def __init__(self, x, y):
        turtle.Turtle.__init__(self)
        self.shape("loot.gif")
        self.color("pink")
        self.penup()
        self.speed(0)
        self.gold = 100
        self.goto(x, y)

    def destroy(self):
        self.goto(2000, 2000)
        self.hideturtle()

class Enemy(turtle.Turtle):
        def __init__(self, x, y):
                turtle.Turtle.__init__(self)
                self.shape("enemyl.gif")
                self.color("red")
                self.penup()
                self.speed(0)
                self.gold = 25
                self.goto(x, y)
                self.direction = random.choice(["up", "down", "left", "right"])

        def move(self):
                if self.direction == "up":
                        dx = 0
                        dy = 24
                elif self.direction == "down":
                        dx = 0
                        dy = -24
                elif self.direction == "left":
                        dx = -24
                        dy = 0
                        self.shape("enemyl.gif")
                elif self.direction == "right":
                        dx = 24
                        dy = 0
                        self.shape("enemyr.gif")
                else:
                        dx = 0
                        dy = 0


                if self.is_close(player):
                        if player.xcor() < self.xcor():
                                self.direction = "left"
                        elif player.xcor() > self.xcor():
                                self.direction = "right"
                        elif player.ycor() < self.ycor():
                                self.direction = "down"
                        elif player.ycor() > self.ycor():
                                self.direction = "up"


                move_to_x = self.xcor() + dx
                move_to_y = self.ycor() + dy


                if (move_to_x, move_to_y) not in walls:
                        self.goto(move_to_x, move_to_y)
                else:
                        self.direction = random.choice(["up", "down", "left", "right"])

                turtle.ontimer(self.move, t=random.randint(100, 300))

        def is_close(self,other):
                a = self.xcor()-other.xcor()
                b = self.ycor()-other.ycor()
                distance = math.sqrt((a ** 2) + (b ** 2))

                if distance < 75:
                        return True
                else:
                        return False 

        def destroy(self):
                self.goto(2000, 2000)
                self.hideturtle()


        
levels = [""]



level_1 = [
"XXXXXXXXXXXXXXXXXXXXXXXXX",
"XP XXXXXXXE  T      XXXXX",
"X  XXXXXXX  XXXXXX  XXXXX",
"X       XX  XXXXXX  XXXXX",
"X       XX  XXX        XX",
"XXXXXX  XX  XXX        XX",
"XXXXXX  XX  XXXXXX  XXXXX",
"XXXXXX  XX    XXXX  XXXXX",
"XT XXX        XXXX  XXXXX",
"X  XXX  XXXXXXXXXXXXXXXXX",
"X         XXXXXXXXXXXXXXX",
"XE               XXXXXXXX",
"XXXXXXXXXXXX     XXXXX  X",
"XXXXXXXXXXXXXXX  XXXXX  X",
"XXX  XXXXXXXXXX         X",
"XXXE                    X",
"XXX         XXXXXXXXXXXXX",
"XXXXXXXXXX  XXXXXXXXXXXXX",
"XXXXXXXXXX             TX",
"XXE  XXXXX              X",
"XX   XXXXXXXXXXXX  XXXXXX",
"XX    YXXXXXXXXXX  XXXXXX",
"XX         XXXXT        X",
"XXXX                   TX",
"XXXXXXXXXXXXXXXXXXXXXXXXX",
]


treasures = []


enemies = []


levels.append(level_1)



def setup_maze(level):
    for y in range(len(level)):
        for x in range(len(level[y])):
            character = level[y][x]
            screen_x = -288 + (x * 24)
            screen_y = 288 - (y * 24)


            if character == "X":
                pen.goto(screen_x, screen_y)
                pen.shape("wall.gif")
                pen.stamp()
                walls.append((screen_x, screen_y))


            if character == "P":
                    player.goto(screen_x, screen_y)


            if character == "T":
                    treasures.append(Treasure(screen_x, screen_y))


            if character == "E":
                    enemies.append(Enemy(screen_x, screen_y))


                                 

                        
pen = Pen()
player = Player()


walls = []


setup_maze(levels[1])


turtle.listen()
turtle.onkey(player.go_left,"Left")
turtle.onkey(player.go_right,"Right")
turtle.onkey(player.go_up,"Up")
turtle.onkey(player.go_down,"Down")


wn.tracer(0)


for enemy in enemies:
        turtle.ontimer(enemy.move, t=250)


while True:
    for treasure in treasures:
        if player.is_collision(treasure):
            player.gold += treasure.gold
            print ("Player Gold: {}".format(player.gold))
            treasure.destroy()
            treasures.remove(treasure)


            
    for enemy in enemies:
            if player.is_collision(enemy):
                    print("Player dies!")




    wn.update()

Answer

Pseudo Code for Maze Game

Overview

This pseudo code outlines the structure and logic for a maze game utilizing turtle graphics. The key components include initializing the game, defining classes for game entities (player, enemies, treasures), handling movements, collisions, and game logic.

Key Components

Game Initialization
Class Definitions
- Pen
- Player
- Treasure
- Enemy
Maze Setup
Game Loop and Event Handling

Pseudo Code

Game Initialization

Start Game
Create turtle screen with black background and title "A Maze Game"
Set screen size to 700x700
Disable screen tracer for smooth graphics updates
Register game shapes (images for player, enemies, walls, loot)

Class Definitions

Pen Class

Define class Pen inheriting from Turtle
    Constructor:
        Set shape to "square"
        Set color to "white"
        Pen up (do not draw)
        Set speed to 0 (no animation)

Player Class

Define class Player inheriting from Turtle
    Constructor:
        Set shape to "wizzr.gif"
        Set color to "blue"
        Pen up (do not draw)
        Set speed to 0 (no animation)
        Initialize gold to 0
        
    Define method go_up:
        Calculate new position (x, y + 24)
        If new position is not a wall:
            Move player to new position
            
    Define method go_down:
        Calculate new position (x, y - 24)
        If new position is not a wall:
            Move player to new position

    Define method go_left:
        Calculate new position (x - 24, y)
        Set shape to "wizzl.gif"
        If new position is not a wall:
            Move player to new position

    Define method go_right:
        Calculate new position (x + 24, y)
        Set shape to "wizzr.gif"
        If new position is not a wall:
            Move player to new position

    Define method is_collision with other:
        Calculate distance between player and other
        If distance < threshold:
            Return true
        Else:
            Return false

Treasure Class

Define class Treasure inheriting from Turtle
    Constructor(x, y):
        Set shape to "loot.gif"
        Set color to "pink"
        Pen up (do not draw)
        Set speed to 0
        Initialize gold to 100
        Move to position (x, y)

    Define method destroy:
        Move treasure off-screen and hide it

Enemy Class

Define class Enemy inheriting from Turtle
    Constructor(x, y):
        Set shape to "enemyl.gif"
        Set color to "red"
        Pen up (do not draw)
        Set speed to 0
        Initialize gold to 25
        Move to position (x, y)
        Set initial direction randomly from ["up", "down", "left", "right"]

    Define method move:
        Determine movement based on direction (dx, dy)
        If close to player, adjust direction towards player
        Calculate new position (x + dx, y + dy)
        If new position is not a wall, move enemy
        Else, change direction randomly

    Define method is_close with other:
        Calculate distance to other
        If distance < threshold:
            Return true
        Else:
            Return false

    Define method destroy:
        Move enemy off-screen and hide it

Maze Setup

Function setup_maze(level):
    For each row in level:
        For each character in row:
            Determine screen coordinates (x, y)
            If character is "X":
                Create a wall at (screen_x, screen_y)
            If character is "P":
                Position player at (screen_x, screen_y)
            If character is "T":
                Create treasure at (screen_x, screen_y)
            If character is "E":
                Create enemy at (screen_x, screen_y)

Game Loop and Event Handling

Create pen and player instances
Initialize walls, treasures, enemies lists

Call setup_maze(level)

Listen for key presses:
    On left arrow, call player.go_left
    On right arrow, call player.go_right
    On up arrow, call player.go_up
    On down arrow, call player.go_down

Run game loop:
    For each treasure:
        If player's position collides with treasure:
            Add treasure's gold to player's total
            Destroy treasure and remove from list
    For each enemy:
        If player's position collides with enemy:
            Notify player dies
    Update screen

Conclusion

This pseudo code provides a clear structure for implementing the maze game with turtle graphics. Each class represents a component of the game, encapsulating its properties and behaviors, while the main loop manages the game's state and interactions.