Turtle Runaway Game

Introduction of game

Concept of game : There are runner, chaser ,food in square stadium. runner must get food escaping chaser!
Score condition

If runner meets food +1 point

If runner meets chaser -1 point

If runner go out of stadium -3point

Game condition
1. There's time left to stadium which counts the time
2. 'In game' coverts to 'Game Over' when time is over 100
Screenshot of game

Source Code

# This example is not working in Spyder directly (F5 or Run)
# Please type '!python turtle_runaway.py' on IPython console in your Spyder.

import turtle, random , time


class RunawayGame:
    def __init__(self, canvas, chaser, runner, catch_radius=10, init_dist=400):
        self.canvas = canvas
        self.runner = runner
        self.chaser = chaser
        self.catch_radius2 = catch_radius**2

        # Initialize 'runner' and 'chaser'

        self.chaser.shape('turtle')
        self.chaser.color('blue')
        self.chaser.penup()
        self.chaser.setx(-init_dist / 2)

        self.runner.shape('turtle')
        self.runner.color('red')
        self.runner.penup()
        self.runner.setx(+init_dist / 2)
        self.runner.setheading(180)
        


        # Instantiate an another turtle for drawing (time,score, game_status)
        self.drawer1 = turtle.RawTurtle(canvas)
        self.drawer1.hideturtle()
        self.drawer1.penup() 
        
        self.drawer2 = turtle.RawTurtle(canvas)
        self.drawer2.hideturtle()
        self.drawer2.penup() 
        
        self.drawer3 = turtle.RawTurtle(canvas)
        self.drawer3.hideturtle()
        self.drawer3.penup() 
        
        # create turtle's food
        self.food = turtle.RawTurtle(canvas)
        self.food.shape('circle')
        self.food.color('yellow')
        self.food.penup()
        self.food.sety(-init_dist/2)
        
        
        # creat game stadium
        self.drawer2 = turtle.RawTurtle(canvas)    
        self.drawer2.hideturtle()
        self.drawer2.speed(0)
        self.drawer2.penup()
        self.drawer2.setpos(300,-300)
        self.drawer2.pendown()
        self.drawer2.setheading(90)
        for i in range(4):
            self.drawer2.forward(600)
            self.drawer2.left(90)

    def is_catch(self):
        p = self.food.pos()
        q = self.runner.pos()
        dx, dy = p[0] - q[0], p[1] - q[1]
        return dx**2 + dy**2 < self.catch_radius2
    
    def is_catch_chaser(self):
        p = self.chaser.pos()
        q = self.runner.pos()
        dx, dy = p[0] - q[0], p[1] - q[1]
        return dx**2 + dy**2 < self.catch_radius2
  
    def start(self, ai_timer_msec=100, score=0):
        self.ai_timer_msec = ai_timer_msec
        self.score=score
        self.start_time=time.time()
        self.canvas.ontimer(self.step, self.ai_timer_msec) 
        
    def step(self):
        self.chaser.run_ai(self.runner) 
        self.runner.run_ai(self.chaser)
        
        # penalty if go out stadium
        if (self.runner.xcor()<-300 or self.runner.xcor()>300):
            self.score=self.score-3
        if (self.runner.ycor()<-300 or self.runner.ycor()>300):
            self.score=self.score-3
            
        # penalty if runner meet chaser
        if self.is_catch_chaser()==True:
            self.score=self.score-1
            
        # New food created and reward when runner meets food 
        if self.is_catch()==False:
            pass
        else:
            new_x=random.randint(-300,300)
            new_y=random.randint(-300,300)
            self.food.goto(new_x,new_y)
            
            self.score=self.score+1
            
        
        elapse=time.time()-self.start_time
        
        #draw elapsed time
        self.drawer1.undo()
        self.drawer1.penup()
        self.drawer1.setpos(-430, 200)
        self.drawer1.write(f'Time {elapse:.0f}', font={'Arial',12})  
        
        #draw score
        self.drawer2.undo()
        self.drawer2.penup()
        self.drawer2.setpos(-430,150)
        self.drawer2.write(f'Score {self.score}',font={'굴림',12})
        
        #draw game_status
        self.drawer3.undo()
        self.drawer3.penup()
        self.drawer3.setpos(-430,100)
        self.drawer3.write('In game',font={'굴림',12})
        
        # Game Over when time is over 100
        if elapse>100:
            self.drawer3.undo()
            self.drawer3.write("Game Over",font={'굴림',12})
            return
        
        self.canvas.ontimer(self.step, self.ai_timer_msec) 
    

class ManualMover(turtle.RawTurtle):
    def __init__(self, canvas, step_move=10, step_turn=10):
        super().__init__(canvas)
        self.step_move = step_move
        self.step_turn = step_turn

        # Register event handlers
        canvas.onkeypress(lambda: self.forward(self.step_move), 'Up')
        canvas.onkeypress(lambda: self.backward(self.step_move), 'Down')
        canvas.onkeypress(lambda: self.left(self.step_turn), 'Left')
        canvas.onkeypress(lambda: self.right(self.step_turn), 'Right')
        canvas.listen()

    def run_ai(self, opponent):
        pass
    

class OpponentMover(turtle.RawTurtle):
    def __init__(self, canvas, step_move=30):
        super().__init__(canvas)
        self.step_move = step_move

    def run_ai(self, opponent):
        prob = random.random()
        opp_pos=opponent.pos()
        ang=self.towards(opp_pos)
        if prob <= 0.2:
            self.setheading(ang)
            self.forward(self.step_move)
    
      
if __name__ == '__main__':
  
    canvas = turtle.Screen()
    canvas.title("Turtle Runaway")

    chaser = OpponentMover(canvas)
    runner = ManualMover(canvas)

    game = RunawayGame(canvas, chaser, runner)
    game.start()
    
    canvas.mainloop()