def main():
#global donePlaying
#global titleScreen
#global howToPlay
#global mainGame
#global gameOver
#global creditScreen
#global startMenu
#global menu
#global clearSprites
while Globals.donePlaying != True:
print Globals.donePlaying
if Globals.titleScreen == True:
Title.title()
elif Globals.howToPlay == True:
Instructions.instructions()
elif Globals.mainGame == True:
Game.game()
elif Globals.pauseMenu == True:
PauseMenu.pausemenu()
elif Globals.gameOver == True:
GameOver.gameover()
elif Globals.creditScreen == True:
Credits.credits()
elif Globals.winScreen == True:
Win.win()
def mov(tela, y_init, x_init, eixo_x, eixo_y, snake_lst, tam):
Blk = (0, 0, 0)
Cobra = (0, 255, 0)
comida, cx, cy, cor = Foods.Food(tela)
spd = pygame.time.Clock()
pygame.display.update()
pontos = 0
while not False:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT and eixo_x != 5:
eixo_x = -5
eixo_y = 0
elif event.key == pygame.K_RIGHT and eixo_x != -5:
eixo_x = 5
eixo_y = 0
elif event.key == pygame.K_UP and eixo_y != 5:
eixo_x = 0
eixo_y = -5
elif event.key == pygame.K_DOWN and eixo_y != -5:
eixo_x = 0
eixo_y = 5
if y_init < 0 or y_init > 590 or x_init < 0 or x_init > 790:
GameOver.over(tela, pontos)
x_init += eixo_x
y_init += eixo_y
if x_init in range(cx - 10, cx + 10) and y_init in range(
cy - 10, cy + 10):
if comida > 2:
pontos += 1
elif comida >= 1 and comida <= 2:
pontos += 5
else:
pontos += 10
comida, cx, cy, cor = Foods.Food(tela)
tam += 1
tela.fill(Blk)
cabeça = []
cabeça.append(x_init)
cabeça.append(y_init)
snake_lst.append(cabeça)
score(pontos, tela)
if len(snake_lst) > tam:
del snake_lst[0]
for x in snake_lst[:-1]:
if x == cabeça:
GameOver.over(tela, pontos)
pygame.draw.rect(tela, cor, [cx, cy, 10, 10])
snake(snake_lst, tela, Cobra)
pygame.display.update()
spd.tick(60)
def update(self, dt):
x,y = self.sprite.position
xm, ym = self.mirror_sprite.position
if(x <=20 ):
self.run_l = False
self.run_r = False
self.sprite.position = (30,410)
self.mirror_sprite.position = (30,320)
if self.life == 0:
self.life = 3
director.push(ZoomTransition(GameOver.get_gameover(2)))
self.kill()
self.heart1.position = (x-20, y+40)
self.heart2.position = (x, y+40)
self.heart3.position = (x+20, y+40)
if self.run_l:
self.sprite.position = (x - 3, y)
self.mirror_sprite.position = (xm-3, ym)
elif self.run_r:
self.sprite.position = (x + 3, y)
self.mirror_sprite.position = (xm +3, ym)
Level2_Background.scroller_2.set_focus(self.sprite.position[0], self.sprite.position[1])
'''
# first stack --------------------------------------------
self.wolf_action(200, self.green_hound_1, 3, -1, 1)
self.wolf_action(200, self.green_hound_2, 3, -1, 1)
self.beast_action(300,self.hell_beast, self.ball)
# second stack -------------------------------------------
self.wolf_action(200, self.red_hound_1, 3, -1, 1)
self.wolf_action(200, self.red_hound_2, 3, -1, 1)
# third stack --------------------------------------------
self.beast_action(300, self.hell_fire_beast, self.ball_f)
self.wolf_action(200, self.nightmare_1, 2.5, -1, 1)
#fourth --------------------------------------------------
self.wolf_action(200, self.nightmare_2, 2.5, -1, 1) '''
self.skeleton_action(300, self.skeleton, 2, -1, 1)
if self.life == 0:
import GameOver
self.life = 3
director.push(ZoomTransition(GameOver.get_gameover(2)))
self.kill()
if(self.sprite.position > (2755,y) and self.skeleton_is_alive == False):
import Level3_Background
director.push(SlideInTTransition(Level3_Background.get_newgame()))
elif(x >= 2755):
self.sprite.position = (2750,410)
self.mirror_sprite.position = (2750,320)
def Result():
#stops game with ball collides with target
if ballPos.colliderect(targetPos):
GameOver.GameOver(True)
return False
#stops game with ball collides edges of the window
elif (ballPos.y > height):
GameOver.GameOver(False)
return False
elif ballPos.x > width:
GameOver.GameOver(False)
return False
else:
return True
def __init__(self, width=cfg.WINDOW_WIDTH, height=cfg.WINDOW_HEIGHT):
#Initialize pygame, window, background, font,...
pygame.init()
pygame.mixer.init()
# Store a copy of setting parameters
self.epsilon = cfg.EPSILON
self.games_number = cfg.GAMES_NUMBER
self.speed_train = cfg.SPEED_TRAIN
self.music = cfg.MUSIC
self.connect_mode = cfg.CONNECT_MODE
self.game_logic = None
self.width = width
self.height = height
self.screen = pygame.display.set_mode((self.width, self.height), pygame.DOUBLEBUF)
self.background = pygame.Surface(self.screen.get_size()).convert()
self.menu = Menu.Menu(self.background, width, height, self.connect_mode)
self.options = Options.Options(self.background, width)
self.game = GameOver.GameOver(self.background, width)
self.win_list = [0,0,0]
def showGameOver():
frame.stop()
gameOver = GameOver((250, 350))
mixer.music.load("Dark Souls - You Died Sound Effect.mp3")
mixer.music.play(0)
#frame = simplegui.create_frame("Half-Life 3", 500, 700)
frame.set_draw_handler(gameOver.draw)
frame.start()
def start_menu1 (screen):
menu1_back = pygame.image.load("image/background/menu1_back.png")
menu4 = pygame.image.load("image/menu/menu4.png")
tutorial = pygame.image.load("image/map/tutorial.png")
map1 = pygame.image.load("image/map/map1.png")
map2 = pygame.image.load("image/map/map2.png")
while True:
screen.blit(menu1_back, (0, 0))
screen.blit(menu4, (192, 576))
screen.blit(tutorial, (128,128))
screen.blit(map1, (128+256+128, 128))
screen.blit(map2, (128+256+128+256+128, 128))
position = pygame.mouse.get_pos()
if position[0] > 384 and position[0] < 896:
if position[1] > 576 and position[1] < 704:
interface.print_click(screen,64,576)
if position[1] > 128 and position[1] < 384:
if position[0] > 128 and position[0] < 128+256:
interface.print_check(screen,128,128)
elif position[0] >128+256+128 and position[0] < 128+256+128+256:
interface.print_check(screen,128+256+128,128)
elif position[0] > 128+256+128+256+128 and position[0] < 128+256+128+256+128+256:
interface.print_check(screen,128+256+128+256+128,128)
pygame.display.flip()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
if event.type == pygame.MOUSEBUTTONDOWN:
pygame.mixer.init()
pygame.mixer.music.load("sound/click.wav")
pygame.mixer.music.set_volume(1) # 1 ~ 0.1
pygame.mixer.music.play()
pygame.mixer.Sound("sound/click.wav")
position = pygame.mouse.get_pos()
if position[0] > 384 and position[0] < 896:
if position[1] > 576 and position[1] < 704:
return 1
if position[1] > 128 and position[1] < 384:
if position[0] > 128 and position[0] < 128+256:
GameOver.GameOver(screen,95000,8,1200)
return 1
elif position[0] > 128 + 256 + 128 and position[0] < 128 + 256 + 128 + 256:
Map_1_start.Map_1_starting(screen)
return 1
elif position[0] > 128 + 256 + 128 and position[0] < 128 + 256 + 128 + 256:
pass
def SetWindow(this, window):
this.currentWindow = window
if (window == 0):
this.mainMenu = MainMenu(this.screen, this.events, this)
elif (window == 1):
this.game = Game(this.screen, this.events, this)
elif (window == 2):
this.gameOver = GameOver(this.screen, this.events, this,
this.game.time)
def event(self, event):
if event.type == PG.KEYDOWN:
#G.Globals.STATE = Main.Game(self.level)
if self.level == 4:
G.Globals.STATE = Main.Game(self.level + 1, 1, self.player)
elif self.level == 5:
G.Globals.STATE = GameOver.GameOver(True, Main.Game.SCORE)
else:
G.Globals.STATE = Main.Game(self.level)
def __init__(this, screen, events):
### Universal Components
this.screen = screen
this.events = events
### Window Options
this.currentWindow = 0
this.gameState = -1
this.mainMenu = MainMenu(screen, events, this)
this.game = this.mainMenu
this.gameOver = GameOver(screen, events, this, 60)
def changeState(self,newState) :
"""
function to change the current state of the main menu
Transition: self.state is updated to new state
exception: none
input: newState - string value of new state
output: none
"""
if self.STATES.count(newState)==1 : self.state = newState
if self.state =='menu' : self.pauseStatus = False
if self.state == 'instructions' : self.pauseStatus = False
if self.state=='game' :
if not(self.pauseStatus) :
self.gameMap = PlayMap()
if self.state=='gameOver':
self.pauseStatus = False
self.gameOver = GameOver(self.gameMap.score)
if self.state=='gamePause':
self.pauseStatus = True
self.gamePause = GamePause(self.gameMap.score)
def update(self, time):
if self.index == -1:
self.index = 0
self.time += time
self.fadein += time * self.fade_value # controls fade in time
if self.fadein <= 255: # values over 255 do not matter
self.images[self.index].set_alpha(self.fadein)
self.surf1 = StoryBoard.FONT.render(self.strings1[self.index],
True, (self.fadein, 0, 0))
self.surf2 = StoryBoard.FONT.render(self.strings2[self.index],
True, (self.fadein, 0, 0))
# begin to fade out if time has reached point
# that is >= the fade in time
if StoryBoard.LENGTH - (self.time % StoryBoard.LENGTH) \
<= 255 / self.fade_value + 1:
# controls the fade out time
self.fadeout -= time * self.fade_value
if self.fadeout >= 0:
# if not the last image, fade out
if self.index != len(self.images):
self.images[self.index].set_alpha(self.fadeout)
self.surf1 = StoryBoard.FONT.render(
self.strings1[self.index], True, (self.fadeout, 0, 0))
self.surf2 = StoryBoard.FONT.render(
self.strings2[self.index], True, (self.fadeout, 0, 0))
# decides whether or not it is time to change the image
if self.time >= (self.index + 1) * StoryBoard.LENGTH:
if self.index + 1 < len(self.images):
self.index += 1
# we changed images so we reset values
self.fadein = 0
self.fadeout = 255
self.images[self.index].set_alpha(self.fadein)
else:
if self.level == 4:
G.Globals.STATE = Main.Game(self.level + 1, 1)
elif self.level == 5:
G.Globals.STATE = GameOver.GameOver(True, Main.Game.SCORE)
else:
G.Globals.STATE = Main.Game(self.level)
self.xy1 = ((400 - self.surf1.get_width() / 2,
500 - self.surf1.get_height()))
self.xy2 = ((400 - self.surf2.get_width() / 2,
500 + self.surf2.get_height()))
G.Globals.SCREEN.blit(self.images[self.index], (0, 0))
G.Globals.SCREEN.blit(self.surf1, self.xy1)
G.Globals.SCREEN.blit(self.surf2, self.xy2)
def _check_game_over(self):
userWon, canMove = self._check_tiles()
won = newHighScore = None
if userWon:
won = True
if self.score > self.highScore:
self.highScore = self.score
newHighScore = True
elif not canMove:
won = newHighScore = False
if won is not None:
GameOver.Window(self, self.score, won, newHighScore)
self.new_game()
else:
self.update_score()
def __init__(self) :
"""
Constructor for MainMenu class
Transition: initialized to main menu state
exception: none
"""
self.STATES = ['menu','game','gameOver','gamePause','instructions']
self.gameMap = PlayMap()
self.gameOver = GameOver(20)
self.gamePause = GamePause(20)
self.gameInstructions = GameInstructions()
self.pauseStatus = False
# What stage of the interface the game is on
self.state = 'menu'
# Display objects for the GUI
self.startGameButton = pygame.Rect(50,200,200,100)
self.exitGameButton = pygame.Rect(300,200,200,100)
self.diff0Button = pygame.Rect(100,400,50,50)
self.diff1Button = pygame.Rect(200,400,50,50)
self.diff2Button = pygame.Rect(300,400,50,50)
self.updateState()
def update(self, dt):
x, y = self.sprite.position
if(x <=20 ):
self.run_l = False
self.run_r = False
self.sprite.position = (30,180)
self.heart1.position = (x-20, y+40)
self.heart2.position = (x, y+40)
self.heart3.position = (x+20, y+40)
if self.run_l:
self.sprite.position = (x - 3, y)
elif self.run_r:
self.sprite.position = (x + 3, y)
Level1_Background.scroller_1.set_focus(self.sprite.position[0], self.sprite.position[1])
# first stack --------------------------------------------
self.wolf_action(200, self.hell_wolf_1, 2, -1, 1)
self.wolf_action(210, self.hell_wolf_2, 2, -1, 1)
self.wolf_action(220, self.dark_wolf_1, 2, -1, 1)
self.wolf_action(230, self.dark_wolf_2, 2, -1, 1)
#---------------------------------------------------------
# second stack -------------------------------------------
self.wolf_action(200, self.blue_wolf_1, 3, -1, 1)
self.wolf_action(200, self.blue_wolf_2, 3, -1, 1)
self.wolf_action(300, self.black_wolf_1, 3, -1, 1)
# third stack--------------------------------------------
self.wolf_action(250, self.hell_hound_1, 4, -1, 1)
self.wolf_action(200, self.dark_wolf_3, 2, -1, 1)
self.wolf_action(200, self.blue_wolf_3, 3, -1, 1)
# fourth stack-------------------------------------------
self.wolf_action(250, self.hell_hound_2, 4, -1, 1)
self.wolf_action(200, self.dark_wolf_4, 2, -1, 1)
self.wolf_action(200, self.blue_wolf_4, 3, -1, 1)
self.beast_action(300, self.hell_beast, self.ball)
#---------------------------------------------------------
if self.life == 0:
self.life = 3
director.push(ZoomTransition(GameOver.get_gameover(1)))
self.kill()
if(self.sprite.position > (3090,y)):
import Level2_Background
director.push(SlideInTTransition(Level2_Background.get_newgame()))
def main():
#window stuff
pygame.init()
if (WINDOWED): screen = pygame.display.set_mode(SCREEN_SIZE)
else: screen = pygame.display.set_mode(SCREEN_SIZE, FULLSCREEN)
pygame.display.set_icon(pygame.image.load(ICON))
pygame.display.set_caption(TITLE_BAR_TEXT)
#repeat keydowns
pygame.key.set_repeat(40, 40)
#load the clock for the framerate
clock = pygame.time.Clock()
#set the initial volume based on the constants
if SOUND_ENABLED: pygame.mixer.music.set_volume(GLOBAL_MUSIC_VOLUME)
else: pygame.mixer.music.set_volume(0)
#main game surface
screen_surface = pygame.Surface(screen.get_size())
screen_surface_rect = screen_surface.get_rect()
#states
gameState = MAIN_MENU
daddyState = [STAND, SOUTH]
babyState = IDLE
stateCache = MAIN_MENU
#sprites
menu = MainMenu()
game = GameScene()
gameOver = GameOver()
soundBtn = SoundBtn()
pauseScreen = PauseScreen()
pauseContainer = pygame.sprite.GroupSingle()
#and the program container
spriteContainer = pygame.sprite.GroupSingle()
def toggleSound():
soundOn = pygame.mixer.music.get_volume()
if soundOn:
pygame.mixer.music.set_volume(0)
soundBtn.image = pygame.image.load(
'images/sound_off.png').convert_alpha()
else:
pygame.mixer.music.set_volume(GLOBAL_MUSIC_VOLUME)
soundBtn.image = pygame.image.load(
'images/sound_on.png').convert_alpha()
spriteContainer.draw(screen_surface)
soundBtnContainer.draw(screen_surface)
screen.blit(screen_surface, (0, 0))
pygame.display.flip()
writeConfig()
def changeMusic(newTrack, volume=GLOBAL_MUSIC_VOLUME):
soundOn = pygame.mixer.music.get_volume()
pygame.mixer.music.load('audio/' + newTrack)
pygame.mixer.music.play(-1)
if (soundOn): pygame.mixer.music.set_volume(volume)
else: pygame.mixer.music.set_volume(0)
def createMenu():
pygame.time.set_timer(USEREVENT + 1, 0)
spriteContainer.add(menu)
spriteContainer.draw(screen_surface)
soundBtnContainer.draw(screen_surface)
screen.blit(screen_surface, (0, 0))
pygame.mixer.music.fadeout(50)
pygame.display.flip()
changeMusic('babyDaddyHookRepeat.ogg')
def startGame():
spriteContainer.add(game)
spriteContainer.draw(screen_surface)
screen.blit(screen_surface, (0, 0))
pygame.mixer.music.fadeout(50)
changeMusic('babyDaddyMainLoop.wav')
pygame.display.flip()
pygame.time.set_timer(USEREVENT + 1, 1500)
pygame.time.set_timer(USEREVENT + 2, 10000)
game.startGame()
def createGameOver():
spriteContainer.add(gameOver)
spriteContainer.draw(screen_surface)
screen.blit(screen_surface, (0, 0))
pygame.time.set_timer(USEREVENT + 1, 0)
pygame.time.set_timer(USEREVENT + 2, 0)
changeMusic('Sad_Male.ogg')
pygame.display.flip()
#display soundBtn
soundBtn.rect.bottomright = screen_surface_rect.bottomright
soundBtn.rect = soundBtn.rect.move(-15, -15)
soundBtnContainer = pygame.sprite.GroupSingle(soundBtn)
#display menu
createMenu()
def writeConfig():
#print(pygame.mixer.music.get_volume()==GLOBAL_MUSIC_VOLUME)
f = open('Config.py', 'w')
f.write('#sound\nSOUND_ENABLED=' +
str(pygame.mixer.music.get_volume() == GLOBAL_MUSIC_VOLUME))
f.close()
#state machine/infinite loop. This may get messy...
while True:
#set the framerate
clock.tick(60)
for event in pygame.event.get():
if event.type == ACTIVEEVENT:
#if game is out of focus or minimized, pause
if (event.state == 2) | ((event.state == 6) &
(event.gain == 0)):
tempSndState = pygame.mixer.music.get_volume()
stateCache = gameState
gameState = PAUSED
pauseContainer.add(pauseScreen)
pauseContainer.draw(screen_surface)
screen.blit(screen_surface, (0, 0))
pygame.mixer.music.set_volume(0)
pygame.display.flip()
#back in the game
elif (event.state == 6) & (event.gain == 1):
pygame.mixer.music.set_volume(tempSndState)
gameState = stateCache
pauseContainer.empty()
spriteContainer.draw(screen_surface)
screen.blit(screen_surface, (0, 0))
pygame.display.flip()
if event.type == QUIT:
sys.exit(0)
if event.type == MOUSEBUTTONDOWN:
x, y = event.pos
if soundBtn.rect.collidepoint(x, y):
toggleSound()
if ((event.type == MOUSEBUTTONDOWN) & (gameState == MAIN_MENU)):
x, y = event.pos
if menu.startBtn_rect.collidepoint(x, y):
startGame()
gameState = GAME_ON
if menu.exitBtn_rect.collidepoint(x, y):
sys.exit(0)
if ((event.type == MOUSEBUTTONDOWN) & (gameState == GAME_OVER)):
createMenu()
gameState = MAIN_MENU
if ((event.type == KEYDOWN) & (gameState == GAME_ON)):
keys = pygame.key.get_pressed()
if (keys[K_RIGHT] | keys[K_d]):
daddyState = [WALK, EAST]
if (keys[K_DOWN] | keys[K_s]):
daddyState = [WALK, SOUTH]
if (keys[K_LEFT] | keys[K_a]):
daddyState = [WALK, WEST]
if (keys[K_UP] | keys[K_w]):
daddyState = [WALK, NORTH]
if ((keys[K_UP] & keys[K_RIGHT]) | (keys[K_w] & keys[K_d])):
daddyState = [WALK, NORTHEAST]
if ((keys[K_UP] & keys[K_LEFT]) | (keys[K_w] & keys[K_a])):
daddyState = [WALK, NORTHWEST]
if ((keys[K_DOWN] & keys[K_RIGHT]) | (keys[K_s] & keys[K_d])):
daddyState = [WALK, SOUTHEAST]
if ((keys[K_DOWN] & keys[K_LEFT]) | (keys[K_s] & keys[K_a])):
daddyState = [WALK, SOUTHWEST]
game.daddy.moveDaddy(daddyState, game.baby.rect)
if ((event.type == KEYUP) & (gameState == GAME_ON)):
if event.key == K_SPACE:
game.shootDaddy()
if event.key == K_ESCAPE:
createMenu()
gameState = MAIN_MENU
else:
daddyState[0] = STAND
if (daddyState[1] == NORTHEAST) | (daddyState[1]
== NORTHWEST):
daddyState[1] = NORTH
if (daddyState[1] == SOUTHEAST) | (daddyState[1]
== SOUTHWEST):
daddyState[1] = SOUTH
game.daddy.moveDaddy(daddyState, game.baby.rect)
if ((event.type == USEREVENT + 1) & (gameState == GAME_ON)):
game.launchEnemy()
if ((event.type == USEREVENT + 2) & (gameState == GAME_ON)):
game.randomItem()
if gameState == MAIN_MENU:
pygame.time.delay(200)
menu.update()
spriteContainer.draw(screen_surface)
soundBtnContainer.draw(screen_surface)
screen.blit(screen_surface, (0, 0))
pygame.display.flip()
if gameState == GAME_ON:
game.update()
spriteContainer.draw(screen_surface)
soundBtnContainer.draw(screen_surface)
screen.blit(screen_surface, (0, 0))
pygame.display.flip()
if ((game.numDH == 0) | (game.numBH <= 0)):
createGameOver()
gameState = GAME_OVER
def tutorial_starting(screen) :
chal = [0,0,0,0,0,0,0,0,0]
chal_sv = [0,0,0,0,0,0,0,0,0]
touer = [False, False, False, False]
chal_scr = [500, 1000, 2000, 4000,6000,2000, 500, 3000, 5000] #도전과제 달성시 보상
chal_money = [100,200,350,550,700,200,100,500,0]
score = 0
virus.Virus.Allnum = 0
virus.game_reset()
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
back_ground = pygame.image.load("image/virus/map2.png")
interface = pygame.image.load("image/virus/interface.png")
map1 = map.map(screen)
map1.ch = [[120,60],[120,300],[900,300],[900,720]]
map1.set([0, 60], [900, 720])
chal_img = []
chal_img.append(pygame.image.load("image/challenge/chal_1.png"))
chal_img.append(pygame.image.load("image/challenge/chal_2.png"))
chal_img.append(pygame.image.load("image/challenge/chal_3.png"))
chal_img.append(pygame.image.load("image/challenge/chal_4.png"))
chal_img.append(pygame.image.load("image/challenge/chal_5.png"))
chal_img.append(pygame.image.load("image/challenge/chal_6.png"))
chal_img.append(pygame.image.load("image/challenge/chal_7.png"))
chal_img.append(pygame.image.load("image/challenge/chal_8.png"))
support_index = []
life = 20
tower1 = []
enemy1 = []
index = -1
vindex = -1
timg = []
timg.append(pygame.image.load("tower/normal_tower1.png"))
timg.append(pygame.image.load("tower/short_tower1.png"))
timg.append(pygame.image.load("tower/long_tower1.png"))
timg.append(pygame.image.load("tower/support_tower1.png"))
cancel_img = pygame.image.load("tower/cancel.png")
build = 0
build_ok = True
game_timer = time.time()
old_time = game_timer
gold = 1000
round123 = 0
count = 0
Font = pygame.font.Font(None, 52)
font = pygame.font.Font(None, 26)
vtimer = time.time()
screen.blit(back_ground, (0, 0))
map1.draw()
Gameoverbool = False
## 바이러스
badguy = []
selectNum = -1
count = 0
type_virus = 0
# copyright -shin hyuk jin
pygame.mixer.init()
pygame.mixer.music.load("sound/tutorbgm.wav")
pygame.mixer.music.set_volume(0.1) # 1 ~ 0.1
pygame.mixer.music.play(-1)
pygame.mixer.Sound("sound/tutorbgm.wav")
managetime = time.time()
viruslist = [[1,0,0,0],[2,0,0,0],[3,0,0,0],[4,0,0,0],[5,0,0,0]]
wave = 0
while True :
screen.blit(back_ground, (0, 0))
screen.blit(interface, (1030, 0))
map1.draw()
pygame.display.flip()
oldtime = time.time()
curtime = time.time()
while True : #Copyright : 노관태
timer = Font.render("Time : " + str(int(10-(curtime-oldtime))),True,(0,0,0)) #Copyright : 노관태
screen.blit(back_ground, (0, 0))
screen.blit(interface, (1030, 0))
if(curtime-oldtime < 10) :
screen.blit(timer,(850,20))
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
position = pygame.mouse.get_pos()
if build == 0:
for n in range(0, len(badguy)): # Copyright : 이동우 ~
badguy[n].calDistance(position[0], position[1])
for i in range(0, len(badguy)):
if badguy[i].boolDtc():
selectNum = i
break
selectNum = -1 # ~ Copyright : 이동우
for i in range(0, len(tower1)): # made by 김재희~
if tower1[i].selected:
if position[0] >= 1048 and position[0] <= 1048 + tower1[i].sell.get_width():
if position[1] >= 512 and position[1] <= 512 + tower1[i].sell.get_height():
gold += tower1[i].sell_tower()
if tower1[i].is_support == True:
for k in range(0, len(support_index)):
if support_index[k] == i:
support_index.pop(k)
break
for k in range(0, len(tower1)):
if tower1[k].is_support == False:
tower1[k].plus_damage = 0
for j in range(0, len(support_index)):
if support_index[j] > i:
support_index[j] -= 1
tower1.pop(i)
index -= 1
break
if position[1] >= 459 and position[1] <= 459 + tower1[i].upgrade.get_height():
if tower1[i].level <= 2:
if gold >= tower1[i].upgrade_price[tower1[i].level]:
gold -= tower1[i].upgrade_tower()
else:
tower1[i].selected = tower1[i].select_tower(position[0], position[1])
else:
tower1[i].selected = tower1[i].select_tower(position[0], position[1])
if position[0] >= 1050 and position[0] <= 1050 + timg[0].get_width() and \
position[1] >= 110 and position[1] <= 110 + timg[0].get_height():
if gold >= 50:
gold -= 50
index += 1
build += 1
tower1.append(tower())
tower1[index].timer = time.time()
if position[0] >= 1170 and position[0] <= 1170 + timg[1].get_width() and \
position[1] >= 110 and position[1] <= 110 + timg[1].get_height():
if gold >= 150:
gold -= 150
index += 1
build += 1
tower1.append(short_tower())
tower1[index].timer = time.time()
if position[0] >= 1050 and position[0] <= 1050 + timg[2].get_width() and \
position[1] >= 230 and position[1] <= 230 + timg[2].get_height():
if gold >= 100:
gold -= 100
index += 1
build += 1
tower1.append(long_tower())
tower1[index].timer = time.time()
if position[0] >= 1170 and position[0] <= 1170 + timg[3].get_width() and \
position[1] >= 230 and position[1] <= 230 + timg[3].get_height():
if gold >= 200:
gold -= 200
index += 1
build += 1
tower1.append(support_tower())
support_index.append(index)
tower1[index].timer = time.time()
elif build == 1:
for i in range(0, len(tower1)):
if (i != index):
if (position[0] <= tower1[i].x + timg[0].get_width() / 2 + 15 and position[0] >= tower1[
i].x - timg[0].get_width() / 2 - 15\
and position[1] <= tower1[i].y + timg[0].get_height() / 2 + 15 and position[1] >=
tower1[i].y - timg[0].get_height() / 2 - 15):
build_ok = False
break
else:
build_ok = True
if on_roadt(position[0], position[1]) == False :
if (build_ok == True) :
build -= 1
if tower1[index].tower_name == "normal tower":# Copyright : 노관태~
touer[0] = True
if tower1[index].tower_name == "short tower":
touer[1] = True
if tower1[index].tower_name == "long tower":
touer[2] = True
if tower1[index].tower_name == "support tower":# ~ Copyright : 노관태
touer[3] = True
if position[0] >= 1150 and position[0] <= 1150 + cancel_img.get_width() and \
position[1] >= 615 and position[1] <= 615 + cancel_img.get_height():
build -= 1
if tower1[index].tower_name == "normal tower": # Copyright : 노관태~
gold += 50
if tower1[index].tower_name == "short tower":
gold += 150
if tower1[index].tower_name == "long tower":
gold += 100
if tower1[index].tower_name == "support tower": # ~ Copyright : 노관태
gold += 200
if tower1[i].is_support:
support_index.pop()
index -= 1
tower1.pop() # ~made by 김재희
if build == 1: # made by 김재희~
position = pygame.mouse.get_pos()
tower1[index].build_tower(position[0], position[1])
for i in range(0, len(tower1)):
attack_on = False
if len(badguy) > 0:
for j in range(0, len(badguy)):
if build == 1:
if index == i :
break
if (tower1[i].is_support != True):
if (badguy[j].center[0] - tower1[i].x) * (badguy[j].center[0] - tower1[i].x) \
+ (badguy[j].center[1] - tower1[i].y) * (badguy[j].center[1] - tower1[i].y) <= tower1[i].range * \
tower1[i].range:
attack_on = True
if tower1[i].tower_attack(game_timer):
badguy[j].hp -= tower1[i].damage + tower1[i].plus_damage
if badguy[j].hp <= 0:
if badguy[j].name == "MERS virus": # Copyright : 노관태~
score += 10
gold += 7
if badguy[j].name == "ZIKA virus":
score += 15
gold += 8
if badguy[j].name == "EBOLA virus":
score += 20
gold += 10
if badguy[j].name == "CORONA virus": # ~ Copyright : 노관태
score += 300
gold += 300
badguy[j].dead()
badguy.pop(j)
if selectNum == j:
selectNum = -1
elif selectNum > j:
selectNum -= 1
vindex -= 1
break
break
else:
if tower1[i].is_support == False:
tower1[i].attack = 0
if tower1[i].is_support == False:
if attack_on == False:
tower1[i].attack = 0
if build == 0:
for i in support_index:
exist = False
for j in range(0, len(tower1)):
if tower1[j].is_support == False:
if (tower1[j].x - tower1[i].x) * (tower1[j].x - tower1[i].x) \
+ (tower1[j].y - tower1[i].y) * (tower1[j].y - tower1[i].y) <= tower1[i].range * \
tower1[i].range:
tower1[j].plus_damage = tower1[i].plus_damage
exist = True
tower1[i].tower_attack(game_timer)
if exist == False:
tower1[i].attack = 0
for i in range(0, len(tower1)):
tower1[i].blit_tower(screen)
for i in range(0, len(enemy1)):
screen.blit(enemy1[i].enemy_img, (
enemy1[i].x - enemy1[i].enemy_img.get_width() / 2, enemy1[i].y - enemy1[i].enemy_img.get_height() / 2)) # ~made by 김재희
gold_font = font.render(str(gold), True, (0, 0, 0))
life_font = font.render(str(life),True,(0,0,0))
screen.blit(life_font, (1080, 32))
screen.blit(gold_font, (1195, 32))
screen.blit(timg[0], (1050, 112))
screen.blit(timg[1], (1175, 115))
screen.blit(timg[2], (1052, 238))
screen.blit(timg[3], (1177, 233))
screen.blit(cancel_img, (1150, 615))
game_timer = time.time()
map1.draw()
chal = challenge.challenge_1_5_8_9(chal,virus.Virus.AllNum,gold,touer)
for z in range (0,7,1) :
if chal_sv[z] ==0 and chal[z] == 1 :
chal_sv[z] = 2
managetime = time.time()
for z in range(0, 7, 1):
if chal_sv[z] == 2 or chal_sv[z] == 3 :
if curtime - managetime < 3 :
scr_giv = font.render("+" + str(chal_scr[z]),True,(0,0,0))
screen.blit(scr_giv,(150,680))
mon_giv = font.render("+" + str(chal_money[z]), True, (0, 0, 0))
screen.blit(mon_giv, (1190, 60))
if chal_sv[z] == 2 :
score += int(chal_scr[z])
gold += int(chal_money[z])
chal_sv[z] =3
screen.blit(chal_img[z],(0,0))
elif curtime - managetime > 3 :
if chal_sv[z] == 3 :
chal_sv[z] =1
wave_print = Font.render("Wave : " + str(int(wave + 1)), True, (0, 0, 0))
Score_print = Font.render("Score : " + str(int(score)), True, (0, 0, 0))
screen.blit(Score_print, (10, 620))
screen.blit(wave_print, (10, 580))
chal = challenge.challenge_6(chal, life)
if chal_sv[7] == 0 and chal[7] == 1:
chal_sv[7] = 2
managetime = time.time()
if chal_sv[7] == 2 or chal_sv[7] == 3:
if curtime - managetime < 3:
scr_giv = font.render("+" + str(chal_scr[7]), True, (0, 0, 0))
screen.blit(scr_giv, (150, 680))
mon_giv = font.render("+" + str(chal_money[7]), True, (0, 0, 0))
screen.blit(mon_giv, (1190, 60))
if chal_sv[7] == 2:
score += int(chal_scr[7])
gold += int(chal_money[7])
chal_sv[7] = 3
screen.blit(chal_img[7], (0, 0))
elif curtime - managetime > 3:
if chal_sv[7] == 3:
chal_sv[7] = 1
if(curtime-oldtime > 10) :
# 타이머 구현 #copyright 이동우
if count < viruslist[wave][0]:
type_virus = 0
elif count >= viruslist[wave][0] and count < viruslist[wave][0] + viruslist[wave][1]:
type_virus = 1
elif count >= viruslist[wave][0] + viruslist[wave][1] and count < viruslist[wave][0] + viruslist[wave][
1] + viruslist[wave][2]:
type_virus = 2
elif count >= viruslist[wave][0] + viruslist[wave][1] + viruslist[wave][2]:
type_virus = 3
if count < viruslist[wave][0] + viruslist[wave][1] + viruslist[wave][2] + viruslist[wave][3] :
if curtime - vtimer >= 1 :
count += 1
vtimer = curtime
badguy.append(virus.Virus(type_virus))
vindex += 1
badguy[vindex].setType()
badguy[vindex].setPos([900, 720])
badguy[vindex].path = [[900,720],[900,300],[120,300],[120,60],[0,60]]
#바이러스 좌표 조정 #copyright 이동우
for n in range(0, len(badguy)):
if badguy[n].pos[0] < badguy[n].x_size: # 바이러스가 맵 끝에 도달하면
vindex -= 1
life -= badguy[n].dmg
badguy.pop(n)
if selectNum == n:
selectNum = -1
elif selectNum > n:
selectNum -= 1
break
else:
badguy[n].move()
# 바이러스 화면 출력 #copyright 이동우
for n in range(0, len(badguy)):
x = badguy[n].pos[0]
y = badguy[n].Repeat(badguy[n].pos[1])
screen.blit(badguy[n].img, (x, y))
# 바이러스 클릭 시 바이러스 정보 출력 #copyright 이동우
if selectNum == -1:
pass
elif selectNum != -1:
badguy[selectNum].drawInfo(screen, 1085, 370)
if(life <=0) :
# copyright -shin hyuk jin
pygame.mixer.init()
pygame.mixer.music.load("sound/damage.wav")
pygame.mixer.music.set_volume(0.1) # 1 ~ 0.1
pygame.mixer.music.play()
pygame.mixer.Sound("sound/damage.wav")
Gameoverbool = True
break
if count >= viruslist[wave][0] + viruslist[wave][1] + viruslist[wave][2] + viruslist[wave][3] :
if len(badguy) == 0 :
count = 0
gold += 100
wave += 1
if wave == 5:
#copyright-shin
pygame.mixer.init()
pygame.mixer.music.load("sound/roundswap.wav")
pygame.mixer.music.set_volume(0.1) # 1 ~ 0.1
pygame.mixer.music.play()
pygame.mixer.Sound("sound/roundswap.wav")
score += life*100
score += gold
GameOver.GameClear(screen, score, life, gold)
return 1
break
pygame.display.flip()
curtime = time.time()
if Gameoverbool :
GameOver.GameOver(screen,score,life,gold)
return 1
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
import unittest
from GameOver import *
testGameOver = GameOver(20)
class TestGameOver(unittest.TestCase):
def testUpdateState(self):
testGameOver.updateState(21)
self.assertEqual(testGameOver.score, 21)
def testGetCurrentState(self):
self.assertEqual(testGameOver.getCurrentState(), [
testGameOver.score, testGameOver.retryButton,
testGameOver.exitButton
])
if __name__ == '__main__':
unittest.main(verbosity=2)
def on_update(self, delta_time):
""" Movement and game logic """
if self.lives_count < 0:
self.music.stop(self.current_music_player)
arcade.play_sound(self.gameover_sound, 1)
# Wait the end of the song
time.sleep(2.5)
gameover_view = GameOver_file.GameOverView()
self.window.show_view(gameover_view)
arcade.set_viewport(0, SCREEN_WIDTH - 1, 0, SCREEN_HEIGHT - 1)
# Move the player with the physics engine
self.physics_engine.update()
# --- Manage Enemy movement ---
# Update goombas position
self.goomba_list.update()
# Update koopas position
self.koopa_list.update()
# Update the fire balls position
self.fireball_list.update()
if self.coin_count >= 10:
self.lives_count += 1
self.coin_count -= 10
# See if the goomba hits a boundary and needs to reverse direction.
for goomba in self.goomba_list:
if goomba.boundary_right and goomba.right > goomba.boundary_right and goomba.change_x > 0:
goomba.change_x *= -1
if goomba.boundary_left and goomba.left < goomba.boundary_left and goomba.change_x < 0:
goomba.change_x *= -1
# See if the koopa hits a boundary and needs to reverse direction.
for koopa in self.koopa_list:
if koopa.boundary_right and koopa.right > koopa.boundary_right and koopa.change_x > 0:
koopa.change_x *= -1
if koopa.boundary_left and koopa.left < koopa.boundary_left and koopa.change_x < 0:
koopa.change_x *= -1
# --- Manage moving platforms ---
if self.level == 4:
self.platform_list.update()
for platform in self.platform_list:
if platform.boundary_right and platform.right > platform.boundary_right and platform.change_x > 0:
platform.change_x *= -1
if platform.boundary_left and platform.left < platform.boundary_left and platform.change_x < 0:
platform.change_x *= -1
# Update the lives img
self.lives_sprite.update()
# --- Manage Collision ---
# Manage Fire Ball extinction and collision
for fireball in self.fireball_list:
# Manage the auto destruction
# Need >= and <= because center_x reflects the delta_time
# After 10 block the fire ball will be extinguished
if fireball.center_x >= (fireball.starting_x + 315):
fireball.remove_from_sprite_lists()
if fireball.center_x <= (fireball.starting_x - 315):
fireball.remove_from_sprite_lists()
# Manage the collision with a wall
if arcade.check_for_collision_with_list(fireball, self.wall_list):
fireball.exploded = True
if fireball.exploded_animation_finished == True:
fireball.remove_from_sprite_lists()
# Manage the collision with a goomba
for goomba in self.goomba_list:
if arcade.check_for_collision(fireball, goomba):
goomba.death = True
fireball.exploded = True
arcade.play_sound(self.enemy_killed, 0.5)
if goomba.death_animation_finished == True:
goomba.remove_from_sprite_lists()
if fireball.exploded_animation_finished == True:
fireball.remove_from_sprite_lists()
# Manage the collision with a koopa
for koopa in self.koopa_list:
if arcade.check_for_collision(fireball, koopa):
koopa.death = True
fireball.exploded = True
arcade.play_sound(self.enemy_killed, 0.5)
if koopa.death_animation_finished == True:
koopa.remove_from_sprite_lists()
if fireball.exploded_animation_finished == True:
fireball.remove_from_sprite_lists()
# See if we hit a a coin
for coin in self.coin_list:
if arcade.check_for_collision(self.player_sprite, coin):
arcade.play_sound(self.coin_sound, 0.5)
coin.remove_from_sprite_lists()
self.coin_count += 1
# See if we hit any enemy or lava
if arcade.check_for_collision_with_list(
self.player_sprite,
self.goomba_list) or arcade.check_for_collision_with_list(
self.player_sprite,
self.koopa_list) or arcade.check_for_collision_with_list(
self.player_sprite, self.lava_list):
self.lives_count -= 1
self.player_sprite.powerup = False
if self.checkpoint_sprite.reached == False:
self.player_sprite.change_x = 0
self.player_sprite.change_y = 0
self.player_sprite.center_x = PLAYER_START_X
self.player_sprite.center_y = PLAYER_START_Y
# Set the camera to the start
self.view_left = 0
self.view_bottom = 0
arcade.set_viewport(0, SCREEN_WIDTH, 0, SCREEN_HEIGHT)
else:
self.player_sprite.change_x = 0
self.player_sprite.change_y = 0
self.player_sprite.center_x = self.checkpoint_sprite.center_x
self.player_sprite.center_y = self.checkpoint_sprite.center_y
self.view_bottom = 0
# See if we reached the checkpoint
if arcade.check_for_collision(self.player_sprite,
self.checkpoint_sprite):
self.checkpoint_sprite.reached = True
if self.first_time == True:
arcade.play_sound(self.checkpoint_sound, 0.34)
self.first_time = False
# Update checkpoint animation only if the checkpoint has been reached
self.checkpoint_sprite.update_animation()
# See if we caught the power up
for powerup in self.powerup_list:
if arcade.check_for_collision(self.player_sprite, powerup):
powerup.remove_from_sprite_lists()
self.player_sprite.powerup = True
self.player_sprite.powerup_start = int(self.total_time)
arcade.play_sound(self.powerup_taken, 0.5)
# See if we reached the door
if arcade.check_for_collision(self.player_sprite, self.door_sprite):
self.door_sprite.animate()
# Advance to the next level
if self.door_sprite.animation_ended == True and self.level < 4:
self.door_sprite.animation_ended = False
self.first_time = True
self.level += 1
self.final_time += self.total_time
arcade.play_sound(self.level_finished, 1)
# Wait the end of the song
time.sleep(5.5)
self.player_sprite.powerup = False
self.setup(self.level)
# Set the camera to the start
self.view_left = 0
self.view_bottom = 0
arcade.set_viewport(0, SCREEN_WIDTH, 0, SCREEN_HEIGHT)
# That was the last level so the game ends
if self.door_sprite.animation_ended == True and self.level == 4:
self.music.stop(self.current_music_player)
self.final_time += self.total_time
arcade.play_sound(self.level_finished, 1)
# Wait the end of the song
time.sleep(5.5)
gamewon_view = game_won_file.GameWonView(
False, self.final_time, self.lives_count)
self.window.show_view(gamewon_view)
arcade.set_viewport(0, SCREEN_WIDTH - 1, 0, SCREEN_HEIGHT - 1)
# --- Manage Scrolling ---
# Track if we need to change the viewport
changed = False
# Scroll left
left_boundary = self.view_left + LEFT_VIEWPORT_MARGIN
if self.player_sprite.left < left_boundary:
self.view_left -= left_boundary - self.player_sprite.left
changed = True
# Scroll right
right_boundary = self.view_left + SCREEN_WIDTH - RIGHT_VIEWPORT_MARGIN
if self.player_sprite.right > right_boundary:
self.view_left += self.player_sprite.right - right_boundary
changed = True
# Scroll up
top_boundary = self.view_bottom + SCREEN_HEIGHT - TOP_VIEWPORT_MARGIN
if self.player_sprite.top > top_boundary:
self.view_bottom += self.player_sprite.top - top_boundary
changed = True
# Scroll down
bottom_boundary = self.view_bottom + BOTTOM_VIEWPORT_MARGIN
if self.player_sprite.bottom < bottom_boundary:
self.view_bottom -= bottom_boundary - self.player_sprite.bottom
changed = True
if changed and self.view_left > 0:
# Only scroll to integers. Otherwise we end up with pixels that
# don't line up on the screen
if self.level <= 2:
if (self.view_left + SCREEN_WIDTH) < 7875:
self.view_bottom = int(self.view_bottom)
self.view_left = int(self.view_left)
# Do the scrolling
arcade.set_viewport(self.view_left,
SCREEN_WIDTH + self.view_left,
self.view_bottom,
SCREEN_HEIGHT + self.view_bottom)
else:
if (self.view_left + SCREEN_WIDTH) < 18900:
self.view_bottom = int(self.view_bottom)
self.view_left = int(self.view_left)
# Do the scrolling
arcade.set_viewport(self.view_left,
SCREEN_WIDTH + self.view_left,
self.view_bottom,
SCREEN_HEIGHT + self.view_bottom)
# --- Manage Position ---
# Too left
if self.player_sprite.center_x <= 10:
self.player_sprite.change_x = 0
# Too right
if self.level <= 2:
if self.player_sprite.center_x >= 7865:
self.player_sprite.change_x = 0
if self.level > 2:
if self.player_sprite.center_x >= 18890:
self.player_sprite.change_x = 0
# --- Manage Animations ---
self.player_list.update_animation(delta_time)
self.fireball_list.update_animation(delta_time)
self.goomba_list.update_animation(delta_time)
self.koopa_list.update_animation(delta_time)
self.coin_list.update_animation(delta_time)
# Update the timer
self.total_time += delta_time
# Useful to know if the song is still running
position = self.music.get_stream_position(self.current_music_player)
# The position pointer is reset to 0 right after we finish the song.
# This makes it very difficult to figure out if we just started playing
# or if we are doing playing.
if position == 0.0:
self.advance_song()
self.play_song()
def keyDown(key):
player1.keyDown(key)
def KeyDown(key):
player1.keyDown(key)
frame = simplegui.create_frame("Menu", 500, 700)
menu = Menu(frame)
frame.set_mouseclick_handler(menu.play_button.mouse_handler)
frame.set_draw_handler(menu.drawMenu)
frame.start()
if menu.play_button.action:
gameOver = GameOver((250, 350))
frame.stop()
mixer.music.load("Dark Souls - You Died Sound Effect.mp3")
mixer.music.play(0)
frame = simplegui.create_frame("Half-Life 3", 500, 700)
frame.set_draw_handler(gameOver.draw)
frame.start()
'''level = 1.5
if level == 1:
mixer.music.load("All Star 8 Bit.mp3")
mixer.music.play(-1)
elif level == 1.5:
mixer.music.load("harder_better_faster_stronger.mp3")
mixer.music.play(-1)
elif level == 2:
checks_ver = [[width - 339, height + 100], [width - 441, height - 150],
[width + 125, height - 170], [width + 373, height + 100]]
# create the player object
player = Car(width + 150, height + 230, 310, 0)
# Player info
name = ""
time = 0 # Time of round (divide by frame_rate to get time in seconds)
scores = score_board.ScoreBoard("score_board.txt")
# set the phase for checking the checkpoints
check_phase = 1
# create an instance for the game over function
gameover = GameOver.Game_Over()
# Buttons
play_button = button.Button(pygame.image.load("graphics/play_button.png"),
screen_width // 2, screen_height // 2 + 120, 400,
160)
exit_button = button.Button(pygame.image.load("graphics/exit_button.png"),
screen_width // 2, screen_height // 2 + 320, 400,
160)
okay_button = button.Button(pygame.image.load("graphics/okay_button.png"),
screen_width // 2, screen_height // 2 + 320, 400,
160)
retry_button = button.Button(pygame.image.load("graphics/retry_button.png"),
screen_width // 2, screen_height // 2 + 120, 400,
160)
menu_button = button.Button(pygame.image.load("graphics/menu_button.png"),
def update(self, dt):
#BOSS
if self.axe_skeleton_b.sprite.visible:
self.skeleton_action(350, self.axe_skeleton_b, 1, -1, 1)
if self.blue_wolf_b.sprite.visible:
self.wolf_action(350, self.blue_wolf_b, 2, 1, -1)
if self.hell_hound_b.sprite.visible:
self.wolf_action(350, self.hell_hound_b, 2, 1, -1)
if self.hell_beast_b.sprite.visible:
self.beast_action(300, self.hell_beast_b, self.hell_ball_b)
if self.red_hound_b.sprite.visible:
self.wolf_action(350, self.red_hound_b, 3, -1, 1)
if self.green_hound_b.sprite.visible:
self.wolf_action(350, self.green_hound_b, 3, -1, 1)
if self.nightmare_b.sprite.visible:
self.wolf_action(350, self.nightmare_b, 3, -1, 1)
if self.red_nightmare_b.sprite.visible:
self.wolf_action(350, self.red_nightmare_b, 3, -1, 1)
if self.green_nightmare_b.sprite.visible:
self.wolf_action(350, self.green_nightmare_b, 3, -1, 1)
if self.green_hell_beast_b.sprite.visible:
self.beast_action(300, self.green_hell_beast_b,
self.green_hell_ball_b)
if self.ghost_b.sprite.visible:
self.ghost_action(350, self.ghost_b, 2)
#first stack
self.skeleton_action(100, self.axe_skeleton_1, 2, -1, 1)
self.ghost_action(200, self.ghost_1, 3)
self.skeleton_action(100, self.axe_skeleton_2, 2, -1, 1)
#second stack
self.wolf_action(200, self.hell_hound, 3, -1, 1)
self.beast_action(300, self.blue_hell_beast, self.blue_hell_ball)
self.wolf_action(350, self.nightmare, 3, -1, 1)
#third stack
self.skeleton_action(100, self.axe_skeleton_3, 2, -1, 1)
self.ghost_action(200, self.ghost_2, 3)
self.skeleton_action(100, self.axe_skeleton_4, 2, -1, 1)
#fourth stack
self.boss_action(350, self.boss)
x, y = self.sprite.position
xm, ym = self.mirror_sprite.position
if (x <= 20):
self.run_l = False
self.run_r = False
self.sprite.position = (30, 215)
self.mirror_sprite.position = (30, 125)
self.heart1.position = (x - 20, y + 40)
self.heart2.position = (x, y + 40)
self.heart3.position = (x + 20, y + 40)
if self.run_l:
self.sprite.position = (x - 3, y)
self.mirror_sprite.position = (xm - 3, ym)
elif self.run_r:
self.sprite.position = (x + 3, y)
self.mirror_sprite.position = (xm + 3, ym)
Level3_Background.scroller_3.set_focus(self.sprite.position[0],
self.sprite.position[1])
if self.life == 0:
import GameOver
self.life = 3
import GameOver
director.push(ZoomTransition(GameOver.get_gameover(3)))
self.kill()
class MainMenu :
"""
MainMenu has state variables:
gameMap: PlayMap object
gameOver: GameOver object
state: string
startGameButton: pygame.Rect object
exitGameButton: pygame.Rect object
Assumptions: __init__() is called before any other access program
"""
def __init__(self) :
"""
Constructor for MainMenu class
Transition: initialized to main menu state
exception: none
"""
self.STATES = ['menu','game','gameOver','gamePause','instructions']
self.gameMap = PlayMap()
self.gameOver = GameOver(20)
self.gamePause = GamePause(20)
self.gameInstructions = GameInstructions()
self.pauseStatus = False
# What stage of the interface the game is on
self.state = 'menu'
# Display objects for the GUI
self.startGameButton = pygame.Rect(50,200,200,100)
self.exitGameButton = pygame.Rect(300,200,200,100)
self.diff0Button = pygame.Rect(100,400,50,50)
self.diff1Button = pygame.Rect(200,400,50,50)
self.diff2Button = pygame.Rect(300,400,50,50)
self.updateState()
# Changed representation by python of object for ease of testing
def __repr__(self) :
return (str(self.startGameButton)+str(self.exitGameButton)+str(self.diff0Button)+ str(self.diff1Button) + str(self.diff2Button) + str(self.state))
#Add ValueError exception
#change value of self.state
def changeState(self,newState) :
"""
function to change the current state of the main menu
Transition: self.state is updated to new state
exception: none
input: newState - string value of new state
output: none
"""
if self.STATES.count(newState)==1 : self.state = newState
if self.state =='menu' : self.pauseStatus = False
if self.state == 'instructions' : self.pauseStatus = False
if self.state=='game' :
if not(self.pauseStatus) :
self.gameMap = PlayMap()
if self.state=='gameOver':
self.pauseStatus = False
self.gameOver = GameOver(self.gameMap.score)
if self.state=='gamePause':
self.pauseStatus = True
self.gamePause = GamePause(self.gameMap.score)
#call necessary functions based on current state
def updateState(self) :
"""
function to return which objects to display on GUI (current state of game)
Transition: an array of objects to display on the screen is returned
exception: none
input: none
output: an array of objects (pygame)
"""
#print "MainMenu.updateState ran"
if self.state=='menu' :
return [self.startGameButton,self.exitGameButton,self.diff0Button,self.diff1Button,self.diff2Button]
if self.state=='instructions' :
return self.gameInstructions.getCurrentState()
if self.state=='game' :
self.gameMap.updateState()
return self.gameMap.getCurrentState()
if self.state=='gameOver' :
self.gameOver.updateState(self.gameMap.score)
return self.gameOver.getCurrentState()
if self.state=='gamePause' :
self.gamePause.updateState(self.gameMap.score)
return self.gamePause.getCurrentState()
def runStoryMode(self, peach):
while not self.__completed:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.__completed = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
self.__completed = True
# fills screen blue only in select rectangular area (sky)
self.__screen.fill((110, 193, 248), rect=(0, 0, 640, 384))
# fills screen green only in select rectangular area (grass/ground)
self.__screen.fill((0, 155, 0), rect=(0, 384, 640, 96))
self.findInput()
# Causes the sprite's x coordinate to change accordingly
peach.__x += self.__moveX
# if sprite hits edge of screen, it will stop there
if peach.__x <= 0:
peach.__x = 0
if peach.__x >= 620:
peach.__x = 620
# writes the super princess peach logo
self.renderLogo()
self.renderCastleRects()
startingPointsX = []
# while peach is before the first castle the sign will show
for x in range(100):
startingPointsX.append(x)
startingPointsY = [355]
if peach.__x in startingPointsX and peach.__y in startingPointsY:
self.renderSpeechBubble()
self.renderBowser()
self.renderMario()
self.writeMessage1()
self.writeMessage2()
self.renderGround()
self.renderCastle()
# associates the sprite with the image in updateSprite()
peach.updateSprite(peach)
# self.__FPS stands for frames per second
self.__clock.tick(self.__FPS)
pygame.display.update()
# stops all music from playing
pygame.mixer.music.stop()
if self.__state == 2:
# You won
playCredits = Credits.Credits()
playCredits.runCredits()
else:
# you lost, game over
playGameOver = GameOver.GameOver()
playGameOver.runGameOver()
import Intro import PlayGame import Rules import GameModeSelection import GameOver Intro.intro() players = GameModeSelection.gameModeSelection() Rules.rules() score = PlayGame.playGame(1) GameOver.gameover(score)
def Map_1_starting(screen):
chal = [0, 0, 0, 0, 0, 0, 0, 0, 0]
chal_sv = [0, 0, 0, 0, 0, 0, 0, 0, 0]
touer = [False, False, False, False]
chal_scr = [500, 1000, 2000, 4000, 6000, 2000, 500, 3000,
5000] #도전과제 달성시 보상
chal_money = [100, 200, 350, 550, 700, 200, 100, 500, 0]
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
back_ground = pygame.image.load("image/virus/map2.png")
interface = pygame.image.load("image/virus/interface.png")
map1 = map.map(screen)
map1.ch = [[120, 60], [120, 420], [300, 420], [300, 180], [540, 180],
[540, 420], [780, 420], [780, 720]]
map1.set([0, 60], [1280, 600])
chal_img = []
chal_img.append(pygame.image.load("image/challenge/chal_1.png"))
chal_img.append(pygame.image.load("image/challenge/chal_2.png"))
chal_img.append(pygame.image.load("image/challenge/chal_3.png"))
chal_img.append(pygame.image.load("image/challenge/chal_4.png"))
chal_img.append(pygame.image.load("image/challenge/chal_5.png"))
chal_img.append(pygame.image.load("image/challenge/chal_6.png"))
chal_img.append(pygame.image.load("image/challenge/chal_7.png"))
chal_img.append(pygame.image.load("image/challenge/chal_8.png"))
support_index = []
life = 20
tower1 = []
enemy1 = []
index = -1
vindex = -1
timg = []
timg.append(pygame.image.load("tower/normal_tower1.png"))
timg.append(pygame.image.load("tower/short_tower1.png"))
timg.append(pygame.image.load("tower/long_tower1.png"))
timg.append(pygame.image.load("tower/support_tower1.png"))
cancel_img = pygame.image.load("tower/cancel.png")
build = 0
build_ok = True
game_timer = time.time()
old_time = game_timer
gold = 1000
round123 = 0
count = 0
Font = pygame.font.Font(None, 52)
font = pygame.font.Font(None, 26)
vtimer = time.time()
screen.blit(back_ground, (0, 0))
map1.draw()
Gameoverbool = False
## 바이러스
badguy = []
selectNum = -1
count = 0
type_virus = 0
# bgm
pygame.mixer.init()
pygame.mixer.music.load("sound/gamebgm.wav")
pygame.mixer.music.set_volume(0.1) # 1 ~ 0.1
pygame.mixer.music.play()
pygame.mixer.Sound("sound/gamebgm.wav")
while True:
screen.blit(back_ground, (0, 0))
screen.blit(interface, (1030, 0))
map1.draw()
pygame.display.flip()
oldtime = time.time()
curtime = time.time()
while True: #Copyright : 노관태
timer = Font.render("Time : " + str(int(10 - (curtime - oldtime))),
True, (0, 0, 0)) #Copyright : 노관태
screen.blit(back_ground, (0, 0))
screen.blit(interface, (1030, 0))
if (curtime - oldtime < 10):
screen.blit(timer, (850, 20))
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
position = pygame.mouse.get_pos()
for n in range(0, len(badguy)): # Copyright : 이동우 ~
badguy[n].calDistance(position[0], position[1])
for i in range(0, len(badguy)):
if badguy[i].boolDtc():
selectNum = i
break
selectNum = -1 # ~ Copyright : 이동우
if build == 0: # made by 김재희~
for i in range(0, len(tower1)):
if tower1[i].selected:
if position[0] >= 1048 and position[
0] <= 1048 + tower1[i].sell.get_width(
):
if position[1] >= 512 and position[
1] <= 512 + tower1[
i].sell.get_height():
gold += tower1[i].sell_tower()
if tower1[i].is_support == True:
for k in range(
0, len(support_index)):
if support_index[k] == i:
support_index.pop(k)
break
for k in range(0, len(tower1)):
if tower1[
k].is_support == False:
tower1[k].plus_damage = 0
tower1.pop(i)
index -= 1
break
if position[1] >= 459 and position[
1] <= 459 + tower1[
i].upgrade.get_height():
if tower1[i].level <= 2:
if gold >= tower1[i].upgrade_price[
tower1[i].level]:
if tower1[i].level == 2:
tower1[i].upgrade_tower()
else:
gold -= tower1[
i].upgrade_tower()
else:
tower1[i].selected = tower1[
i].select_tower(
position[0], position[1])
else:
tower1[i].selected = tower1[i].select_tower(
position[0], position[1])
if position[0] >= 1050 and position[0] <= 1050 + timg[0].get_width() and \
position[1] >= 110 and position[1] <= 110 + timg[0].get_height():
if gold >= 50:
gold -= 50
index += 1
build += 1
tower1.append(tower())
tower1[index].timer = time.time()
if position[0] >= 1170 and position[0] <= 1170 + timg[1].get_width() and \
position[1] >= 110 and position[1] <= 110 + timg[1].get_height():
if gold >= 100:
gold -= 100
index += 1
build += 1
tower1.append(short_tower())
tower1[index].timer = time.time()
if position[0] >= 1050 and position[0] <= 1050 + timg[2].get_width() and \
position[1] >= 230 and position[1] <= 230 + timg[2].get_height():
if gold >= 100:
gold -= 100
index += 1
build += 1
tower1.append(long_tower())
tower1[index].timer = time.time()
if position[0] >= 1170 and position[0] <= 1170 + timg[3].get_width() and \
position[1] >= 230 and position[1] <= 230 + timg[3].get_height():
if gold >= 100:
gold -= 100
index += 1
build += 1
tower1.append(support_tower())
support_index.append(index)
tower1[index].timer = time.time()
elif build == 1:
for i in range(0, len(tower1)):
if (i != index):
if (position[0] <= tower1[i].x + timg[0].get_width() / 2 and position[0] >= tower1[
i].x - timg[0].get_width() / 2 \
and position[1] <= tower1[i].y + timg[0].get_height() / 2 and position[1] >=
tower1[i].y - timg[0].get_height() / 2):
build_ok = False
break
else:
build_ok = True
if build_ok == True:
build -= 1
if tower1[index].tower_name == "normal tower":
touer[0] = True
if tower1[index].tower_name == "short tower":
touer[1] = True
if tower1[index].tower_name == "long tower":
touer[2] = True
if tower1[index].tower_name == "support tower":
touer[3] = True
if position[0] >= 1150 and position[0] <= 1150 + cancel_img.get_width() and \
position[1] >= 615 and position[1] <= 615 + cancel_img.get_height():
index -= 1
if tower1[i].is_support:
support_index.pop()
tower1.pop()
if build == 1: # made by 김재희~
position = pygame.mouse.get_pos()
tower1[index].build_tower(position[0], position[1])
for i in range(0, len(tower1)):
attack_on = False
if len(badguy) > 0:
for j in range(0, len(badguy)):
if build == 1:
if index == i:
break
if (tower1[i].is_support != True):
if (badguy[j].center[0] - tower1[i].x) * (badguy[j].center[0] - tower1[i].x) \
+ (badguy[j].center[1] - tower1[i].y) * (badguy[j].center[1] - tower1[i].y) <= tower1[i].range * \
tower1[i].range:
attack_on = True
if tower1[i].tower_attack(game_timer):
badguy[j].hp -= tower1[i].damage + tower1[
i].plus_damage
if badguy[j].hp <= 0:
badguy[j].dead()
badguy.pop(j)
if selectNum == j:
selectNum = -1
elif selectNum > j:
selectNum -= 1
vindex -= 1
break
break
else:
if tower1[i].is_support == False:
tower1[i].attack = 0
if tower1[i].is_support == False:
if attack_on == False:
tower1[i].attack = 0
if build == 0:
for i in support_index:
exist = False
for j in range(0, len(tower1)):
if tower1[j].is_support == False:
if (tower1[j].x - tower1[i].x) * (tower1[j].x - tower1[i].x) \
+ (tower1[j].y - tower1[i].y) * (tower1[j].y - tower1[i].y) <= tower1[i].range * \
tower1[i].range:
tower1[j].plus_damage = tower1[i].plus_damage
exist = True
tower1[i].tower_attack(game_timer)
if exist == False:
tower1[i].attack = 0 # ~made by 김재희
for i in range(0, len(tower1)):
tower1[i].blit_tower(screen)
for i in range(0, len(enemy1)):
screen.blit(
enemy1[i].enemy_img,
(enemy1[i].x - enemy1[i].enemy_img.get_width() / 2,
enemy1[i].y - enemy1[i].enemy_img.get_height() / 2))
gold_font = font.render(str(gold), True, (0, 0, 0))
life_font = font.render(str(life), True, (0, 0, 0))
screen.blit(life_font, (1080, 32))
screen.blit(gold_font, (1195, 32))
screen.blit(timg[0], (1050, 112))
screen.blit(timg[1], (1175, 115))
screen.blit(timg[2], (1052, 238))
screen.blit(timg[3], (1177, 233))
screen.blit(cancel_img, (1150, 615))
game_timer = time.time()
map1.draw()
chal = challenge.challenge_1_5_8_9(chal, virus.Virus.AllNum, gold,
touer)
for z in range(0, 7, 1):
if chal_sv[z] == 0 and chal[z] == 1:
chal_sv[z] = 2
managetime = time.time()
for z in range(0, 7, 1):
if chal_sv[z] != 0:
if curtime - managetime < 3:
scr_giv = font.render("+" + str(chal_scr[z]), True,
(0, 0, 0))
screen.blit(scr_giv, (1075, 60))
mon_giv = font.render("+" + str(chal_money[z]), True,
(0, 0, 0))
screen.blit(mon_giv, (1190, 60))
if chal_sv[z] == 2:
gold += int(chal_money[z])
chal_sv[z] = 1
screen.blit(chal_img[z], (0, 0))
elif curtime - managetime > 3:
if chal_sv[z] == 2:
chal_sv[z] = 1
if (curtime - oldtime > 2):
# 타이머 구현 #copyright 이동우
if count < 40:
if curtime - vtimer >= 1:
count += 1
vtimer = curtime
badguy.append(virus.Virus(type_virus))
vindex += 1
badguy[vindex].setType()
badguy[vindex].setPos([780, 720])
badguy[vindex].path = [[780, 720], [780, 420],
[540, 420], [540, 180],
[300, 180], [300, 420],
[120, 420], [120, 60], [0, 60]]
type_virus = count // 10
# 문구 출력 #copyright 이동우
virus.draw_text("remaining virus : ", screen, 110, 20, BLACK)
virus.draw_text(str(len(badguy)), screen, 210, 20, BLACK)
#virus.draw_text(str(selectNum), screen, 210, 40, BLACK)
if life < 0:
virus.draw_text("Game over", screen, 640, 300, BLACK)
#바이러스 좌표 조정 #copyright 이동우
for n in range(0, len(badguy)):
if badguy[n].pos[0] < badguy[n].x_size: # 바이러스가 맵 끝에 도달하면
vindex -= 1
life -= badguy[n].dmg
badguy.pop(n)
if selectNum == n:
selectNum = -1
elif selectNum > n:
selectNum -= 1
break
else:
badguy[n].move()
# 바이러스 화면 출력 #copyright 이동우
for n in range(0, len(badguy)):
x = badguy[n].pos[0]
y = badguy[n].Repeat(badguy[n].pos[1])
screen.blit(badguy[n].img, (x, y))
# 바이러스 클릭 시 바이러스 정보 출력 #copyright 이동우
if selectNum == -1:
pass
elif selectNum != -1:
badguy[selectNum].drawInfo(screen, 1085, 370)
if (life <= 0):
Gameoverbool = True
break
if count >= 40:
if len(badguy) == 0:
break
pygame.display.flip()
curtime = time.time()
if Gameoverbool:
GameOver.GameOver(screen, 95000, life, gold)
return 1
chal = challenge.challenge_6(chal, life)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
def game(level, screen):
score = 0
boolean = False
time_initial = pygame.time.get_ticks()
clock = pygame.time.Clock()
music_selection(level)
#Level selection
if level.id == 0:
point1 = Checkpoint(842, 50)
point2 = Checkpoint(130, 480)
screen.blit(intro1.image, intro1.rect)
pygame.display.update()
while True: # wait for user to acknowledge and return
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN and event.key in [pygame.K_RETURN, pygame.K_KP_ENTER,
pygame.K_BACKSPACE]:
boolean = True
break
if boolean:
break
pygame.time.wait(20)
elif level.id == 1:
point1 = Checkpoint(730, 30)
point2 = Checkpoint(858, 500)
screen.blit(intro2.image, intro2.rect)
pygame.display.update()
while True: # wait for user to acknowledge and return
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN and event.key in [pygame.K_RETURN, pygame.K_KP_ENTER,
pygame.K_BACKSPACE]:
boolean = True
break
if boolean:
break
pygame.time.wait(20)
else:
point1 = Checkpoint(20, 70)
point2 = Checkpoint(900, 400)
screen.blit(intro3.image, intro3.rect)
pygame.display.update()
while True: # wait for user to acknowledge and return
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN and event.key in [pygame.K_RETURN, pygame.K_KP_ENTER,
pygame.K_BACKSPACE]:
boolean = True
break
if boolean:
break
pygame.time.wait(20)
level.mapa(screen)
screen.blit(point1.image, point1.rect)
screen.blit(point2.image, point2.rect)
#Initialization variables
player_x0, player_y0, player_angle = player_constants(level)
heli_x0, heli_y0, heli_angle, patrol_radius = heli_constants(level)
#Terrain parameters
angle_step = 7.5
terrain_factor = 1
cont = 0
Font = pygame.font.SysFont("arial", 20, True)
txt_surf = Font.render("", True, WHITE)
#Class initialization
object_group = pygame.sprite.Group()
player = Player(player_x0, player_y0, player_angle)
heli = Heli(1, SCREENHEIGHT-1, heli_angle)
second_heli = Heli(heli_x0, heli_y0, heli_angle)
capivara = Capivara()
soldier = Soldier()
object_group.add(heli)
object_group.add(second_heli)
object_group.add(capivara)
object_group.draw(screen)
screen.blit(player.image, player.rect)
if soldier.state:
screen.blit(soldier.image, soldier.rect)
#Game Over criteria
game_over = GameOver()
while not game_over.state:
# GET EVENT
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN and event.key == K_p:
pause(screen)
player.handle_event(event)
#Handle terrain
level.mapa(screen)
terrain_factor = measure_terrain(player, level, screen)
if cont == 0:
Font = pygame.font.SysFont("arial", 20, True)
txt_surf = Font.render("", True, WHITE)
else:
cont -= 1
# Atualização de Score e Verificação de Flags das etapas dos Jogos
if level.verificarmissao(player, point1, point2):
time_flag = pygame.time.get_ticks()
Font = pygame.font.SysFont("arial", 24, True)
txt_surf = Font.render("CHECKPOINT ACEITO", True, WHITE)
cont = 45
score += int(1000 - 5 * (time_flag / 1000 - time_initial / 1000)) # modelo de Score
if level.vencedor():
pygame.mixer.music.stop()
arq = level.file()
get_score(screen, arq, score)
break
#Player movement
player.move(terrain_factor, angle_step)
#Bot reaction
'''bot_1.follow(player.x, player.y)
bot_2.follow(player.x, player.y)'''
capivara.time_counter(level, screen, SCREENHEIGHT)
soldier.time_counter(level, screen, SCREENHEIGHT)
player.update_pos(angle_step)
heli.follow(player.x, player.y)
second_heli.patrol(heli_x0, heli_y0, patrol_radius)
heli.update_pos(player.x)
second_heli.update_pos(player.x)
level.mapa(screen)
screen.blit(player.image, player.rect)
screen.blit(point1.image, point1.rect)
screen.blit(point2.image, point2.rect)
screen.blit(txt_surf, (600, 450))
object_group.draw(screen)
if soldier.state:
screen.blit(soldier.image, soldier.rect)
#Game over verification
object_group.add(soldier)
game_over.measure_state(player, object_group)
object_group.remove(soldier)
#Screen update
pygame.display.update()
clock.tick(20) # Time do relógio
if game_over.state:
pygame.mixer.music.stop()
screen.blit(gameover.image, gameover.rect)
pygame.display.update()
game_over_sound()
while True: # wait for user to acknowledge and return
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN and event.key in [pygame.K_RETURN, pygame.K_KP_ENTER,
pygame.K_BACKSPACE]:
return
pygame.time.wait(20)
from MainMenu import *
from Gameplay import *
from GameOver import *
from HighScores import *
from LevelScreen import *
# load game resources
big_font = pygame.font.Font("data/visitor.ttf", 64)
small_font = pygame.font.Font("data/visitor.ttf", 48)
mesh_list = loadMeshes("data/meshes.dsc", "data/sprites.png")
# create & init subsystems
screen = pygame.display.set_mode((800, 600))
mainMenu = MainMenu(big_font, (255, 0, 0), (0, 255, 0))
gameplay = Gameplay(mesh_list, big_font)
gameOver = GameOver(big_font)
highScores = HighScores(big_font)
levelScreen = LevelScreen(big_font)
mainMenu._gameplay = gameplay
mainMenu._highScores = highScores
gameplay._mainMenu = mainMenu
gameplay._gameOver = gameOver
gameOver._highScores = highScores
highScores._mainMenu = mainMenu
levelScreen._gameplay = gameplay
gameplay._levelScreen = levelScreen
mainMenu._levelScreen = levelScreen
quit = False
# game main loop
gameState = mainMenu
def update(self, time):
self.l_interval = self.l_interval + .01
if self.l_interval >= 4 * math.pi:
self.l_interval = 0.0
self.time += time
while self.time > G.Globals.INTERVAL:
self.time -= G.Globals.INTERVAL
curr_enemies = PS.Group()
for i, e in enumerate(self.enemies.sprites()):
dead, bull = e.update(G.Globals.INTERVAL, self.player,
self.map, self.enemies.sprites(), i)
if dead:
self.enemies.remove(e)
if self.map.boss_coord is not None:
Game.SCORE += 500
G.new_level(self.player)
return
elif not (e.rect.x < - e.rect.width or e.rect.x > G.Globals.WIDTH + e.rect.width \
or e.rect.y < -e.rect.height or e.rect.y > G.Globals.HEIGHT + e.rect.height):
curr_enemies.add(e)
if bull is not None:
self.e_bullets.add(bull)
for b in self.bullets.sprites():
if b.update(G.Globals.INTERVAL):
self.bullets.remove(b)
for b in self.e_bullets.sprites():
if b.update(G.Globals.INTERVAL):
self.e_bullets.remove(b)
for blood in self.blood:
blood.update(G.Globals.INTERVAL)
if blood.gone:
self.blood.remove(blood)
for stain in self.blood_stains:
stain.update()
for heart in self.hearts_group.sprites():
heart.update()
self.player.update(G.Globals.INTERVAL)
self.set_screen_cords_player()
#self.collision(curr_enemies, self.bullets, self.e_bullets, self.player_group, self.wall_sprites_list)
# Are there collisions
# Player Collision with walls
result = PS.groupcollide(self.player_group, self.wall_sprites_list,
False, False)
for key in result:
for wall in result[key]:
if self.player.rect.colliderect(wall.rect):
val = self.player.wall_collision(wall, self.map)
self.set_screen_cords_player()
if val == 1:
self.wall_sprites_list.remove(wall)
if val == 2:
Game.SCORE += 100
G.new_level(self.player)
# Player collision with enemies
result = PS.groupcollide(self.player_group, curr_enemies, False,
False)
for key in result:
for enemy in result[key]:
if enemy.dying is False and self.player.take_damage(1):
G.Globals.STATE = GameOver.GameOver(False, Game.SCORE)
# Player collision with enemy bullets
result = PS.groupcollide(self.player_group, self.e_bullets, False,
False)
for player in result:
if self.player.take_damage(1):
G.Globals.STATE = GameOver.GameOver(False, Game.SCORE)
blood_x = player.world_coord_x + Player.Player.WIDTH / 2
blood_y = player.world_coord_y + Player.Player.HEIGHT / 2
self.blood.append(Blood.Blood(blood_x, blood_y, .8))
p_width = Player.Player.WIDTH
p_height = Player.Player.HEIGHT
self.blood_stains.append(
BloodStain.BloodStain(blood_x, blood_y, p_width, p_height))
for bullet in result[player]:
self.e_bullets.remove(bullet)
# Enemy Collision with Bullets
result = PS.groupcollide(curr_enemies, self.bullets, False, False)
for enemy in result:
if enemy.dying is True:
continue
if self.double_kill is False:
self.double_kill = True
self.double_kill_timer = 0
self.last_killed = enemy
if self.double_kill_timer < Game.DOUBLE_KILL_TIME and self.double_kill \
and self.last_killed is not enemy:
#Game.DOUBLE_KILL_SOUND.play()
self.double_kill = False
enemy.start_death()
blood_x = int(enemy.world_x + enemy.width / 2)
blood_y = int(enemy.world_y + enemy.height / 2)
self.blood.append(Blood.Blood(blood_x, blood_y, .8))
self.blood_stains.append(
BloodStain.BloodStain(blood_x, blood_y, enemy.width,
enemy.height))
Game.SCORE = Game.SCORE + 10
for bullet in result[enemy]:
if self.player.piercing is False and bullet.__class__.__name__ is not "Laser":
self.bullets.remove(bullet)
if random.random() < Game.HEALTH_DROP_RATE:
self.hearts_group.add(
Heart.Heart(enemy.world_x, enemy.world_y))
# Bullets Collide with Wall
result = PS.groupcollide(self.bullets, self.wall_sprites_list,
False, False)
for bullet in result:
if bullet.__class__.__name__ is not "Laser":
self.bullets.remove(bullet)
# Enemy Bullets Collide with Wall
result = PS.groupcollide(self.e_bullets, self.wall_sprites_list,
False, False)
for bullet in result:
self.e_bullets.remove(bullet)
# Player picking up hearts
if self.player.health < self.player.max_health:
heart = PS.spritecollideany(self.player, self.hearts_group)
if heart is not None:
self.hearts_group.remove(heart)
self.player.health += 1
if self.player.health > self.player.max_health:
self.player.health = self.player.max_health
if self.double_kill:
self.double_kill_timer += time
if self.double_kill_timer > Game.DOUBLE_KILL_TIME:
self.double_kill = False
