class AsteroidsMinigame(GameStage):
GO_BACK_TIME = 3000
ONE_SECOND_INTERVAL = 1000
MARGIN = 70
def __init__(self, game):
GameStage.__init__(self, game)
def initialize(self):
GameStage.initialize(self)
stream = file('data/fonts.yaml', 'r')
fonts = load(stream)
for font in fonts:
setattr(
self, font,
assets.load_font(fonts[font]['file_name'],
fonts[font]['size']))
self.data = DictClass(load(file('data/asteroids.yaml')))
self.game_over_layer = Layer()
image = assets.load_image(
self.data.game_over[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.game_over.left, self.data.game_over.top,
image)
self.game_over_layer.add(item)
self.main_layer = Layer()
self.top_layer = Layer()
self.time = self.data.time.max
self.timer = DictClass({})
image = assets.load_image(self.data.time.src)
self.timer['skin'] = ItemImage(self.data.time.left, self.data.time.top,
image)
self.timer['value'] = ItemText(self.data.time.left,
self.data.time.top,
self.font,
0,
format_time(self.time),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.timer.skin)
self.top_layer.add(self.timer.value)
self.score = 0
self.score_board = DictClass({})
image = assets.load_image(self.data.score.src)
self.score_board['skin'] = ItemImage(self.data.score.left,
self.data.score.top, image)
self.score_board['value'] = ItemText(self.data.score.left,
self.data.score.top,
self.font,
0,
str(self.score),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.score_board.skin)
self.top_layer.add(self.score_board.value)
self.level = self.data.start
self.asteroids = []
self.max_width = 0
self.max_height = 0
for a in self.data.asteroids:
item = assets.load_image(a)
if self.max_width < item.get_width():
self.max_width = item.get_width()
if self.max_height < item.get_height():
self.max_height = item.get_height()
self.max_col = int(SCREEN_WIDTH / self.max_width)
self.max_row = int(SCREEN_HEIGHT / self.max_height)
self.margin_left = (SCREEN_WIDTH % self.max_width) / 2
self.margin_top = (SCREEN_HEIGHT % self.max_height) / 2
# Load the sound
self.click_sound = assets.load_sound('DGI_Click.ogg')
self.item_found_sound = assets.load_sound('DGI_item_found.ogg')
self.wrong_sound = assets.load_sound('DGI_wrong.ogg')
self.lose_bell_sound = assets.load_sound('DGI_lose_bell.ogg')
self.lose_music_sound = assets.load_sound('DGI_lose_music.ogg')
def prepare(self):
self.show()
self.add_layer(self.main_layer)
self.add_layer(self.top_layer)
dialog = Intro(self, self.data.intro, self.start_game)
dialog.start()
def start_game(self):
self.start_timer(0, self.ONE_SECOND_INTERVAL, self.update_time)
def show(self):
if 'selector' in self.data.levels[self.level]:
selector = eval(self.data.levels[self.level].selector)
aux_seq = eval(self.data.levels[self.level][selector])
else:
aux_seq = eval(self.data.levels[self.level].range)
self.sequence = []
for value in range(0, self.data.levels[self.level].quantity):
value = random.choice(aux_seq)
aux_seq.remove(value)
self.sequence.append(value)
self.sequence = sorted(self.sequence)
self.sequence.reverse()
positions = range(0, self.max_col * self.max_row)
for value in self.sequence:
src = random.choice(self.data.asteroids)
asteroid = Asteroid(self, 0, 0, src, value)
position = random.choice(positions)
positions.remove(position)
i = int(position / self.max_col)
j = int(position % self.max_col)
left = self.margin_left + j * self.max_width + random.uniform(
0, self.max_width % asteroid.item.get_width())
top = self.margin_top + i * self.max_height + random.uniform(
0, self.max_height % asteroid.item.get_height())
asteroid.set_left(left)
asteroid.set_top(top)
self.asteroids.append(asteroid)
self.main_layer.add(asteroid.item)
self.main_layer.add(asteroid.text)
if self.level + self.data.step <= self.data.max:
self.level += self.data.step
def select(self, asteroid):
self.click_sound.play()
expected = self.sequence.pop()
if asteroid.value == expected:
self.item_found_sound.play()
self.score += self.data.score.points
self.score_board.value.set_text(str(self.score))
self.asteroids.remove(asteroid)
self.main_layer.remove(asteroid.item)
self.main_layer.remove(asteroid.text)
asteroid.exit()
else:
self.wrong_sound.play()
self.sequence.append(expected)
if not self.asteroids:
self.show()
def update_time(self, key, data):
self.time -= 1
self.timer.value.set_text(format_time(self.time))
if not self.time:
self.game_over()
def game_over(self):
self.lose_bell_sound.play()
self.lose_music_sound.play()
self.stop_timer(0)
for asteroid in self.asteroids:
asteroid.item.remove_event_handler(ItemEvent.CLICK,
asteroid.handle_click)
self.add_layer(self.game_over_layer)
self.start_timer("go_back_timer", self.GO_BACK_TIME, self.go_back)
def go_back(self, *args, **kwargs):
from game.stages.map import Map
self.game.set_stage(Map(self.game))
class MemoryMinigame(GameStage):
GO_BACK_TIME = 3000
ONE_SECOND_INTERVAL = 1000
def __init__(self, game):
GameStage.__init__(self, game)
def initialize(self):
GameStage.initialize(self)
stream = file('data/fonts.yaml', 'r')
fonts = load(stream)
for font in fonts:
setattr(
self, font,
assets.load_font(fonts[font]['file_name'],
fonts[font]['size']))
self.data = DictClass(load(file('data/memory.yaml')))
self.game_over_layer = Layer()
image = assets.load_image(
self.data.game_over[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.game_over.left, self.data.game_over.top,
image)
self.game_over_layer.add(item)
self.main_layer = Layer()
self.top_layer = Layer()
self.time = self.data.time.max
self.timer = DictClass({})
image = assets.load_image(self.data.time.src)
self.timer['skin'] = ItemImage(self.data.time.left, self.data.time.top,
image)
self.timer['value'] = ItemText(self.data.time.left,
self.data.time.top,
self.font,
0,
format_time(self.time),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.timer.skin)
self.top_layer.add(self.timer.value)
self.score = 0
self.score_board = DictClass({})
image = assets.load_image(self.data.score.src)
self.score_board['skin'] = ItemImage(self.data.score.left,
self.data.score.top, image)
self.score_board['value'] = ItemText(self.data.score.left,
self.data.score.top,
self.font,
0,
str(self.score),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.score_board.skin)
self.top_layer.add(self.score_board.value)
self.deck = []
image_back = assets.load_image(self.data.board.card_back)
for k in range(0, len(self.data.board.cards)):
image = assets.load_image(self.data.board.cards[k])
self.deck.append([
Card(self, k, image, image_back),
Card(self, k, image, image_back)
])
self.range = self.data.start
self.cards = []
self.deal()
# Load the sound
self.card_flip_sound = assets.load_sound('DGI_card_flip.ogg')
self.item_found_sound = assets.load_sound('DGI_item_found.ogg')
self.wrong_sound = assets.load_sound('DGI_wrong.ogg')
self.lose_bell_sound = assets.load_sound('DGI_lose_bell.ogg')
self.lose_music_sound = assets.load_sound('DGI_lose_music.ogg')
def deal(self):
self.first = None
self.second = None
for k in range(0, self.range):
self.cards.append(self.deck[k][0])
self.cards.append(self.deck[k][1])
random.shuffle(self.cards)
d = ceil(sqrt(2 * self.range))
for i, card in zip(range(2 * self.range), self.cards):
card.item.set_left(self.data.board.left + card.item.get_width() *
(i % d))
card.item.set_top(self.data.board.top +
card.item.get_height() * int(i / d))
self.main_layer.add(card.item)
def select(self, card):
self.card_flip_sound.play()
if not self.second:
if self.first:
if self.first != card:
self.second = card
card.select()
self.start_timer(1, 500, self.check_match)
else:
self.first = card
card.select()
def check_match(self, key, data):
self.stop_timer(1)
if self.first.key == self.second.key:
self.item_found_sound.play()
self.cards.remove(self.first)
self.cards.remove(self.second)
self.main_layer.remove(self.first.item)
self.main_layer.remove(self.second.item)
self.score += self.data.score.points
self.score_board.value.set_text(str(self.score))
else:
self.wrong_sound.play()
self.first.unselect()
self.second.unselect()
self.first = self.second = None
if len(self.cards) == 2:
self.first = self.cards[0]
self.second = self.cards[1]
self.first.select()
self.second.select()
self.start_timer(1, 500, self.check_match)
elif not self.cards:
if self.range + self.data.step <= len(self.deck):
self.range += self.data.step
self.deal()
def prepare(self):
self.show_board()
dialog = Intro(self, self.data.intro, self.start_game)
dialog.start()
def start_game(self):
self.start_timer(0, self.ONE_SECOND_INTERVAL, self.update_time)
def update_time(self, key, data):
self.time -= 1
self.timer.value.set_text(format_time(self.time))
if not self.time:
self.game_over()
def show_board(self):
self.add_layer(self.main_layer)
self.add_layer(self.top_layer)
def game_over(self):
self.lose_bell_sound.play()
self.lose_music_sound.play()
self.stop_timer(0)
for card in self.cards:
card.item.remove_event_handler(ItemEvent.CLICK, card.handle_click)
self.add_layer(self.game_over_layer)
self.start_timer("go_back_timer", self.GO_BACK_TIME, self.go_back)
def exit(self, other_item):
GameStage.exit(self, other_item)
for card1, card2 in self.deck:
card1.exit()
card2.exit()
self.deck = None
self.cards = None
def go_back(self, *args, **kwargs):
from game.stages.map import Map
self.game.set_stage(Map(self.game))
class InvadersMinigame(GameStage):
MOVE_INTERVAL = 30
GOOD_INDICATOR_INTERVAL = 1000
DIFFICULTY_INTERVAL = 10000
GO_BACK_TIME = 3000
def __init__(self, game):
GameStage.__init__(self, game, Color('#333333'))
def initialize(self):
GameStage.initialize(self)
stream = file('data/fonts.yaml', 'r')
fonts = load(stream)
for font in fonts:
setattr(
self, font,
assets.load_font(fonts[font]['file_name'],
fonts[font]['size']))
self.data = DictClass(load(file('data/invaders.yaml')))
self.good = self.data.start.good
self.velocity = self.data.start.velocity
self.interval = self.data.start.interval
self.game_over_layer = Layer()
image = assets.load_image(
self.data.bad[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.bad.left, self.data.bad.top, image)
self.game_over_layer.add(item)
image = assets.load_image(
self.data.game_over[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.game_over.left, self.data.game_over.top,
image)
self.game_over_layer.add(item)
image = assets.load_image(
self.data.good[self.game.datastore.datamodel.character].src)
self.good_indicator = ItemImage(self.data.good.left,
self.data.good.top, image)
self.text_indicators = []
self.main_layer = Layer()
self.top_layer = Layer()
self.score = 0
self.score_board = DictClass({})
image = assets.load_image(self.data.score.src)
self.score_board['skin'] = ItemImage(self.data.score.left,
self.data.score.top, image)
self.score_board['value'] = ItemText(self.data.score.left,
self.data.score.top,
self.font,
0,
str(self.score),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.score_board.skin)
self.top_layer.add(self.score_board.value)
data = DictClass(load(file('data/map/common.yaml')))
params = data.character[self.game.datastore.datamodel.character]
params['base'] = data.character.base[
self.game.datastore.datamodel.character].big
self.character_animation = Character(**params)
self.character = self.character_animation.item
self.character.set_left(
(SCREEN_WIDTH - self.character.get_width()) / 2)
self.character.set_top(SCREEN_HEIGHT - self.character.get_height())
left = self.character.get_left() + self.data.collision.left
top = self.character.get_top() + self.data.collision.top
width = self.character.get_width(
) - self.data.collision.left - self.data.collision.right
height = self.character.get_height(
) - self.data.collision.top - self.data.collision.bottom
if DEBUG:
self.debug_character = ItemRect(left,
top,
width,
height,
border=(255, 255, 255))
self.invaders = []
# Load the sound
self.item_found_sound = assets.load_sound('DGI_item_found.ogg')
self.lose_hit_sound = assets.load_sound('DGI_lose_hit.ogg')
self.lose_music_sound = assets.load_sound('DGI_lose_music.ogg')
def increase_difficulty(self, key, data):
if self.good + self.data.step.good >= self.data.min.good:
self.good += self.data.step.good
if self.velocity + self.data.step.velocity <= self.data.max.velocity:
self.velocity += self.data.step.velocity
if self.interval + self.data.step.interval >= self.data.min.interval:
self.interval += self.data.step.interval
self.stop_timer(1)
self.start_timer(1, self.interval, self.create_invader)
def create_invader(self, key, data):
lst = [(True, self.good), (False, 1 - self.good)]
good = w_choice(lst)
if good:
index = random.randint(0, len(self.data.invaders.good) - 1)
invader = self.data.invaders.good[index]
else:
index = random.randint(0, len(self.data.invaders.bad) - 1)
invader = self.data.invaders.bad[index]
src = invader.src
points = invader.points
collision = invader.collision
min = invader.min
max = invader.max
velocity = invader.velocity
invader = Invader(0, 0, min, max, velocity, good, src, points,
collision)
left = random.randint(
0, SCREEN_WIDTH - invader.item.get_image().get_width())
invader.set_left(left)
top = -invader.item.get_image().get_height()
invader.item.set_top(top)
self.invaders.append(invader)
self.main_layer.add(invader.item)
if DEBUG:
self.main_layer.add(invader.debug_item)
def move_invaders(self, key, data):
for item in self.text_indicators:
item.set_top(item.get_top() - 2)
for invader in self.invaders:
invader.move(self.MOVE_INTERVAL, self.velocity)
if (invader.item.get_top() > SCREEN_HEIGHT):
self.remove_invader(invader)
else:
left = self.character.get_left() + self.data.collision.left
top = self.character.get_top() + self.data.collision.top
width = self.character.get_width(
) - self.data.collision.left - self.data.collision.right
height = self.character.get_height(
) - self.data.collision.top - self.data.collision.bottom
character = Rect(left, top, width, height)
item = Rect(invader.get_left(), invader.get_top(),
invader.get_width(), invader.get_height())
k = character.collidelist([item])
if k != -1:
if invader.good:
self.character_animation.footsteps_concrete_sound.stop(
)
self.item_found_sound.play()
self.character_animation.first_walking = True
self.score += invader.points
self.score_board.value.set_text(str(self.score))
self.top_layer.add(self.good_indicator)
item = ItemText(invader.get_left(),
invader.get_top(),
self.font,
0,
"+" + str(invader.points),
h_align=2,
v_align=2)
self.text_indicators.append(item)
self.top_layer.add(item)
fade_out_item(item, True, self.GOOD_INDICATOR_INTERVAL)
self.start_timer(3, self.GOOD_INDICATOR_INTERVAL,
self.remove_good_indicator)
else:
self.stop_timer(1)
self.stop_timer(2)
self.game_over()
return
self.remove_invader(invader)
def remove_invader(self, invader):
self.invaders.remove(invader)
self.main_layer.remove(invader.item)
invader.exit()
if DEBUG:
self.main_layer.remove(invader.debug_item)
def remove_good_indicator(self, key, data):
self.stop_timer(3)
self.top_layer.remove(self.good_indicator)
def prepare(self):
self.show_board()
self.key = None
dialog = Intro(self, self.data.intro, self.start_game)
dialog.start()
def start_game(self):
self.start_timer(1, self.interval, self.create_invader)
self.start_timer(2, self.MOVE_INTERVAL, self.move_invaders)
self.start_timer(4, self.DIFFICULTY_INTERVAL, self.increase_difficulty)
self.start_timer(0, 30, self.manage_key)
def show_board(self):
self.main_layer.add(self.character)
if DEBUG:
self.main_layer.add(self.debug_character)
self.add_layer(self.main_layer)
self.add_layer(self.top_layer)
def handle_event(self, e):
if e.type == KEYDOWN:
self.key = e.key
if e.type == KEYUP:
self.key = None
def manage_key(self, key, data):
delta = 0
if self.key == K_LEFT:
delta = -8
if self.key == K_RIGHT:
delta = 8
left = self.character.get_left() + delta
if 0 <= left and left <= SCREEN_WIDTH - self.character.get_width():
self.character.set_left(left)
if DEBUG:
self.debug_character.set_left(left + self.data.collision.left)
self.character_animation.update(self.MOVE_INTERVAL,
delta_left=delta)
def game_over(self):
self.good_indicator.set_visible(False)
self.character_animation.footsteps_concrete_sound.stop()
self.lose_hit_sound.play()
self.lose_music_sound.play()
self.stop_timer(0)
self.stop_timer(1)
self.stop_timer(2)
self.stop_timer(3)
self.stop_timer(4)
self.top_layer.remove(self.good_indicator)
self.add_layer(self.game_over_layer)
self.start_timer("go_back_timer", self.GO_BACK_TIME, self.go_back)
def exit(self, other_stage):
GameStage.exit(self, other_stage)
self.good_indicator.exit()
self.good_indicator = None
self.character_animation.exit()
self.character_animation = None
for invader in self.invaders:
invader.exit()
self.invaders = None
def go_back(self, *args, **kwargs):
from game.stages.map import Map
self.game.set_stage(Map(self.game))
