def load(self):
self.boundary = Boundary(self.screen, 0, 0)
snake_position_x, snake_position_y = self.random_position()
self.snake = Snake(self.screen, snake_position_x, snake_position_y)
apple_position_x, apple_position_y = self.random_position()
self.apple = Apple(self.screen, apple_position_x, apple_position_y)
self.collision = Collision(self.boundary.get_boundaries())
class ExperimentalScene(Scene):
def __init__(self, screen, id=0):
super().__init__(screen, id)
def load(self):
self.boundary = Boundary(self.screen, 0, 0)
snake_position_x, snake_position_y = self.random_position()
self.snake = Snake(self.screen, snake_position_x, snake_position_y)
apple_position_x, apple_position_y = self.random_position()
self.apple = Apple(self.screen, apple_position_x, apple_position_y)
self.collision = Collision(self.boundary.get_boundaries())
def random_position(self):
x = random.randint(21, 379)
y = random.randint(21, 379)
return x, y
def draw(self):
self.boundary.draw()
self.apple.draw()
self.snake.draw_snake()
def limit_movements(self):
is_collider, object_collider = self.collision.check_collision(
self.snake)
if object_collider == self.boundary.horizontal_bar_left.get_rectangule(
):
self.snake.update(25, 0, 25, -25)
elif object_collider == self.boundary.horizontal_bar_right.get_rectangule(
):
self.snake.update(0, -25, 25, -25)
elif object_collider == self.boundary.vertical_bar_botton.get_rectangule(
):
self.snake.update(25, -25, 0, -25)
elif object_collider == self.boundary.vertical_bar_top.get_rectangule(
):
self.snake.update(25, -25, 25, 0)
else:
self.snake.update(25, -25, 25, -25)
def eat_apple(self):
is_collider, object_collider = self.collision.check_collision(
self.snake)
if self.collision.object_colision(self.snake, self.apple):
del self.apple
new_x, new_y = self.random_position()
self.apple = Apple(self.screen, new_x, new_y)
self.snake.grow_body(self.snake.get_position()[0],
self.snake.get_position()[1])
def update(self):
self.limit_movements()
self.eat_apple()
def __init__(self, screen, screen_x, info_x, rocket, world):
self.screen = screen
self.info_x = info_x
self.rocket = rocket
self.world = world
self.factory = NumberFactory()
self.basic_unit = 25
#Setup boundary
self.info_width = screen_x - self.info_x
self.boundary = Boundary(self.info_width, 0, 3, screen.get_height(),
screen)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_BouncingBall()
self.ui.setupUi(self)
self.setWindowTitle( "Bouncing Balls" )
self.boundary = Boundary(self.ui.bouncingFrame.frameGeometry( ))
self.ui.pressure_timer = QtCore.QTimer( )
self.ui.pressure_timer.timeout.connect(self.pressure_measure)
self.ui.pressure_timer.start(PRESSURE_TIMER)
self.ui.pauseButton.clicked.connect(self.cmd_pauseButton)
self.ui.resetButton.clicked.connect(self.cmd_resetButton)
self.ui.resetButton.clicked.connect(self.cmd_resetButton)
self.ui.globalSpeedSlider.setMinimum(GLOBAL_SPEED_RANGE[0])
self.ui.globalSpeedSlider.setMaximum(GLOBAL_SPEED_RANGE[1])
self.connect(self.ui.globalSpeedSlider, QtCore.SIGNAL('valueChanged(int)'), self.change_global_speed)
self.connect(self.ui.nbSlider, QtCore.SIGNAL('valueChanged(int)'), self.nb_slider_change)
self.ui.SoundBox.stateChanged.connect(self.cmd_setSoundBox)
self.ui.backgroundSoundBox.stateChanged.connect(self.cmd_setBackgroundSoundBox)
self.ui.allowCollisionBox.stateChanged.connect(self.cmd_setCollisionBox)
self.ui.backgroundSoundBox.hide( )
self.setValueSignal = QtCore.pyqtSignal(int)
#self.setValueSignal.connect(self.ui.collisionNumber.display)
self.connect(self.ui.collisionNumber, SIGNAL('setValueSignal(int)'), self.ui.collisionNumber.display)
self.ui.collisionNumber.display(str(0))
self.backgroundSound = SoundCell("background/Autumn_Winds_preview_whitenoisemp3s-com.mp3")
self.sound_status = False
self.spriteList = [];
self.set_nb_ball(INITIAL_NB_BALL);
self.nb_wall_hit = 0;
self.total_nb_collision = 0
self.update_balls = True
self.allow_collision = False
self.animation_thread = AnimationThread()
self.connect( self.animation_thread, SIGNAL( "window_update_request" ), self.process_window_update_request )
# After the following method call, the program execution
# system will automatically call the run() method of the
# AnimationThread class. The run() method is executed
# in parallel with "this" thread.
self.animation_thread.start()
def __init__(self, name):
Component.__init__(self, name, facility="exchanger")
self.sink = None
self.source = None
self.mesh = None
self.rank = None
self.communicator = None
from Boundary import Boundary
self.boundary = Boundary()
import journal
self._info = journal.debug("exchanger")
return
def start_battle(self, clock):
pygame.display.set_caption("Fight!!")
# ENTITIES
# Background
background = pygame.Surface(self.screen.get_size())
background.fill((0, 0, 0))
self.screen.blit(background, (0, 0))
# Sprites
top_widget_size = (self.screen.get_size()[0],
round(self.screen.get_size()[1] / 10))
top_widget = Boundary((self.screen.get_size()[0] / 2,
round(self.screen.get_size()[1] / 20)),
color=(255, 255, 0),
size=top_widget_size)
# Grids
grid_sprites, safe_grid, grid_position = self.make_grid(
(0, round(self.screen.get_size()[1] / 10)))
curr_map = Map(grid_position)
obsticles = curr_map.make_map(OBSTACLE_GRID_TILE)
potential_box = curr_map.get_box_position()
obsticles = pygame.sprite.Group(obsticles)
# Boundary
top_boundary = Boundary((600, 69), (255, 255, 255), (1200, 20))
left_boundary = Boundary((-4, 350), (255, 255, 255), (20, 700))
right_boundary = Boundary((1204, 350), (255, 255, 255), (20, 700))
bottom_boundary = Boundary((600, 701), (255, 255, 255), (1200, 20))
top_boundary.make_invisible()
left_boundary.make_invisible()
right_boundary.make_invisible()
bottom_boundary.make_invisible()
obsticles.add(top_boundary, left_boundary, right_boundary,
bottom_boundary)
# Player
player_1 = Player(grid_position[7][32])
player_2 = Player(grid_position[7][0])
player_1_attacks = pygame.sprite.Group()
player_2_attacks = pygame.sprite.Group()
# Player score zone
p1_score_zone = Boundary((0, 0), (0, 0, 0), (72, 144))
p1_score_zone.rect.topleft = (grid_position[6][0][0] - 18,
grid_position[6][0][1] - 18)
p1_score_zone.make_invisible()
p2_score_zone = Boundary((0, 0), (0, 0, 0), (72, 144))
p2_score_zone.rect.topleft = (grid_position[6][31][0] - 18,
grid_position[6][31][1] - 18)
p2_score_zone.make_invisible()
score_zone = [p1_score_zone, p2_score_zone]
# Zombies
zombie_group = pygame.sprite.Group()
zombie_group.add(Zombie(player_1, player_2, (500, -5), safe_grid))
zombie_group.add(Zombie(player_1, player_2, (700, -5), safe_grid))
zombie_group.add(Zombie(player_1, player_2, (600, 350), safe_grid))
zombie_group.add(Zombie(player_1, player_2, (500, 705), safe_grid))
zombie_group.add(Zombie(player_1, player_2, (700, 705), safe_grid))
# HP Bar
player_2_bar = StatBar((200, 35), (0, 255, 0), (300, 25), MAX_HP)
player_1_bar = StatBar((1000, 35), (0, 255, 0), (300, 25), MAX_HP)
player_1_bar.set_reversed_direction()
bars = [
player_2_bar.get_full_bar((255, 0, 0)),
player_1_bar.get_full_bar((255, 0, 0))
]
# Box
# Item Box
box_sprites = pygame.sprite.Group()
# Goals
flag = Flag((600, 350))
goal = CaptureFlag([player_1, player_2], score_zone, flag, num_round=3)
# Label color
p1_label_color = (0, 0, 255)
p2_label_color = (255, 0, 0)
# Flag
flag_p2 = Label(44, (400, 35))
flag_p2.set_color(p2_label_color)
flag_p1 = Label(44, (780, 35))
flag_p1.set_color(p1_label_color)
# timer
timer = Timer(30, (560, 35), 4, 20, FRAME_RATE)
# Labels
p2_label = Label(20, (20, 35))
p2_label.set_color(p2_label_color)
p2_label.set_msg("P2 ")
p1_label = Label(20, (1160, 35))
p1_label.set_color(p1_label_color)
p1_label.set_msg("P1")
p1_head = Label(15, (player_1.rect.centerx - 8, player_1.rect.top - 5))
p1_head.set_color(p1_label_color)
p1_head.set_msg("P1")
p2_head = Label(15, (player_2.rect.centerx - 8, player_2.rect.top - 5))
p2_head.set_color(p2_label_color)
p2_head.set_msg("P2")
p1_weapon = Label(20, (990, 56))
p1_weapon.set_msg("sada")
p2_weapon = Label(20, (170, 56))
p2_weapon.set_msg("sada")
labels = [
p1_label, p2_label, p1_head, p2_head, p1_weapon, p2_weapon,
flag_p1, flag_p2
]
keep_going = True
box_flag = True
all_sprites = pygame.sprite.OrderedUpdates(grid_sprites, obsticles,
flag, player_1, player_2,
zombie_group, top_widget,
timer, labels, bars,
player_1_bar, player_2_bar)
# LOOP
while keep_going:
if goal.screen_pause:
pygame.time.wait(1500)
goal.screen_pause = False
# TIME
clock.tick(FRAME_RATE)
if timer.get_real_second() % 5 == 0:
# Box
if box_flag:
box_flag = False
box = self.generate_box(potential_box)
box_sprites.add(box)
all_sprites.add(box)
else:
box_flag = True
if timer.get_real_second() % 20 == 0 and len(zombie_group) <= 1:
zombie_group.add(
Zombie(player_1, player_2, (500, -5), safe_grid))
zombie_group.add(
Zombie(player_1, player_2, (700, -5), safe_grid))
zombie_group.add(
Zombie(player_1, player_2, (600, 350), safe_grid))
zombie_group.add(
Zombie(player_1, player_2, (500, 705), safe_grid))
zombie_group.add(
Zombie(player_1, player_2, (700, 705), safe_grid))
all_sprites.add(zombie_group)
for z in zombie_group:
z.move(zombie_group)
# Check for Goal
if goal.check_for_win():
keep_going = False
if timer.time_up():
keep_going = False
flag_p1.set_msg(str(goal.score[0]))
flag_p2.set_msg(str(goal.score[1]))
# EVENT HANDLING
for event in pygame.event.get():
if event.type == pygame.QUIT:
return 3
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_p:
keep_going = False
#Player 1 event handle
if pygame.key.get_pressed()[pygame.K_RIGHT]:
temp_block = TempBlock(player_1.rect.center,
player_1.rect.size)
temp_block.rect.x += player_1.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
# Check the previous directoin
if player_1.direction == 1 or player_1.prev_direction == 1:
i = 1
# Check if the we continue with previous direction for more frames will be able to pass through
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_down()
break
elif player_1.direction == 3 or player_1.prev_direction == 3:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_up()
break
else:
pass
else:
player_1.go_right()
elif pygame.key.get_pressed()[pygame.K_DOWN]:
temp_block = TempBlock(player_1.rect.center,
player_1.rect.size)
temp_block.rect.y += player_1.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_1.direction == 0 or player_1.prev_direction == 0:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_right()
break
elif player_1.direction == 2 or player_1.prev_direction == 2:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_left()
break
else:
pass
else:
player_1.go_down()
elif pygame.key.get_pressed()[pygame.K_UP]:
temp_block = TempBlock(player_1.rect.center,
player_1.rect.size)
temp_block.rect.y -= player_1.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_1.direction == 0 or player_1.prev_direction == 0:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_right()
break
elif player_1.direction == 2 or player_1.prev_direction == 2:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_left()
break
else:
pass
else:
player_1.go_up()
elif pygame.key.get_pressed()[pygame.K_LEFT]:
temp_block = TempBlock(player_1.rect.center,
player_1.rect.size)
temp_block.rect.x -= player_1.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_1.direction == 1 or player_1.prev_direction == 1:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_down()
break
elif player_1.direction == 3 or player_1.prev_direction == 3:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_up()
break
else:
pass
else:
player_1.go_left()
if pygame.key.get_pressed()[pygame.K_RCTRL]:
lst = player_1.attack()
player_1_attacks.add(lst)
all_sprites.add(lst)
# Player 2 event handle
if pygame.key.get_pressed()[pygame.K_d]:
temp_block = TempBlock(player_2.rect.center,
player_2.rect.size)
temp_block.rect.x += player_2.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
# Check the previous directoin
if player_2.direction == 1 or player_2.prev_direction == 1:
i = 1
# Check if the we continue with previous direction for more frames will be able to pass through
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_down()
break
elif player_2.direction == 3 or player_2.prev_direction == 3:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_up()
break
else:
pass
else:
player_2.go_right()
elif pygame.key.get_pressed()[pygame.K_s]:
temp_block = TempBlock(player_2.rect.center,
player_2.rect.size)
temp_block.rect.y += player_2.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_2.direction == 0 or player_2.prev_direction == 0:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_right()
break
elif player_2.direction == 2 or player_2.prev_direction == 2:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_left()
break
else:
pass
else:
player_2.go_down()
elif pygame.key.get_pressed()[pygame.K_w]:
temp_block = TempBlock(player_2.rect.center,
player_2.rect.size)
temp_block.rect.y -= player_2.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_2.direction == 0 or player_2.prev_direction == 0:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_right()
break
elif player_2.direction == 2 or player_2.prev_direction == 2:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_left()
break
else:
pass
else:
player_2.go_up()
elif pygame.key.get_pressed()[pygame.K_a]:
temp_block = TempBlock(player_2.rect.center,
player_2.rect.size)
temp_block.rect.x -= player_2.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_2.direction == 1 or player_2.prev_direction == 1:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_down()
break
elif player_2.direction == 3 or player_2.prev_direction == 3:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_up()
break
else:
pass
else:
player_2.go_left()
if pygame.key.get_pressed()[pygame.K_SPACE]:
lst2 = player_2.attack()
player_2_attacks.add(lst2)
all_sprites.add(lst2)
# Collisions handleling
for box1 in pygame.sprite.spritecollide(player_1, box_sprites,
False):
temp_label = TempLabel(
15, (player_1.rect.centerx - 8, player_1.rect.top - 5), 3,
FRAME_RATE)
temp_label.set_msg(box1.__str__())
all_sprites.add(temp_label)
box1.collide(player_1)
for box2 in pygame.sprite.spritecollide(player_2, box_sprites,
False):
box2.collide(player_2)
temp_label = TempLabel(
15, (player_2.rect.centerx - 8, player_2.rect.top - 5), 3,
FRAME_RATE)
temp_label.set_msg(box2.__str__())
all_sprites.add(temp_label)
# Zombie hit player
for zombie in pygame.sprite.spritecollide(player_1, zombie_group,
False):
zombie.collide(player_1)
for zombie in pygame.sprite.spritecollide(player_2, zombie_group,
False):
zombie.collide(player_2)
# Players hit zombies
for zombie in zombie_group:
for bullet in pygame.sprite.spritecollide(
zombie, player_2_attacks, False):
bullet.collide(zombie)
for bullet in pygame.sprite.spritecollide(
zombie, player_1_attacks, False):
bullet.collide(zombie)
# bullet_hit_walls
for wall in obsticles:
for bullet in pygame.sprite.spritecollide(
wall, player_1_attacks, False):
bullet.end()
for bullet in pygame.sprite.spritecollide(
wall, player_2_attacks, False):
bullet.end()
# Player_1 attacks
for hit in pygame.sprite.spritecollide(player_2, player_1_attacks,
False):
hit.collide(player_2)
# Player_2 attacks
for hit in pygame.sprite.spritecollide(player_1, player_2_attacks,
False):
hit.collide(player_1)
# Player hp bar
player_2_bar.set_curr_stat(player_2.health)
player_1_bar.set_curr_stat(player_1.health)
# Player head
p1_head.set_position(
(player_1.rect.centerx - 8, player_1.rect.top - 5))
p2_head.set_position(
(player_2.rect.centerx - 8, player_2.rect.top - 5))
p1_weapon.set_msg(str(player_1.weapon))
p2_weapon.set_msg(str(player_2.weapon))
if player_1.is_dead():
if flag.get_player() == player_1:
flag.drop()
player_1.respawn()
if player_2.is_dead():
if flag.get_player() == player_2:
flag.drop()
player_2.respawn()
for zombie in zombie_group:
if zombie.is_dead(): zombie.kill()
all_sprites.clear(self.screen, background)
all_sprites.update()
all_sprites.draw(self.screen)
pygame.display.flip()
lst = player_1.weapon.update()
player_1_attacks.add(lst)
all_sprites.add(lst)
lst = player_2.weapon.update()
player_2_attacks.add(lst)
all_sprites.add(lst)
end_msg = Label(60, (500, 350))
end_msg.set_color((255, 255, 0))
end_msg.set_msg(goal.get_wining_msg())
self.screen.blit(end_msg.image, end_msg)
pygame.display.flip()
pygame.time.wait(2000)
return 2
class InfoField():
def __init__(self, screen, screen_x, info_x, rocket, world):
self.screen = screen
self.info_x = info_x
self.rocket = rocket
self.world = world
self.factory = NumberFactory()
self.basic_unit = 25
#Setup boundary
self.info_width = screen_x - self.info_x
self.boundary = Boundary(self.info_width, 0, 3, screen.get_height(),
screen)
#Hp display
def hp_display_setup(self):
heart_size = 60
if self.rocket.hp > 5:
heart_image = 'max_health.png'
else:
heart_image = 'extra_health.png'
heart_x = self.screen.get_width() - self.info_x / 2 - heart_size / 2
heart_y = self.screen.get_height() / 2 - heart_size / 2
return_list = []
return_list.append(
DisplayObject(heart_size, heart_size, heart_image, heart_x,
heart_y, self.screen))
return_list.append(self.hp_number_display(heart_x, heart_y))
return return_list
def hp_number_display(self, parent_x, parent_y):
if self.rocket.hp < 6:
hp = str(self.rocket.hp)
number_image = self.factory.number_picker(hp)
else:
number_image = 'six_max.png'
number_width = 20
number_height = 28
number_x = parent_x + number_width
number_y = parent_y + number_height / 2 + 5
return DisplayObject(number_width, number_height, number_image,
number_x, number_y, self.screen)
#Powerup display
def powerup_display_setup(self):
if self.rocket.piercingshot:
powerup_width = 48
powerup_height = 80
powerup_image = 'piercing_shot.png'
elif self.rocket.wideshot:
powerup_width = 90
powerup_height = 64
powerup_image = 'wide_shot.png'
elif self.rocket.rapidshot:
powerup_width = 60
powerup_height = 90
powerup_image = 'rapid_shot.png'
elif self.rocket.bombshot:
powerup_width = 84
powerup_height = 84
powerup_image = 'bomb_shot.png'
else:
powerup_width = 56
powerup_height = 56
powerup_image = 'default_shot.png'
powerup_x = self.screen.get_width(
) - self.info_x / 2 - powerup_width / 2
powerup_y = self.screen.get_height(
) - self.screen.get_height() / 3 - powerup_height / 2
return_list = []
return_list.append(
DisplayObject(powerup_width, powerup_height, powerup_image,
powerup_x, powerup_y, self.screen))
return_list.append(
self.powerup_number_display(powerup_x + powerup_width / 2,
powerup_y + powerup_height / 2))
return return_list
def powerup_number_display(self, parent_x, parent_y):
powerup_num = str(len(self.rocket.powerup_projectiles))
if len(self.rocket.powerup_projectiles) < 10:
if len(self.rocket.powerup_projectiles) <= 0:
number_width = 28
number_height = 20
number_image = 'infinite.png'
else:
number_width = 20
number_height = 28
number_image = self.factory.number_picker(powerup_num)
else:
number_width = 45
number_height = 28
number_image = 'ten_max.png'
number_x = parent_x - number_width / 2
number_y = parent_y + number_height + self.basic_unit
return DisplayObject(number_width, number_height, number_image,
number_x, number_y, self.screen)
#Ufo display
def ufo_display_setup(self):
ufo_size = 60
for ufo in self.world.enemies:
ufo_image = ufo.chosen_image
ufo_x = self.screen.get_width() - self.info_x / 2 - ufo_size / 2
ufo_y = self.screen.get_height(
) - self.screen.get_height() * 2 / 3 - ufo_size / 2 - self.basic_unit
return_list = []
return_list.append(
DisplayObject(ufo_size, ufo_size, ufo_image, ufo_x, ufo_y,
self.screen))
return_list.append(
self.ufo_number_display(ufo_x + ufo_size / 2,
ufo_y + ufo_size / 2))
return return_list
def ufo_number_display(self, parent_x, parent_y):
for ufo in self.world.enemies:
ufo_hp = str(ufo.hp)
number_width = 20
number_height = 28
number_image = self.factory.number_picker(ufo_hp)
number_x = parent_x - number_width / 2
number_y = parent_y + number_height + self.basic_unit / 2
return DisplayObject(number_width, number_height, number_image,
number_x, number_y, self.screen)
def score_display_setup(self):
score_width = 120
score_height = 28
score_image = 'score.png'
score_x = self.screen.get_width() - self.info_x / 2 - score_width / 2
score_y = self.basic_unit
return_list = []
return_list.append(
DisplayObject(score_width, score_height, score_image, score_x,
score_y, self.screen))
return_list = return_list + self.score_number_display(
score_x + score_width, score_y + score_height / 2)
return return_list
def score_number_display(self, parent_x, parent_y):
score = self.world.score
number_width = 20
number_height = 28
number_x = parent_x - number_width
number_y = parent_y + number_height
gap = 5
return_list = []
if len(str(score)) == 1:
return_list.append(
DisplayObject(number_width, number_height,
self.factory.number_picker(str(score)), number_x,
number_y, self.screen))
if len(str(score)) == 2:
return_list.append(
DisplayObject(number_width, number_height,
self.factory.number_picker(str(score)[0]),
number_x - number_width - gap, number_y,
self.screen))
return_list.append(
DisplayObject(
number_width, number_height,
self.factory.number_picker(
str(score)[len(str(score)) - 1]), number_x, number_y,
self.screen))
if len(str(score)) == 3:
return_list.append(
DisplayObject(number_width, number_height,
self.factory.number_picker(str(score)[0]),
number_x - number_width * 2 - gap * 2, number_y,
self.screen))
return_list.append(
DisplayObject(number_width, number_height,
self.factory.number_picker(str(score)[1]),
number_x - number_width - gap, number_y,
self.screen))
return_list.append(
DisplayObject(
number_width, number_height,
self.factory.number_picker(
str(score)[len(str(score)) - 1]), number_x, number_y,
self.screen))
return return_list
#Rendering
def render(self):
self.boundary.render()
hp_display = self.hp_display_setup()
for object in hp_display:
object.render()
powerup_display = self.powerup_display_setup()
for object in powerup_display:
object.render()
if len(self.world.enemies) > 0:
ufo_display = self.ufo_display_setup()
for object in ufo_display:
object.render()
score_display = self.score_display_setup()
for object in score_display:
object.render()
##End
winningPlayer = myfont.render(winnerText, False, WHITE)
while (run):
for event in pygame.event.get():
if (event.type == pygame.QUIT):
pygame.quit()
quit()
screen.fill(BLACK)
screen.blit(header, (350, 100))
screen.blit(winningPlayer, (350, 300))
pygame.display.update()
boundaryArray.append(Boundary((0, 0), (0, WINDOW_HEIGHT), BLACK))
boundaryArray.append(Boundary((0, 0), (WINDOW_WIDTH, 0), BLACK))
boundaryArray.append(
Boundary((0, WINDOW_HEIGHT), (WINDOW_WIDTH, WINDOW_HEIGHT), BLACK))
boundaryArray.append(
Boundary((WINDOW_WIDTH, 0), (WINDOW_WIDTH, WINDOW_HEIGHT), BLACK))
boundaryArray.append(
Boundary((WINDOW_WIDTH / 2, 0), (WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2),
BLACK))
playerArray.append(Player(100, 100, GREEN, 45, 1))
playerArray.append(Player(700, 100, RED, 135, 2))
game1 = Game(boundaryArray, playerArray, screen, [0, 0])
game_menu()
#pygame configurations
pygame.init()
pygame.display.set_caption("2D Raymarching")
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
fps = 60
screen_offset = 50
object_count = 10
angle = 0
objects = []
for i in range(object_count):
obj = Boundary(randint(screen_offset, width - screen_offset),
randint(screen_offset, height - screen_offset),
randint(20, 100))
objects.append(obj)
run = True
while run:
clock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
ray = Ray(width // 2, height // 2, 0, screen, white)
ray.angle = angle
screen.fill(black)
for object in objects:
class BouncingBallWindow(QtGui.QWidget):
"""
The main window. Contains a region for the bouncing balls, and controls
widgets.
Pause Button: stop the sprite
Reset Button: recreate the sprite list, with random sizes, speeds
Global Speed Slider: Controls a multipler factor to all current sprite speeds.
Nb Sprites Sliders: Number of objects in the screen
Sound Check box: turns on/off sound
"""
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_BouncingBall()
self.ui.setupUi(self)
self.setWindowTitle( "Bouncing Balls" )
self.boundary = Boundary(self.ui.bouncingFrame.frameGeometry( ))
self.ui.pressure_timer = QtCore.QTimer( )
self.ui.pressure_timer.timeout.connect(self.pressure_measure)
self.ui.pressure_timer.start(PRESSURE_TIMER)
self.ui.pauseButton.clicked.connect(self.cmd_pauseButton)
self.ui.resetButton.clicked.connect(self.cmd_resetButton)
self.ui.resetButton.clicked.connect(self.cmd_resetButton)
self.ui.globalSpeedSlider.setMinimum(GLOBAL_SPEED_RANGE[0])
self.ui.globalSpeedSlider.setMaximum(GLOBAL_SPEED_RANGE[1])
self.connect(self.ui.globalSpeedSlider, QtCore.SIGNAL('valueChanged(int)'), self.change_global_speed)
self.connect(self.ui.nbSlider, QtCore.SIGNAL('valueChanged(int)'), self.nb_slider_change)
self.ui.SoundBox.stateChanged.connect(self.cmd_setSoundBox)
self.ui.backgroundSoundBox.stateChanged.connect(self.cmd_setBackgroundSoundBox)
self.ui.allowCollisionBox.stateChanged.connect(self.cmd_setCollisionBox)
self.ui.backgroundSoundBox.hide( )
self.setValueSignal = QtCore.pyqtSignal(int)
#self.setValueSignal.connect(self.ui.collisionNumber.display)
self.connect(self.ui.collisionNumber, SIGNAL('setValueSignal(int)'), self.ui.collisionNumber.display)
self.ui.collisionNumber.display(str(0))
self.backgroundSound = SoundCell("background/Autumn_Winds_preview_whitenoisemp3s-com.mp3")
self.sound_status = False
self.spriteList = [];
self.set_nb_ball(INITIAL_NB_BALL);
self.nb_wall_hit = 0;
self.total_nb_collision = 0
self.update_balls = True
self.allow_collision = False
self.animation_thread = AnimationThread()
self.connect( self.animation_thread, SIGNAL( "window_update_request" ), self.process_window_update_request )
# After the following method call, the program execution
# system will automatically call the run() method of the
# AnimationThread class. The run() method is executed
# in parallel with "this" thread.
self.animation_thread.start()
def set_nb_ball(self, nb=1):
if nb<=0:
self.spriteList = []
else:
current_size = len(self.spriteList)
delta = (nb-current_size)
print delta
if delta>0:
for i in range(0, delta):
size = randrange(1, 20)
eps = 2*size
center = QPointF(randrange(eps, self.boundary.width()-eps), randrange(eps, self.boundary.height()-eps))
self.spriteList.append(RotatingBouncer(center, size, get_random_color( ), self.boundary, self.sound_status))
else:
# remove the n-th last eleemnts
self.spriteList = self.spriteList[ : current_size-abs(delta)]
# print "debug: sprite list size: nb=%d current_size=%d" %(nb, len(self.spriteList))
def pressure_measure(self):
current_pressure = int(100.0* (self.nb_wall_hit / (float(PRESSURE_TIMER)/1000.0)))
self.ui.pressureBar.setValue(current_pressure)
# changes the temperature values (val in 0...100)
def change_global_speed(self, val):
alpha = val/GLOBAL_SPEED_RANGE[1]
[ sprite.set_global_speed(alpha) for sprite in self.spriteList ]
# changes the number of balls
def nb_slider_change(self, val):
self.set_nb_ball(val);
def process_window_update_request(self):
collision = False
nb_wall_hit_before = self.nb_wall_hit
if self.update_balls:
for sprite in self.spriteList:
hit_wall = sprite.move( )
self.nb_wall_hit += hit_wall
if self.allow_collision:
reverted = set([])
for S1, S2 in list(combinations(self.spriteList, 2)):
if S1.colides(S2):
reverted.add(S1)
reverted.add(S2)
collision = True
self.total_nb_collision += 1
[S.revert() for S in reverted]
if collision and self.ui.stopBox.isChecked( ):
self.cmd_pauseButton( )
if collision:
self.ui.collisionNumber.display(str(self.total_nb_collision))
if self.nb_wall_hit > nb_wall_hit_before:
self.ui.wallCollisionNumber.display(str(self.nb_wall_hit))
self.update()
def cmd_pauseButton(self):
if self.update_balls:
self.ui.pauseButton.setText("Start")
else:
self.ui.pauseButton.setText("Pause")
self.update_balls = not self.update_balls
def cmd_setSoundBox(self, i):
if(i == 0): # sound is off
self.sound_status = False
[S.set_sound_status(False) for S in self.spriteList]
self.ui.backgroundSoundBox.hide( )
self.backgroundSound.set_sound_status(False)
else: # sound is on
self.sound_status = True
self.ui.backgroundSoundBox.show( )
if self.ui.backgroundSoundBox.isChecked():
self.backgroundSound.set_sound_status(True)
self.backgroundSound.play( )
self.backgroundSound.set_sound_status(True)
[S.set_sound_status(True) for S in self.spriteList]
def cmd_setBackgroundSoundBox(self, i):
if(i == 0): # sound is off
self.backgroundSound.stop( )
else: # sound is on
if self.sound_status:
self.backgroundSound.set_sound_status(True)
self.backgroundSound.play( )
def cmd_setCollisionBox(self, i):
if(i == 0): # collision if off
self.allow_collision = False
self.ui.stopBox.hide( )
else:
self.allow_collision = True
self.ui.stopBox.show( )
def cmd_resetButton(self):
nb = len(self.spriteList)
self.set_nb_ball(0)
self.set_nb_ball(nb)
self.total_nb_collision = 0
self.nb_wall_hit = 0
self.ui.collisionNumber.display(str(self.total_nb_collision))
self.ui.wallCollisionNumber.display(str(self.nb_wall_hit))
#self.setValueSignal.emit(self.total_nb_collision)
self.emit(SIGNAL("setValueSignal(val)"), self.total_nb_collision)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
[ S.move() for S in self.spriteList]
def paintEvent( self, event):
painter = QPainter( )
painter.begin(self)
[S.draw(painter) for S in self.spriteList]
self.boundary.draw(painter)
painter.end( )
def exit_this_window(self):
self.animation_thread.stop( )
self.close() #is this necessary???
#pygame configs
pygame.init()
pygame.display.set_caption("2D raymarching")
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
fps = 60
objects = []
object_count = 10
angle = 0
screen_offset = 50
for i in range(object_count):
obj = Boundary(randint(screen_offset, width - screen_offset),
randint(screen_offset, height - screen_offset),
randint(10, 100))
objects.append(obj)
run = True
while run:
clock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
ray = Ray(width // 2, height // 2, 0, screen, white)
ray.angle = angle
screen.fill(black)
for obj in objects:
pygame.init()
pygame.display.set_caption("2D Raymarching")
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
fps = 60
screen_offset = 50
Collisions = []
object_count = 10
angle = 0
objects = []
for i in range(object_count):
obj = Boundary(randint(screen_offset, width - screen_offset),
randint(screen_offset, height - screen_offset),
randint(20, 100))
obj.color = (0, 0, 0)
obj.outline = 0
objects.append(obj)
autoRotation = True
run = True
while run:
clock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.KEYDOWN:
