def __init__(self, file_name):
global active_camera
self.models = None
self.cameras = None
self.lights = None
self.active_camera = active_camera
# shared resources
self.textures = {} # name -> tex lookup
self.shaders = {} # name -> tex lookup
self.meshes = {} # name -> tex lookup
with open(file_name, "r") as fp:
data = json.load(fp)
# models
self.models = {name: Model(m) for (name, m) in data["models"].items()}
for model in self.models.values():
vert_file = model.io['shader']['vert']
frag_file = model.io['shader']['frag']
shader_name = vert_file.split('.')[0]
shader = ResourceManager.get_shader(shader_name)
if not shader:
shader = Shader(vert_file, frag_file)
ResourceManager.add_shader(shader_name, shader)
model.shader = shader
mesh_name = model.io['mesh'] # contains relative path string
mesh = ResourceManager.get_mesh(mesh_name)
if not mesh:
mesh = Mesh(mesh_name)
ResourceManager.add_mesh(mesh_name, mesh)
model.mesh = mesh
tex_files = model.io['textures']
for (layer, tex_file) in tex_files.items():
tex = ResourceManager.get_texture(tex_file)
if not tex:
tex = Texture(tex_file)
ResourceManager.add_texture(tex_file, tex)
model.textures[layer] = tex
# cameras, set first camera to active
self.cameras = {
name: Camera(c)
for (name, c) in data["cameras"].items()
}
if len(self.cameras) > 0:
# get first items value
active_camera = next(iter(self.cameras.items()))[1]
logging.warn('camera needs to set shader uniforms')
# lights
self.lights = {name: Light(l) for (name, l) in data["lights"].items()}
logging.warn('light needs to set shader uniforms')
def _sendCurrentFrame(self): """ Sends the current image (based on currentFrameId) to the client through the dataSocket. """ (image, nextFrameId) = ResourceManager.getFrame(self._mediaId, self._currentFrameId) message = self._prepareMessage(self._currentFrameId, image) self._dataSocket.send(message) self._currentFrameId = nextFrameId
def draw_loading_screen(self):
"""
Draws a nifty loading page to the screen
"""
self.window.fill((0,0,0))
loading_pic = ResourceManager.load_ui_image("loading")
loading_pic_rect = loading_pic.get_rect()
loading_pic_rect.center = (self.resolution[0]/2,
self.resolution[1]/2)
# And draw it to the screen
self.window.blit(loading_pic, loading_pic_rect)
pygame.display.update()
def __init__(self, size, im):
self.rm=ResourceManager()
self.size=size
self.x=0
self.W=World.World(size,self.rm)
self.im = im #copy the input manager passed to us by the core
#input testing
self.paused = False
self.pause = ga.GameAction("Pause", ga.GameAction.DETECT_INITIAL_PRESS_ONLY) #create action
self.im.mapToKey(self.pause, pygame.K_SPACE) #register it with the input manager for the space key
self.reset = ga.GameAction ("Reset", ga.GameAction.DETECT_INITIAL_PRESS_ONLY)
self.im.mapToKey(self.reset, pygame.K_r)
def _sendCurrentFrame(self): """ Sends the current image (based on currentFrameId) to the client through a socket created for the occasion. """ (image, nextFrameId) = ResourceManager.getFrame(self._mediaId, self._currentFrameId) messages = self._prepareMessages(self._currentFrameId, image) for fragment in messages: try: self._dataSocket.send(fragment) # Sometimes a 'no route to host' error happens, but we can just ignore it and keep trying again except OSError: pass self._currentFrameId = nextFrameId
def __init__(self, size, im):
self.rm=ResourceManager()
self.size=size
self.x=0
self.World = self.rm.loadMap("test.map")
self.im = im #copy the input manager passed to us by the core
self.World.im = self.im
#input testing
self.paused = False
self.pause = ga.GameAction("Pause", ga.GameAction.DETECT_INITIAL_PRESS_ONLY) #create action
self.im.mapToKey(self.pause, pygame.K_SPACE) #register it with the input manager for the space key
self.reset = ga.GameAction ("Reset", ga.GameAction.DETECT_INITIAL_PRESS_ONLY)
self.im.mapToKey(self.reset, pygame.K_r)
class GameManager:
def __init__(self, size, im):
self.rm=ResourceManager()
self.size=size
self.x=0
self.World = self.rm.loadMap("test.map")
self.im = im #copy the input manager passed to us by the core
self.World.im = self.im
#input testing
self.paused = False
self.pause = ga.GameAction("Pause", ga.GameAction.DETECT_INITIAL_PRESS_ONLY) #create action
self.im.mapToKey(self.pause, pygame.K_SPACE) #register it with the input manager for the space key
self.reset = ga.GameAction ("Reset", ga.GameAction.DETECT_INITIAL_PRESS_ONLY)
self.im.mapToKey(self.reset, pygame.K_r)
def update(self,dtime):
#check if the action was triggered
if self.pause.getAmount() > 0:
self.paused = not self.paused
#if the pause button has been pressed since last time
#we set it to not itself, which will toggle it to the other value since
# not False -> True
# not True -> False
if self.reset.getAmount() > 0:
self.World.reset()
if not self.paused: #only update the world if we are not paused
self.World.update(dtime)
def draw(self,screen):
pygame.draw.rect(screen,[200,200,200],[0,0,self.size[0],self.size[1]])
self.World.draw(screen)
def init(self):
self.entities = pg.sprite.Group()
self.street = pg.sprite.Group()
self.grass = pg.sprite.Group()
self.manager = ResourceManager.Manager()
self.tileset = Tileset(self.manager)
self.coords = []
for row, tiles in enumerate(self.map.data):
for col, tile in enumerate(tiles):
if tile == 'a':
Street(self.tileset.getTile('street100'), col, row,
[self.entities, self.street])
elif tile == 'b':
Street(self.tileset.getTile('street101'), col, row,
[self.entities, self.street])
elif tile == 'c':
Street(self.tileset.getTile('street102'), col, row,
[self.entities, self.street])
elif tile == 'd':
Street(self.tileset.getTile('street000'), col, row,
[self.entities, self.street])
elif tile == 'e':
Street(self.tileset.getTile('street200'), col, row,
[self.entities, self.street])
elif tile == 'f':
Street(self.tileset.getTile('street201'), col, row,
[self.entities, self.street])
elif tile == 'g':
Street(self.tileset.getTile('street202'), col, row,
[self.entities, self.street])
elif tile == 'h':
Street(self.tileset.getTile('street203'), col, row,
[self.entities, self.street])
elif tile == 'i':
Street(self.tileset.getTile('street210'), col, row,
[self.entities, self.street])
elif tile == 'j':
Street(self.tileset.getTile('street211'), col, row,
[self.entities, self.street])
elif tile == 'k':
Street(self.tileset.getTile('street212'), col, row,
[self.entities, self.street])
elif tile == 'l':
Street(self.tileset.getTile('street213'), col, row,
[self.entities, self.street])
elif tile == 'm':
Street(self.tileset.getTile('street230'), col, row,
[self.entities, self.street])
elif tile == 'n':
Street(self.tileset.getTile('street231'), col, row,
[self.entities, self.street])
elif tile == 'o':
Street(self.tileset.getTile('street232'), col, row,
[self.entities, self.street])
elif tile == 'p':
Street(self.tileset.getTile('street233'), col, row,
[self.entities, self.street])
elif tile == 'q':
Street(self.tileset.getTile('street240'), col, row,
[self.entities, self.street])
elif tile == '1':
Gras(self.tileset.getTile('gras000'), col, row,
self.entities)
elif tile == '2':
Gras(self.tileset.getTile('gras000'), col, row,
[self.entities, self.grass])
self.corners = [[(1 * TILESIZE, 2 * TILESIZE),
(1 * TILESIZE, 13 * TILESIZE)],
[(1 * TILESIZE, 13 * TILESIZE),
(7 * TILESIZE, 13 * TILESIZE)],
[(7 * TILESIZE, 13 * TILESIZE),
(7 * TILESIZE, 10 * TILESIZE)],
[(7 * TILESIZE, 10 * TILESIZE),
(9 * TILESIZE, 10 * TILESIZE)],
[(9 * TILESIZE, 10 * TILESIZE),
(9 * TILESIZE, 12 * TILESIZE)],
[(9 * TILESIZE, 12 * TILESIZE),
(16 * TILESIZE, 12 * TILESIZE)],
[(16 * TILESIZE, 12 * TILESIZE),
(16 * TILESIZE, 1 * TILESIZE)],
[(16 * TILESIZE, 1 * TILESIZE),
(9 * TILESIZE, 1 * TILESIZE)],
[(9 * TILESIZE, 1 * TILESIZE),
(9 * TILESIZE, 5 * TILESIZE)],
[(9 * TILESIZE, 5 * TILESIZE),
(7 * TILESIZE, 5 * TILESIZE)],
[(7 * TILESIZE, 5 * TILESIZE),
(7 * TILESIZE, 2 * TILESIZE)],
[(7 * TILESIZE, 2 * TILESIZE),
(1 * TILESIZE, 2 * TILESIZE)],
[(4 * TILESIZE, 4 * TILESIZE),
(5 * TILESIZE, 4 * TILESIZE)],
[(5 * TILESIZE, 4 * TILESIZE),
(5 * TILESIZE, 7 * TILESIZE)],
[(4 * TILESIZE, 4 * TILESIZE),
(4 * TILESIZE, 7 * TILESIZE)],
[(3 * TILESIZE, 7 * TILESIZE),
(4 * TILESIZE, 7 * TILESIZE)],
[(5 * TILESIZE, 7 * TILESIZE),
(11 * TILESIZE, 7 * TILESIZE)],
[(11 * TILESIZE, 7 * TILESIZE),
(11 * TILESIZE, 3 * TILESIZE)],
[(11 * TILESIZE, 3 * TILESIZE),
(14 * TILESIZE, 3 * TILESIZE)],
[(14 * TILESIZE, 3 * TILESIZE),
(14 * TILESIZE, 10 * TILESIZE)],
[(14 * TILESIZE, 10 * TILESIZE),
(11 * TILESIZE, 10 * TILESIZE)],
[(11 * TILESIZE, 10 * TILESIZE),
(11 * TILESIZE, 8 * TILESIZE)],
[(11 * TILESIZE, 8 * TILESIZE),
(5 * TILESIZE, 8 * TILESIZE)],
[(5 * TILESIZE, 8 * TILESIZE),
(5 * TILESIZE, 11 * TILESIZE)],
[(5 * TILESIZE, 11 * TILESIZE),
(3 * TILESIZE, 11 * TILESIZE)],
[(3 * TILESIZE, 11 * TILESIZE),
(3 * TILESIZE, 7 * TILESIZE)]]
self.car = Car(self.manager, self.entities, self._worldX, self._worldY)
self.line = Line(self.camera, self.car, self.corners)
def __init__(self, screen):
random.seed()
self.resource_manager = ResourceManager(self)
self.resource_manager['surface_screen'] = screen
self.screen_getter = ResourceCapsule(self.resource_manager,
"surface_screen")
self.clock_getter = ResourceCapsule(self.resource_manager, "clock_0")
self.background_getter = ResourceCapsule(self.resource_manager,
'image_background-hd2.png')
self.heart_getter = ResourceCapsule(self.resource_manager,
'image_heart.png')
self.ball_image_getter = ResourceCapsule(self.resource_manager,
"image_ball.png")
self.extraball_image_getter = ResourceCapsule(
self.resource_manager, 'image_extraball_powerup.png')
self.extralife_image_getter = ResourceCapsule(
self.resource_manager, 'image_extralife_powerup.png')
self.extrapoint_image_getter = ResourceCapsule(
self.resource_manager, 'image_extrapoint_powerup.png')
self.double_damage_image_getter = ResourceCapsule(
self.resource_manager, 'image_double_damage_powerup.png')
self.time_distortion_powerup_image_getter = ResourceCapsule(
self.resource_manager, 'image_time_distortion_field_powerup.png')
self.time_distortion_field_image_getter = ResourceCapsule(
self.resource_manager, 'image_time_distortion_field.png')
self.paddles = pygame.sprite.RenderUpdates()
self.paddle = Paddle(
ResourceCapsule(self.resource_manager, "image_paddle.png"),
(390, PADDLE_HEIGHT_POS))
self.paddles.add(self.paddle)
self.balls = pygame.sprite.RenderUpdates()
self.powerups = pygame.sprite.RenderUpdates()
self.blocks = pygame.sprite.RenderUpdates()
self.invulnerable_blocks = pygame.sprite.RenderUpdates()
self.balls_on_paddle = 0
self.time_distortion_field_active = False
self.time_passed_this_level = 0
self.lives = 3
self.livesfont_getter = ResourceCapsule(self.resource_manager,
"font_audiowide.ttf/28")
self.lives_surface_getter = ResourceCapsule(
self.resource_manager, "livesfont_ " + str(self.lives))
self.game_over = False
self.score = 0
self.combo = 0
self.combo_hits = 0
self.scorefont_getter = ResourceCapsule(self.resource_manager,
"font_audiowide.ttf/17")
self.scorelabelfont_getter = ResourceCapsule(self.resource_manager,
"font_audiowide.ttf/17")
self.score_label_surface_getter = ResourceCapsule(
self.resource_manager, "scorefont_Score Board:")
self.combo_surface_getter = ResourceCapsule(
self.resource_manager, "scorefont_" + str(self.combo))
self.combo_hits_surface_getter = ResourceCapsule(
self.resource_manager,
"scorefont_" + str(self.combo_hits) + " Hits Bouns)")
self.score_combo_plus_sign_surface_getter = ResourceCapsule(
self.resource_manager, "comboplussign_+")
self.score_surface_getter = ResourceCapsule(
self.resource_manager, "scorefont_" + str(self.score))
self.touching = False
self.lowest_fps = 10000
self.text_messages = []
self.detect_levels()
self.load_level(1)
self.waiting_for_level = False
self.loading_init()
class Game(object):
MUSIC = 'coherence.ogg'
WAIT_NEW_LEVEL = USEREVENT + 5
TIME_DISTORTION_FIELD = USEREVENT + 6
ORANGE = (230, 40, 0)
def __init__(self, screen):
random.seed()
self.resource_manager = ResourceManager(self)
self.resource_manager['surface_screen'] = screen
self.screen_getter = ResourceCapsule(self.resource_manager,
"surface_screen")
self.clock_getter = ResourceCapsule(self.resource_manager, "clock_0")
self.background_getter = ResourceCapsule(self.resource_manager,
'image_background-hd2.png')
self.heart_getter = ResourceCapsule(self.resource_manager,
'image_heart.png')
self.ball_image_getter = ResourceCapsule(self.resource_manager,
"image_ball.png")
self.extraball_image_getter = ResourceCapsule(
self.resource_manager, 'image_extraball_powerup.png')
self.extralife_image_getter = ResourceCapsule(
self.resource_manager, 'image_extralife_powerup.png')
self.extrapoint_image_getter = ResourceCapsule(
self.resource_manager, 'image_extrapoint_powerup.png')
self.double_damage_image_getter = ResourceCapsule(
self.resource_manager, 'image_double_damage_powerup.png')
self.time_distortion_powerup_image_getter = ResourceCapsule(
self.resource_manager, 'image_time_distortion_field_powerup.png')
self.time_distortion_field_image_getter = ResourceCapsule(
self.resource_manager, 'image_time_distortion_field.png')
self.paddles = pygame.sprite.RenderUpdates()
self.paddle = Paddle(
ResourceCapsule(self.resource_manager, "image_paddle.png"),
(390, PADDLE_HEIGHT_POS))
self.paddles.add(self.paddle)
self.balls = pygame.sprite.RenderUpdates()
self.powerups = pygame.sprite.RenderUpdates()
self.blocks = pygame.sprite.RenderUpdates()
self.invulnerable_blocks = pygame.sprite.RenderUpdates()
self.balls_on_paddle = 0
self.time_distortion_field_active = False
self.time_passed_this_level = 0
self.lives = 3
self.livesfont_getter = ResourceCapsule(self.resource_manager,
"font_audiowide.ttf/28")
self.lives_surface_getter = ResourceCapsule(
self.resource_manager, "livesfont_ " + str(self.lives))
self.game_over = False
self.score = 0
self.combo = 0
self.combo_hits = 0
self.scorefont_getter = ResourceCapsule(self.resource_manager,
"font_audiowide.ttf/17")
self.scorelabelfont_getter = ResourceCapsule(self.resource_manager,
"font_audiowide.ttf/17")
self.score_label_surface_getter = ResourceCapsule(
self.resource_manager, "scorefont_Score Board:")
self.combo_surface_getter = ResourceCapsule(
self.resource_manager, "scorefont_" + str(self.combo))
self.combo_hits_surface_getter = ResourceCapsule(
self.resource_manager,
"scorefont_" + str(self.combo_hits) + " Hits Bouns)")
self.score_combo_plus_sign_surface_getter = ResourceCapsule(
self.resource_manager, "comboplussign_+")
self.score_surface_getter = ResourceCapsule(
self.resource_manager, "scorefont_" + str(self.score))
self.touching = False
self.lowest_fps = 10000
self.text_messages = []
self.detect_levels()
self.load_level(1)
self.waiting_for_level = False
self.loading_init()
def loading_init(self):
pygame.mouse.set_visible(False)
pygame.event.set_grab(
True) #required to capture mouse input outside of the window
self.background_getter().blit(self.heart_getter(), (30, 0))
self.background_getter().blit(self.score_label_surface_getter(),
(45, 60))
self.screen_getter().blit(self.background_getter(), (0, 0))
pygame.display.update()
def detect_levels(self):
self.available_levels = 0
while True:
if os.path.isfile(
os.path.join('levels',
str(self.available_levels + 1) + ".lvl")):
self.available_levels += 1
else:
break
def load_level(self, level):
self.time_passed_this_level = 0
b = len(self.balls)
if b > 0:
remaining_balls = b
else:
remaining_balls = 1
self.balls.empty()
self.powerups.empty()
self.blocks.empty()
self.invulnerable_blocks.empty()
self.balls_on_paddle = 0
for ball in range(remaining_balls):
self.add_ball()
if android:
self.text_messages.append(
widgets.TextMessage(self.screen_getter(),
"Touch to begin level " + str(level),
Vector(
self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=2800,
size=24,
initialdelay=1200))
else:
self.text_messages.append(
widgets.TextMessage(self.screen_getter(),
"Press SPACE to begin level " + str(level),
Vector(
self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=2800,
size=24,
initialdelay=1200))
if level <= self.available_levels:
self.level = level
level_data = open(os.path.join('levels', str(level) + ".lvl"), 'r')
i = 0
for row in level_data:
row = row.split()
for j in range(25):
if self.is_int(row[j]):
if int(row[j]) != 0:
self.blocks.add(
Block((LEFT_BOUND + BLOCK_SIZE[0] * j,
BLOCK_SIZE[1] * i),
abs(int(row[j])),
ResourceCapsule(self.resource_manager,
"fn_create_powerup"),
self.resource_manager,
invisible=int(row[j]) < 0))
elif row[j] == "*" or row[j] == "-*": #invulnerable block!
self.invulnerable_blocks.add(
Block((LEFT_BOUND + BLOCK_SIZE[0] * j,
BLOCK_SIZE[1] * i),
1,
ResourceCapsule(self.resource_manager,
"fn_create_powerup"),
self.resource_manager,
invulnerable=True,
invisible=row[j][0] == "-"))
i += 1
level_data.close()
else:
self.load_level(level - 1)
def is_int(self, txt):
try:
int(txt)
return True
except ValueError:
return False
def run(self):
self.play_music()
self.total_time_passed = 0
fps_limit = 60
if android:
fps_limit = 40
while True: #main game loop
if android:
if android.check_pause():
self.pause()
#self.pause_music()
self.save()
print("Block Breaker progress saved!")
self.stop_music()
android.wait_for_resume()
self.pause(resume=True)
self.play_music()
#self.pause_music(resume=True)
time_passed = self.clock_getter().tick(fps_limit) / 1000.0
# If too long has passed between two frames, lie and tell the game it's still at more than 21 FPS (0.046 seconds since last frame)
# (either the game must have suspended for some reason, in which case we don't want it to "jump forward" suddenly -
# or the game is running on too weak hardware (single core < 1GHz android phones for example), in which case we'd rather have the game be slow than messing up collision detection)
if time_passed > 0.046:
time_passed = 0.046
#continue
self.total_time_passed += time_passed
input = self.process_input()
self.update(time_passed, input, moveToPos=android)
self.draw()
def release_a_ball(self):
rightmost_ball = None
for ball in self.balls:
if ball.attached_to_paddle:
if rightmost_ball:
if rightmost_ball.attach_pos < ball.attach_pos:
rightmost_ball = ball
else:
rightmost_ball = ball
if rightmost_ball:
rightmost_ball.release_from_paddle()
self.balls_on_paddle -= 1
def process_input(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.quit()
elif event.key == pygame.K_SPACE:
self.release_a_ball()
elif event.key == pygame.K_a:
if DEBUGGING:
self.load_level(self.level + 1)
elif event.key == pygame.K_f:
if DEBUGGING:
self.create_powerup((480, 0))
elif event.key == pygame.K_y and self.game_over:
if android:
android.hide_keyboard()
self.restart()
elif event.key == pygame.K_n and self.game_over:
if android:
android.hide_keyboard()
self.force_quit()
elif event.type == pygame.MOUSEBUTTONDOWN:
self.touching = True
if not android:
self.release_a_ball()
elif event.type == pygame.MOUSEBUTTONUP:
if android:
self.release_a_ball()
self.touching = False
elif event.type == self.WAIT_NEW_LEVEL:
self.waiting_for_level = False
self.powerups.empty()
self.load_level(self.level + 1)
pygame.time.set_timer(self.WAIT_NEW_LEVEL, 0)
elif event.type == self.TIME_DISTORTION_FIELD:
self.disable_time_distortion_field()
if android:
if self.touching:
return pygame.mouse.get_pos()[0]
else:
return 0
return pygame.mouse.get_rel()[0]
def update(self, time_passed, input, moveToPos=False):
self.time_passed_this_level += time_passed
self.balls.update(time_passed, self.paddle, self.balls, self.blocks,
self.invulnerable_blocks)
self.powerups.update(time_passed, self.paddle)
for paddle in self.paddles:
paddle.update(input, moveToPos=moveToPos)
for text_message in self.text_messages:
text_message.update(time_passed * 1000) #convert to ms
if len(self.blocks
) == 0 and not self.waiting_for_level and not self.game_over:
self.level_complete()
if len(self.balls
) == 0 and not self.game_over and not self.waiting_for_level:
self.dropped_balls()
self.update_score()
if DEBUGGING:
fps = self.clock_getter().get_fps()
if fps > 0:
self.lowest_fps = min(fps, self.lowest_fps)
if android:
print("fps: " + str(fps) + " Lowest fps: " +
str(self.lowest_fps))
else:
pygame.display.set_caption(TITLE + " %.0f fps" % fps +
", lowest: %0.f fps" %
self.lowest_fps)
def play_music(self):
music_file_name = os.path.join('audio', self.MUSIC)
if not mixer:
print("mixer not enabled! Skipping music.")
return
elif not os.path.exists(music_file_name):
print("Music file not found: "), music_file_name
return
mixer.music.load(music_file_name)
mixer.music.set_volume(0.8)
mixer.music.play(-1)
def stop_music(self):
mixer.music.stop()
def pause_music(self, resume=False):
if not resume:
mixer.music.pause()
else:
mixer.music.unpause()
def erase_rect(self, surface, rect):
surface.blit(self.background_getter(), rect, rect)
def draw(self, update=True):
self.screen_getter().blit(self.background_getter(), (0, 0))
for ball in self.balls:
self.screen_getter().blit(ball.image_getter(), ball.rect)
if self.game_over:
self.screen_getter().blit(self.lives_surface_getter(), (10, 10))
else:
self.screen_getter().blit(self.lives_surface_getter(), (66, 10))
self.screen_getter().blit(
self.combo_surface_getter(),
(58 - self.combo_surface_getter().get_width() // 10, 92))
self.screen_getter().blit(
self.combo_hits_surface_getter(),
(58 - self.combo_hits_surface_getter().get_width() // 10, 122))
self.screen_getter().blit(
self.score_surface_getter(),
(58 - self.score_surface_getter().get_width() // 10, 152))
for block in self.blocks:
self.screen_getter().blit(block.image_getter(), block.rect)
if block.health < block.orig_health:
self.screen_getter().blit(block.shatter_image_getter(),
block.rect)
for block in self.invulnerable_blocks:
self.screen_getter().blit(block.image_getter(), block.rect)
for powerup in self.powerups:
self.screen_getter().blit(powerup.image_getter(), powerup.rect)
for paddle in self.paddles:
self.screen_getter().blit(paddle.image_getter(), paddle.rect)
if self.time_distortion_field_active:
self.screen_getter().blit(
self.time_distortion_field_image_getter(), (232, 520))
for text_message in self.text_messages:
if not text_message.timealive > text_message.duration or text_message.duration == 0:
text_message.draw()
else:
self.text_messages.remove(text_message)
if update:
pygame.display.update()
def clear(self, surface, rectlist, background):
for rect in rectlist:
surface.blit(background, rect, rect)
def update_score(self):
highest_combo = 0
combo_length = 0
for ball in self.balls:
if ball.score != 0:
self.erase_rect(
self.screen_getter(),
Rect((730, 83,
self.scorefont_getter().size(str(self.score))[0],
self.scorefont_getter().size(str(self.score))[1])))
self.score += ball.score
ball.score = 0
if ball.combo_length > 0:
if ball.combo > highest_combo:
highest_combo = ball.combo
combo_length = ball.combo_length
self.erase_rect(
self.screen_getter(),
Rect((730, 120, self.scorefont_getter().size(str(self.combo))[0],
self.scorefont_getter().size(str(self.combo))[1])))
self.combo = highest_combo
self.combo_hits = combo_length
self.combo_surface_getter = ResourceCapsule(
self.resource_manager, "scorefont_Points: " + str(self.combo))
self.combo_hits_surface_getter = ResourceCapsule(
self.resource_manager,
"scorefont_" + str(self.combo_hits) + " Hits XP")
self.score_surface_getter = ResourceCapsule(
self.resource_manager, "scorefont_Total: " + str(self.score))
def collect_all_score(self):
for ball in self.balls:
self.score += ball.combo
def create_powerup(self, pos):
available_powerups = [
ExtraLife(self.extralife_image_getter, pos,
ResourceCapsule(self.resource_manager, "fn_add_life")),
ExtraPoint(
self.extrapoint_image_getter, pos,
ResourceCapsule(self.resource_manager, "fn_add_extrapoint")),
ExtraBall(self.extraball_image_getter, pos,
ResourceCapsule(self.resource_manager, "fn_add_ball")),
TimeDistortionField(
self.time_distortion_powerup_image_getter, pos,
ResourceCapsule(self.resource_manager,
"fn_activate_time_distortion_field")),
DoubleDamage(
self.double_damage_image_getter, pos,
ResourceCapsule(self.resource_manager, "fn_double_damage"))
]
chosen_powerup = random.choice(available_powerups)
self.powerups.add(chosen_powerup)
self.text_messages.append(
widgets.TextMessage(self.screen_getter(),
chosen_powerup.name + " spawned!",
Vector(self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=1200,
size=32,
initialdelay=1100))
def add_ball(self, release_instantly=False):
ball = Ball(self.ball_image_getter, (230 + 82, 625),
Vector(-3, -5),
ResourceCapsule(self.resource_manager,
"fn_is_time_distortion_field_active"),
self.resource_manager,
attached=True,
attach_pos=self.balls_on_paddle)
self.balls.add(ball)
self.balls_on_paddle += 1
if release_instantly:
ball.update(1, self.paddle, self.balls, self.blocks,
self.invulnerable_blocks)
self.release_a_ball()
def add_life(self):
if (self.lives < 5):
self.lives += 1
self.text_messages.append(
widgets.TextMessage(self.screen_getter(),
"Extra Life Added!",
Vector(
self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=1800,
size=32,
initialdelay=800))
self.lives_surface_getter = ResourceCapsule(
self.resource_manager, "livesfont_" + str(self.lives))
else:
self.text_messages.append(
widgets.TextMessage(self.screen_getter(),
"Max Lives Allowed!",
Vector(
self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=1800,
size=32,
initialdelay=800))
def activate_time_distortion_field(self, duration):
pygame.time.set_timer(self.TIME_DISTORTION_FIELD, 0)
self.time_distortion_field_active = True
pygame.time.set_timer(self.TIME_DISTORTION_FIELD, duration)
def disable_time_distortion_field(self):
self.time_distortion_field_active = False
pygame.time.set_timer(self.TIME_DISTORTION_FIELD, 0)
def is_time_distortion_field_active(self):
return self.time_distortion_field_active
def add_extrapoint(self):
for ball in self.balls:
ball.combo += 100
self.text_messages.append(
widgets.TextMessage(self.screen_getter(),
"You got 100 XP!",
Vector(self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=1800,
size=32,
initialdelay=800))
def double_damage(self):
for ball in self.balls:
ball.damage = 2
ball.image_getter = ResourceCapsule(self.resource_manager,
"image_large_ball.png")
def level_complete(self):
self.waiting_for_level = True
self.collect_all_score()
if self.level < self.available_levels:
pygame.time.set_timer(self.WAIT_NEW_LEVEL, 1800)
self.text_messages.append(
widgets.TextMessage(self.screen_getter(),
"Level Complete!",
Vector(
self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=1800,
size=32,
initialdelay=800))
else:
if android:
self.text_messages.append(
widgets.TextMessage(
self.screen_getter(),
"Congratulations! You beat all " +
str(self.available_levels) +
" levels. Play again? Y/n",
Vector(self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2 - 120),
duration=9999999,
size=24,
initialdelay=9999990))
android.show_keyboard()
else:
self.text_messages.append(
widgets.TextMessage(
self.screen_getter(),
"Congratulations! You beat all " +
str(self.available_levels) +
" levels. Play again? Y/n",
Vector(self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=9999999,
size=24,
initialdelay=9999990))
self.add_to_highscore()
self.game_over = True
def dropped_balls(self):
self.erase_rect(
self.screen_getter(),
Rect((168, 88, self.livesfont_getter().size(str(self.lives))[0],
self.livesfont_getter().size(str(self.lives))[1])))
self.lives -= 1
if self.lives > 0:
self.add_ball()
self.text_messages.append(
widgets.TextMessage(self.screen_getter(),
"Press SPACE to begin",
Vector(
self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=1800,
size=32,
initialdelay=800))
else:
self.lost()
self.lives_surface_getter = ResourceCapsule(
self.resource_manager, "livesfont_" + str(self.lives))
def lost(self):
self.game_over = True
self.lives = " NO LIVES"
if android:
self.text_messages.append(
widgets.TextMessage(
self.screen_getter(),
" Play again? Y/n",
Vector(self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2 - 120),
duration=9999999,
size=32,
initialdelay=9999990))
android.show_keyboard()
else:
self.text_messages.append(
widgets.TextMessage(self.screen_getter(),
" Play again? Y/n",
Vector(
self.screen_getter().get_width() / 2,
self.screen_getter().get_height() / 2),
duration=9999999,
size=32,
initialdelay=9999990))
self.add_to_highscore()
def add_to_highscore(self):
if not os.path.exists('playername.txt'):
playername_file = open('playername.txt', 'w')
playername_file.write("Player")
playername_file.close()
playername_file = open('playername.txt', 'r')
playername = playername_file.readline()
playername.rstrip()
playername_file.close()
now = datetime.datetime.now()
highscore = open('highscores.txt', 'a')
highscore.write(
str(now.year) + "-" + str(now.month) + "-" + str(now.day) + " " +
str(now.hour).zfill(2) + ":" + str(now.minute) + " " +
str(playername) + " scored " + str(self.score) + "\n")
highscore.close()
def pause(self, resume=False):
if not resume:
pygame.event.set_grab(False)
pygame.mouse.set_visible(True)
else:
pygame.event.set_grab(True)
pygame.mouse.set_visible(False)
self.clock_getter().tick(
) #Tick the clock to discard the passed time
def restart(self):
screen = self.screen_getter()
del self
game = Game(screen)
game.run()
def save(self, fileName=SAVE_FILE_NAME):
if not self.game_over:
self.resource_manager.clear()
self.text_messages = []
shouldRemoveSaveFile = False
try:
saveFile = open(fileName, 'wb')
try:
pickle.dump(self, saveFile, 2)
except (TypeError):
shouldRemoveSaveFile = True
print("Couldn't save: ") + str(e)
finally:
saveFile.close()
except (IOError):
print(str(e))
if shouldRemoveSaveFile:
os.remove(fileName)
def quit(self):
self.pause()
if widgets.UserConfirm(
self.screen_getter,
self.resource_manager,
message="Return to Main Menu? (Your progress will be saved)",
backgroundclass=self):
self.add_to_highscore()
self.force_quit()
self.screen_getter().blit(self.background_getter(), (0, 0))
pygame.display.update()
self.pause(resume=True)
def force_quit(self):
self.save()
self.pause() #Restores mouse state
self.stop_music()
del self
menu = Menu(get_screen())
def __getstate__(self):
return dict((k, v) for k, v in self.__dict__.iteritems()
if not is_instance_method(getattr(self, k)))
import ResourceManager
import Process
import json
import common
if __name__ == "__main__":
r = common.readobj("resources.json")
nresources = len(r['resources'])
ResourceManager.createCluster(r)
print("Enter number of process")
n = int(raw_input())
for i in range(n):
ResourceManager.newProcess()
ResourceManager.startService()
def addMediaToResourceManager(): for media in _catalog: ResourceManager.addResource(int(media["id"]), media["files"])
