def check_for_level_complete(self):
if Collision.is_colliding(self.top_player, self.level.top_goal):
if Collision.is_colliding(self.bottom_player,
self.level.bottom_goal):
if self.level_num == self.max_level_num - 1:
self.transition_to(GameState.CREDITS)
else:
self.transition_to(GameState.GAMEPLAY)
def ray_line(self, start_x, start_y, alpha, x1, y1, x2, y2):
x, y, dis = raycast(start_x, start_y, self.rotation + alpha, x1, y1,
x2, y2)
if x != -1 and y != -1:
if abs(
Collision.dis(x1, y1, x, y) + Collision.dis(x, y, x2, y2) -
Collision.dis(x1, y1, x2, y2)) < 0.0001:
return x, y, dis
return -1, -1, -1
def load_game(self):
pygame.init()
self.screen = pygame.display.set_mode(self.size_window)
pygame.display.set_caption("breakout")
self.escenario = Escenario(self.screen)
self.collision = Collision(5)
self.pelota = Pelota(self.screen, 16, 16, "sprites/pelota_white.png")
self.pelota.set_velocity(2, 5)
self.raquet = Raqueta(self.screen, 74, 12, "sprites/raquet_white.png")
self.raquet.set_position(300, 550)
self.bricks = self.load_bricks(12, self.nivel)
self.tam_list = len(self.bricks)
self.loop()
def Update(self, Brick_num):
#Run Your Beat는 화면 스크롤링을 택하고있음
#따라서 캐릭터는 고정되있고 화면이 이동
#따라서 화면을 구성하는 객체도 일정하게 이동해줘야한다
if (PCharacter.Player.move_x >= 500):
for i in range(Brick_num):
Brick.List_tile[i][0] -= PCharacter.Player.move_size
if Brick.List_tile[i][0] <= -1500:
Brick.List_tile[i][0] = -1500
for i in range(Brick_num):
if Collision.collide_for_brick(character, self, i):
Brick.List_tile[i][8] = True
else:
Brick.List_tile[i][8] = False
if Brick.List_tile[i][8] == True:
PCharacter.Player.CollwithTile = True
PCharacter.Player.move_y = Brick.List_tile[i][
1] + Brick.List_tile[i][5] + character.half_height
PCharacter.Player.jump_cnt = 0
#종료조건
for i in range(Brick_num):
if Brick.List_tile[i][8] == True and i == Brick_num:
PCharacter.Player.move_size = 0
def __init__(self, **kwargs):
"""
Create a component.
kwarg : description : default
x : local x coordinate of bottom-left corner : 0
y : local y coordinate of bottom-left corner : 0
w : width of the component : 0
h : height of the component : 0
parent : parent's component : None
batch : rendering batch : None
group : the component's base rendering group : None
visible : if the component is drawing/visible : True
"""
self._x, self._y = kwargs.get('x', 0), kwargs.get('y', 0) #pylint:disable-msg=C0103,C0301
self._w, self._h = kwargs.get('w', 0), kwargs.get('h', 0) #pylint:disable-msg=C0103,C0301
self._visible = kwargs.get('visible', True)
self._collider = Collision.make_rect_at_bottom_left(
self._x, self._y, self._w, self._h)
self._id = Engine.ID.get_id(self)
self._parent = kwargs.get('parent', None)
self._elements = []
self._batch = kwargs.get('batch', None)
self._group = kwargs.get('group', None)
self._element_group = None
self.update_batch(self._batch, self._group)
self._dirty = False
def clock_titlescreen(color_playground, rgg_led_drawer, red_playground, led_matrix_drawer, controller):
while True:
color_playground.clear()
red_playground.clear()
# TODO: this is a quite ugly hack, since NumberToBlock only supports 4 digit numbers
now = datetime.datetime.now()
min = now.time().minute
hour = now.time().hour
mon = now.date().month
today = now.date().day
sec = now.time().second
year = now.date().year % 100
color_playground.add_block(numbertoblock.NumberToBlock.get_block(hour * 100), 0, 0)
color_playground.add_block(numbertoblock.NumberToBlock.get_block(min * 100), 0, 6)
color_playground.add_block(numbertoblock.NumberToBlock.get_block(sec * 100), 0, 12)
red_playground.add_block(numbertoblock.NumberToBlock.get_block(today * 100 + mon), 0, 0)
red_playground.add_block(numbertoblock.NumberToBlock.get_block(year * 100), 21, 0)
rgg_led_drawer.draw_playground(color_playground)
led_matrix_drawer.draw_playground(red_playground)
pygame.time.Clock().tick(1)
result = controller.get_button_pressed((1, 1), Collision.Collision_Dedektor(),
Playground.Playground(20, 10))
if result == "Restart":
break
color_playground.clear()
red_playground.clear()
def __init__(self, **kwargs):
"""
Create a component.
kwarg : description : default
x : local x coordinate of bottom-left corner : 0
y : local y coordinate of bottom-left corner : 0
w : width of the component : 0
h : height of the component : 0
parent : parent's component : None
batch : rendering batch : None
group : the component's base rendering group : None
visible : if the component is drawing/visible : True
"""
self._x, self._y = kwargs.get('x', 0), kwargs.get(
'y', 0) #pylint:disable-msg=C0103,C0301
self._w, self._h = kwargs.get('w', 0), kwargs.get(
'h', 0) #pylint:disable-msg=C0103,C0301
self._visible = kwargs.get('visible', True)
self._collider = Collision.make_rect_at_bottom_left(
self._x, self._y, self._w, self._h)
self._id = Engine.ID.get_id(self)
self._parent = kwargs.get('parent', None)
self._elements = []
self._batch = kwargs.get('batch', None)
self._group = kwargs.get('group', None)
self._element_group = None
self.update_batch(self._batch, self._group)
self._dirty = False
def check_collision(self, screen, charx, chary, charsize):
for ny, i in enumerate(self.map):
for nx, j in enumerate(i):
if j == 1 or j == 2 or j == 3 or j ==4:
collided = Collision.rect_collision(int((nx)*self.size-charx+screen.get_width()/2), int((ny)*self.size-chary+screen.get_height()/2), self.size, self.size, int(screen.get_width()/2-charsize/2), int(screen.get_height()/2-charsize/2), charsize, charsize, "pos")
if collided[0] != 0 and collided[1] != 0:
return (collided, [j, nx, ny])
'''
posx = int((charx+charsize/2)/self.size)
posy = int((chary+charsize/2)/self.size)
try:
if self.map[posy][posx] == 1:
return Collision.rect_collision(charx, chary, charsize, charsize, posx*self.size, posy*self.size, self.size, self.size, "pos")
except IndexError:
pass
posx = int((charx-charsize/2)/self.size)
posy = int((chary+charsize/2)/self.size)
try:
if self.map[posy][posx] == 1:
return Collision.rect_collision(charx-charsize/2, chary, charsize, charsize, posx*self.size, posy*self.size, self.size, self.size, "pos")
except IndexError:
pass
posx = int((charx+charsize/2)/self.size)
posy = int((chary-charsize/2)/self.size)
try:
if self.map[posy][posx] == 1:
return Collision.rect_collision(charx, chary-charsize/2, charsize, charsize, posx*self.size, posy*self.size, self.size, self.size, "pos")
except IndexError:
pass'''
return ([0, 0], [-1, 0, 0])
def __init__(self):
self.pywindow = pygame.display.set_mode((900, 600), 0, 32) #窗口大小
self.image = Image.Image() #导入图片
self.botany = Botany.Botany() #植物类
self.zombie = Zombie.Zombie() #僵尸类
self.collision = Collision.Collision() #碰撞类
self.audio = Audio.Audio() #音频类
self.Sunny_Collect = [] #回收的阳光坐标列表
self.Sunny_Collect_x = 0
self.Sunny_Collect_y = 0
self.Botany_Type = 0 #植物类型
self.Botany_Animation_Type = 0 #植物动画类型
self.Zombie_Animation_Type = 0 #僵尸动画类型
self.Stop_image = self.image.game_pause_nor #暂停初始图标
self.Zombie_image_list = 0 #僵尸图片列表索引
self.SunFlower_image_list = 16 #向日葵图片列表索引(从后往前索引只是想测试一下，并无大碍）
self.Peashooter_image_list = 12 #豌豆列表索引
self.ZombieAttack_image_list = 0 #僵尸吃植物索引
self.FootballZombie_image_list = 0 #重装僵尸图片索引
self.FootballZombieAttack_image_list = 0 #重装僵尸吃植物图片索引
self.FootballZombieDie_image_list = 0 #重装僵尸死亡图片索引
self.evillaugh = pygame.mixer.Sound(self.audio.evillaugh) #僵尸暴走音效
self.Zombie_Go_ballistic_audio = 0 #暴走音效控制变量
self.scream = pygame.mixer.Sound(self.audio.scream) #僵尸胜利音效
self.buttonclick = pygame.mixer.Sound(self.audio.buttonclick) # 按钮音效
self.Zdie = pygame.mixer.Sound(self.audio.groan4) #僵尸死亡音效
self.ZWon = 0 #僵尸胜利后音效控制
def Draw():
global Global, sound
sound.play_bgm(Global.stage)
if (Global.stage == "main"):
TitleDraw()
elif (Global.stage == "stage"):
CreateBullet()
StageDraw()
shoot()
Global.MonsterActive()
Global.MonsterMove()
Global.MonsterAttack()
BulletDraw()
MonsterDraw()
Collision()
BulletEffect()
UI_Draw()
if (Global.g_Clear == True):
ClearUI_Draw()
elif (Global.stage == "level"):
LevelDraw()
if (Global.stage != "stage"):
EffectDraw()
#mouse cursor
Texture.P_mouse.draw(Global.MyMouse[0], Global.MyMouse[1], 100, 100)
def enter():
global braveCookie, Back_Ground, Back_Ground2, JellyOb, CollisionCh_I
braveCookie = BraveCookie_Object.Brave_Cookie()
Back_Ground = Scrolling.Background(1136, 640)
Back_Ground2 = Scrolling.Background2(1136, 640)
JellyOb = [Jelly(1136 + i * 150, 165) for i in range(1000)]
CollisionCh_I = Collision.Collide()
def Moteur(self, stop):
print("Lancement de la thread du moteur physique")
while res.continuer_jeu == 1:
pygame.time.Clock().tick(res.VitesseJeu)
if res.character.vitesse_x != 0:
#La vitesse n'est pas nulle, on fait avancer le personnage
res.character.PosX = res.character.vitesse_x + res.character.PosX
if(Collision.Collision() == 1):
res.character.PosX = res.character.PosX - res.character.vitesse_x
if res.character.vitesse_y != 0:
#La vitesse n'est pas nulle, on fait avancer le personnage
res.character.PosY = res.character.vitesse_y + res.character.PosY
if(Collision.Collision() == 1):
res.character.PosY = res.character.PosY - res.character.vitesse_y
def main():
Run = True
screen = pg.display.set_mode((WIN_WIDTH, WIN_HEIGHT))
clock = pg.time.Clock()
Walls = createWalls()
Rays = createRays()
while Run:
clock.tick(30)
for event in pg.event.get():
if event.type == pg.QUIT:
Run = False
pg.quit()
sys.exit(0)
# Update Ray Position and Intersection points
for ray in Rays:
Collision.checkIntersection(Walls, ray)
#Draw
Draw_Window(screen, Rays, Walls)
def main(): # Main
screen = Screen.gameWindow() # Initialize game window parameters
startTime = pygame.time.get_ticks() # Initialize game start clock time
Player1 = Player.getPlayer(screen) # Initialize player
professors = Professor.getProfessors(screen) # Initialize professors
running = True # Control variable for game loop
while running: # Run while true
currentTime = pygame.time.get_ticks(
) # Get clock time since game started
Screen.setMaxFPS() # Set max frames per second
for event in pygame.event.get(
): # Event handling, gets all event from the event queue
if (event.type == pygame.QUIT
): # Player clicked the window's X to quit
running = False # Set game loop control variable to false
Player1.getInput() # Get player 1 input
Professor.getInput(screen, professors) # Get input of professors
Collision.checkCollision(
Player1, professors,
screen) # Check if player collides with any professors
Screen.updateScreen(Player1, screen,
professors) # Update screen output
def checkNoCollision(T1I, T2I, T3I, DI):
state = CSpace.cspaceToState(T1I, T2I, T3I, DI)
worldState = forwardKinematics(*state)
for i in range(0, len(worldState), 2):
pos = worldState[i]
fwd = worldState[i + 1]
for o in OBS:
if Collision.sphereInter(pos, fwd, o.pos, o.radius):
return False
return True
def normalGame(score, difficulty, record):
while True:
flap = False
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN and event.key == K_ESCAPE:
if pause():
return True
if event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_UP):
SOUNDS['wing'].play()
flap = True
collision = Collision(OBJECTS['bird'], OBJECTS['pipe'], HITMASK)
infoCollision = collision.checkCollision()
if infoCollision[0]:
if gameOver({'collision': infoCollision, 'score': score, 'difficulty': difficulty, 'record': record}):
return True
else:
return False
SCREEN.blit(IMAGES['background'], (0, 0))
OBJECTS['pipe'].draw(SCREEN, hard=difficulty)
OBJECTS['base'].draw(SCREEN)
OBJECTS['bird'].draw(SCREEN)
OBJECTS['bird'].movement(flap)
score = showScore(score)
stringRecord = "Record: " + str(record)
drawText(10, 10, stringRecord, (255, 255, 255), 35)
pygame.display.update()
CLOCK.tick(FPS)
def run_game():
# Some stuff needed by PyGame
pygame.init()
# use Joystick and Controller
pygame.joystick.init()
joystick = pygame.joystick.Joystick(0)
joystick.init()
# todo: new sounds
pygame.mixer.init()
pygame.mixer.music.load('./Music/Tetris Edit 1 Export 3.mp3')
new_block = pygame.mixer.Sound('./Music/New_Block.wav')
game_over_sound = pygame.mixer.Sound('./Music/GameOver.wav')
break_sound = pygame.mixer.Sound('./Music/break.wav')
lines1_3 = pygame.mixer.Sound('./Music/1.-3.lane.wav')
line4 = pygame.mixer.Sound('./Music/4.lane.wav')
# pygame.mixer.music.play(-1)
pygame.mixer.music.set_volume(0.5)
pygame.mixer.music.play(-1)
gamepad = Controller.Controller(joystick)
# drawer for playfield
rgg_led_drawer = rgbleddrawer.RgbLedDrawer()
# drawer for scoreboard
led_matrix_drawer = Matrix_Drawer.LedMatrixDrawer()
# Playgrounds
color_playground = Playground.Playground(20, 10)
red_playground = Playground.Playground(8, 32)
score1 = 0
score2 = 0
collision = Collision.Collision_Dedektor()
clock = pygame.time.Clock() # type: pygame.time.Clock
clock_titlescreen(color_playground, rgg_led_drawer, red_playground, led_matrix_drawer, Controller)
game_over = False
while not game_over:
color_playground.add_object(Objects.Objecttype.paddle_left, 3, 3)
rgg_led_drawer.draw_playground(color_playground)
#todo: here is were the game is written
del led_matrix_drawer
del rgg_led_drawer
pygame.event.get()
pygame.quit()
def Update(self):
#장애물 이미지프레임변화
for i in range(Obstacle.total_Obstacle_num):
if (Obstacle.Obstacle_List[i][7] == True):
Obstacle.Obstacle_List[i][2] = (Obstacle.Obstacle_List[i][2] +
1) % 5
if Obstacle.Obstacle_List[i][2] == 4:
Obstacle.Obstacle_List[i][4] = (
Obstacle.Obstacle_List[i][4] + 1) % 7
Obstacle.Obstacle_List[i][8] -= 1
else:
Obstacle.Obstacle_List[i][2] = (Obstacle.Obstacle_List[i][2] +
1) % 6
if (Obstacle.Obstacle_List[i][2] == 5):
Obstacle.Obstacle_List[i][4] = (
Obstacle.Obstacle_List[i][4] + 1) % 7
if (Obstacle.Obstacle_List[i][8] <= 0):
Obstacle.Obstacle_List.remove(Obstacle.Obstacle_List[i])
Obstacle.total_Obstacle_num -= 1
break
#캐릭터 이동에 따른 장애물 이동
if (character.move_x >= 500):
for i in range(Obstacle.total_Obstacle_num):
Obstacle.Obstacle_List[i][0] -= character.move_size
if (Obstacle.Obstacle_List[i][0] <= -1000):
Obstacle.Obstacle_List[i][0] = -1000
#장애물 충돌체크
for i in range(Obstacle.total_Obstacle_num):
if (Collision.collide_for_obstacle(character, self, i)):
#print("Collision ", self.Obstacle_num)
if Obstacle.Obstacle_List[i][9] == False:
#장애물 죽는 모션 이미지 프레임 = 0
Player_UI.User_UI.User_point -= 1000
Player_UI.User_UI.User_HP -= 10
Obstacle.Obstacle_List[i][3] = 0
Obstacle.Obstacle_List[i][4] = 0
Obstacle.Obstacle_List[i][7] = True
Obstacle.Obstacle_List[i][9] = True
def Update_meso(self):
#메소(포인트) 업데이트
for i in range(self.coin_num):
#if(GameManager.List_meso[i][0] >= 0 and GameManager.List_meso[i][0] <= 1500): #화면에 보이는 메소들만 충돌체크
if(Collision.collide_for_coin(character,self,i)):
GameManager.List_meso[i][3] = 0
GameManager.List_meso[i][6] = True
if (PCharacter.Player.move_x >= 500):
GameManager.List_meso[i][0] -= character.move_size
Point_meso.meso_counting = 0
#메소 프레임 업데이트
for Point_meso.meso_counting in range(self.coin_num):
GameManager.List_meso[Point_meso.meso_counting][2] = (GameManager.List_meso[Point_meso.meso_counting][2] + 1) % 11
if(GameManager.List_meso[Point_meso.meso_counting][2] == 10):
GameManager.List_meso[Point_meso.meso_counting][7] = (GameManager.List_meso[Point_meso.meso_counting][7] + 1) % 4
Point_meso.meso_counting = 0
# 메소와 캐릭터간의 충돌체크
for Point_meso.meso_counting in range(self.coin_num):
if(GameManager.List_meso[Point_meso.meso_counting][6] == True):
if(GameManager.List_meso[Point_meso.meso_counting][5] == 4):
Player_UI.User_UI.User_point += GameManager.List_meso[Point_meso.meso_counting][4]
GameManager.List_meso.remove(GameManager.List_meso[Point_meso.meso_counting])
self.coin_num -= 1
break
#Point_meso.meso_counting -= 1
else:
if (GameManager.List_meso[Point_meso.meso_counting][5] == 0):
GameManager.List_meso[Point_meso.meso_counting][1] += 5
elif (GameManager.List_meso[Point_meso.meso_counting][5] == 1):
GameManager.List_meso[Point_meso.meso_counting][1] += 10
elif (GameManager.List_meso[Point_meso.meso_counting][5] == 2):
GameManager.List_meso[Point_meso.meso_counting][1] += 15
elif (GameManager.List_meso[Point_meso.meso_counting][5] == 3):
GameManager.List_meso[Point_meso.meso_counting][1] += 20
GameManager.List_meso[Point_meso.meso_counting][5] += 1
Point_meso.meso_counting = 0
def raycast(xt, yt, alpha, x1, y1, x2, y2):
if x1 > x2:
x1, x2 = x2, x1
y1, y2 = y2, y1
xt = float(xt)
yt = float(yt)
alpha = float(alpha)
x1 = float(x1)
y1 = float(y1)
x2 = float(x2)
y2 = float(y2)
m = math.tan(alpha)
m2 = (y2 - y1) / (x2 - x1)
x = (m * xt - m2 * x1 + y1 - yt) / (m - m2)
y = x * m2 - x2 * m2 + y2
d = (xt - x1) * (y2 - y1) - (yt - y1) * (x2 - x1)
a2 = math.atan(m2)
ezer = round((alpha - a2 + math.pi / 2) / (math.pi)) % 2
if (d >= 0 and ezer == 1) or (d < 0 and ezer == 0):
return x, y, Collision.dis(x, y, xt, yt)
return -1, -1, -1
def is_colliding(self, blocks, x, y):
for block in blocks:
if Collision.is_colliding_at(self, block, x, y):
return block
return None
#if the ball hits the top, change its velocity so it goes down
if ball.y < 10:
vy = 3
#if the paddle hits the left wall, change its velocity so it stops moving
if paddle.x < 0:
paddle.x = 0
#if the paddle hits the right wall, change its velocity so it stops moving
if paddle.x > 450:
paddle.x = 450
#if the ball hits the paddle, change the ball's velocity so it goes up
if Collision.collide(ball.x,ball.y,ball.r,(paddle.x,paddle.y,paddle.w,paddle.h)):
vy = -3
if paddle.x < ball.x:
vx = -((paddle.x+paddle.w/2.)-ball.x)/15
elif paddle.x >= ball.x:
vx = ((paddle.x+paddle.w/2.)-ball.x)/15
#slows down the screen
clock.tick(60)
#move the ball vx pixels right and vy pixels down
ball.move(vx,vy)
#move the paddle px pixels right
paddle.move(px)
class Breakout():
def __init__(self):
self.WHITE = 225, 225, 225
self.BLACK = 0, 0, 0
self.clock = pygame.time.Clock()
self.size_window = (700, 600)
self.game_over = False
self.salir = False
self.soltar_pelota = False
self.puntaje = 0
self.nivel = 1
self.vidas = 3
self.SCREEN_WIDTH = self.size_window[0]
self.SCREEN_HEIGHT = self.size_window[1]
def load_game(self):
pygame.init()
self.screen = pygame.display.set_mode(self.size_window)
pygame.display.set_caption("breakout")
self.escenario = Escenario(self.screen)
self.collision = Collision(5)
self.pelota = Pelota(self.screen, 16, 16, "sprites/pelota_white.png")
self.pelota.set_velocity(2, 5)
self.raquet = Raqueta(self.screen, 74, 12, "sprites/raquet_white.png")
self.raquet.set_position(300, 550)
self.bricks = self.load_bricks(12, self.nivel)
self.tam_list = len(self.bricks)
self.loop()
def loop(self):
dt = 0
while (not self.salir):
while (not self.game_over):
self.ctrl_events()
self.update(dt)
self.render()
self.clock.tick(60)
self.ctrl_events()
def reset_game(self):
self.screen.fill(self.BLACK)
self.clock.tick(1)
self.game_over = False
self.soltar_pelota = False
self.puntaje = 0
self.nivel = 1
self.vidas = 3
self.pelota.set_velocity(2, 5)
self.raquet.set_position(300, 550)
self.bricks = self.load_bricks(12, self.nivel)
def aumentar_nivel(self):
self.screen.fill(self.BLACK)
self.clock.tick(1)
self.soltar_pelota = False
self.nivel += 1
self.vidas = 3
self.bricks = self.load_bricks(12, self.nivel)
self.tam_list = len(self.bricks)
self.pelota.set_velocity(2 + self.nivel, 5 + self.nivel)
self.raquet.set_velocity(self.nivel)
def update(self, delta):
self.pelota.update()
if (self.soltar_pelota):
self.collision.detect_colision(self.pelota, self.raquet)
self.pelota.move()
else:
self.center_pelota()
self.pelota.pelota_perdida = False
self.raquet.update()
for b in self.bricks:
if (self.collision.detect_colision(self.pelota, b)):
b.sub_resist()
self.puntaje += 10
if (b.cant_resist == 0):
self.bricks.remove(b)
self.tam_list -= 1
b.update()
if (self.tam_list == 0):
self.aumentar_nivel()
if (self.pelota.pelota_perdida):
self.vidas -= 1
if (self.vidas == 0):
self.game_over = True
self.bricks.clear()
else:
self.soltar_pelota = False
def render(self):
self.screen.fill(self.BLACK)
if (not self.game_over):
self.pelota.draw()
self.raquet.draw()
for b in self.bricks:
b.draw()
else:
self.escenario.draw_game_over()
self.escenario.draw_margen()
self.escenario.draw_text(self.puntaje, self.vidas, self.nivel)
pygame.display.flip()
def center_pelota(self):
posX = self.raquet.rect.x + (self.raquet.width /
2) - (self.pelota.width / 2)
posY = self.raquet.rect.y - self.pelota.height
self.pelota.set_position(posX, posY)
def ctrl_events(self):
for event in pygame.event.get():
if (event.type == pygame.QUIT):
sys.exit(1)
keys = pygame.key.get_pressed()
if (keys[pygame.K_RIGHT]):
self.raquet.move_to_rigth()
elif (keys[pygame.K_LEFT]):
self.raquet.move_to_left()
if (keys[pygame.K_SPACE]):
self.soltar_pelota = True
if (keys[pygame.K_r]):
self.reset_game()
def load_bricks(self, rows, cols):
list_bricks = []
c = 0
while (c < cols):
r = 0
while (r < rows):
path = images.select_image()
brick = Brick(self.screen, 50, 30, path)
brick.set_position((r + 1) * 52, (c + 1) * 32)
list_bricks.append(brick)
r += 1
c += 1
return list_bricks
def new_game(self):
"""
Function representing playable game mode
:return:
"""
asteroids = []
player = Objects.Player()
score = 0
running = True
asteroid_count_clock = pygame.time.get_ticks()
asteroid_max_count = 3
text_font = pygame.font.SysFont("Comic Sans MS", 11)
while running:
dt = Display.clock.tick() / 100
Display.screen.fill((0, 0, 0))
# drawing and updating objects
for i in range(len(asteroids)):
asteroids[i].update(dt)
asteroids[i].draw()
if len(asteroids) < asteroid_max_count:
asteroids.extend(self.spawn())
player.update(dt)
player.draw()
# drawing gui
score_surface = text_font.render("Score: " + str(score), True, (255, 255, 255))
lives_surface = text_font.render(("Lives left: " + str(player.lives)), True, (255, 255, 255))
Display.screen.blit(score_surface, (0, 0))
Display.screen.blit(lives_surface, (0, 20))
pygame.display.flip()
# collision detections:
for i in range(len(asteroids) - 1, -1, -1):
# asteroid with a player
if player.ship is not None:
if Collision.rect_to_rect(
player.ship.get_initial_collision(),
asteroids[i].get_initial_collision()):
if Collision.polygon_to_polygon(
player.ship.get_vertices(),
asteroids[i].get_vertices()):
player.ship = None
player.lives -= 1
# asteroid with projectiles from a player
if player.projectiles is not None:
for j in range(len(player.projectiles) - 1, -1, -1):
if Collision.rect_to_rect(
asteroids[i].get_initial_collision(),
player.projectiles[j].get_initial_collision()):
if Collision.point_to_polygon(
asteroids[i].pos,
asteroids[i].vertices,
player.projectiles[j].pos):
score += asteroids[i].size*2
asteroids.extend(self.spawn(asteroids[i]))
asteroids.pop(i)
player.projectiles.pop(j)
break
# event checking
for event in pygame.event.get():
if event.type == pygame.QUIT or\
(event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE):
running = False
if pygame.time.get_ticks() - asteroid_count_clock > 10000:
asteroid_max_count += 1
asteroid_count_clock = pygame.time.get_ticks()
if player.lives == 0:
running = False
# if end, return score
return score
x = randint(taille, 800 - taille)
y = randint(taille, 400 - taille)
col = choice(color)
name = self.canvas.create_oval(x, y, x + taille, y + taille, fill=col)
Balle.ball(name, x, y, col)
self.nombreBalle += 1
self.nb_ball["text"] = ("nombre de balle: {}".format(self.nombreBalle))
def retirer(self):
if ball.liste != []:
supp = self.canvas.find_all()
self.canvas.delete(supp[len(supp) - 1])
Balle.ball.liste.pop(len(Balle.ball.liste) - 1)
self.nombreBalle -= 1
self.nb_ball["text"] = ("nombre de balle: {}".format(
self.nombreBalle))
fenetre = main()
collision = Collision.calcul()
fenetre.start()
collision.start()
fenetre.fenetre.mainloop()
fenetre.canDo = False
# Read Inputs
screen.listen()
# Red Inputs
screen.onkeypress(red_go_left, "a")
screen.onkeypress(red_go_right, "d")
screen.onkeypress(red_go_up, "w")
screen.onkeypress(red_go_down, "s")
# Blue Inputs
screen.onkeypress(blue_go_left, "Left")
screen.onkeypress(blue_go_right, "Right")
screen.onkeypress(blue_go_up, "Up")
screen.onkeypress(blue_go_down, "Down")
# Screen Refresh
delay = 0.1
while True:
screen.update()
time.sleep(delay)
col.check_collission(red.dict, red.parts, food.food, blue.parts)
col.check_collission(blue.dict, blue.parts, food.food, red.parts)
setup.snake_body(red.segment, red.head)
setup.snake_body(blue.segment, blue.head)
mov.move(red.head)
mov.move(blue.head)
clock = pygame.time.Clock()
ship = Ship.Ship(gameDisplay)
enemy = Enemies.Enemies(gameDisplay,110, 50, random.choice((0.1, -0.1)))
level = LevelMaker.LevelMaker(gameDisplay, enemy, 5)
enemy1 = Enemies.Enemies(gameDisplay, 80, 100, random.choice((0.1, -0.1)))
level1 = LevelMaker.LevelMaker(gameDisplay, enemy1, 6)
enemy2 = Enemies.Enemies(gameDisplay, 110, 150, random.choice((0.1, -0.1)))
level2 = LevelMaker.LevelMaker(gameDisplay, enemy2, 5)
enemy3 = Enemies.Enemies(gameDisplay, 80, 200, random.choice((0.1, -0.1)))
level3 = LevelMaker.LevelMaker(gameDisplay, enemy3, 6)
collision = Collision.Collision()
def game_exit():
time.sleep(2)
pygame.quit()
quit()
def loose():
for i in Missiles.Missile.missile_list:
if i.position_y >= ship.position_y and ship.position_x < i.position_x < ship.position_x + ship.block_size:
text = smallfont.render("GAME OVER", True, red)
gameDisplay.blit(text, [300, 400])
pygame.display.update()
game_exit()
# Jonathan * (7 / 8)Petersen # A01236750 # Collision Pygame Assignment # Driver Code import Collision game = Collision.Collision()
