def main():
screen = Screen()
screen.setup(width=600, height=600)
screen.tracer(0)
player = Player()
car_manager = CarManager()
scoreboard = Scoreboard()
screen.listen()
screen.onkeypress(player.move_up, 'Up')
game_is_on = True
while game_is_on:
time.sleep(0.1)
screen.update()
car_manager.create_car()
car_manager.move_cars()
# Detect collision with car
for car in car_manager.all_cars:
if player.distance(car) < 20:
game_is_on = False
scoreboard.game_over()
# Check if the player has reached finish line
if player.is_at_finish_line():
player.go_to_start()
car_manager.increase_speed()
scoreboard.increase_level()
screen.exitonclick()
class Game():
def __init__(self):
self.gameRunns = True
self.gamePaused = True
self.screen = Screen()
self.screen.setup(width=600, height=600)
self.screen.bgcolor("black")
self.screen.tracer(0)
self.screen.title("...SnAkE....")
self.screen.onkeypress(self.pauseMode, "space")
self.screen.onkeypress(self.exitGame, "Escape")
def pauseMode(self):
self.gamePaused = not self.gamePaused
def exitGame(self):
print("closing")
self.gameRunns = False
def play(self):
snake = Snake(3)
snake.registerKeyListener(self.screen)
while self.gameRunns:
start = time.time()
if not self.gamePaused:
snake.move()
self.screen.update()
time.sleep(max(1.0 / snake.speed - (time.time() - start), 0))
class GameMaster:
def __init__(self):
self.screen = Screen()
self.screen.setup(width=600, height=600)
self.set_up_screen()
self.scoreboard = Scoreboard()
self.cars = CarManager()
self.player = Player()
self.set_up_control(self.player)
self.game_loop(self.player, self.cars, self.scoreboard)
def set_up_screen(self):
self.screen.clear()
self.screen.tracer(0)
self.screen.bgcolor("black")
self.screen.listen()
def set_up_control(self, player):
self.screen.onkeypress(player.move_up, "Up")
self.screen.onkey(self.new_game, "n")
def new_game(self):
self.__init__()
self.set_up_screen()
self.set_up_control(self.player)
self.game_loop(self.player, self.cars, self.scoreboard)
def game_loop(self, player, cars, scoreboard):
game_is_on = True
while game_is_on:
time.sleep(0.1)
self.screen.update()
cars.move_cars()
# Detect finish line
if player.detect_finish_line():
print("Finish achieved")
scoreboard.level_up()
cars.increase_speed()
cars.increase_probability_threshold()
# Detect collision with car
for car in cars.cars:
if abs(player.ycor() -
car.ycor()) < 20 and player.distance(car) < 36:
print(f"Collision with distance {player.distance(car)}")
print(
f"Car x: {car.xcor()}, Player x: {int(player.xcor())}, Car y: {car.ycor()}, "
f"Player y: {player.ycor()}, ")
scoreboard.game_over()
game_is_on = False
cars.generate_new_car()
def main():
t = Turtle()
s = Screen()
s.colormode(255)
s.bgcolor((76, 237, 87))
t.color((122, 59, 71))
s.listen()
s.onkey(lambda: left(t), 'Left')
s.onkey(lambda: right(t), 'Right')
s.onkeypress(lambda: up(t), 'Up')
s.mainloop()
class PongGame:
def __init__(self):
self.running = True
self.screen = Screen()
self.screen.setup(width=900, height=900)
self.boundaries = {
"ceiling": self.screen.window_height() // 2 - 60,
"right_wall": self.screen.window_width() // 2 - 30,
"floor": self.screen.window_height() // -2 + 60,
"left_wall": self.screen.window_width() // -2 + 30
}
self.player1 = Paddle("left", self.boundaries)
self.player2 = Paddle("right", self.boundaries)
self.ball = Ball(self.boundaries, (self.player1, self.player2))
self.scoreboard = Scoreboard()
self.screen.onkeypress(self.player1.move_up, "w")
self.screen.onkeypress(self.player1.move_down, "s")
self.screen.onkeypress(self.player2.move_up, "Up")
self.screen.onkeypress(self.player2.move_down, "Down")
self.screen.onkeyrelease(self.player1.stop, "w")
self.screen.onkeyrelease(self.player1.stop, "s")
self.screen.onkeyrelease(self.player2.stop, "Up")
self.screen.onkeyrelease(self.player2.stop, "Down")
self.screen.listen()
def run(self):
self.ball.tick()
self.player1.tick()
self.player2.tick()
if self.ball.xcor()-1 <= self.boundaries["left_wall"]:
self.scoreboard.player2()
self.ball.start_over()
elif self.ball.xcor()+1 >= self.boundaries["right_wall"]:
self.scoreboard.player1()
self.ball.start_over()
elif (self.ball.ycor() >= self.boundaries["ceiling"] or
self.ball.ycor() <= self.boundaries["floor"]):
self.ball.y_direction *= -1
elif self.ball.xcor() < 0:
player_x, player_y = self.player1.position()
if self.ball.xcor() <= player_x and self.ball.ycor() <= player_y + 69 and self.ball.ycor() >= player_y - 69:
self.ball.x_direction *= -1
else:
player_x, player_y = self.player2.position()
if self.ball.xcor() >= player_x and self.ball.ycor() <= player_y + 69 and self.ball.ycor() >= player_y - 69:
self.ball.x_direction *= -1
if self.scoreboard.player1score >= 3 or self.scoreboard.player2score >= 3:
self.scoreboard.game_over()
self.running = False
if self.running:
self.screen.ontimer(self.run, 1)
def pong():
screen = Screen()
screen.setup(width=900, height=1000)
screen.bgcolor("black")
screen.title("Pong: The Famous Arcade Game")
screen.tracer(0)
print_logo()
l_paddle = Paddle((-380, -100))
r_paddle = Paddle((380, -100))
ball = Ball()
scoreboard = ScoreBoard()
game_graphics()
def restart():
screen.clear()
pong()
screen.listen()
screen.onkeypress(r_paddle.go_up, "Up")
screen.onkeypress(r_paddle.go_down, "Down")
screen.onkeypress(l_paddle.go_up, "w")
screen.onkeypress(l_paddle.go_down, "s")
screen.onkey(restart, "r")
game_off = False
while not game_off:
time.sleep(ball.move_speed)
screen.update()
ball.move()
if ball.ycor() > 180 or ball.ycor() < -380:
ball.bounce_y()
if (ball.distance(r_paddle) < 50 and ball.xcor() > 355) or (ball.distance(l_paddle) < 50 and ball.xcor() < -355):
ball.bounce_x()
if ball.xcor() > 395:
ball.refresh()
l_paddle.refresh()
r_paddle.refresh()
scoreboard.l_point()
if ball.xcor() < -395:
ball.refresh()
l_paddle.refresh()
r_paddle.refresh()
scoreboard.r_point()
game_off = scoreboard.game_over()
screen.exitonclick()
def setup_screen(screen: turtle.Screen) -> None:
screen.setup(SCREEN_WIDTH, SCREEN_HEIGHT)
screen.colormode(255)
screen.title("Blitz crossing")
screen.onkeypress(lambda: player.sety(player.ycor() + 10), "Up")
screen.onkeypress(lambda: player.sety(player.ycor() - 10), "Down")
screen.onkeypress(lambda: player.setx(player.xcor() + 10), "Right")
screen.onkeypress(lambda: player.setx(player.xcor() - 10), "Left")
screen.tracer(0)
screen.listen()
def init_game():
global screen, score, ball, wall, paddle
screen = Screen()
screen.bgcolor("black")
screen.setup(width=800, height=600)
screen.title("Breakout")
screen.tracer(0)
wall = BlockBuilder()
wall.create_wall(SCREEN_SIZE)
paddle = Paddle(STARTING_POSITION,SCREEN_SIZE)
ball = Ball(SCREEN_SIZE)
score = Scoreboard()
screen.listen()
screen.update()
screen.onkeypress(paddle.go_left, "Left")
screen.onkeypress(paddle.go_right, "Right")
def main():
print(
'For controlling the paddle, the right player uses "Up" and "Down" arrow keys while the left player uses '
'"w" and "s" keys')
screen = Screen()
screen.setup(width=800, height=600)
screen.bgcolor('black')
screen.title('Pong Game')
screen.tracer(0)
r_paddle = Paddle((350, 0))
l_paddle = Paddle((-350, 0))
ball = Ball()
scoreboard = Scoreboard()
screen.listen()
screen.onkeypress(r_paddle.up, 'Up')
screen.onkeypress(r_paddle.down, 'Down')
screen.onkeypress(l_paddle.up, 'w')
screen.onkeypress(l_paddle.down, 's')
is_game_on = True
while is_game_on:
screen.update()
sleep(ball.ball_speed)
ball.move()
# Detect collision with wall
if ball.ycor() > 280 or ball.ycor() < -280:
ball.bounce_y()
# Detect collision with paddles
if (ball.distance(r_paddle) < 50
and ball.xcor() > 320) or (ball.distance(l_paddle) < 50
and ball.xcor() < -320):
ball.bounce_x()
# Detect Right paddle miss
if ball.xcor() > 380:
ball.reset_position()
scoreboard.l_point()
# Detect Left paddle miss
if ball.xcor() < -380:
ball.reset_position()
scoreboard.r_point()
screen.exitonclick()
class Game():
def __init__(self) -> None:
self.running = True
self.screen = Screen()
self.screen.setup(width=SCREEN_WIDTH, height=SCREEN_HIGHT)
self.screen.bgcolor("black")
self.screen.tracer(0)
self.screen.title("PONG")
self.screen.listen()
self.screen.onkeypress(self.exitGame, "Escape")
def exitGame(self):
print("closing")
self.running = False
def run(self):
scoreboard = Scoreboard()
pad_l = Paddle(POS_LEFT)
pad_l.register_listener(self.screen)
pad_r = Paddle(POS_RIGHT)
pad_r.register_listener(self.screen)
ball = Ball()
while self.running:
start = time.time()
ball.move()
ball.collision(pad_l, pad_r, scoreboard)
scoreboard.update_score()
self.screen.update()
time.sleep(max(1.0 / 10 - (time.time() - start), 0))
def getScreen(ariaPic, llamaPic):
win = Screen()
win.title("Pong - Aria VS Llama")
win.bgcolor("black")
win.setup(width=800, height=600)
win.tracer(0)
win.register_shape(ariaPic)
win.register_shape(llamaPic)
# bind keys with player moves
win.listen()
win.onkeypress(aria_up,'w')
win.onkeypress(aria_down, 'x')
win.onkeypress(llama_up,'9')
win.onkeypress(llama_down, '3')
return win
class Game():
"""Make the game loop into a class.
Responsible for drawing and updating all our objects"""
def __init__(self):
# Set up the screen
self.screen = Screen()
self.screen.bgcolor("green")
self.screen.setup(width=800, height=600)
self.screen.title("Pong Game")
# accelerate time program
self.screen.tracer(0)
self.screen.colormode(255)
# initial objects
self.paddle_left = Paddle(-350)
self.paddle_right = Paddle(350)
self.score = Score()
self.ball = Ball(0.5, 0.5)
# Create keyboard bindings
self.screen.listen()
self.screen.onkeypress(self.paddle_left.go_up, "w")
self.screen.onkeypress(self.paddle_left.go_down, "s")
self.screen.onkeypress(self.paddle_right.go_up, "Up")
self.screen.onkeypress(self.paddle_right.go_down, "Down")
def run(self):
"""Make the game loop a function."""
while True:
# move the ball
self.ball.move()
# checking the left border
if self.ball.xcor() < -390:
# add score for player A
self.score.add_score(0, 1)
# checking the right border
if self.ball.xcor() > 390:
# add score for player B
self.score.add_score(1, 0)
self.ball.check_collision()
# checking collision between ball and left paddle
if is_collision(self.paddle_left, self.ball):
self.ball.bounce_off()
# checking collision between ball and right paddle
if is_collision(self.paddle_right, self.ball):
self.ball.bounce_off()
# Display the screen.
self.screen.update()
class Game():
def __init__(self):
self.game_is_on = False
self.l_score = Score((-100, 250))
self.r_score = Score((100, 250))
self.l_paddle = Paddle((-370, 0))
self.r_paddle = Paddle((370, 0))
self.screen = Screen()
self.ball = Ball()
self.setup_screen()
def setup_screen(self):
self.screen.setup(width=800, height=600)
self.screen.bgcolor("black")
self.screen.title("MY Pong Game")
self.screen.tracer(0)
self.screen.listen()
self.screen.onkeypress(fun=self.r_paddle.up, key="Up")
self.screen.onkeypress(fun=self.r_paddle.backward, key="Down")
self.screen.onkeypress(fun=self.l_paddle.up, key="w")
self.screen.onkeypress(fun=self.l_paddle.backward, key="s")
# self.screen.exitonclick()
def play(self):
self.game_is_on = True
while self.game_is_on:
time.sleep(self.ball.move_speed)
self.screen.update()
self.ball.move()
if self.ball.ycor() > 280 or self.ball.ycor() < -280:
self.ball.bounce_y()
if self.ball.distance(self.r_paddle) < 50 and self.ball.xcor(
) > 320 or self.ball.distance(
self.l_paddle) < 50 and self.ball.xcor() < -320:
self.ball.bounce_x()
elif self.ball.xcor() > 380:
self.l_score.score_count()
self.ball.new_game()
elif self.ball.xcor() < -380:
self.r_score.score_count()
self.ball.new_game()
def stop(self):
self.game_is_on = False
def main():
# Setup the screen
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor('black')
screen.title('Snake Game')
screen.tracer(0)
# Create snake, food & score object and bind keys for snake movement
snake = Snake()
food = Food()
scoreboard = Scoreboard()
screen.listen()
screen.onkeypress(snake.up, 'Up')
screen.onkeypress(snake.down, 'Down')
screen.onkeypress(snake.left, 'Left')
screen.onkeypress(snake.right, 'Right')
# Start the game
is_game_on = True
while is_game_on:
scoreboard.display_score()
screen.update()
sleep(0.1)
snake.move()
# Detect collision with the food
if snake.head.distance(food) < 15:
food.refresh()
snake.extend()
scoreboard.update_score()
# Detect collision with wall
if snake.head.xcor() > 280 or snake.head.xcor(
) < -280 or snake.head.ycor() > 280 or snake.head.ycor() < -280:
scoreboard.game_over()
is_game_on = False
# Detect collision with tail
for square in snake.snake_list[1:]:
if snake.head.distance(square) < 10:
is_game_on = False
scoreboard.game_over()
screen.exitonclick()
def game(lvl):
# Screen Setup
screen = Screen()
screen.setup(width=600, height=600)
screen.tracer(0)
screen.colormode(255)
# Turtle Setup
player = Player()
# Scoreboard Setup
scoreboard = Scoreboard(lvl)
# Car Manager Setup
car_manager = CarManager(lvl)
# Control listeners
screen.listen()
screen.onkeypress(fun=player.move_up, key="Up")
screen.onkeypress(fun=player.move_down, key="Down")
screen.onkeypress(fun=player.move_left, key="Left")
screen.onkeypress(fun=player.move_right, key="Right")
# Main Game Loop
is_game = True
while is_game:
screen.update()
time.sleep(0.1)
car_manager.move_cars()
if player.ycor() > 290:
screen.clear()
lvl += 2
game(lvl)
for car in car_manager.cars_list:
if player.distance(car) < 20:
scoreboard.game_over()
is_game = False
screen.exitonclick()
def main():
# Setup the screen
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor('black')
screen.title('Snake Game')
screen.tracer(0)
# Create snake object and bind keys for snake movement
snake = Snake()
screen.listen()
screen.onkeypress(snake.up, 'Up')
screen.onkeypress(snake.down, 'Down')
screen.onkeypress(snake.left, 'Left')
screen.onkeypress(snake.right, 'Right')
# Start the game
is_game_on = True
while is_game_on:
screen.update()
sleep(0.1)
snake.move()
screen.exitonclick()
from scoreboard import Scoreboard
import time
screen = Screen()
screen.screensize(canvwidth=640, canvheight=640)
screen.bgcolor("black")
screen.tracer(0)
paddle1 = Paddle([(-440, -30), (-440, -10), (-440, 10), (-440, 30)])
paddle2 = Paddle([(440, -30), (440, -10), (440, 10), (440, 30)])
ball = Ball()
scoreboard = Scoreboard()
screen.listen()
screen.onkeypress(paddle1.down, "s")
screen.onkeypress(paddle1.up, "w")
screen.onkeypress(paddle2.down, "Down")
screen.onkeypress(paddle2.up, "Up")
game_is_on = True
while game_is_on:
screen.update()
time.sleep(0.02)
ball.move()
if 0 <= ball.direction() <= 90 or 90 <= ball.direction() <= 180:
ball.bounce1()
for i in range(0, 1):
def turn_right():
# t.left(20)
new_heading = t.heading() - 20
t.setheading(new_heading)
def move_backward():
t.backward(100)
def clear():
t.home()
t.clear()
s.onkey(fun=move_forward, key="w")
# s.onkey(fun=move_backward, key="s")
# s.onkey(fun=turn_left, key="a")
s.onkey(fun=turn_left, key="a")
# s.onkeyrelease(fun=move_forward, key="a")
# s.onkey(fun=turn_right, key="d")
s.onkey(fun=turn_right, key="d")
# s.onkeyrelease(fun=move_forward, key="d")
s.onkeypress(fun=clear, key="c")
s.listen()
s.exitonclick()
def d():
t.setheading(0)
t.forward(100)
def right():
t.setheading(0)
t.forward(100)
def s():
t.setheading(270)
t.forward(100)
def down():
t.setheading(270)
t.forward(100)
screen =Screen()
screen.window_height()
screen.window_width()
screen.listen()
screen.onkey(up, "Up")
screen.onkey(down, "Down")
screen.onkey(left, "Left")
screen.onkey(right, "Right")
screen.onkeypress(a, "a")
screen.onkeypress(s, "s")
screen.onkeypress(w, "w")
screen.onkeypress(d, "d")
screen.mainloop()
import time
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard
screen = Screen()
screen.setup(width=600, height=600)
screen.tracer(0)
scoreboard = Scoreboard()
car_manager = CarManager()
timmy = Player()
screen.listen()
screen.onkeypress(timmy.move, 'Up') # Move the turtle with keypress
game_is_on = True
while game_is_on:
time.sleep(0.1)
screen.update()
car_manager.create_car() # Create and move the cars
car_manager.move()
for car in car_manager.all_cars: # Detect collision with car
if timmy.distance(car) < 20:
game_is_on = False
scoreboard.game_over()
break
if timmy.ycor() > 280: # Detect when turtle reaches the other side
timmy.reset_player()
car_manager.level_up()
border.penup()
border.goto(-280, 280)
border.pendown()
border.goto(280, 280)
border.goto(280, -280)
border.goto(-280, -280)
border.goto(-280, 280)
snake = Snake()
food = Food()
scoreboard = ScoreBoard()
draw_border()
screen.listen()
screen.onkeypress(fun=snake.move_up, key="Up")
screen.onkeypress(fun=snake.move_down, key="Down")
screen.onkeypress(fun=snake.move_right, key="Right")
screen.onkeypress(fun=snake.move_left, key="Left")
game_on = True
while game_on:
time.sleep(0.1)
screen.update()
snake.move()
# Detect collision with Food
if snake.head.distance(food) <= 15:
food.refresh()
scoreboard.increase_score()
# Setting up screen.
screen = Screen()
screen.setup(width=800, height=600)
screen.bgcolor("black")
screen.title("Pong")
screen.tracer(0)
# Creating up game objects.
p1_paddle = Paddle(-350, 0)
p2_paddle = Paddle(350, 0)
score = Score()
puck = Puck()
# Accepting user input.
screen.onkeypress(p1_paddle.move_up, "w")
screen.onkeypress(p1_paddle.move_down, "s")
screen.onkeypress(p2_paddle.move_up, "Up")
screen.onkeypress(p2_paddle.move_down, "Down")
screen.listen()
# Game loop
run = True
while run:
time.sleep(puck.acceleration)
screen.update()
puck.move()
puck.handle_wall_collision()
point_winner = puck.handle_goal_collision()
puck.handle_paddle_collision(p1_paddle, p2_paddle)
class TurtleRace:
def __init__(self):
self.game_setup()
self.winner = None
def game_setup(self):
"""Resets the screen and asks for how many turtles to send to the races"""
self.screen = Screen()
self.screen.setup(width=500, height=400)
self.screen.clearscreen()
self.num_turtles = int(self.screen.numinput("num_turtle", "How many turtles race today?", 2, 2, 5))
# Sets initial parameters for the turtles - 5 options
self.names = ["Bob", "John", "Sally", "Rufus", "Marvin"]
self.colors = ["red", "purple", "green", "yellow", "orange"]
self.turtley = [-150, -50, 0, 50, 150]
self.start = -230
self.is_winner = False
self.turtles = {}
self.create_turtles()
self.play()
def create_turtles(self):
"""Generates the turtles!!"""
for turtle_ind in range(self.num_turtles):
self.turtles[self.names[turtle_ind]]=(Turtle(shape="turtle"))
self.turtles[self.names[turtle_ind]].color(self.colors[turtle_ind])
self.turtles[self.names[turtle_ind]].penup()
self.turtles[self.names[turtle_ind]].goto(x=self.start,y=self.turtley[turtle_ind])
def start_race(self):
while not self.is_winner:
for turtle in self.turtles:
this_turtle = self.turtles[turtle]
xchange=randint(1,10)
next_x = this_turtle.xcor()+xchange
this_turtle.goto(x=next_x,y=this_turtle.ycor())
if next_x>=230:
self.winner = turtle
self.is_winner = True
break
# self.is_winner(next_x)
self.end_race()
def end_race(self):
print(f"We have a winner! Great job, {self.winner}!!!")
print("Replay? Press r")
def play(self):
"""Listens for player input"""
self.screen.listen()
self.screen.onkeypress(key="g", fun=self.start_race)
self.screen.onkeypress(key="r", fun=self.game_setup)
self.screen.exitonclick()
dino.penup()
dino.goto(-WIDTH / 3, BASELINE + CURSOR_SIZE / 2)
cacti = []
for _ in range(NUMBER_CACTI):
cactus = Turtle()
cactus.shape('square')
cactus.shapesize(CACTUS_HEIGHT / CURSOR_SIZE, CACTUS_WIDTH / CURSOR_SIZE)
cactus.color('green')
cactus.penup()
cactus.sety(BASELINE + CACTUS_HEIGHT / 2)
place_cactus(cactus)
cacti.append(cactus)
pen = Turtle()
pen.hideturtle()
pen.penup()
pen.sety(155)
pen.write("Score: 0 High Score: 0", align='center', font=FONT)
screen.onkeypress(jump, 'space')
screen.listen()
run()
screen.mainloop()
if k == 'w':
move.forward(5)
elif k == 'a':
move.left(5)
elif k == 's':
move.back(5)
elif k == 'd':
move.right(5)
screen.ontimer(move_it, 25)
keys = []
move = Turtle()
screen = Screen()
move.speed(0)
screen.onkeypress(lambda:key_add('w'), "w")
screen.onkeypress(lambda:key_add('a'), "a")
screen.onkeypress(lambda:key_add('s'), "s")
screen.onkeypress(lambda:key_add('d'), "d")
screen.onkeyrelease(lambda:key_remove('w'), 'w')
screen.onkeyrelease(lambda:key_remove('a'), 'a')
screen.onkeyrelease(lambda:key_remove('s'), 's')
screen.onkeyrelease(lambda:key_remove('d'), 'd')
screen.listen()
screen.ontimer(move_it, 25)
screen.mainloop()
car_speed = 10
car.dx = car_speed
car.dy = 0
# UI
pen = Turtle()
pen.speed(0)
pen.color("white")
pen.penup()
pen.hideturtle()
pen.goto(0, 0)
pen.write('flags', align="center", font=("Courier", 11, "normal"))
# Key binding
wn.listen()
wn.onkeypress(m_mode_on, "z")
wn.onkeypress(m_mode_off, "x")
wn.onkeypress(get_obstacle, "a")
wn.onkeypress(rm_obstacle, "s")
# Connect to HQ
HQ_ip = 'localhost'
HQ_port = 8090
clientSock = socket(AF_INET, SOCK_STREAM)
clientSock.connect((HQ_ip, HQ_port))
print('connected')
direction = 1
current_address = 0
import time
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard
screen = Screen()
screen.setup(width=600, height=600)
screen.tracer(0)
player = Player()
scoreboard = Scoreboard()
manager = CarManager()
screen.listen()
screen.onkeypress(key="Up", fun=player.move)
game_is_on = True
while game_is_on:
scoreboard.refresh()
manager.update()
# Check player win
if player.ycor() > player.y_win:
player.reset()
scoreboard.level += 1
manager.next_level()
# Check car collision
screen.bgcolor("black")
screen.setup(width=800, height=600)
screen.title("Пинг-Понг")
screen.tracer(0)
# Introducing main parts of the game:
left_paddle = Paddle((-380, 0))
right_paddle = Paddle((380, 0))
ball = Ball()
scoreboard = Scoreboard()
# Introducing controls:
screen.listen()
screen.onkey(left_paddle.up, "a")
screen.onkey(left_paddle.down, "z")
screen.onkeypress(right_paddle.up, "Up")
screen.onkeypress(right_paddle.down, "Down")
# Main game cycle:
game_is_on = True
while game_is_on:
time.sleep(ball.move_speed)
screen.update()
ball.move()
# Detect collision with the upper or lower wall:
if ball.ycor() > 280 or ball.ycor() < -280:
ball.bounce_y()
# Detect collision with the paddles:
screen.listen()
def move_fwd():
tim.fd(10)
def move_bck():
tim.bk(10)
def turn_left():
tim.setheading(tim.heading() + 10)
def turn_right():
tim.setheading(tim.heading() - 10)
def screen_clear():
tim.reset()
screen.onkeypress(move_fwd, "w")
screen.onkeypress(move_bck, "s")
screen.onkey(turn_left, "a")
screen.onkey(turn_right, "d")
screen.onkey(screen_clear, "c")
screen.exitonclick()
screen.tracer(0)
# Paddle Setup
paddle_1 = Paddle((350, 0))
paddle_2 = Paddle((-350, 0))
# Score Setup
score_1 = Score((40, 260))
score_2 = Score((-40, 260))
# Ball Setup
ball = Ball()
# Controls listeners
screen.listen()
screen.onkeypress(fun=paddle_1.move_up, key="Up")
screen.onkeypress(fun=paddle_1.move_down, key="Down")
screen.onkeypress(fun=paddle_2.move_up, key="w")
screen.onkeypress(fun=paddle_2.move_down, key="s")
# game Loop
is_gaming = True
while is_gaming:
time.sleep(ball.move_speed)
screen.update()
ball.update()
ball.check_collision(screen.window_height(), paddle_1, paddle_2)
# Check Goals
if ball.xcor() > paddle_1.xcor() + 10:
ball.reset_position()
fontsize=50,
fonttype="bold italic")
level_message = Messenger(position=(0, 0),
fontcolor="dark green",
fontsize=50,
fonttype="italic")
# Create Level Display
level_display = Messenger(position=(-250, 276),
fontcolor="black",
fontsize=16,
fonttype="normal")
# Create Player
player = Player()
screen.onkeypress(player.move_up, "Up")
game_is_on = True
counter = 0
cars = []
level = 1
level_message.display_message(f"Level {level}", time=1)
while game_is_on:
level_display.display_message(f"Level {level}", time=-1)
time.sleep(0.1)
screen.update()
counter += 1
if counter == 6:
# Create Car
cars.append(CarManager(level))
counter = 0
