def run_game():
"""main loop of the game"""
#intialization of pygame library
pygame.init()
#initializing all needed objects
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
ball = Ball(screen)
pad = Pad(settings, screen)
pad1 = Pad1(settings, screen)
stats = Game_stats(settings)
pygame.display.set_caption("Pong")
sb = Scoreboard(screen, stats)
sb1 = Scoreboard1(screen, stats)
start_button = Button(screen, settings, "START")
while True:
#using functions from module
gf.check_events(settings, screen, pad, pad1, stats, start_button)
gf.update_screen(settings, screen, pad, pad1, ball, stats,
start_button, sb, sb1)
if stats.game_active:
pad.update(settings)
pad1.update(settings)
gf.update_ball(ball, settings, pad, pad1, stats, sb, sb1)
def run_game():
#initialize pygame, settings and screen object
pygame.init()
game_settings = Settings()
screen = pygame.display.set_mode(
(game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption("PONG!")
rpaddle = Rpaddle(game_settings, screen)
lpaddle = Lpaddle(game_settings, screen)
ball = Ball(game_settings, screen)
play_button = Button(screen, "Play")
stats = Stats()
scoreboard = Scoreboard(game_settings, screen, stats)
winner_msg = Winnermsg(game_settings, screen)
#start main loop
while True:
#watch for keyboard and mouse events
gf.check_events(rpaddle, lpaddle, stats)
if stats.game_active:
gf.update_rpaddle(game_settings, rpaddle)
gf.update_lpaddle(game_settings, lpaddle)
gf.update_ball(game_settings, rpaddle, lpaddle, ball, stats,
scoreboard, winner_msg)
#update screen
gf.update_screen(game_settings, screen, rpaddle, lpaddle, ball,
play_button, stats, scoreboard, winner_msg)
def run_game():
"""Initialize pygame, settings and screen object"""
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Jordan Catch")
button = Button(screen, "Play")
player = Player(settings, screen)
ball = Ball(settings, screen)
stats = GameStats()
# Start the main loop for the game.
while True:
gf.check_events(stats, player, button)
if stats.game_active:
player.update()
gf.update_ball(ball, stats, settings, screen, player)
gf.update_screen(settings, screen, stats, player, ball, button)
def run_game():
# Initialize pygame, settings, and screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Catch")
# Create an instance to store game statistics.
stats = GameStats(ai_settings)
# Make a catcher, and ball group
catcher = Catcher(ai_settings, screen)
balls = Group()
# Create the falling ball.
gf.create_ball(ai_settings, screen, balls)
# Start the main loop for the game.
while True:
# Check for any input events
gf.check_events(catcher)
# Keep updating the catcher and ball until gameover
if stats.game_active:
catcher.update()
gf.update_ball(ai_settings, stats, screen, catcher, balls)
gf.update_screen(ai_settings, screen, catcher, balls)
def run_game():
# Initialize pygame, settings, and screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Pong")
stats = GameStats(ai_settings)
winner = stats.winner
play_button = Button(screen, "PLAY GAME", "PONG", "AI -- NO WALLS", winner)
sb = Scoreboard(ai_settings, screen, stats)
# Make paddles, ball, divider
divider = Divider(ai_settings, screen)
ball = Ball(ai_settings, screen)
paddles = Paddle(ai_settings, screen, divider, ball)
effect = pygame.mixer.Sound('audio/pop2.wav')
# Start the main loop for the game.
while True:
gf.check_events(ai_settings, paddles, play_button, sb)
if ai_settings.game_active:
gf.update_paddles(paddles)
gf.update_ball(ball, ai_settings, paddles, divider, stats, sb,
effect, play_button)
gf.update_screen(ai_settings, screen, paddles, ball, divider,
play_button, sb)
def run_game():
"""Run game."""
# Initialize game
pygame.init()
# Initialize settings
settings = Settings()
# Create window
screen = pygame.display.set_mode((1200, 800))
# Create caption
pygame.display.set_caption('Catch Game')
# Generate a ball
ball = gf.create_ball(screen)
# Create a person
person = gf.create_person(screen)
# Initialize stats
stats = Stats(settings)
# Run loop
while True:
gf.check_events(person)
if stats.game_active:
# Update sprite positions
gf.update_person(person)
gf.update_ball(ball, person, settings, stats)
# Re-render screen
gf.update_screen(screen, ball, person)
else:
print('game over')
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode((1200, 800))
pygame.display.set_caption("Pong")
ball = Ball(ai_settings, screen)
human_paddle = Paddle(ai_settings, screen, 'right')
ai_paddle = Paddle(ai_settings, screen, 'left')
stats = GameStats(ai_settings)
while True:
gf.check_events(ai_settings, screen, human_paddle, stats)
if stats.game_active:
human_paddle.update()
ball.update()
gf.ai_update(ball, ai_paddle, ai_settings)
ai_paddle.update()
gf.update_ball(ai_settings, screen, human_paddle, ai_paddle, ball,
stats)
gf.update_screen(ai_settings, screen, human_paddle, ai_paddle,
ball)
def run_game():
pygame.init()
pygame.display.set_caption('4-Sided Pong')
settings = Settings()
screen = pygame.display.set_mode(
(settings.screenwidth, settings.screenheight))
ball = Ball(screen)
player = Player(screen, settings)
enemy = Enemy(screen, settings, ball)
play_button = Button(screen, "Pong AI-No Walls: ")
stats = Stats()
scoreboard = Scoreboard(screen, settings, stats)
#ball.start_game()
while True:
gf.check_key_events(ball, player, play_button, stats, scoreboard)
if stats.game_active:
player.update()
enemy.update()
gf.update_ball(screen, settings, ball, player, enemy, stats,
scoreboard)
gf.update_screen(screen, settings, ball, player, enemy, play_button,
stats, scoreboard)
def run_game():
# Initialize game and create a screen object
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("PONG")
# Create sounds for when the paddle is hit.
user_paddle_hit_sound = pygame.mixer.Sound('sounds/user_paddle_hit.wav')
comp_paddle_hit_sound = pygame.mixer.Sound('sounds/comp_paddle_hit.wav')
# Create and instance to store game statistics
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# Make the Net
net = Net(screen)
# Make top paddle:
paddle_top = PaddleTop(ai_settings, screen)
paddle_bottom = PaddleBottom(ai_settings, screen)
paddle_left = PaddleLeft(ai_settings, screen)
# Make a paddle controlled by the computer.
comp_paddle_top = CompPaddleTop(ai_settings, screen)
comp_paddle_right = CompPaddleRight(ai_settings, screen)
comp_paddle_bottom = CompPaddleBottom(ai_settings, screen)
# Create the ball
ball = Ball(ai_settings, screen)
# Make the play button.
play_button = Button(screen, "Play")
# Start the main loop for the game.
while True:
gf.check_events(ai_settings, stats, sb, play_button, paddle_top,
paddle_bottom, paddle_left, comp_paddle_top,
comp_paddle_right, comp_paddle_bottom, ball)
if stats.game_active:
gf.update_comp_paddle_top(comp_paddle_top, ball)
gf.update_comp_paddle_right(comp_paddle_right, ball)
gf.update_comp_paddle_bottom(comp_paddle_bottom, ball)
gf.update_user_paddle_top(paddle_top)
gf.update_user_paddle_bottom(paddle_bottom)
gf.update_user_paddle_left(paddle_left)
gf.update_ball(ai_settings, screen, stats, sb, paddle_top,
paddle_bottom, paddle_left, comp_paddle_top,
comp_paddle_right, comp_paddle_bottom, ball,
user_paddle_hit_sound, comp_paddle_hit_sound)
gf.update_screen(ai_settings, screen, stats, sb, paddle_top,
paddle_bottom, paddle_left, comp_paddle_top,
comp_paddle_right, comp_paddle_bottom, ball,
play_button, net)
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Pong")
stats = GameStats(ai_settings)
sb = Score_Ai(ai_settings, screen, stats)
sb2 = Score_User(ai_settings, screen, stats)
#Make the play button
play_button = Button(ai_settings, screen, "Play Game")
#start menu
start_up = Start_Up(ai_settings, screen)
#Make paddles
paddle_bottom = Paddle_Bottom(ai_settings, screen)
paddle_top = Paddle_Top(ai_settings, screen)
paddle_right = Paddle_Right(ai_settings, screen)
paddle_bottom_ai = Paddle_Bottom_Ai(ai_settings, screen)
paddle_top_ai = Paddle_Top_Ai(ai_settings, screen)
paddle_left_ai = Paddle_Left_Ai(ai_settings, screen)
#Make a ball
ball = Ball(ai_settings, screen)
while True:
gf.check_events(ai_settings, stats, play_button, paddle_bottom,
paddle_top, paddle_right, sb, sb2)
if stats.game_active:
paddle_bottom.update()
paddle_top.update()
paddle_right.update()
paddle_bottom_ai.update()
paddle_top_ai.update()
paddle_left_ai.update()
gf.update_ball(ai_settings, stats, screen, ball, paddle_bottom,
paddle_top, paddle_right, paddle_bottom_ai,
paddle_top_ai, paddle_left_ai)
gf.update_screen(ai_settings, start_up, screen, stats, sb, sb2,
paddle_bottom_ai, paddle_left_ai, paddle_top_ai,
paddle_bottom, paddle_top, paddle_right, ball,
play_button)
def run_game():
pygame.mixer.pre_init(44100, 16, 2, 4096)
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Pong")
# Make play button
play_button = Button(ai_settings, screen, "Play")
title_screen = TitleScreen(ai_settings, screen, "PONG")
# Handle stats and scoreboard
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# Make a paddle
p1paddle = P1Paddle(ai_settings, screen)
# Make another one
p2paddle = P2Paddle(ai_settings, screen)
# Make a ball
ball = Ball(ai_settings, screen, p1paddle)
# Start the main loop for the game.
while True:
# Watch for keyboard and mouse events
gf.check_events(ai_settings, stats, sb, play_button, p1paddle,
title_screen)
if stats.game_active:
p1paddle.update()
p2paddle.ai_update(ai_settings, ball)
gf.update_ball(ai_settings, stats, sb, screen, p1paddle, p2paddle,
ball, title_screen)
gf.update_screen(ai_settings, screen, stats, sb, p1paddle, p2paddle,
ball, play_button, title_screen)
def run_game():
# Initialize game and create a screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Basket Catch")
# Make a basket and a ball groups and create them
baskets = Group()
balls = Group()
gf.create_basket(ai_settings, screen, baskets)
gf.create_ball(ai_settings, screen, balls)
# Start the main loop for the game
while True:
gf.check_events(ai_settings, baskets)
gf.update_basket(baskets)
gf.update_ball(ai_settings, screen, baskets, balls)
gf.update_screen(ai_settings, screen, baskets, balls)
def run_game():
"""运行游戏"""
#初始化
pygame.init()
#导入设置
my_settings = Settings()
#创建屏幕实例
screen = pygame.display.set_mode(
(my_settings.screen_width, my_settings.screen_height))
#创建男孩实例
boy = Boy(screen, my_settings)
#创建球的编组
balls = Group()
while True:
#检查按键
gf.check_events(boy)
#boy更新
gf.update_boy(screen, my_settings, boy)
#ball更新
gf.update_ball(screen, my_settings, balls, boy)
#刷新屏幕
gf.update_screen(screen, my_settings, boy, balls)
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
start_menu = StartMenu(screen, "'SPACE' to start")
paddles = Paddles(ai_settings, screen)
cp = CPaddles(ai_settings, screen)
ball = Ball(ai_settings, screen, paddles, cp)
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats, ball)
while True:
gf.check_events(stats, sb, paddles, cp, ball)
if stats.game_active:
paddles.update()
gf.computer_update(ai_settings, screen, cp, ball)
gf.update_ball(ai_settings, screen, stats, sb, paddles, cp, ball)
gf.update_screen(ai_settings, screen, stats, sb, paddles, cp, ball, start_menu)
