def run_game ():
#inicjalizacja gry i utworzenie obiektu ekranu
pygame.init()
dolphingame_settings=Settings()
screen=pygame.display.set_mode((dolphingame_settings.screen_width, dolphingame_settings.screen_height))
pygame.display.set_caption("Dolphin Game")
play_button=Button(dolphingame_settings, screen,"Play")
stats=GameStats(dolphingame_settings)
dolphin_scores=Scoreboard(dolphingame_settings,screen,stats)
#Utworzenie statku rybackiego
dolphin=Dolphin(dolphingame_settings,screen)
bubbles = Group()
fishers=Group()
#Utworzenie wielu statków
functions.create_fishers(dolphingame_settings,screen,dolphin,fishers)
#rozpocięcie pętli glownej gry
while True:
functions.check_events(dolphingame_settings,screen,stats, dolphin_scores, play_button,dolphin,fishers,bubbles)
if stats.game_active:
dolphin.update()
functions.update_fishers(dolphingame_settings, screen, stats,dolphin_scores,dolphin, fishers, bubbles)
functions.update_bubbles(dolphingame_settings,screen,stats, dolphin_scores, dolphin,fishers,bubbles)
functions.update_screen(dolphingame_settings, screen, stats, dolphin_scores, dolphin, fishers, bubbles,play_button)
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("Alien War")
play_button = Button(ai_settings, screen, "Play")
stats = GameStats(ai_settings)
sb = ScoreBoard(ai_settings, screen, stats)
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
f.create_fleet(ai_settings, screen, ship, aliens)
# Назначение цвета фона
bg_color = (100, 100, 100)
alien = Alien(ai_settings, screen)
while True:
f.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update()
f.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
f.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets)
f.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button)
def run_game():
"""Engine of the game"""
# Initialize game and create a screen object.
pygame.init()
game_set = Settings()
screen = pygame.display.set_mode(
(game_set.screen_width, game_set.screen_height))
# Setting caption
pygame.display.set_caption("Alien Invasion")
# An instance to store game statistics and create a scoreboard.
stats = GameStats(game_set)
sb = Scoreboard(game_set, screen, stats)
# Make a ship, a group of bullets, and a group of aliens.
ship = Ship(game_set, screen)
flag = 0
# Create the fleet of aliens.
Timer(0.0, gf.create_alien, [game_set, screen]).start()
Timer(8.0, gf.delete_alien, [game_set, screen, ship]).start()
# Start the main loop for the game.
while True:
# Watch for keyboard events.
flag = gf.check_events(game_set, screen, ship, stats, flag)
# End game check
if flag == 1:
break
# Update condition of bullets and ship
ship.update()
Bullet_Norm.bullets.update()
Bullet_Wait.bullets.update()
# Get rid of bullets that have disappeared.
gf.update_bullets(game_set, screen, stats, sb, ship)
gf.update_screen(game_set, screen, stats, sb, ship)
print("Counter : " + (str)(stats.score))
os._exit(0)
def run():
pygame.init()
# load the game settings
settings = Settings()
# create the screen and add a title
screen = pygame.display.set_mode(settings.screen_dimension)
pygame.display.set_caption('BreakOut - Python')
# create the game elements
bar = Bar(screen, settings)
chances = Chances(screen, settings)
score = Score(screen, settings)
ball = Ball(screen, bar, settings, chances, score)
btn_start = Button(screen, 'press space to start')
btn_game_over = Button(screen, 'Game Over')
object_group = []
function.dispose_objects(screen, object_group, score)
while True:
function.check_events(bar, settings, chances, score)
function.update_screen(bar, screen, ball, settings, object_group,
btn_start, btn_game_over, chances, score)
def run_game():
''' Inicjalizacja gry i utworzenie ekranu '''
pygame.init()
kk_settings = Settings()
screen = pygame.display.set_mode(
(kk_settings.screen_width, kk_settings.screen_height))
pygame.display.set_caption('Kołko i krzyżyk')
rectangles = Group()
circles = Group()
crosses = Group()
# utworzenie menu gry
functions.create_menu(screen, kk_settings)
#utworzenie prostokatów planszy
functions.create_rectangles(kk_settings, screen, rectangles)
#rozpoczęcie pętli głównej gry
while kk_settings.game_running:
#sprawdzanie myszki i klawiatury
functions.check_events(rectangles, screen, circles, kk_settings,
crosses)
#odwiezenie ekranu po przejsciu kazdej iteracji
functions.update_screen(kk_settings, screen, rectangles, circles,
crosses)
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("Alien Invasion")
ship = Ship(ai_settings, screen)
alien = Alien(ai_settings, screen)
bullets = Group()
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
#bullets.update()
gf.update_bullets(bullets)
gf.update_aliens(ai_settings, aliens)
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
#print(len(bullets))
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
def run():
#初始化窗口
pygame.init
#创建ai_settings存放Settings对象
ai_settings = Settings()
#设置窗口宽高
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
#设置窗口标题
pygame.display.set_caption('yudi')
#创建雨滴编组
yudis = Group()
#创建雨滴群
f.create_yudis(ai_settings, screen, yudis)
while True:
#监听键盘事件
f.check_events()
#更新雨滴位置
f.update_yudis(ai_settings, screen, yudis)
#更新窗口
f.update_screen(ai_settings, screen, yudis)
def game():
pygame.init()
game_settings = settings.Settings()
screen = pygame.display.set_mode(
(game_settings.width, game_settings.height))
pygame.display.set_caption("Space Invaders")
play_button = play.Button(settings, screen, "Play")
stats = statistics.GameStats(game_settings)
scoreboard = score.Score(game_settings, screen, stats)
player_render = ship.Ship(screen, game_settings)
bullets = pygame.sprite.Group()
alien_group = pygame.sprite.Group()
functions.alien_fleet(game_settings, screen, alien_group)
while True:
functions.check_events(game_settings, screen, player_render, bullets,
play_button, stats, alien_group, scoreboard)
if stats.game_active:
player_render.update()
functions.update_bullets(alien_group, bullets, screen,
game_settings, scoreboard, stats)
functions.update_aliens(game_settings, stats, player_render,
alien_group, screen, bullets, scoreboard)
functions.update_screen(game_settings, screen, player_render,
alien_group, bullets, play_button, stats,
scoreboard)
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("邓明星大战外星人！")
bg_color = ai_settings.bg_color
ship = Ship(ai_settings, screen)
aliens = Group()
bullets = Group()
# 创建外星人群
gf.creat_fleet(ai_settings, screen, ship, aliens)
# 主循环开始
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
gf.update_aliens(ai_settings, aliens)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
def run_game():
pygame.init()
ai_setting = setting()
scree = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_hight))
aliens = Group()
ship = Ship(scree, ai_setting)
alien = Alien(ai_setting, scree)
gf.create_fleet(ai_setting, scree, ship, aliens)
bullets = Group()
pygame.display.set_caption('New game')
stats = GameStats(ai_setting)
sb = Scoreboard(ai_setting, scree, stats)
play_button = Button(ai_setting, scree, "Play")
while True:
gf.check_events(ship, ai_setting, scree, bullets, stats, play_button,
aliens)
if stats.game_active:
ship.update()
gf.update_aliens(ai_setting, aliens, ship, stats, bullets, scree)
gf.update_bullet(ai_setting, scree, ship, aliens, bullets, sb,
stats)
gf.update_screen(ai_setting, scree, ship, bullets, aliens, play_button,
stats, sb)
def run_game():
pygame.init()
ai_settings = Settings
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
alien = Alien(ai_settings, screen)
pygame.display.set_caption("Invasion2.0")
play_button = Button(ai_settings, screen, "Play")
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
# main loop
while True:
gf.check_events(ai_settings, screen, stats, play_button, ship, aliens,
bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, ship, aliens, bullets,
stats)
gf.update_aliens(ai_settings, stats, screen, ship, aliens, bullets)
gf.update_screen(ai_settings, screen, stats, ship, aliens, bullets,
play_button, sb)
def run_game():
# initialize game and create screen object
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(settings.screen_res)
pygame.display.set_caption("Alien Invasion")
stats = Stats()
ship = Ship(screen)
bullets = Group()
aliens = Group()
play_button = Button(settings, screen, 'Play')
scoreboard = Scoreboard(settings, screen, stats)
fun.create_fleet(settings, screen, aliens, ship.rect.height, stats)
# start the main loop for the game
while True:
fun.check_events(settings, screen, ship, bullets, stats, aliens, play_button, scoreboard)
if stats.game_active:
ship.update()
bullets.update()
aliens.update()
fun.drop_aliens(aliens)
fun.collide(ship, aliens, bullets, settings, stats)
fun.delete_bullets(bullets)
fun.update_screen(screen, settings, ship, bullets, aliens, stats, play_button, scoreboard)
def run_game():
pygame.init()
ai_settings = settings.Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
#screen=pygame.display.set_mode((1200,800))
#bg_color=(200,200,222)
pygame.display.set_caption("alien invasion")
ship = Ship(ai_settings, screen)
play_button = Button(ai_settings, screen, "play")
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
#存储子弹
bullets = Group()
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
#开始游戏的主循环
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
bullets, aliens)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets)
#每次循环都重绘屏幕
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button)
def run():
pygame.init()
game_settings = Settings()
screen = pygame.display.set_mode(
(game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
play_button = Button(game_settings, screen, "Play")
stats = GameStats(game_settings)
sb = Scoreboard(game_settings, screen, stats)
ship = Ship(game_settings, screen)
bullets = Group()
aliens = Group()
f.create_fleet(game_settings, screen, ship, aliens)
while True:
f.check_events(game_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update()
f.update_bullets(game_settings, screen, stats, sb, play_button,
ship, aliens, bullets)
f.update_aliens(game_settings, stats, sb, screen, ship, aliens,
bullets)
f.update_screen(game_settings, screen, stats, sb, ship, aliens,
bullets, play_button)
def run_game():
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(settings.screen_size)
stats = Stats()
scoreboard = Scoreboard(screen, stats)
button = Button(screen, 'play')
pygame.display.set_caption('Snake')
blocks = Group()
foods = Group()
snake1 = Snakes(screen, settings.color1, blocks, 1)
snake2 = Snakes(screen, settings.color2, blocks, -1)
food1 = Food((125, 0, 0), blocks, screen, foods, 1)
food2 = Food((0, 125, 0), blocks, screen, foods, -1)
while True:
pygame.display.flip()
input.check(snake1, snake2, button, stats, blocks)
if stats.active:
snake1.update(blocks, foods, stats, scoreboard)
snake2.update(blocks, foods, stats, scoreboard)
f.update_screen(screen, settings, snake1, snake2, foods, scoreboard,
button, stats)
sleep(0.2)
def run_game():
# Initialize game and create a screen object.
pygame.init()
bstats_settings = Settings()
screen = pygame.display.set_mode(
(bstats_settings.screen_width, bstats_settings.screen_height))
pygame.display.set_caption("Basketball Scoring")
# Create an instance to store game statistics.
stats = ScoreStats(bstats_settings)
# Create a scoreboard object
sb = Scoreboard(bstats_settings, screen, stats)
# Make the play button
play_button = Button(bstats_settings, screen, "Play")
playerdict = {}
teams = []
# Open Player List CSV, and get players from file in a dictionary
csvfunc.read_playersCSV(bstats_settings, playerdict, teams)
# List of team objects
# teams = [
# Team(bstats_settings, 'A', -1, 'Home'),
# Team(bstats_settings, 'B', -2, 'Away')
# ]
# Populate teamlist of team object with correct player
for team in teams:
for player in playerdict.values():
if player.team == team.team:
team.teamlist.append(player)
# bstats_settings.get_playerdict(playerdict)
# Make the stats buttons for players and put it in a dictionary, buttons
buttons = func.make_stats_buttons(bstats_settings, teams, screen)
# Create player stats class object
pstats = Playerstats(bstats_settings, screen, teams)
# Create a running score class object
runScore = RunningScore(bstats_settings, screen, teams)
# Make a player
# player = players.Player('Lorelei', 5)
# Start the main loop for the game.
while True:
func.check_events(stats, buttons, playerdict, play_button,
bstats_settings, teams, runScore)
func.update_screen(stats, bstats_settings, screen, play_button,
buttons, playerdict, sb, pstats, teams, runScore)
def run_level(levels, current_level, wof_settings, screen, stats):
# select the current level map
levelMap = levels[current_level]
# the level status
status = None
# load sounds for events
sound_diamond = pygame.mixer.Sound(wof_settings.sounds['diamond'])
sound_bomb = pygame.mixer.Sound(wof_settings.sounds['bomb'])
sound_blot = pygame.mixer.Sound(wof_settings.sounds['blot'])
# start and play background music - infinit loop
pygame.mixer.music.load(wof_settings.bckg_music)
pygame.mixer.music.play(-1)
# create groups and objects
walls = Group() # Make a group to store walls
hero = Hero(wof_settings, screen, levelMap['hero']) # create the hero
bombs = Group() # Make a group to store bombs in
diamonds = Group() # Make a group to store all diamonds in
explosions = Group() # Make a group to store all explosions in
inkblots = Group() # Make a group to store all inkblots in
deaths = Group() # # Make a group to store all deaths in
# Create Walls according to the level map
fns.create_walls(wof_settings, screen, walls, levelMap)
# Create Diamonds according to the level map
fns.create_diamonds(wof_settings, screen, diamonds, levelMap)
# Create Inkblots according to the level map
fns.create_inkblots(wof_settings, screen, inkblots, levelMap)
# Create Deaths according to the level map
fns.create_deaths(wof_settings, screen, deaths, levelMap)
while wof_settings.running:
# here is the game logic
status = fns.check_events(wof_settings, screen, hero,
bombs) # check if keys pressed or released
hero.update(walls) # update Hero position and state
fns.update_inkblots(inkblots, walls, diamonds, hero, levelMap,
sound_blot, stats)
fns.update_deaths(hero, deaths, walls, inkblots, diamonds, stats)
fns.update_diamonds(hero, diamonds, sound_diamond, stats)
fns.update_bombs(wof_settings, screen, bombs, explosions, sound_bomb,
stats)
fns.update_explosions(explosions, inkblots, hero, deaths, stats)
fns.update_screen(wof_settings, screen, walls, hero, diamonds, bombs,
explosions, inkblots, deaths)
if not hero.alive:
status = 'replay'
wof_settings.running = False
pygame.mixer.music.stop()
return status
def main():
pygame.init()
screen = pygame.display.set_mode((400, 300))
pygame.display.set_caption("按键测试")
message = Message(screen, 'Press a key...')
while True:
func.check_events(message)
func.update_screen(screen, message)
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("Alien Invasion")
ship = Ship(ai_settings,screen)
while True:
gf.check_events(ship)
ship.update()
gf.update_screen(ai_settings,screen,ship)
def run_game():
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Game Character")
game_char = Character(screen)
while True:
f.check_events()
f.update_screen(settings, screen, game_char)
def run_game():
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Rocket")
rocket = Rocket(settings, screen)
while True:
f.check_events_rocket(rocket)
rocket.update()
f.update_screen(settings, screen, rocket)
def game():
# Instantiate objects 1
settings = Settings()
# GUI display
screen = pygame.display.set_mode(settings.size)
pygame.display.set_caption("JumpUp!")
# Instantiate objects 2
player = Player(screen)
plats = Group()
score = Score(screen, settings)
play_again = GameOver(screen, settings)
clock = pygame.time.Clock()
# create the first instance of a platform
new_plat = JPlatform(screen, settings)
plats.add(new_plat)
new_plat.update()
new_plat.draw_me()
# update screen
pygame.display.flip()
# draw player on the top of the first platform.
player.rect.centerx = new_plat.rect.centerx
player.rect.bottom = new_plat.rect.top
# [0] - x and [1] - y velocity
velocity = [settings.x_speed, settings.jump_speed * (-1)]
# [0] - negative x, [1] - positive x [2] - jumping
movement = [False, False, False]
# first image for animation
image_no = [1]
# create initial previous position
#for not getting an error on the first frame
prev_pos = [-30]
while True:
# check if the ball is still in game
if f.still_playing(player, settings) == True:
score.update_time() # update score by the second
score.check_highscore() # check whether we beat the highscore
delta_t = clock.tick(settings.fps) / 1000
f.create_platform(player, screen, settings, clock, plats)
f.check_events(player, movement)
f.moving_the_ball(player, screen, settings, movement, plats,
velocity, delta_t, prev_pos)
f.animate_the_ball(player, movement, image_no)
f.update_screen(f.still_playing(player, settings), screen,
settings, player, play_again, plats, score)
else:
f.update_screen(f.still_playing(player, settings), screen,
settings, player, play_again, plats, score)
score.save_highscore() # save the current highscore
if f.check_quit() == False:
game()
def main():
pygame.init()
ms_settings = Settings()
ms_screen = pygame.display.set_mode(ms_settings.screen_size())
pygame.display.set_caption(ms_settings.caption)
ms_clock = pygame.time.Clock()
ms_minautor = Minautor(ms_screen, ms_settings)
ms_swarm = [
Theseus(ms_screen, ms_settings, ms_minautor) for i in range(25)
]
while True:
ms_clock.tick(ms_settings.FPS)
event_check()
update_screen(ms_screen,
ms_settings,
characters=[*ms_swarm, ms_minautor])
def run():
pygame.init()
sets = Set()
screen = pygame.display.set_mode((sets.width, sets.height))
stats = GameStats(sets)
bird = Bird(sets, screen)
blocks = Group()
pygame.display.set_caption("小鸟闯关")
f.create_blocks(sets, screen, blocks, bird)
while True:
f.check_events(bird)
if stats.game_active:
bird.update()
f.update_blocks(sets, stats, bird, screen, blocks)
f.update_screen(sets, screen, bird, blocks)
def main():
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("ROCKET")
#make rocket
rocket = Rocket(settings=settings, screen=screen)
while True:
functions.check_events(rocket=rocket)
rocket.update()
functions.update_screen(settings=settings,
screen=screen,
rocket=rocket)
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("Raindrops")
rain_drop = Group()
bg_color = (230, 230, 230)
raindrops = Group()
while True:
gf.check_events()
if ai_settings.new_grid:
gf.create_grid(ai_settings, screen, rain_drop)
gf.rain_update(ai_settings, rain_drop)
gf.update_screen(ai_settings, screen, rain_drop)
def run_game():
pygame.init()
pygame.display.set_caption("Mario")
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
scores = Scoreboard(ai_settings, screen)
music = Music()
g_blocks = Group()
bg_blocks = Group()
enemies = Group()
chunks = Group()
items = Group()
pygame.mixer.set_reserved(0)
pygame.mixer.set_reserved(1)
pygame.mixer.set_reserved(2)
pygame.mixer.set_reserved(3)
pygame.mixer.set_reserved(4)
pygame.mixer.set_reserved(5)
monitor = Monitor(ai_settings, screen, g_blocks, bg_blocks, chunks,
enemies, items)
mario = Mario(ai_settings, screen, g_blocks, bg_blocks, enemies, monitor,
chunks, items, scores)
while True:
gf.check_events(ai_settings, screen, mario, g_blocks, bg_blocks, items,
music)
mario.update(music, mario)
gf.check_time(ai_settings, scores, mario)
gf.check_lives(ai_settings, scores)
music.check_star(mario)
music.check_dies(mario)
music.check_win(mario)
music.check_win2(mario)
music.change_bg_music()
gf.update_screen(ai_settings, screen, mario, g_blocks, bg_blocks,
enemies, monitor, chunks, items, scores, music)
mainClock.tick(40)
def play_chess():
"""Inicjalizacja programu i wczytywanie początkowych wartości."""
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Chess")
#Lista pól, które mogą być atakowane przez figury danego koloru.
check_white = []
check_black = []
#Tworzenie szachownicy i figur.
chess_board = Group()
board_pieces = Group()
create_board_and_pieces(settings, screen, chess_board, board_pieces,
check_white, check_black)
#Lista, w której będą się zjadnowały pola mozliwo do zasłonięcia,
#jeżeli król będzie szachowany prze figure poszuszajacą się rzędem.
king_attack_path = []
#Sprawdzenie możliwych ruchów poszczególnych figur.
fct.check_moves(board_pieces, chess_board, check_white, check_black,
king_attack_path)
#Lista w której będzie znajdował się znacznik pokazujący wybrane
#pole.
highlight = []
#Lista w której będzie znajdował się komunikat końca gry.
game_end = []
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
#Aktywowanie funkcji, tylko raz podczas kliknięcia.
if not settings.clicked:
fct.button_click(settings, screen, chess_board, highlight,
check_white, check_black, board_pieces,
game_end, king_attack_path)
elif event.type == pygame.MOUSEBUTTONUP:
#Umożliwienie ponownych aktywacji funkcji przy kolejnych
#kliknięciach.
settings.clicked = False
#Wyświetlenie obiektów szacownicy.
fct.update_screen(screen, chess_board, board_pieces, highlight,
game_end)
def rungame():
#initializin pygame,settings,and scr objs
pygame.init()
s = Settings()
screen = pygame.display.set_mode((s.screen_width,s.screen_height))
pygame.display.set_caption("CORONA INVASION!")
#make the play button
play_button = Button(s,screen,"Play")
#create instance to store game statistics and create a scoreboard
stats = GameStats(s)
sb = Scoreboard(s,screen,stats)
#time to make a ship
sanit = Sanitizer(s , screen)
#make a virus
#coro = Coro(s,screen) ####optional for now
#making a group to store bullets in
bubbles = Group()
coros = Group()
#create fleet of viruses
f.create_fleet(s,screen,sanit,coros)
#main loop for the game
while True:
f.check_events(s,screen,stats,sb,play_button,sanit,coros,bubbles)
bubbles.update()
if stats.game_active:
sanit.update()
f.update_bubbles(s,screen,stats,sb,sanit,coros,bubbles)
f.update_coros(s,screen,stats,sb,sanit,coros,bubbles)
f.update_screen(s,screen,stats,sb,sanit,coros,bubbles,play_button)
def main():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
bullets = Group()
enemies = Group()
enemybullets = Group()
enemy = Enemy(ai_settings, screen)
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
play_button = Button(ai_settings, screen, "Play")
pygame.display.set_caption("Space Battle")
player = Player(ai_settings, screen)
bground = pygame.image.load('images/wallhaven-41034.bmp')
x = 0
#main loop
while True:
gf.check_events(ai_settings, screen, stats,sb, play_button, player,enemies, bullets)
if stats.game_active:
player.update()
gf.update_bullets(ai_settings, screen, stats, sb, player, enemies,bullets)
gf.update_enemy(ai_settings, screen, stats,sb, player,enemies, bullets)
gf.update_screen(ai_settings, screen, stats, sb, player, enemies, bullets, play_button)
#moving background
screen.fill((0,0,0))
rel_x = x % bground.get_rect().width
screen.blit(bground, (rel_x - bground.get_rect().width,0))
if rel_x < ai_settings.screen_width:
screen.blit(bground, (rel_x,0))
x -= 3
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("Pong")
play_button = Button(settings, screen, "Play")
player = Player(settings, screen)
ball = Ball(settings, screen)
ai = Ai(settings, screen)
audio = Audio()
sb = Scorebord(settings, screen, audio)
# Start the main loop for the game.
while True:
func.check_events(player, settings, ai, play_button, audio, ball)
if settings.game_active:
func.updates(player, ai, ball, settings)
func.update_screen(settings, screen, player, ball, ai, sb, play_button, audio)
pygame.time.Clock().tick(settings.game_speed)
def run_game():
#Initialize and create screen project
pygame.init()
game_settings = Settings()
# screen = pygame.display.set_mode((1200,800))
screen = pygame.display.set_mode(
(game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption("Rocket game")
# make a rocket
rocket = Rocket(game_settings, screen)
# Make a group to store bullets in.
bullets = Group()
aliens = Group()
fn.create_fleet(game_settings, screen, rocket, aliens)
# Main loop
while True:
# Watch for keyboard and mouse events
fn.check_events(game_settings, screen, rocket, bullets)
rocket.update()
fn.update_bullets(bullets)
fn.update_screen(game_settings, screen, rocket, aliens, bullets)
def run():
# Initialize game, settings and create a screen object
pygame.init()
settings = Settings()
screen_setup = display.build(settings)
screen = screen_setup[0]
pygame.display.set_caption("Fake It Til You Make It")
# Change screen dims to match fullscreen dims
settings.screen_width = screen_setup[1]
settings.screen_height = screen_setup[2]
# create variables for screen center
scx = settings.screen_width / 2
scy = settings.screen_height / 2
# Make Main Menu
buttons = []
play_button = Button(settings, screen, "NEW GAME", scx - 100, 500, 300, 75, (0, 0, 0), None)
quit_button = Button(settings, screen, "QUIT", scx - 100, 600, 300, 75, (0, 0, 0), None)
buttons.append(play_button)
buttons.append(quit_button)
# Make Ingame Menu
ig_buttons = []
inv_button = Button(settings, screen, "INVENTORY", settings.screen_width * 0.2 - 100, 100, 300, 75, (0, 0, 0), None)
craft_button = Button(settings, screen, "CRAFT", settings.screen_width * 0.35 - 100, 100, 300, 75, (0, 0, 0), None)
build_button = Button(settings, screen, "BUILD", settings.screen_width / 2 - 100, 100, 300, 75, (0, 0, 0), None)
character_button = Button(
settings, screen, "CHARACTER", settings.screen_width * 0.65 - 100, 100, 300, 75, (0, 0, 0), None
)
menu_button = Button(settings, screen, "MENU", settings.screen_width * 0.8 - 100, 100, 300, 75, (0, 0, 0), None)
ig_buttons.append(inv_button)
ig_buttons.append(craft_button)
ig_buttons.append(build_button)
ig_buttons.append(character_button)
ig_buttons.append(menu_button)
# Make Loot PIP menu
lp_buttons = []
lp_title = Button(settings, screen, "", scx - 250, scy - 200, 500, 50, (0, 0, 0), None, 20)
lptake_button = Button(settings, screen, "TAKE", scx + 25, scy - 125, 200, 50, (0, 0, 0), None, 20)
lpdesc_button = Button(settings, screen, "", scx + 25, scy - 50, 200, 175, (0, 0, 0), None, 10)
lp_window = Button(settings, screen, "", scx - 250, scy - 150, 500, 300, (100, 100, 100), None)
lp_loot_window = Button(settings, screen, "", scx - 225, scy - 125, 200, 250, (180, 180, 180), None)
lp_loot = Button(settings, screen, "", scx - 215, scy - 115, 180, 230, (250, 250, 250), None)
lp_buttons.append(lp_title)
lp_buttons.append(lp_window)
lp_buttons.append(lptake_button)
lp_buttons.append(lpdesc_button)
lp_buttons.append(lp_loot_window)
lp_buttons.append(lp_loot)
# Create a stats instance
stats = Stats(settings)
# Create item groups
player = Player(settings, screen)
furniture = Group()
items = Group()
loots = Group()
customers = Group()
# Create clock to stabilize framerate
clock = pygame.time.Clock()
# Initialize Global Variables
day = 1
hour = 6
minute = 0
while True:
clock.tick(100)
gf.check_events(settings, screen, stats, buttons, ig_buttons, lp_buttons, loots)
gf.update_screen(settings, screen, stats, buttons, ig_buttons, lp_buttons, player, loots)
