def setup(self):
super(Game, self).setup()
pygame.key.set_repeat(100, 20)
self.FPSCLOCK = pygame.time.Clock()
self.racket_p1 = Racket(self.screen)
self.ball = Ball(self.screen)
self.racket_p2 = Racket(self.screen, mode='auto')
def reset(self): self.racket_left = Racket(pyglet.resource.image(settings.RACKET_IMG)).center_anchor_y(settings.WINDOW_HEIGHT) self.racket_right = Racket(pyglet.resource.image(settings.RACKET_IMG)).center_anchor_y(settings.WINDOW_HEIGHT) self.ball = Ball(pyglet.resource.image(settings.BALL_IMG)).center_anchor_y(settings.WINDOW_HEIGHT).center_anchor_x(settings.WINDOW_WIDTH) self.racket_right.x = settings.WINDOW_WIDTH - self.racket_right.width self.racket_me = self.racket_left self.ball.reset()
def load_sprites(self):
self.score_lp = pyglet.text.Label('', font_size=15, x=settings.WINDOW_WIDTH/2 - 30, y=settings.WINDOW_HEIGHT - 15, anchor_x='center', anchor_y='center')
self.score_rp = pyglet.text.Label('', font_size=15, x=settings.WINDOW_WIDTH/2 + 30, y=settings.WINDOW_HEIGHT - 15, anchor_x='center', anchor_y='center')
self.racket_left = Racket(pyglet.resource.image(settings.RACKET_IMG)).center_anchor_y(settings.WINDOW_HEIGHT)
self.racket_right = Racket(pyglet.resource.image(settings.RACKET_IMG)).center_anchor_y(settings.WINDOW_HEIGHT)
self.ball = Ball(pyglet.resource.image(settings.BALL_IMG)).center_anchor_y(settings.WINDOW_HEIGHT).center_anchor_x(settings.WINDOW_WIDTH)
self.racket_right.x = settings.WINDOW_WIDTH - self.racket_right.width
self.racket_me = self.racket_left
self.ball.reset()
class Game(BaseLoop):
def __init__(self, screen: pygame.Surface):
super(Game, self).__init__(screen)
self.FPSCLOCK = None
self.racket_p1 = Racket(self.screen)
self.racket_p2 = None
self.ball = Ball(self.screen)
def setup(self):
super(Game, self).setup()
pygame.key.set_repeat(100, 20)
self.FPSCLOCK = pygame.time.Clock()
self.racket_p1 = Racket(self.screen)
self.ball = Ball(self.screen)
self.racket_p2 = Racket(self.screen, mode='auto')
def update_screen(self):
super(Game, self).update_screen()
pygame.draw.rect(self.screen, WHITE, ((self.screen.get_width() // 2) - 1, 0, 2,
self.screen.get_height()))
self.racket_p1.render()
self.racket_p2.render()
self.ball.render()
def process_event(self, event: pygame.event):
if event.type == KEYDOWN:
if event.key == CONTROLS[UP]:
self.racket_p1.move(UP)
elif event.key == CONTROLS[DOWN]:
self.racket_p1.move(DOWN)
if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
self.LOOP_RUN = False
print('Ending the game...')
def start(self, game_type="one_player"):
print('Starting the game...')
self.game_type = game_type
super(Game, self).start()
while self.LOOP_RUN:
for event in pygame.event.get():
self.process_event(event)
self.update_screen()
self.ball.move(self.racket_p1, self.racket_p2)
self.racket_p2.auto_move(self.ball)
pygame.display.flip()
self.FPSCLOCK.tick(FPS)
def draw_elements(self):
self.racket1 = Racket(self, 60, 10, 'l')
self.racket2 = Racket(self, 60, 10, 'r')
self.create_line(self.width / 2, 0, self.width / 2, self.height)
self.score1 = self.create_text(self.width / 4,
20,
text='0',
font=('Verdana', 25, 'normal'))
self.score2 = self.create_text(self.width / 4 * 3,
20,
text='0',
font=('Verdana', 25, 'normal'))
self.ball = Ball(self)
self.text = self.create_text(self.width / 2,
self.height / 2,
text='Press any button to start',
font=('Verdana', 25, 'normal'),
fill='red')
def main():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.win_width, ai_settings.win_height))
pygame.display.set_caption("PyPong_v01")
pygame.display.set_icon(pygame.image.load("images/ball.png"))
player1 = Racket(screen, 1)
player2 = Racket(screen, 2)
g_ball = Ball(screen)
sb = Scoreboard(screen)
bplay1 = Button(screen, '1 Player', 'active', 0)
bplay2 = Button(screen, '2 Players', 'noactive', 1)
bplayOnlineServer = Button(screen, 'Create Online Game', 'noactive', 2)
bplayOnlineClient = Button(screen, 'Connect Online Game', 'noactive', 3)
bquit = Button(screen, 'Exit', 'noactive', 4)
button_box = [bplay1, bplay2, bquit, bplayOnlineServer, bplayOnlineClient]
music = pygame.mixer.music.load('music/Sound.mp3')
pygame.mixer.music.play(-1, 0.0)
ai = Pong_ai(screen, ai_settings)
sock = False
conn = False
while True:
if ai_settings.game_active == 'fase_menu':
game_functions.menu_controll(ai_settings, screen, button_box)
if ai_settings.game_active == 'game_fase' or ai_settings.game_active == 'fase_end':
if ai_settings.server_on == True and ai_settings.yes_online != 1:
sock, conn = game_functions.create_server(ai_settings)
if ai_settings.client_on == True and ai_settings.yes_online != 2:
sock = game_functions.create_client(ai_settings)
game_functions.check_events(ai_settings, screen, player1, player2,
g_ball, sb, ai, sock, conn)
game_functions.check_collide(screen, player1, player2, g_ball)
game_functions.up_score(screen, player1, player2, g_ball, sb)
game_functions.update_screen(ai_settings, screen, player1, player2,
g_ball, sb)
def __init__(self, screen: pygame.Surface):
super(Game, self).__init__(screen)
self.FPSCLOCK = None
self.racket_p1 = Racket(self.screen)
self.racket_p2 = None
self.ball = Ball(self.screen)
class Desk(Canvas):
def __init__(self, parent=None, h=None, w=None, **configs):
super().__init__(parent, height=h, width=w, bd=0, **configs)
self.height = h
self.width = w
self.pack(expand=YES, fill=BOTH)
self.score_board = ScoreBoard()
self.draw_elements()
self.dr_l = [(4, 4), (4, -4), (5, 3), (5, -3), (6, 2), (6, -2), (7, 1),
(7, -1)]
self.dr_r = [(-4, 4), (-4, -4), (-5, 3), (-5, -3), (-6, 2), (-6, -2),
(-7, 1), (-7, -1)]
self.upf = False
self.downf = False
self.focus_set()
self.bind('<KeyPress>', self.start)
self.bind('<Up>', self.up_pressed)
self.bind('<KeyRelease-Up>', self.up_released)
self.bind('<Down>', self.down_pressed)
self.bind('<KeyRelease-Down>', self.down_released)
def draw_elements(self):
self.racket1 = Racket(self, 60, 10, 'l')
self.racket2 = Racket(self, 60, 10, 'r')
self.create_line(self.width / 2, 0, self.width / 2, self.height)
self.score1 = self.create_text(self.width / 4,
20,
text='0',
font=('Verdana', 25, 'normal'))
self.score2 = self.create_text(self.width / 4 * 3,
20,
text='0',
font=('Verdana', 25, 'normal'))
self.ball = Ball(self)
self.text = self.create_text(self.width / 2,
self.height / 2,
text='Press any button to start',
font=('Verdana', 25, 'normal'),
fill='red')
def start(self, event=None):
self.delete(self.text)
self.move_ball()
def up_pressed(self, event):
self.upf = True
def up_released(self, event: Event):
self.upf = False
def down_pressed(self, event):
self.downf = True
def down_released(self, event):
self.downf = False
def redraw_ball(self):
x = self.width / 2 - self.ball.x2 + self.ball.width / 2
y = self.height / 2 - self.ball.y1 - self.ball.height / 2
self.ball.move(x, y)
y = self.height / 2 - self.racket2.y1 - self.racket2.racket_height / 2
self.racket2.move(0, y)
y = self.height / 2 - self.racket1.y1 - self.racket1.racket_height / 2
self.racket1.move(0, y)
def draw_racket(self, rh, rw, side=''):
self.racket_width = rw
self.racket_height = rh
if side == 'l':
self.rx_from = 2
self.rx_to = self.racket_width
elif side == 'r':
self.rx_from = self.width - self.racket_width
self.rx_to = self.width
self.ry_from = self.height / 2 + self.racket_height / 2
self.ry_to = self.height / 2 - self.racket_height / 2
rid = self.create_rectangle(self.rx_from,
self.ry_from,
self.rx_to,
self.ry_to,
fill='yellow')
return rid
def wait(self, t):
if t:
self.after(1000, self.wait, t - 1)
else:
self.move_ball()
def create_report(self, player):
self.score_board = ScoreBoard()
self.itemconfigure(self.score1, text=0)
self.itemconfigure(self.score2, text=0)
log = Toplevel(self.master)
log.geometry('+550+300')
Label(log, text=f'{player} won',
font=('Verdana', 25, 'normal')).pack(side=TOP)
Button(log,
text='Quit',
font=('Verdana', 10, 'normal'),
command=lambda: log.destroy() or self.master.quit()).pack(
side=LEFT)
Button(log,
text='Start New',
font=('Verdana', 10, 'normal'),
command=lambda: log.destroy() or self.start()).pack(side=RIGHT)
log.focus_set()
log.grab_set()
log.wait_window()
def move_ball(self, x=-8, y=0):
# ricochet top and bot
drct1 = choice(self.dr_l)
drct2 = choice(self.dr_r)
if (self.ball.y2 > self.height) or (self.ball.y1 < 0):
y = -y
# real player racket logic
direction = [1, -1]
if ((self.racket1.y1 <= self.ball.y2)
and (self.racket1.y2 >= self.ball.y1)):
if self.racket1.x2 >= self.ball.x1:
x = -x
self.ball.move(self.racket2.racket_width - 1, 0)
x = drct1[0]
y = drct1[1]
print(x, y)
# angel ricochet
# if self.racket1.x2 > self.ball.x1:
# print(x, y)
# x = -x
# y = -y
if self.ball.x1 <= 0:
if self.score_board.second_won():
self.create_report('Second')
self.itemconfigure(self.score2, text=self.score_board.player2)
self.redraw_ball()
self.wait(1)
return 0
if self.ball.x2 > self.width / 2:
# x = -x
if (self.ball.y_center >
self.racket2.y_center) and (self.racket2.y2 < self.height):
self.racket2.move(0, 3.5)
if (self.ball.y_center <
self.racket2.y_center) and (self.racket2.y1 > 0):
self.racket2.move(0, -3.5)
if ((self.ball.y2 >= self.racket2.y1)
and (self.racket2.y2 >= self.ball.y1)):
if self.racket2.x1 <= self.ball.x2:
x = -x
self.ball.move(x - self.racket2.racket_width, 0)
x = drct2[0]
y = drct2[1]
print(x, y)
#angel ricochet
# elif self.racket2.x1 < self.ball.x2:
# x = -x
# y = -y
# self.ball.move(x - self.racket2.racket_width, 0)
if self.ball.x2 >= self.width:
if self.score_board.first_won():
self.create_report('First')
self.itemconfigure(self.score1, text=self.score_board.player1)
self.redraw_ball()
self.wait(1)
return 0
self.ball.move(x, y)
if self.upf:
if self.racket1.y1 > 0:
self.racket1.move(0, -5)
if self.downf:
if self.racket1.y2 < self.height:
self.racket1.move(0, 5)
self.after(14, self.move_ball, x, y)
WIN_HEIGHT = 640
MAX_SCORE = 5
DISPLAY = (WIN_WIDTH, WIN_HEIGHT)
pygame.init()
clock = pygame.time.Clock()
screen = pygame.display.set_mode(DISPLAY, 0, 32)
DONE = False
FPS = 30
left_player = Player(Directions.LEFT, 'Left')
right_player = Player(Directions.RIGHT, 'Right')
curr_ball = Ball(screen, WIN_WIDTH, WIN_HEIGHT)
left_racket = Racket(screen, WIN_WIDTH, WIN_HEIGHT, Directions.LEFT)
right_racket = Racket(screen, WIN_WIDTH, WIN_HEIGHT, Directions.RIGHT)
rackets = pygame.sprite.Group()
rackets.add(left_racket)
rackets.add(right_racket)
stuff_to_draw = pygame.sprite.Group()
stuff_to_draw.add(left_racket)
stuff_to_draw.add(right_racket)
def game_over(screen, winner, left_paper, right_player):
gray_overlay = pygame.Surface((WIN_WIDTH, WIN_HEIGHT))
gray_overlay.fill(GRAY)
gray_overlay.set_colorkey(GRAY)
pygame.draw.rect(gray_overlay, BLACK, [0, 0, WIN_WIDTH, WIN_HEIGHT])
import pygame from racket import Racket import square #Global Colors GREEN = (31, 161, 61) RED = (255, 0, 0) WHITE = (255, 255, 255) BLUE = (3, 73, 252) pygame.init() #Game objects racketA = Racket(RED, 10, 100) racketA.rect.x = 20 racketA.rect.y = 200 scoreA = 0 scoreB = 0 racketB = Racket(BLUE, 10, 100) racketB.rect.x = 670 racketB.rect.y = 200 ball = square.Ball(WHITE, 10, 10) ball.rect.x = 345 ball.rect.y = 195 #Window size = (700, 500) screen = pygame.display.set_mode(size)
def __init__(self):
super().__init__("game")
self.next_gamestate = None
self.rackets = [
Racket((Config.MARGIN,
Config.SCREENHEIGHT // 2 - Config.RACKET_HEIGHT // 2),
(Config.RACKET_WIDTH, Config.RACKET_HEIGHT)),
Racket((Config.SCREENWIDTH - Config.MARGIN - Config.RACKET_WIDTH,
Config.SCREENHEIGHT // 2 - Config.RACKET_HEIGHT // 2),
(Config.RACKET_WIDTH, Config.RACKET_HEIGHT))
]
self.ball = Ball(self.rackets,
(Config.SCREENWIDTH // 2 - Config.BALL_SIZE // 2,
Config.SCREENHEIGHT // 2 - Config.BALL_SIZE // 2))
self.ball.on_boundary_hit.append(
self.score_point) # subscribe to event to update the score
self.ball.on_boundary_hit.append(
self.play_boundary_sound) # play boundary sound
self.ball.on_racket_hit.append(
self.increase_speed
) # subscribe to event to increase speed on every racket hit
self.ball.on_racket_hit.append(
self.play_racket_sound) # play racket bounce sound
self.racket_controls = []
for i, control in enumerate(Config.controls):
if control == "ai":
self.racket_controls.append(
Control_ai(self.rackets[i], self.ball))
# nerf ai players - otherwise they are too strong
self.rackets[i].max_speed = Config.AI_PLAYER_SPEED
elif control == "mouse":
self.racket_controls.append(Control_mouse(self.rackets[i]))
self.rackets[
i].max_speed = Config.MOUSE_SPEED # higher speed for mouse input
elif control == "keyboard":
self.racket_controls.append(Control_keyboard(self.rackets[i]))
self.info_text = Text_widget(
(Config.SCREENWIDTH // 2, Config.SCREENHEIGHT - Config.MARGIN),
"ESC zum Beenden",
color_normal=pygame.Color(100, 100, 100),
text_justify="center",
vertical_align="top")
self.score_widgets = [
Text_widget(
(Config.MARGIN + Config.RACKET_WIDTH * 2, Config.MARGIN), "0"),
Text_widget(
(Config.SCREENWIDTH - Config.MARGIN - Config.RACKET_WIDTH * 2,
Config.MARGIN),
"0",
text_justify="right")
]
self.countdown = Config.START_COUNTDOWN
self.countdown_text = Text_widget(
(Config.SCREENWIDTH // 2, Config.SCREENHEIGHT // 2),
"",
text_justify="center",
vertical_align="center")
self.gui = GUI_group()
self.gui.add(self.score_widgets[0], self.score_widgets[1],
self.info_text, self.countdown_text)
Sound_manager.change_song()
def create_rackets(sys_settings, screen, rackets):
racket = Racket(sys_settings, screen)
rackets.add(racket)
def start(size):
main_clock = pygame.time.Clock()
pygame.display.init()
window = pygame.display.set_mode(size)
window_ = window.copy()
b = Ball()
r_right = Racket('R')
r_left = Racket('L')
while True:
# Event manager
for event in pygame.event.get():
if event.type == QUIT:
end()
elif event.type == MOUSEBUTTONDOWN:
if event.button == 1:
pass
elif event.type == KEYDOWN:
#print(event.key)
if event.key == 273: # Direction key up
r_right.direction = 'up'
break
if event.key == 274: # Direction key down
r_right.direction = 'down'
break
r_right.direction = False
window.blit(window_, (0, 0))
r_right.draw(window)
r_right.update()
r_left.computerAI(b)
r_left.draw(window)
r_left.update()
b.draw(window)
b.update()
b.collides(r_right, r_left)
Interface.draw(window, r_left.mark, r_right.mark)
pygame.display.flip()
main_clock.tick(100)
import time
import random
LEFT_END = -580
RIGHT_END = 580
screen = Screen()
screen.setup(width=1200, height=600)
screen.bgcolor('black')
screen.title("Naru's Ping-Pong Game")
screen.tracer(0)
board = Board()
ball = Ball()
player_left = Racket()
player_right = Racket()
player_left.make_rackets(LEFT_END)
player_right.make_rackets(RIGHT_END)
screen.listen()
screen.onkey(player_left.up, "w")
screen.onkey(player_left.down, "s")
screen.onkey(player_right.up, "Up")
screen.onkey(player_right.down, "Down")
while True:
screen.update()
time.sleep(0.08)
ball.move()
def start(size):
main_clock = pygame.time.Clock()
pygame.display.init()
window = pygame.display.set_mode(size)
window_ = window.copy()
b = Ball()
r_right = Racket('R')
r_left = Racket('L')
while True:
# Event manager
for event in pygame.event.get():
if event.type == QUIT:
end()
elif event.type == MOUSEBUTTONDOWN:
if event.button == 1:
pass
elif event.type == KEYDOWN:
#print(event.key)
if event.key == 273: # Direction key up
r_right.direction = 'up'
break
if event.key == 274: # Direction key down
r_right.direction = 'down'
break
r_right.direction = False
window.blit(window_, (0, 0))
r_right.draw(window)
r_right.update()
r_left.computerAI(b)
r_left.draw(window)
r_left.update()
b.draw(window)
b.update()
b.collides(r_right, r_left)
Interface.draw(window, r_left.mark, r_right.mark)
pygame.display.flip()
main_clock.tick(100)
