def run_game():
#Инициализация игры и создание объекта на экране
#timer = pygame.time.Clock()
pygame.init()
ai_setting = Settings()
screen = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_height))
pygame.display.set_caption("Arcanoid")
platform = Platform(ai_setting, screen)
bricks = Group()
ball = Ball(ai_setting, screen, platform, bricks)
#блок музыки - начало игры
music_file = "mus/title.mp3"
pygame.mixer.music.load(music_file)
pygame.mixer.music.play() #Проигрываем5
#
# Create the wall of bricks.
gameF.create_wall(ai_setting, screen, platform, bricks)
#Запуск основного цикла в игре
while True:
# timer.tick(240)
if (ai_setting.life == 0):
break
gameF.checkEvents(platform) #Функция реагирования на события
platform.update() #Обновление платформы
ball.update() #Обновление мяча
gameF.updateScreen(ai_setting, screen, platform, ball,
bricks) #Функция перерисовки экрана
def runGame():
# Initialize game, settings and screen object
pygame.init()
drSettings = Settings()
screen = pygame.display.set_mode(
(drSettings.screenWidth, drSettings.screenHeight))
pygame.display.set_caption("Drag Race")
totalTime = 0
# Make the car
car = Car(drSettings, screen)
# Initialize the timer, gear text and speed
hud = HeadUpDisplay(drSettings, screen, totalTime, car)
# Store the game statistics
stats = GameStats()
# Start the main loop for the game
while True:
# Check for keypresses
gf.checkEvents(car, stats)
# Update the game active state
if not car.onScreen:
stats.gameActive = False
if stats.gameActive:
# Update the position of the car and the hud
car.update()
hud.update(stats.totalTime, car)
stats.totalTime += drSettings.timeIncrement
# Update the screen
gf.updateScreen(drSettings, screen, car, hud)
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("Alien Invasion")
#Make a ship
ship = Ship(ai_settings,screen)
#Make a group to store bullets in (similar to lists)
bullets = Group()
#Make a group of Aliens
aliens = Group()
#Create a fleet of aliens
gf.createFleet(ai_settings, screen, ship, aliens)
# Start the main loop for the game.
while True:
# Watch for keyboard and mouse events.
gf.checkEvents(ai_settings, screen, ship, bullets)
ship.update()
gf.updateBullets(bullets)
gf.updateAliens(ai_settings, aliens)
gf.updateScreen(ai_settings, screen, ship, aliens, bullets)
def runGame(): #funcion que iniciara el juego
pygame.init()
aiSettings = Config()
screen = pygame.display.set_mode(
(aiSettings.screenW, aiSettings.screenH
)) #instanciamos el objeto para definir las dimensiones de la ventana
imagen_defondo = pygame.image.load("images/space.jpg").convert()
rectangulo = imagen_defondo.get_rect()
screen.blit(imagen_defondo, (0, 0))
pygame.display.set_caption("ALIEN INVASION") #Titulo de nuestra ventana
pygame.mixer.init()
pygame.display.init()
bgCOLOR = (230, 230, 230)
ship = Ship(aiSettings, screen)
meteor = Meteor(aiSettings, screen)
bullets = Group()
meteoritos = Group()
tiempo = 1
puntuacion = 0
letra = pygame.font.SysFont("Arial", 18)
while True:
if tiempo == 1 or tiempo % 100 == 0:
meteor = Meteor(aiSettings, screen)
meteoritos.add(meteor)
gf.check_events(ship, aiSettings, screen, bullets)
ship.update()
bullets.update()
meteoritos.update()
gf.updateScreen(aiSettings, screen, ship, meteoritos, bullets)
ship.animation()
for bullet in bullets.copy():
if bullet.rect.left >= 1200:
bullets.remove(bullet)
for x in meteoritos.copy():
if x.rect.right <= 0:
meteoritos.remove(x)
if pygame.sprite.groupcollide(meteoritos, bullets, True, True):
puntuacion += 1
print(puntuacion)
gf.updateScreen(aiSettings, screen, ship, meteoritos, bullets)
screen.blit(imagen_defondo, (0, 0))
tiempo += 1
def runGame():
pygame.init()
aiSettings = Settings()
screen = pygame.display.set_mode(
(aiSettings.screenWidth, aiSettings.screenHeight))
pygame.display.set_caption("Alien Invision")
ship = Ship(aiSettings, screen)
bullets = Group()
while True:
# gf.checkEvents(ship)
gf.checkEvents(aiSettings, screen, ship, bullets)
ship.update()
gf.updateBullets(bullets)
gf.updateScreen(aiSettings, screen, ship, bullets)
def startGame():
setting = Settings()
pg.init()
screen = pg.display.set_mode(
(setting.screen_width, setting.screeen_height))
pg.display.set_caption('Alien: Isolation')
ship = Ship(screen)
while True:
gf.checkEvents(ship) # цикл обработки событий
ship.update()
gf.updateScreen(setting, screen,
ship) # функция отрисовки/обновления экрана
def run_game():
pygame.init()
pygame.mixer.init()
pygame.mixer.music.load("images/music.mp3")
pygame.mixer.music.play(-1, 130.0)
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Aliens")
stats = GameStats(ai_settings)
playButton = Button(ai_settings, screen, "Play")
highScore = HighScores(screen, ai_settings)
score = Score(ai_settings, screen, "Wave#: " + str(stats.waveNumber),
stats)
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
stars = Group()
badBullets = Group()
barriers = Group()
gf.makeBarriers(barriers, screen, ai_settings)
gf.createFleet(ai_settings, screen, ship, aliens)
highScore.prepScores()
screen.fill(ai_settings.bg_color)
while True:
screen.fill(ai_settings.bg_color)
gf.updateBackground(ai_settings, screen, stars)
gf.drawBarrier(barriers)
gf.check_events(ai_settings, screen, ship, stats, playButton, aliens,
bullets, barriers)
gf.updateScreen(ai_settings, screen, stats, ship, aliens, bullets,
playButton, score, badBullets)
if stats.gameActive:
ship.update()
gf.barriersCollide(barriers, bullets)
gf.updateBullets(ai_settings, screen, stats, ship, aliens, bullets,
badBullets, highScore, barriers)
gf.updateAliens(ai_settings, stats, screen, ship, aliens, bullets,
highScore, badBullets)
gf.badShotting(aliens, badBullets, ai_settings, screen)
else:
highScore.prepScores()
highScore.drawScores()
pygame.display.flip()
def run_game():
# Initialisiere das Spiel.
pygame.init()
# mySettings ist eine Instanz der Klasse Settings aus der Datei settings.
mySettings = settings.Settings()
# Spiel im Fenstermodus. Sinnvoll bei der Fehlersuche.
# Darum ist die Zeile auskommentiert.
# So kann die Zeile einfach wieder aktiviert werden.
screen = pygame.display.set_mode((mySettings.screenWidth, mySettings.screenHight))
# Spiel im Vollbilsmodus.
#screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
pygame.display.set_caption(mySettings.windowCaption)
# Schalte die Maus aus, damit sie nicht mehr sichtbar ist.
pygame.mouse.set_visible(False)
# einstellen der fps
clock = pygame.time.Clock()
font = pygame.freetype.Font("fonts/sans.ttf")
gameRunning = True
# myShip ist eine Instanz der Klasse Ship aus der Datei ship.
myShip = ship.Ship(screen)
bullets = pygame.sprite.Group()
asteroids = pygame.sprite.Group()
# Starte die Hauptschleife des Spiels.
if mySettings.gameRunning == True:
while True:
clock.tick(mySettings.fps)
gf.checkEvents(mySettings, screen, myShip, bullets)
myShip.update()
gf.updateBullets(bullets, asteroids)
gf.updateAsteriods(mySettings, screen, asteroids)
gf.updateScreen(mySettings, screen, myShip, bullets, asteroids)
if mySettings.gameRunning == False:
break
if mySettings.gameRunning == False:
while True:
gf.checkEventNewGame(mySettings)
if mySettings.newGame == True:
break
if mySettings.newGame == True:
mySettings.newGame = False
run_game()
def runGame():
#runs the game and sets proper display resolution
pygame.init()
gameSettings = Settings()
screen = pygame.display.set_mode(
(gameSettings.screen_width, gameSettings.screen_height
) #imports screen resolution from settings.py
)
#create an instance to store the game's stats
stats = gameStats(gameSettings)
#draws the ship on the screen, creates a group of bullets, and a group of aliens
ship = Ship(gameSettings, screen)
bullets = Group()
aliens = Group()
#create first fleet of aliens
gf.createFleet(gameSettings, screen, ship, aliens)
#main loop for the game
while True:
#window title
pygame.display.set_caption("Space Invaders Ripoff")
#draw the play button
playButton = Button(gameSettings, screen, "PLAY")
#draw everything on screen constantly
screen.fill(gameSettings.bgColor)
ship.blit()
#updates the ship based on real-time occurences in-game
gf.checkEvents(gameSettings, screen, stats, playButton, ship, aliens,
bullets)
if stats.gameActive:
ship.update()
gf.updateBullets(gameSettings, screen, ship, aliens, bullets)
gf.updateAliens(gameSettings, stats, screen, ship, aliens, bullets)
gf.updateScreen(gameSettings, screen, stats, ship, aliens, bullets,
playButton)
#drawing the most recent screen refresh
pygame.display.flip()
def runGame():
pygame.init()
pongSettings = Settings()
screen = pygame.display.set_mode(
(pongSettings.screenWidth, pongSettings.screenHeight))
pygame.display.set_caption("Pong 2")
paddleTopBottom = Group()
paddleLeftRight = Group()
paddle = Paddle(pongSettings, screen, "player", "bottom")
paddle3 = Paddle2(pongSettings, screen, "right")
paddle5 = Paddle(pongSettings, screen, "player", "top")
paddle2 = Paddle2(pongSettings, screen, "left")
paddle4 = Paddle(pongSettings, screen, "AI", "top")
paddle6 = Paddle(pongSettings, screen, "AI", "bottom")
paddleTopBottom.add(paddle, paddle4, paddle5, paddle6)
paddleLeftRight.add(paddle2, paddle3)
ball = Ball(pongSettings, screen)
divide = Divider(pongSettings, screen)
play_button = Button(pongSettings, screen, "Play")
sb = Scoreboard(pongSettings, screen)
startScreen = Start(pongSettings, screen)
while True:
gf.checkEvents(pongSettings, paddle, paddle3, paddle5, play_button, sb)
if pongSettings.gameActive:
gf.checkPaddleBallCollision(ball, paddleTopBottom, paddleLeftRight,
pongSettings)
gf.checkOutOfBounds(ball, pongSettings, screen, sb)
paddle.update(ball)
paddle2.update(ball)
paddle3.update(ball)
paddle4.update(ball)
paddle5.update(ball)
paddle6.update(ball)
ball.update()
gf.updateScreen(pongSettings, screen, paddle, paddle2, paddle3,
paddle4, paddle5, paddle6, ball, divide, sb)
else:
gf.startGame(play_button, startScreen)
def runGame():
pygame.init()
aiSettings = Settings()
screen = pygame.display.set_mode((aiSettings.screenWidth, aiSettings.screenHeight))
pygame.display.set_caption("Alien Invasion")
stats = GameStats(aiSettings)
ship = Ship(aiSettings, screen)
bullets = Group()
aliens = Group()
gf.createFleet(aiSettings, screen, aliens, ship)
playButton = Button(aiSettings, screen, "Play")
sb = Scoreboard(aiSettings, screen, stats)
while True:
gf.checkEvents(aiSettings, screen, ship, bullets, aliens, stats, playButton, sb)
if stats.gameActive:
ship.update()
gf.updateBullets(aiSettings, bullets, aliens, screen, ship, stats, sb)
gf.updateAliens(aiSettings, stats, screen, aliens, bullets, ship, sb)
gf.updateScreen(aiSettings, screen, ship, bullets, aliens, stats, playButton, sb)
def runGame():
# Initialize game and create a screen object.
pygame.init() # initialize background settings
pygame.display.set_caption("Alien Invasion")
# Set background size.
aiSettings = Settings()
screen = pygame.display.set_mode(
(aiSettings.screenWidth, aiSettings.screenHeight))
# Make a ship.
ship = Ship(aiSettings, screen)
# Start main loop for the game.
while True:
# Watch for keyboard and mouse events.
gf.checkEvents(ship)
ship.update()
gf.updateScreen(aiSettings, screen, ship)
def runGame():
pygame.init()
pygame.display.set_caption("Pong")
settings = Settings()
gameStats = GameStats()
screen = pygame.display.set_mode(
(settings.screenWidth, settings.screenHeight))
menu = Menu()
button = Button(screen, settings, "Play")
scores = ScoreBoard(screen, settings, gameStats)
player = Player(screen, settings)
bot = AI(screen, settings, menu)
balls = Group()
newBall = Ball(screen, settings, menu)
balls.add(newBall)
while True:
screen.fill(settings.bgColor)
gf.drawField(screen, settings)
gf.checkEvent(player, settings, menu, gameStats, scores, button)
gf.updateScreen(player, balls, bot, scores)
if gameStats.gameActive == True:
player.update()
bot.update(balls)
balls.update(settings, gameStats, scores, balls)
scores.showScore()
gf.checkBallAmount(screen, settings, bot, balls, menu)
if gameStats.playerScore >= settings.scoreLimit or gameStats.botScore >= settings.scoreLimit:
gf.restartGame(screen, settings, gameStats, player, bot, balls,
menu)
if gameStats.gameActive == False:
button.drawButton()
pygame.mouse.set_visible(True)
menu.drawWin(gameStats, settings)
menu.prepMenu(screen, settings, balls, bot)
menu.drawMenu()
pygame.display.flip()
def run_game():
# intialize
pygame.init()
pygame.mixer.init()
# save y of bGround to move it up
y = 0
bGround = Background('pic/background.png', [0, y])
aiSettings = Setting()
screen = pygame.display.set_mode(
(aiSettings.screenWidth, aiSettings.screenHeight))
pygame.display.set_caption(aiSettings.caption)
# create an instance to store game statistics and scoreboard
stats = GameStats(aiSettings)
sb = Scoreboard(aiSettings, screen, stats)
# sound effect
shootSound = pygame.mixer.Sound(aiSettings.pew)
explosionSound = pygame.mixer.Sound(aiSettings.boom)
wowSound = pygame.mixer.Sound(aiSettings.wow)
failSound = pygame.mixer.Sound(aiSettings.fail)
pygame.mixer.music.load(aiSettings.background)
pygame.mixer.music.set_volume(0.3)
# make ship
ship = Ship(screen, aiSettings)
# make a group to store the bullet
bullets = Group()
# make an alien group
aliens = Group()
# make an explosion group
explode = Group
# play background music
pygame.mixer.music.play(loops=-1)
# start screen
while True:
gf.checkStart(screen, aiSettings, stats)
if not stats.gameActive:
gf.updateStartScreen(screen, aiSettings)
else:
break
# main game
gf.createFleet(aiSettings, screen, ship, aliens)
# start the main loop for the game
while True:
if stats.gameActive:
gf.checkEvents(aiSettings, screen, ship, bullets, shootSound,
stats)
ship.update(screen)
gf.updateBullet(aiSettings, screen, ship, bullets, aliens,
explosionSound, wowSound, stats, sb)
gf.updateAlien(aiSettings, aliens, ship, failSound, stats, screen,
bullets, sb)
gf.updateScreen(screen, ship, bGround, bullets, aliens, sb)
else:
# end screen
gf.checkEnd(screen, aiSettings, stats)
aliens.empty()
bullets.empty()
if not stats.gameActive:
gf.updateEndScreen(screen, aiSettings)
else:
stats.resetStats()
aiSettings.reset()
ship.reset()
def runGame():
#Initialize game and create a window
pg.init()
#create a new object using the settings class
setting = Settings()
#creaete a new object from pygame display
screen = pg.display.set_mode((setting.screenWidth, setting.screenHeight))
#set window caption using settings obj
pg.display.set_caption(setting.windowCaption)
playBtn = Button(setting, screen, "PLAY", 200)
menuBtn = Button(setting, screen, "MENU", 250)
twoPlayBtn = Button(setting, screen, "2PVS", 250)
#setBtnbtn = Button(setting, screen, "SETTING", 300)
aboutBtn = Button(setting, screen, "ABOUT", 300)
quitBtn = Button(setting, screen, "QUIT", 400)
greyBtn = Button(setting, screen, "GREY", 200)
redBtn = Button(setting, screen, "RED", 250)
blueBtn = Button(setting, screen, "BLUE", 300)
#make slector for buttons
sel = Selector(setting, screen)
sel.rect.x = playBtn.rect.x + playBtn.width + 10
sel.rect.centery = playBtn.rect.centery
#Create an instance to stor game stats
stats = GameStats(setting)
sb = Scoreboard(setting, screen, stats)
#Make a ship
ship = Ship(setting, screen)
#Ships for two player
ship1 = Ship(setting, screen)
ship2 = Ship(setting, screen)
#make a group of bullets to store
bullets = Group()
eBullets = Group()
setting.explosions = Explosions()
#Make an alien
aliens = Group()
gf.createFleet(setting, screen, ship, aliens)
pg.display.set_icon(pg.transform.scale(ship.image, (32, 32)))
#plays bgm
pg.mixer.music.load("sounds/galtron.mp3")
pg.mixer.music.set_volume(0.25)
pg.mixer.music.play(-1)
runGame = True
#Set the two while loops to start mainMenu first
while runGame:
#Set to true to run main game loop
while stats.mainMenu:
mm.checkEvents(setting, screen, stats, sb, playBtn, twoPlayBtn,
aboutBtn, quitBtn, menuBtn, sel, ship, aliens,
bullets, eBullets)
mm.drawMenu(setting, screen, sb, playBtn, menuBtn, twoPlayBtn,
aboutBtn, quitBtn, sel)
while stats.playMenu:
pm.checkEvents(setting, screen, stats, sb, playBtn, greyBtn,
redBtn, blueBtn, quitBtn, menuBtn, sel, ship,
aliens, bullets, eBullets)
pm.drawMenu(setting, screen, sb, greyBtn, redBtn, blueBtn, menuBtn,
quitBtn, sel)
while stats.mainGame:
#Game functions
gf.checkEvents(setting, screen, stats, sb, playBtn, quitBtn, sel,
ship, aliens, bullets, eBullets) #Check for events
if stats.gameActive:
gf.updateAliens(setting, stats, sb, screen, ship, aliens,
bullets, eBullets) #Update aliens
gf.updateBullets(setting, screen, stats, sb, ship, aliens,
bullets, eBullets) #Update collisions
ship.update(bullets) #update the ship
#Update the screen
gf.updateScreen(setting, screen, stats, sb, ship, aliens, bullets,
eBullets, playBtn, menuBtn, quitBtn, sel)
while stats.mainAbout:
About.checkEvents(setting, screen, stats, sb, playBtn, quitBtn,
menuBtn, sel, ship, aliens, bullets, eBullets)
About.drawMenu(setting, screen, sb, menuBtn, quitBtn, sel)
while stats.twoPlayer:
tp.checkEvents(setting, screen, stats, playBtn, quitBtn, sel,
bullets, eBullets, ship1, ship2)
if stats.gameActive:
ship1.update(bullets)
ship2.update(bullets)
tp.updateBullets(setting, screen, stats, ship1, ship2, bullets,
eBullets)
tp.updateScreen(setting, screen, stats, bullets, eBullets, playBtn,
menuBtn, quitBtn, sel, ship1, ship2)
while stats.mainGame:
if runGame == True:
print("test")
def runGame():
#Initialize game and create a window
pg.init()
pg.mixer.init()
pg.time.delay(1000)
#create a new object using the settings class
setting = Settings()
#creaete a new object from pygame display
screen = pg.display.set_mode((setting.screenWidth, setting.screenHeight))
#set window caption using settings obj
pg.display.set_caption(setting.windowCaption)
bgm = pg.mixer.Sound('music/背景音乐.ogg')
bgm.set_volume(0.05)
bgm.play(-1)
fps = 120
fclock = pg.time.Clock()
playBtn = Button(setting, screen, "PLAY", 200)
menuBtn = Button(setting, screen, "MENU", 250)
aboutBtn = Button(setting, screen, "ABOUT", 250)
quitBtn = Button(setting, screen, "QUIT", 300)
#make slector for buttons
sel = Selector(setting, screen)
sel.rect.x = playBtn.rect.x + playBtn.width + 10
sel.rect.centery = playBtn.rect.centery
#Create an instance to stor game stats
stats = GameStats(setting)
sb = Scoreboard(setting, screen, stats)
#Make a ship
ship = Ship(setting, screen)
#Ships for two player
ship1 = Ship(setting, screen)
ship2 = Ship(setting, screen)
#make a group of bullets to store
bullets = Group()
#Make an alien
aliens = Group()
gf.createFleet(setting, screen, ship, aliens)
icon = pg.image.load('gfx/SpaceShip.png')
pg.display.set_icon(icon)
runGame = True
#Set the two while loops to start mainMenu first
while runGame:
#Set to true to run main game loop
while stats.mainMenu:
mm.checkEvents(setting, screen, stats, sb, playBtn, aboutBtn, quitBtn, menuBtn, sel, ship, aliens, bullets)
mm.drawMenu(setting, screen, sb, playBtn, menuBtn, aboutBtn, quitBtn, sel)
while stats.mainGame:
#Game functions
gf.checkEvents(setting, screen, stats, sb, playBtn, quitBtn, sel, ship, aliens, bullets) #Check for events
if stats.gameActive:
gf.updateAliens(setting, stats, sb, screen, ship, aliens, bullets) #Update aliens
gf.updateBullets(setting, screen, stats, sb, ship, aliens, bullets) #Update collisions
ship.update() #update the ship
gf.updateScreen(setting, screen, stats, sb, ship, aliens, bullets, playBtn, menuBtn, quitBtn, sel) #Update the screen
fclock.tick(fps)
while stats.mainAbout:
About.checkEvents(setting, screen, stats, sb, playBtn, quitBtn, menuBtn, sel, ship, aliens, bullets)
About.drawMenu(setting, screen, sb, menuBtn, quitBtn, sel)
while stats.mainGame:
if runGame == True:
print("test")
def runGame():
# Initialize game and create a window
pg.init()
# create a new object using the settings class
setting = Settings()
# creaete a new object from pygame display
screen = pg.display.set_mode((setting.screenWidth, setting.screenHeight))
# intro
intro.introimages()
# set window caption using settings obj
pg.display.set_caption(setting.windowCaption)
bMenu = ButtonMenu(screen)
bMenu.addButton("play", "PLAY")
bMenu.addButton("menu", "MENU")
bMenu.addButton("twoPlay", "2PVS")
bMenu.addButton("settings", "SETTINGS")
bMenu.addButton("invert", "INVERT")
bMenu.addButton("about", "ABOUT")
bMenu.addButton("quit", "QUIT")
bMenu.addButton("grey", "GREY")
bMenu.addButton("red", "RED")
bMenu.addButton("blue", "BLUE")
bMenu.addButton("retry", "RETRY")
bMenu.addButton("hard", "HARD")
bMenu.addButton("normal", "NORMAL")
mainMenuButtons = ["play", "about", "settings", "quit"] # delete "twoPlay"
playMenuButtons = ["grey", "red", "blue", "menu", "quit"]
levelMenuButtons = ["hard", "normal", "quit"]
mainGameButtons = ["play", "menu", "quit"]
aboutButtons = ["menu", "quit"]
settingsMenuButtons = ["menu", "invert", "quit"]
bgManager = BackgroundManager(screen)
bgManager.setFillColor((0, 0, 0))
bgManager.addBackground(
"universe_1", "gfx/backgrounds/stars_back.png", 0, 1)
bgManager.addBackground(
"universe_1", "gfx/backgrounds/stars_front.png", 0, 1.5)
bgManager.selectBackground("universe_1")
# Create an instance to stor game stats
stats = GameStats(setting)
sb = Scoreboard(setting, screen, stats)
# Make a ship
ship = Ship(setting, screen)
# Ships for two player
ship1 = Ship(setting, screen)
ship2 = Ship(setting, screen)
# make a group of items to store
items = Group()
# make a group of bullets to store
bullets = Group()
charged_bullets = Group()
eBullets = Group()
setting.explosions = Explosions()
# Make an alien
aliens = Group()
gf.createFleet(setting, stats, screen, ship, aliens)
pg.display.set_icon(pg.transform.scale(ship.image, (32, 32)))
bgImage = pg.image.load('gfx/title_c.png')
bgImage = pg.transform.scale(
bgImage, (setting.screenWidth, setting.screenHeight))
bgImageRect = bgImage.get_rect()
aboutImage = pg.image.load('gfx/About_modify2.png')
aboutImage = pg.transform.scale(
aboutImage, (setting.screenWidth, setting.screenHeight))
aboutImageRect = aboutImage.get_rect()
# plays bgm
pg.mixer.music.load('sound_bgms/galtron.mp3')
pg.mixer.music.set_volume(0.25)
pg.mixer.music.play(-1)
rungame = True
sounds.stage_clear.play()
# Set the two while loops to start mainMenu first
while rungame:
# Set to true to run main game loop
bMenu.setMenuButtons(mainMenuButtons)
while stats.mainMenu:
if not stats.gameActive and stats.paused:
setting.initDynamicSettings()
stats.resetStats()
##stats.gameActive = True
# Reset the alien and the bullets
aliens.empty()
bullets.empty()
eBullets.empty()
# Create a new fleet and center the ship
gf.createFleet(setting, stats, screen, ship, aliens)
ship.centerShip()
mm.checkEvents(setting, screen, stats, sb, bMenu,
ship, aliens, bullets, eBullets)
mm.drawMenu(setting, screen, sb, bMenu, bgImage, bgImageRect)
bMenu.setMenuButtons(levelMenuButtons)
while stats.levelMenu:
lm.checkEvents(setting, screen, stats, sb, bMenu,
ship, aliens, bullets, eBullets)
lm.drawMenu(setting, screen, sb, bMenu, bgImage, bgImageRect)
bMenu.setMenuButtons(playMenuButtons)
while stats.playMenu:
pm.checkEvents(setting, screen, stats, sb, bMenu,
ship, aliens, bullets, eBullets)
pm.drawMenu(setting, screen, sb, bMenu)
bMenu.setMenuButtons(mainGameButtons)
while stats.mainGame:
# Game functions
gf.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens,
bullets, eBullets, charged_bullets) # Check for events
# Reset Game
if gf.reset == 1:
gf.reset = 0
pg.register_quit(runGame())
if stats.gameActive:
gf.updateAliens(setting, stats, sb, screen, ship,
aliens, bullets, eBullets) # Update aliens
gf.updateBullets(setting, screen, stats, sb, ship, aliens, bullets,
eBullets, charged_bullets, items) # Update collisions
gf.updateItems(setting, screen, stats, sb, ship,
aliens, bullets, eBullets, items)
ship.update(bullets, aliens) # update the ship
# Update the screen
gf.updateScreen(setting, screen, stats, sb, ship, aliens,
bullets, eBullets, charged_bullets, bMenu, bgManager, items)
bMenu.setMenuButtons(aboutButtons)
bMenu.setPos(None, 500)
while stats.mainAbout:
About.checkEvents(setting, screen, stats, sb,
bMenu, ship, aliens, bullets, eBullets)
About.drawMenu(setting, screen, sb, bMenu,
aboutImage, aboutImageRect)
while stats.twoPlayer:
tp.checkEvents(setting, screen, stats, sb, bMenu,
bullets, aliens, eBullets, ship1, ship2)
if stats.gameActive:
ship1.update(bullets, aliens)
ship2.update(bullets, aliens)
tp.updateBullets(setting, screen, stats, sb,
ship1, ship2, aliens, bullets, eBullets, items)
tp.updateScreen(setting, screen, stats, sb, ship1,
ship2, aliens, bullets, eBullets, bMenu, items)
bMenu.setMenuButtons(settingsMenuButtons)
while stats.settingsMenu:
sm.checkEvents1(setting, screen, stats, sb, bMenu,
ship, aliens, bullets, eBullets)
sm.drawMenu(setting, screen, sb, bMenu)
while stats.mainGame:
if rungame == True:
print("test")
def runGame():
"""Runs the game, duh!"""
#initialize window and such
settings = Settings()
game.init()
game.font.init()
screen = game.display.set_mode(
(settings.screenWidth, settings.screenHeight))
game.display.set_caption(settings.title)
character = boy(screen)
game.display.set_icon(character.image)
font = Fonts(character)
total = 2
#create a path
pathList = []
for i in range(0, 20):
path = Tile('OverworldPath.png',
screen.get_rect().centerx,
screen.get_rect().bottom - (i * 32), screen, 0)
pathList.append(path)
#create a wall
wallList = []
for i in range(0, 8):
for j in range(0, 8, 2):
wall = Tile('OverworldWall.png',
(screen.get_rect().centerx * 1.5) + (i * 32),
(screen.get_rect().centery * 1.5) + (j * 32), screen,
1)
wallList.append(wall)
for i in range(0, 15):
wall = Tile('OverworldWall.png', 240, 0 + (32 * i), screen, 1)
wallList.append(wall)
for i in range(0, 4):
wall = Tile('OverworldWall.png', 272 + (32 * i), 96 + (32 * i), screen,
1)
wallList.append(wall)
#generate some rocks
rockList = []
for i in range(0, total):
randX = randint(0, 1200 - 32)
randY = randint(0, 800 - 32)
rock = Tile('OverworldRock.png', randX, randY, screen, 1)
rockList.append(rock)
usedMinerals = []
mineral = -1
bossPresent = False
bossCounter = 0
#main loop for game
while True:
if len(usedMinerals) % total == 0 and bossPresent == False and len(
usedMinerals) != 0:
boss1 = Tile('BossRock.png', 583, 120, screen, 1)
bossPresent = True
bossCounter += 1
while len(rockList) > 0:
rockList.pop()
rockList.append(boss1)
if character.stage == "OVERWORLD":
character.walkAnimate()
character.checkCollision(wallList)
if character.checkCollision(rockList) == True:
while True:
mineral = randint(1, 10)
if mineral not in usedMinerals:
break
if bossPresent == True:
enemy = Rock(11 * bossCounter, screen)
else:
enemy = Rock(mineral, screen)
character.stage = "BATTLE"
character.setBattleImage("Battle.png")
character.updatePos()
if character.stage == "BATTLE":
gf.checkEvents(character, font, enemy, rockList, mineral,
usedMinerals, bossPresent)
gf.updateScreen(settings, screen, character, pathList, wallList,
rockList, font, enemy)
else:
gf.checkEvents(character, font)
gf.updateScreen(settings, screen, character, pathList, wallList,
rockList, font)
def runGame():
#initsialise game and create screen object
pygame.init() #To initialise the background settings
cNM_S = Settings(
) # object of the settings class cNM_S stands for "Creeper Nah Man! Settings"
screen = pygame.display.set_mode(
(cNM_S.screen_width, cNM_S.screen_height)
) # We create a display called screen, (1200,800) is a tuple which defines
# the dimensions of the game window.
# The screen object just created is called a surface
# In pygame a surface is part of the screen where we display a game element,eg creeper will be a surface and the Pewdiepie model will be a surface in the game
pygame.display.set_caption("Creeper Nah Man!")
#Make a play button
playButton = Button(cNM_S, screen, "Play")
#Create an instance to store game stats and create a scoreboard
stats = GameStats(cNM_S)
sb = Scoreboard(cNM_S, screen, stats)
#Make a Pewds model, a group of tridents and a group of creepers:-
#Create a Pewdiepie model
pewdsModel = Pewds(
cNM_S, screen
) # Creating an instance of Pewds class , this part is outside while since we do not want to create a new instance of Pewds class on each
#Make a group to store tridents in
tridents = Group()
#The group is created outside the while loop so that we dont create a new group each time we pass through the while loop
#This group will store all the live tridents so that we can manage the tridents that have already been fired by the user
#This group will be an instance of the class pygame.sprite.Group, which behaves like a list with some extra functionality which is helpful when
# building games, we will use this group to draw tridents on the screen on each pass through the main loop (while loop) and to update each tridents'
# position
#Make a group of creepers
creepers = Group()
#Create a collection of creepers
gf.createCreeperCollection(cNM_S, screen, pewdsModel, creepers)
#setting up backround image for the game
bkgnd = pygame.image.load(
"C:\\Users\\Rahul Pillai\\Desktop\\_\\College\\SkillShare\\PythonGameDevelopment\\Codes\\CreeperNahMan\\CreeperNahMan\\CreeperNahMan\\ImageAssets\\bkgnd.png"
)
#.convert() #convert is used since the image needs to be converted to a format Pygame can more easily work with.
#set background color (Already done in Settings.py)
#bg_color=(135,206,250) (Can use this if there was no Settings file)
#start main loop for the game
while True: # while loop that contains the game
screen.blit(
bkgnd, [0, 0]) # to set our background initially before everything
# watch for keyboard and mouse events
gf.checkEvents(cNM_S, screen, stats, sb, playButton, pewdsModel,
creepers,
tridents) #this function exists in gameFunctions.py
#tridents is passed to this function since we need to check the event when space bar is pressed to shoot trident
if stats.gameActive:
pewdsModel.update()
#tridents is passed to this function since we need to update the tridents drawn to the screen so we see the tridents moving up
gf.updateTridents(
cNM_S, screen, stats, sb, creepers, pewdsModel, tridents
) # instead of doing tridents.update() and removal of off screen tridents here
# we have moved that code to a new function in gameFunctions.py
gf.updateCreepers(cNM_S, stats, screen, sb, pewdsModel, creepers,
tridents)
gf.updateScreen(cNM_S, screen, stats, sb, pewdsModel, tridents,
creepers, playButton)
mm.checkEvents(setting, screen, stats, sb, playBtn, twoPlayBtn, aboutBtn, quitBtn, menuBtn, sel, ship, aliens, bullets, eBullets)
mm.drawMenu(setting, screen, sb, playBtn, menuBtn, twoPlayBtn, aboutBtn, quitBtn, sel)
while stats.playMenu:
pm.checkEvents(setting, screen, stats, sb, playBtn, greyBtn, redBtn, blueBtn, quitBtn, menuBtn, sel, ship, aliens, bullets, eBullets)
pm.drawMenu(setting, screen, sb, greyBtn, redBtn, blueBtn, menuBtn, quitBtn, sel)
while stats.mainGame:
#Game functions
gf.checkEvents(setting, screen, stats, sb, playBtn, quitBtn, sel, ship, aliens, bullets, eBullets) #Check for events
if stats.gameActive:
gf.updateAliens(setting, stats, sb, screen, ship, aliens, bullets, eBullets) #Update aliens
gf.updateBullets(setting, screen, stats, sb, ship, aliens, bullets, eBullets) #Update collisions
ship.update(bullets,aliens) #update the ship
#Update the screen
gf.updateScreen(setting, screen, stats, sb, ship, aliens, bullets, eBullets, playBtn, menuBtn, quitBtn, sel)
while stats.mainAbout:
About.checkEvents(setting, screen, stats, sb, playBtn, quitBtn, menuBtn, sel, ship, aliens, bullets, eBullets)
About.drawMenu(setting, screen, sb, menuBtn, quitBtn, sel)
while stats.twoPlayer:
tp.checkEvents(setting, screen, stats, sb, playBtn, quitBtn, sel, ship1, ship2, aliens, bullets, eBullets)
if stats.gameActive:
ship1.update(bullets)
ship2.update(bullets)
# tp.updateBullets(setting, screen, stats, ship1, ship2, bullets, eBullets)
# tp.updateScreen(setting, screen, stats, bullets, eBullets, playBtn, menuBtn, quitBtn, sel, ship1, ship2)
while stats.mainGame:
if runGame == True:
print("test")
bMenu.setMenuButtons(mainGameButtons)
while stats.mainGame:
# Game functions
gf.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens, bullets, eBullets, charged_bullets) # Check for events
# Reset Game
if gf.reset == 1:
gf.reset = 0
pg.register_quit(runGame())
if stats.gameActive:
gf.updateAliens(setting, stats, sb, screen, ship, aliens, bullets, eBullets) # Update aliens
gf.updateBullets(setting, screen, stats, sb, ship, aliens, bullets, eBullets, charged_bullets, items) # Update collisions
gf.updateItems(setting, screen, stats, sb, ship, aliens, bullets, eBullets, items)
ship.update(bullets, aliens) # update the ship
# Update the screen
gf.updateScreen(setting, screen, stats, sb, ship, aliens, bullets, eBullets, charged_bullets, bMenu, bgManager, items)
bMenu.setMenuButtons(aboutButtons)
bMenu.setPos(None, 500)
while stats.mainAbout:
About.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens, bullets, eBullets)
About.drawMenu(setting, screen, sb, bMenu, aboutImage, aboutImageRect)
while stats.twoPlayer:
tp.checkEvents(setting, screen, stats, sb, bMenu, bullets, aliens, eBullets, ship1, ship2)
if stats.gameActive:
ship1.update(bullets, aliens)
ship2.update(bullets, aliens)
tp.updateBullets(setting, screen, stats, sb, ship1, ship2, aliens, bullets, eBullets, items)
tp.updateScreen(setting, screen, stats, sb, ship1, ship2, aliens, bullets, eBullets, bMenu, items)
