def __init__(self, game):
Sprite.__init__(self)
self.game = game
self.player_health = game.player.health
self.health_surface = pygame.Surface((200, 50))
self.health_surface.fill((40, 30, 30))
self.health_surface.set_colorkey((30, 30, 30))
self.rect = self.health_surface.get_rect()
self.full_heart = load_image('assets/room/full_heart.png', (40, 40))
self.half_heart = load_image('assets/room/half_heart.png', (40, 40))
def on_start(self):
self.next_wave_started = True
self.wave = False
self.end_wave = True
core.monster.Monster.load_resources()
core.player.Hero.load_resources()
weapon_imgs = core.load_spritesheet_alpha(core.Var.path_weapon, 96, 4, 3)
core.player.Hero.img_weapons = weapon_imgs[0:4]
core.player.Hero.img_weapons.append(weapon_imgs[9])
core.Item.img_weaponground = weapon_imgs[4:8]
core.Item.img_weaponground.insert(0, weapon_imgs[8])
core.Item.img_weaponground.append(weapon_imgs[10])
core.Var.level_boundries = (0, round(core.Var.SCREEN_WIDTH*1.5), 0, round(core.Var.SCREEN_HEIGHT*1.5))
core.Var.level_background = core.p.Surface((core.Var.level_boundries[1] - core.Var.level_boundries[0],
core.Var.level_boundries[3] - core.Var.level_boundries[2]))
core.Var.level_background.fill(core.Var.BLACK)
tile = core.load_image(core.Var.path_grassybk)
tile_x = tile.get_width()
tile_y = tile.get_height()
for x in range(core.Var.level_background.get_width()//tile_x+1):
for y in range(core.Var.level_background.get_height()//tile_y+1):
core.Var.level_background.blit(tile, (x*tile_x, y*tile_y))
core.Var.level_background.convert()
core.Gameobj.reset()
if not core.Var.game_loaded:
core.Var.reset_score()
core.Gameobj.reset_hero()
core.Gameobj.hero = core.player.Hero(0, 0, core.Var.hero_max_health, core.Var.hero_speed)
core.Gameobj.hero.x = core.Var.level_boundries[1] / 2
core.Gameobj.hero.y = core.Var.level_boundries[3] / 2
core.Var.survival_wave = 1
else:
core.Var.game_loaded = False
self.time_wave_end = time()
def bg(new_bg, overlay=True):
ls = core.screen.copy().convert()
core.screen.blit( core.load_image("gfx/" + new_bg), (0,0) )
if overlay:
core.screen.blit( mo, (0,0) )
core.dissolve_transition(ls, core.screen.copy().convert(), nvl.intime)
nvl.intime = 100
def test_compress_image_supply_iterations(self):
data = load_image("images/for_compression/marmite_100x100.jpg")
result = compress_image(data, terms=10, iterations=7)
assert result['compressed_data'].shape == (100, 100, 3)
assert result['iterations'] == 7
def create_feather(self, char, direction=None):
if direction is None:
direction = char.direction
feather = sprite.oSprite()
feather.attackMgr = self
tw, th = core.level.tileSize
feather.speed = .25
feather.direction = direction
if char.direction == "N":
feather.y -= th/2
if char.direction == "S":
feather.y += th/2
if char.direction == "E":
feather.x += tw/2
if char.direction == "W":
feather.x -= tw/2
feather.life = 700
feather.AI = self.AI
feather_char = core.load_image("feather.png", directory="gfx")
feather.animFromStrip( feather_char, [
["stopped","E",0,1,0,True, (3, 15)],
["stopped","N",1,1,0,True, (5,13)],
["stopped","W",2,1,0,True, (12,15)],
["stopped","S",3,1,0,True, (5,11)]
], 24, 24, feather_char)
feather.changeState("stopped")
feather.x = char.rx() + char.action_point()[0] - feather.hotspot()[0]
feather.y = char.ry() + char.action_point()[1] - feather.hotspot()[1]
core.attack_group.add(feather)
core.render_group.add(feather)
return feather
def update(self, lag):
for bug in self.bugs:
if bug.dead:
self.bugs.remove(bug)
if self.state < self.maxState:
self.openWork += lag
open_prob = 0
if self.openWork > 6000:
open_prob = 1
if self.openWork > 15000:
open_prob = 100
if random.randint(0,100) < open_prob:
self.changeState(self.state + 1)
self.openWork = 0
if self.state <= 0:
return
if len(self.bugs) < (self.capacity*self.state/2):
self.unactive += lag
if self.unactive > 5000:
if random.randint(0,100) < self.state*self.state*10:
# create a new bug...
self.mapa.created_bugs += 1
bug = sprite.oSprite()
tw, th = self.mapa.tileSize
bug.x = (self.mapID % self.mapa.width)
bug.y = (self.mapID / self.mapa.width)
bug.speed = .1
bug.direction = random.choice(self.direction)
bug.stuck = 0
if bug.direction == "N":
bug.y -= 1
elif bug.direction == "W":
bug.x -= 1
elif bug.direction == "S":
bug.y += 1
elif bug.direction == "E":
bug.x += 1
bug.AI = sprite.bugAI
bug_sprite = core.load_image("bug.png", directory="gfx")
bug.animFromStrip( bug_sprite, [
["stopped","E",0,1,0,True],
["stopped","N",4,1,0,True],
["stopped","W",8,1,0,True],
["stopped","S",12,1,0,True],
["dying", "N",1,3,.01,False],
], 48, 48, bug_sprite)
bug.changeState("stopped")
bug.x = bug.x * tw + bug.hotspot()[0]
bug.y = bug.y * th + bug.hotspot()[1] + 33
self.group.add(bug)
core.render_group.add(bug)
self.bugs.append(bug)
self.unactive = 0
def __init__(self):
oSprite.__init__(self)
self.animations = {
"default": {
"N": [0,True,[oFrame(core.load_image("gfx/pickups/heart.png"), hotspot=(0,30))]]
}
}
self.direction = "N"
self.changeState("default")
def get_ctc():
ctc = sprite.oSprite()
ctc.direction = "N"
ctc_sprite = core.load_image("gfx/cursor.png")
ctc.animFromStrip( ctc_sprite, [
["default","N",0,10,.01,True,(0,5)],
], 24, 24)
ctc.changeState("default")
return ctc
def __init__(self):
""" Creates the tateti setting its grid """
sprite.Sprite.__init__(self) # Call Sprite initializer
self.image, self.rect = load_image('tateti.png')
self.tick_sound = load_sound('button.wav')
self.error_sound = load_sound('error.wav')
self.pieces = [Piece('cross.png'), Piece('circle.png')]
self.grid = []
for i in range(3):
col = []
for j in range(3):
col.append(-1)
self.grid.append(col)
def on_start(self):
core.widgets.Button.load_resources()
Menu.img_background = core.load_image(core.Var.path_background)
self.img_title = core.Var.font_title.render(core.Var.CAPTION[core.Var.language_id].upper(), True,
core.Var.BLACK)
self.frame_title = self.img_title.get_rect()
self.frame_title.center = (core.Var.SCREEN_WIDTH / 3, core.dpp(130))
Menu.menu_items.clear()
for i in range(len(core.Var.str_mainmenu)):
Menu.menu_items.append(core.widgets.Button(core.Var.str_mainmenu[i][core.Var.language_id],
core.Var.SCREEN_WIDTH / 3 - core.widgets.Button.width / 2,
core.dpp(220) + i * core.widgets.Button.height,
self.menu_commands[i]))
def test_load_image():
result = load_image('images/test_3x3_gray.bmp')
assert result.shape == (3, 3)
assert result[0][0] == 79
assert result[0][1] == 59
assert result[0][2] == 0
assert result[1][0] == 149
assert result[1][1] == 119
assert result[1][2] == 99
assert result[2][0] == 254
assert result[2][1] == 219
assert result[2][2] == 199
def card_of_world(window):
"""
Create a main menu
"""
# Play music
jukebox = Jukebox()
jukebox.load('intro')
jukebox.play()
# Create background
background = pygame.Surface(window.get_size())
background = background.convert()
background.fill(CIEL)
window.blit(background, (0, 0))
pygame.display.flip()
#bomb = Bomb()
allsprites = pygame.sprite.RenderPlain()
for number in range(random.randint(4, 6)):
altitude = random.randint(0, 300)
speed = random.randint(1, 6)
allsprites.add(Cloud(altitude, speed))
hero = Hero()
allsprites.add(hero)
pygame.draw.rect(background, GREEN_PELOUSE, (0, 500, WINDOW_WIDTH, 100))
brand, brand_rect = core.load_image('Battle-story.png', -1)
brand_rect.left = WINDOW_WIDTH / 2 - brand_rect.width / 2
brand_rect.top = WINDOW_HEIGHT / 3 - brand_rect.height / 2
background.blit(brand, brand_rect)
#bombsprites = pygame.sprite.RenderPlain((bomb))
while True:
for event in pygame.event.get():
if event.type == QUIT:
return
hero.play_auto_animation()
allsprites.update()
#bombsprites.update()
window.blit(background, (0, 0))
allsprites.draw(window)
pygame.display.flip()
FPS_CLOCK.tick(FPS_FREQUENCY)
def test_load_image_four_chanels():
result = load_image('images/test_3x3.bmp')
assert result.shape == (3, 3, 3)
red = result[:, :, 0]
assert red[0][0] == 80
assert red[0][1] == 60
assert red[0][2] == 0
assert red[1][0] == 150
assert red[1][1] == 120
assert red[1][2] == 100
assert red[2][0] == 255
assert red[2][1] == 220
assert red[2][2] == 200
green = result[:, :, 1]
assert green[0][0] == 85
assert green[0][1] == 65
assert green[0][2] == 5
assert green[1][0] == 155
assert green[1][1] == 125
assert green[1][2] == 105
assert green[2][0] == 255
assert green[2][1] == 225
assert green[2][2] == 205
blue = result[:, :, 2]
assert blue[0][0] == 90
assert blue[0][1] == 70
assert blue[0][2] == 10
assert blue[1][0] == 160
assert blue[1][1] == 130
assert blue[1][2] == 110
assert blue[2][0] == 255
assert blue[2][1] == 230
assert blue[2][2] == 210
def __init__(self, coords):
image_path = 'assets/room/door-frame.png'
SpriteObject.__init__(self, image_path, coords, 1.9)
self.closed_door_image = load_image('assets/room/doors.png', 1.9)
self.is_closed = False
angle = 0
if coords == (450, 25):
angle = 0
self.doors_coords = (self.rect.x + 20, self.rect.y + 14)
elif coords == (80, 210):
angle = 90
self.doors_coords = (self.rect.x + 14, self.rect.y + 20)
elif coords == (450, 455):
angle = 180
self.doors_coords = (self.rect.x + 20, self.rect.y + 5)
elif coords == (820, 210):
angle = -90
self.doors_coords = (self.rect.x + 4, self.rect.y + 20)
self.rotate(angle)
self.room_created = False
def credits_screen():
goscreen = core.load_image("credits.png", directory="gfx", auto_alpha=False)
core.dissolve_transition( core.screen.copy().convert(), goscreen.copy().convert(), 1000 )
while True:
core.clock.tick(core.MAX_FPS)
events = pygame.event.get()
if core.handleEvents(events) == "quit":
exit()
for event in events:
if event.type == KEYUP:
core.play_sound("button_click")
Input.update()
core.next_screen = main_menu
return
core.screen.blit(goscreen, (0,0))
core.updateScreen()
def __init__(self):
from creatures import Player
from core import Game, SpriteGroup, load_image
from uis import HealthBar
from room import Room
self.rooms_seeds_dict = {}
self.start_time = time()
self.player = Player((460, 230))
self.gameover = False
# door_cords (450, 25), (80, 210), (450, 455), (820, 210)
self.room = Room((0, 0), self)
self.interface = SpriteGroup(HealthBar(self),
RoomsCounterText(f'Комнат пройдено: '
f'{len(self.rooms_seeds_dict.keys()) - 1}',
(0, 40), 36,
(180, 180, 180)))
self.background = load_image('assets/room/room-background.png')
self.create_new_room((0, 0), 'any')
Game.__init__(self)
def game_over(score, rank):
core.play_music("game over", queue=True)
# load game over screen
goscreen = core.load_image("game_over.png", directory="gfx", auto_alpha=False)
core.dissolve_transition( core.screen.copy().convert(), goscreen.copy().convert(), 1000 )
while True:
core.clock.tick(core.MAX_FPS)
events = pygame.event.get()
if core.handleEvents(events) == "quit":
exit()
for event in events:
if event.type == KEYUP:
core.next_screen = core.curry(hiscores_screen, score, rank)
Input.update()
return
core.screen.blit(goscreen, (0,0))
core.updateScreen()
def feather_received(attack):
last_screen = core.screen.copy().convert()
ls = last_screen.copy().convert()
core.screen.blit( core.load_image("gfx/feather_received.png"), (0,0) )
core.screen.blit( attack.image, (165, 265) )
received_text = "You've received the %s Feather!" % attack.name
core.fonts.Draw( core.screen, None, 24, received_text, pygame.Rect(275,250,450,50), (255,255,255,255),
alignHoriz='center', alignVert='center', antialias=True)
core.dissolve_transition( last_screen, core.screen.copy().convert(), 1000)
try:
while True:
lag = core.clock.tick(core.MAX_FPS)
events = pygame.event.get()
for event in events:
if event.type == KEYUP:
raise eOutOfLoop
if core.handleEvents(escape_exits=False) == "quit":
exit()
except eOutOfLoop:
pass
core.dissolve_transition( core.screen.copy().convert(), ls, 1000 )
def game_ending(ns):
core.play_music("ending", queue=True)
text_bg = core.load_image("gfx/bg_text.png")
mo = core.load_image("gfx/movie_overlay.png")
def _(texts):
if not nvl.show_texts(texts):
raise eSkipCutScene
def bg(new_bg, overlay=True):
ls = core.screen.copy().convert()
core.screen.blit( core.load_image("gfx/" + new_bg), (0,0) )
if overlay:
core.screen.blit( mo, (0,0) )
core.dissolve_transition(ls, core.screen.copy().convert(), nvl.intime)
nvl.intime = 100
def cls(color=(0,0,0,255)):
ls = core.screen.copy().convert()
core.screen.fill(color)
core.screen.blit( mo, (0,0) )
core.dissolve_transition(ls, core.screen.copy().convert(), nvl.intime)
nvl.intime = 100
nvl = fontmgr.oNvlScreen(x=80,y=80,width=440,height=440,background=text_bg,bg_pos=(50,50),ctc=get_ctc())
nvl.intime = 1000
cls()
try:
_(['"I was waiting for you."',
'The gentle voice greeted me as I entered that warm place.',
'I couldn\'t open my eyes at that time.',
'I was just so angry at myself.',
'So angry because I didn\'t realized it before.'])
_(['But you could say it was just me.',
'The selfish me.',
'The unreliable me.',
'The dummy me.',
'Even though it was always in front of me I couldn\'t see it.'])
_([u'\n\n\n\n\n\n\n\n———no.',
'Rather, I couldn\'t accept it.'])
_(['I was afraid of hurting myself.',
'Of breaking the mask of big sis I always wore, even though I never acted like one.'])
_(['\n\n\n\n\n\n\n\n\nThe stupid selfish me.',
'The one who always, always hurt the others so to not hurt myself.',
'The one that sealed the bright part of me deep inside my heart.'])
_(['It was easier this way.',
'I needn\'t care about other people problems.',
'To tell the truth, I didn\'t even care about my owns.'])
_([u'\n\n\n\n\n\n\n\n———but it\'s already enough.'])
_(['Like a lie, which can be sweet at start, acting like this will just harm my heart more and more.',
'\nBecause even if I pretend I don\'t care about the ones I like, I still get hurt when they do.',
'I still cry when they cry.',
'I still suffer when they suffer.'])
_(['But I don\'t smile, for I can\'t show I\'m happy for they.',
'I don\'t have anyone to cry with me, because I conceal all my feelings.',
'And even when they\'re down because of me, I still scold them for being so...',
u'\n\n\n———human.'])
_(['"It\'s okay now."',
'Yeah, it\'s okay now.',
'Because I won\'t run from myself anymore.',
'I\'ll embrace these feelings and be who I am until the very end.',
'So I can open my eyes again and lift my gaze.'])
nvl.intime = 1000
bg("cg/join_hands.png")
_(['\n\n\n\n\n\n\n\n\n\nThere\'s a beautiful world waiting for me, if only I want to enjoy it.'])
_(['"That\'s true."',
'"Let\'s go togheter."'])
nvl.intime = 2000
cls(color=(255,255,255,255))
_(['"Yume."',
'\nA familiar voice.',
'\n\n"Hey, Yume!"',
'\nA gentle voice.',
'\n\n"Geez, stop day dreaming already."'])
nvl.intime = 1000
bg("cg/yume.png")
_(['"Ah, Dai-kun?"',
u'\nDai-kun — Daisuke Minato — is one of my classmates.',
'We are computer science students and I\'m one of the few girls in the class.',
'Well, not that I\'d make friends with lots of them if there were, actually.',
u'After all, Dai-kun is one of the few — and by few I mean three — friends I have at college.'])
_(['"Geez, you\'re so hopeless. I bet you didn\'t listen to a word I said."',
'He has a point.',
'\n"Sorry."',
'"Eh?! Are you all there?"',
'"Silly"',
'We laughed.'])
_(['"That\'s like the first time ever you said "sorry" and made such a "sorry" face."',
'"Yeah. I guess I found myself once again."',
'"Weirdo."',
'He giggled.'])
_(['"I was thinking..."',
'"Hm? What is it?"',
'"Want to go to the karaoke next friday... if you\'re free, I mean."',
'"Of course!"',
'My voice sounded more cheerfuly than what I wanted.'])
_(['Daisuke took a while to understand those words, as he just kept staring at me with the most surprised face I\'ve ever seen.',
'"Are you sure you\'re Yume?"',
'"Eh?!"',
'"I mean, you\'re not some alien with her body, or an android, or something, are you?"',
'"Hm... I guess I\'m something."',
'We both laughed.'])
_(['"Anyways, I was thinking."',
'\nHe looked at me with an odd inquiring look, "What is it?"',
'"Will there be a problem if we add my sis too?"',
'"Eh?!"',
'"I\'m warning you, she\'s a singing godness."',
'"Haha. I guess there won\'t be a problem, but..."',
'"But...?"',
'"Hm, it\'s nothing. Just forget about it."'])
nvl.intime = 1000
bg("cg/yume_to_daidai.png")
_(['He came closer and gave me a kiss on my cheeks.',
'"Please look forward to it."',
'"I-I will..."'])
nvl.intime = 2000
cls()
_([u'\n\n\n\n\n\n\nI definetly will———',
u'\n———enjoy life to my hearts contents from now on.'])
nvl.intime = 2000
bg("cg/fin.png", overlay=False)
except eSkipCutScene:
pass
core.next_screen = ns
return
def game_intro():
core.play_music("intro", queue=True)
text_bg = core.load_image("gfx/bg_text.png")
mo = core.load_image("gfx/movie_overlay.png")
def _(texts):
if not nvl.show_texts(texts):
raise eSkipCutScene
def bg(new_bg):
ls = core.screen.copy().convert()
core.screen.blit( core.load_image("gfx/" + new_bg), (0,0) )
core.screen.blit( mo, (0,0) )
core.dissolve_transition(ls, core.screen.copy().convert(), nvl.intime)
nvl.intime = 100
def cls(color=(0,0,0,255)):
ls = core.screen.copy().convert()
core.screen.fill(color)
core.screen.blit( mo, (0,0) )
core.dissolve_transition(ls, core.screen.copy().convert(), nvl.intime)
nvl.intime = 100
nvl = fontmgr.oNvlScreen(x=80,y=80,width=440,height=440,background=text_bg,bg_pos=(50,50),ctc=get_ctc())
bg("cg/feather.png")
try:
nvl.y = 280
_(['A feather.'])
nvl.y = 80
_(['For a long time that was the only thing to fill my dreams.\n',
'A lone feather over the tidy ocean of darkness.',
'The pure white which seemed to defy the very place it lied, eternally.'])
_([u'\n\n———or maybe it was the other way around.',
'Maybe, just maybe, for the white feather was so pure the entire universe seemed ugly.\n'])
_(['I didn\'t know.\n',
'Even after so long I couldn\'t understand the meaning of that dream.\n',
u'\n\n———but I could feel that feather.\n',
'Somehow it seemed real.',
'Even more real than reality.',
'It was a crying soul.',
'A maiden in distress calling for her brave prince.',
'A faithful beauty letting out her last deep breath before being engulfed by darkness.'])
nvl.intime = 2000
cls()
_(['...',
'......',
'.........',
u'\n\n\n————no!',
'Not yet!',
'It can\'t end this way.',
u'Just———!'])
_(['I stretched my hands in the feather\'s direction.\n',
'......',
u'———but it wasn\'t there',
'The feather wasn\' there anymore.\n',
'It was over and for some reason I felt sad.',
'As if my entire world didn\'t make any sense at all without that feather.'])
_(['Why?'])
_([u'\n\n\n\n\n————silence.'])
_(['Why?', 'Why?', 'Why?',
'\n\n\nIt. Was. Just. A. Feather.',
'\n\nSo, why?'])
_(['Because I\'m the prince?',
'Because I couldn\'t save who I was supposed to?',
'...',
'I don\'t know.',
'I just...'])
_(['"You shouldn\'t cry."',
'"Eh?!"',
'"Because a prince should be brave, right?"',
'\nIt was a gentle voice echoing in a motherly way.',
'\n\n\nMy mind was clear now.',
'That voice killed not just my fears, but also my thoughts.',
'I could only open my eyes and look at the person above me.'])
nvl.intime = 1000
bg("cg/hikari_floating.png")
_(['Her pink hair, wavering slightly with the wind, covered part of her face.',
'\nThe pale complexion was concealed by a queer pastel red dress, while a red thread conected its pinky finger to mine.',
'\n\nThe maiden floated slowly with its only wing, stretching her soft hand in my direction.'])
_(['It wasn\'t just that she was pretty.',
u'———she was bewitching.',
'\n\n\nWhich explains why I couldn\'t reach her hands.',
'\n\nOr maybe it was the depressed expression she carried.',
'Even if it seemed she was passing through a lot of troubles, it also seemed she would broke if I just touched her.'])
_(['"I wish I could stay longer."',
'For the first time her eyes were cast down.'])
_(['That brought me to reality.',
'After all, I\'m her prince.',
'If she needs my help I shall help her.',
'Moreover, I shall protect her with my life if I must.'])
_(['"The gods said there\'s a red thread which connects people."',
'\n\n\nI heard about that from my sister.',
'It\'s a thread of destiny, which connects two peoples by their pinkies.',
'But this line isn\'t visible, so those people should love one another to find their soulmates.'])
_(['...',
'"That should mean..."'])
_(['Do I love her?',
'"But..."\n',
'(I don\'t know her), I wanted to say.',
'\nThe words just didn\'t come off.',
'\n\n\n\n\nBecause I knew her.',
'For some strange reason I knew her so well.',
'And yet, I haven\'t any idea of who she was.'])
_(['She smiled beautifully.',
u'That beautiful smile———',
u'\n\n\n———how can I say no to it?'])
_(['"I know I\'ll regret it later, but..."',
'"Is that a "yes"?"',
'"Sort of."',
'She giggled, "I knew you would agree. Please take this feather with you."',
'"Eh?!"'])
_(['"This is a debug feather.\nUnfortunately your dream still runs on Ruindows, so you\'ll have to use it a lot."',
'"Yeah missy. But why can\'t you just stay here?"',
'Her eyes were cast down once again.',
'She seemed rather depressed, and that made me sad.'])
nvl.intime = 2000
cls()
_(['The girl slowly faded away.',
'She didn\'t answered my question, but I already knew the answer.',
'\n\n\n\n\n"I guess I can\'t just leave it at this, can I?"'])
except eSkipCutScene:
pass
core.next_screen = main_game
return
def __init__(self, **kwargs):
"""Initializes oMap class."""
self.width = kwargs.pop("width" , 0)
self.height = kwargs.pop("height", 0)
self.mapData = kwargs.pop("mapData", [])
self.tileset = kwargs.pop("tileset", [
core.load_image("plain_block.png", directory="gfx/tileset"), # 0
core.load_image("brown_block.png", directory="gfx/tileset"), # 1
core.load_image("dirty_block.png", directory="gfx/tileset"), # 2
core.load_image("stone_block.png", directory="gfx/tileset"), # 3
core.load_image("grass_block.png", directory="gfx/tileset"), # 4
core.load_image("water_block.png", directory="gfx/tileset"), # 5
core.load_image("wall_block.png", directory="gfx/tileset"), # 6
core.load_image("wood_block.png", directory="gfx/tileset"), # 7
core.load_image("portal_inactive.png", directory="gfx/tileset"),# 8
core.load_image("portal_active.png", directory="gfx/tileset"), # 9
core.load_image("star_0.png", directory="gfx/tileset"), # 10
core.load_image("star_1.png", directory="gfx/tileset"), # 11
core.load_image("star_2.png", directory="gfx/tileset"), # 12
core.load_image("star_3.png", directory="gfx/tileset"), # 13
core.load_image("star_4.png", directory="gfx/tileset"), # 14
core.load_image("star_5.png", directory="gfx/tileset"), # 15
core.load_image("star_6.png", directory="gfx/tileset"), # 16
core.load_image("star_7.png", directory="gfx/tileset"), # 17
core.load_image("star_8.png", directory="gfx/tileset"), # 18
core.load_image("star_9.png", directory="gfx/tileset"), # 19
core.load_image("mult.png", directory="gfx/tileset"), # 20
core.load_image("add.png", directory="gfx/tileset"), # 21
core.load_image("sub.png", directory="gfx/tileset"), # 22
core.load_image("div.png", directory="gfx/tileset"), # 23
core.load_image("mod.png", directory="gfx/tileset"), # 24
core.load_image("star_0a.png", directory="gfx/tileset"), # 25
core.load_image("star_1a.png", directory="gfx/tileset"), # 26
core.load_image("star_2a.png", directory="gfx/tileset"), # 27
core.load_image("star_3a.png", directory="gfx/tileset"), # 28
core.load_image("star_4a.png", directory="gfx/tileset"), # 29
core.load_image("star_5a.png", directory="gfx/tileset"), # 30
core.load_image("star_6a.png", directory="gfx/tileset"), # 31
core.load_image("star_7a.png", directory="gfx/tileset"), # 32
core.load_image("star_8a.png", directory="gfx/tileset"), # 33
core.load_image("star_9a.png", directory="gfx/tileset"), # 34
core.load_image("active.png", directory="gfx/tileset"), # 35
core.load_image("tree_ugly.png", directory="gfx/tileset"), # 36
core.load_image("tree.png", directory="gfx/tileset"), # 37
core.load_image("tree_tall.png", directory="gfx/tileset") # 38
])
self.x = kwargs.pop("x", 0)
self.y = kwargs.pop("y", 0)
self.tileSize = kwargs.pop("tileSize", (64,50))
self.portalN = kwargs.pop("portal", 0)
self.portalActive = False
self.created_bugs = 0
self.time = kwargs.pop("time", 300)
self.nests = [ ]
self.genBitmask()
def level_clear_screen(mc, killed_bugs, ltime, lives, lost_lives, score):
core.play_music("stage clear", queue=True)
last_screen = core.screen.copy().convert()
ls = last_screen.copy().convert()
bg = core.load_image("stage_clear.png", directory="gfx")
stars = core.load_image("rank_star.png", directory="gfx")
stars = [ core.im_crop(stars, pygame.Rect(0,0,55,51)),
core.im_crop(stars, pygame.Rect(55,0,55,51)) ]
ltime = int(ltime)
used_feathers, wasted_feathers, waste_penalty = getFeatherStats(mc)
rank = getRank(mc, lost_lives, lives, ltime, killed_bugs)
state = 0
skilled_bugs = oStatsDisp(0, (465,155), useNumbers=True, xalign=1.0, width=100, formatValue=format_level_time)
stime = oStatsDisp(0, (465,190), useNumbers=True, xalign=1.0, width=100, formatValue=format_level_time)
slives = oStatsDisp(0, (465,225), useNumbers=True, xalign=1.0, width=100, formatValue=format_level_time)
sfeathers = oStatsDisp(0, (465,260), useNumbers=True, xalign=1.0, width=100, formatValue=format_level_time)
stotal = oStatsDisp(score, (235,370), useNumbers=True, xalign=1.0, width=330, formatValue=format_score)
last_total = score
forceUpdate = True
vel = .3
vel2 = 100
while True:
lag = core.clock.tick(core.MAX_FPS)
if lag <= 0:
lag = 1
dirty_rects = []
if core.handleEvents() == "quit":
exit()
vel = 0.2
if Input.up(K_RETURN):
if state < 8:
vel = sys.maxint
else:
core.dissolve_transition(core.screen.copy().convert(), ls, 1000)
return stotal.value, rank
core.screen.blit(ls, (0,0))
core.screen.blit(bg, (0,0))
# points
if state == 0:
skilled_bugs.update( skilled_bugs.value + vel*lag )
if skilled_bugs.value >= killed_bugs:
skilled_bugs.value = killed_bugs
state += 1
elif state == 1:
stime.update( stime.value + vel*lag )
if stime.value >= ltime:
stime.value = ltime
state += 1
elif state == 2:
slives.update( slives.value + vel*lag )
if slives.value >= lives:
slives.value = lives
state += 1
elif state == 3:
sfeathers.update( sfeathers.value + vel*lag )
if sfeathers.value >= wasted_feathers:
sfeathers.value = wasted_feathers
state += 1
elif state == 4:
stotal.update( stotal.value + vel2*lag )
if stotal.value >= last_total + killed_bugs*10:
stotal.value = last_total + killed_bugs*10
last_total = stotal.value
state += 1
elif state == 5:
stotal.update( stotal.value + vel2*lag )
if stotal.value >= last_total + ltime*100:
stotal.value = last_total + ltime*100
last_total = stotal.value
state += 1
elif state == 6:
stotal.update( stotal.value + vel2*lag )
if stotal.value >= last_total + lives*1000:
stotal.value = last_total + lives*1000
last_total = stotal.value
state += 1
elif state == 7:
stotal.update( stotal.value - vel2*lag )
if stotal.value <= last_total - waste_penalty:
stotal.value = last_total - waste_penalty
last_total = stotal.value
state += 1
# draw
dirty_rects.extend( skilled_bugs.draw(core.screen) )
if state > 0:
dirty_rects.extend( stime.draw(core.screen) )
if state > 1:
dirty_rects.extend( slives.draw(core.screen) )
if state > 2:
dirty_rects.extend( sfeathers.draw(core.screen) )
if state > 3:
dirty_rects.extend( stotal.draw(core.screen) )
if state > 7:
def draw_rank_star(pos, rank_need):
if rank >= rank_need:
return core.screen.blit(stars[1], pos)
else:
return core.screen.blit(stars[0], pos)
dirty_rects.append( draw_rank_star((405,430), 3) )
dirty_rects.append( draw_rank_star((460,430), 2) )
dirty_rects.append( draw_rank_star((515,430), 1) )
if last_screen is not None:
core.dissolve_transition(last_screen, core.screen.copy().convert(), 1000)
last_screen = None
if forceUpdate:
dirty_rects = None
forceUpdate = False
core.updateScreen(dirty_rects)
def process(dirname, out_subdir, silent=False, only_widths=[]):
"""
Compresses sample images from `dirname` using different number of terms in
singular value expansion.
Parameters
----------
dirname : string
Path to directory for the images to process.
out_subdir : string
Path to directory where the compressed images will be created.
silent : bool
Does not show any output when True.
only_widths : list of int
If the list is not empty, process only images that have given widths.
"""
filenames = os.listdir(dirname)
if not silent:
print("Creating images:")
supported_extensions = [".jpg", ".jpeg", ".png", ".bmp", ".gif"]
for filename in filenames:
_, file_extension = os.path.splitext(filename)
if file_extension.lower() not in supported_extensions:
continue
path = os.path.join(dirname, filename)
data = load_image(path)
width, height = image_size(data)
size_test = f"{width}x{height}"
if len(only_widths) > 0 and width not in only_widths:
continue
for terms in [1, 2, 5, 10, 20, 50, 100, 150, 200, 300, 500]:
outdir = os.path.join(out_subdir, size_test)
if not os.path.exists(outdir):
os.makedirs(outdir)
ratio = compression_ratio(width=width, height=height, terms=terms)
if ratio > 1.2:
continue
path_out = compressed_image_path(path,
width=width,
height=height,
terms=terms,
outdir=outdir)
if not silent:
print(path_out)
result = compress_image(data, terms=terms)
compressed_data = result['compressed_data']
imageio.imwrite(path_out, compressed_data)
annotate_from_width(path=path_out,
terms=terms,
width=width,
ratio=ratio)
if not silent:
print("Done")
def yesno_prompt(text):
last_screen = core.screen.copy().convert()
ls = last_screen.copy().convert()
bg = core.load_image("yesno_prompt.png", directory="gfx")
selected = 0
button_group = sprite.oSpriteGroup()
def genButton(images, pos):
button = sprite.oSprite()
button.x = pos[0]
button.y = pos[1]
button.animations = {
"active": {
"N": [0,True,[sprite.oFrame(images[0])]]
},
"inactive": {
"N": [0,True,[sprite.oFrame(images[1])]]
}
}
button_group.add(button)
return button
selected = 0
buttons = []
buttons.append( genButton(core.game_images["no"], (200,300)) )
buttons.append( genButton(core.game_images["yes"], (400,300)) )
forceUpdate = True
while True:
lag = core.clock.tick(core.MAX_FPS)
if core.handleEvents() == "quit":
exit()
if Input.up(K_LEFT):
core.play_sound("cursor_move")
selected -= 1
if selected < 0:
selected = len(buttons)-1
if Input.up(K_RIGHT):
core.play_sound("cursor_move")
selected += 1
if selected >= len(buttons):
selected = 0
if Input.up(K_RETURN):
core.play_sound("button_click")
core.dissolve_transition(core.screen.copy().convert(), ls, 1000)
return bool(selected)
for i, button in enumerate(buttons):
button.changeState("active" if i == selected else "inactive")
dirty_rects = button_group.update(lag)
core.screen.blit(ls, (0,0))
core.screen.blit(bg, (0,0))
button_group.draw(core.screen)
dirty_rects.append(core.fonts.Draw(core.screen, None, 36, text,
pygame.Rect(50,250,700,50), (255,255,255,255), alignHoriz='center', antialias=True))
if last_screen is not None:
core.dissolve_transition(last_screen, core.screen.copy().convert(), 1000)
last_screen = None
core.updateScreen(dirty_rects)
parser.add_argument("--sharpen",
action="store_true",
help="sharpens the image")
parser.add_argument("--blur", action="store_true", help="blurs the image")
parser.add_argument("--edges",
action="store_true",
help="enhances edges of the image")
args = parser.parse_args()
# argparse filetype seems weird when using the same io files
if not os.access(args.input_file, os.R_OK):
print("Cannot access input file!")
exit()
image = ez.load_image(args.input_file)
if image.ndim not in [2, 3]:
print("Invalid input file!")
exit()
mode = "RGB" if image.ndim == 3 else "L"
# perhaps implementing custom Namespace object that stores
# count and order of the arguments would be a better choice
while sys.argv:
item = sys.argv.pop(0)
if item not in functions:
continue
def test_compress_image_that_crashed(self):
data = load_image("images/none_type_test.png")
result = compress_image(data, terms=3)
assert result['compressed_data'].shape == (256, 302, 3)
def __init__(self, image_name):
sprite.Sprite.__init__(self)
self.image, self.rect = load_image(image_name)
def main_menu(window):
"""
Create a main menu
"""
# Play music
jukebox = Jukebox()
jukebox.load('intro')
jukebox.play()
# Create background
background = pygame.Surface(window.get_size())
background = background.convert()
background.fill(CIEL)
if pygame.font:
font = pygame.font.Font(FONT_DK_SAMHAIN, 46)
play_txt = font.render(_('JOUER'), 1, (10, 10, 10))
play_txt_pos = play_txt.get_rect(
centerx=200,
centery=background.get_height()/2
)
background.blit(play_txt, play_txt_pos)
load_txt = font.render(_('CHARGER'), 1, (10, 10, 10))
load_txt_pos = load_txt.get_rect(
centerx=550,
centery=background.get_height()/2
)
background.blit(load_txt, load_txt_pos)
window.blit(background, (0, 0))
pygame.display.flip()
#bomb = Bomb()
allsprites = pygame.sprite.RenderPlain()
for number in range(random.randint(4, 6)):
altitude = random.randint(0, 300)
speed = random.randint(1, 6)
allsprites.add(Cloud(altitude, speed))
hero = Hero()
allsprites.add(hero)
pygame.draw.rect(background, GREEN_PELOUSE, (0, 500, WINDOW_WIDTH, 100))
brand, brand_rect = core.load_image('Battle-story.png', -1)
brand_rect.left = WINDOW_WIDTH / 2 - brand_rect.width / 2
brand_rect.top = WINDOW_HEIGHT / 3 - brand_rect.height / 2
background.blit(brand, brand_rect)
#bombsprites = pygame.sprite.RenderPlain((bomb))
while True:
for event in pygame.event.get():
if event.type == QUIT:
quit_menu(window)
elif event.type == MOUSEBUTTONDOWN:
posx, posy = pygame.mouse.get_pos()
if posx >= play_txt_pos.left and \
posx <= play_txt_pos.left + play_txt_pos.width and \
posy >= play_txt_pos.top and \
posy <= play_txt_pos.top + play_txt_pos.height:
print("jeu")
game = Game('map1')
game.play(window)
elif posx >= load_txt_pos.left and \
posx <= load_txt_pos.left + load_txt_pos.width and \
posy >= load_txt_pos.top and \
posy <= load_txt_pos.top + load_txt_pos.height:
print("Load")
hero.play_auto_animation()
allsprites.update()
#bombsprites.update()
window.blit(background, (0, 0))
allsprites.draw(window)
pygame.display.flip()
FPS_CLOCK.tick(FPS_FREQUENCY)
def test_compress_image_to_file_3_by_3(self):
path = "images/test_3x3.bmp"
path_out = "images/test_3x3_output.bmp"
result = compress_image_to_file(path, path_out=path_out, terms=1, iterations=1,
annotate=False)
output_path = result['output_path']
assert output_path == path_out
assert os.path.exists(output_path)
# Verify image pixels
# ------------------
result = load_image(path_out)
assert result.shape == (3, 3, 3)
# Red
# ------
data = result[:, :, 0]
assert data[0][0] == 59
assert data[0][1] == 49
assert data[0][2] == 41
assert data[1][0] == 145
assert data[1][1] == 122
assert data[1][2] == 102
assert data[2][0] == 255
assert data[2][1] == 221
assert data[2][2] == 185
# Green
# ------
data = result[:, :, 1]
assert data[0][0] == 64
assert data[0][1] == 54
assert data[0][2] == 46
assert data[1][0] == 150
assert data[1][1] == 128
assert data[1][2] == 107
assert data[2][0] == 255
assert data[2][1] == 226
assert data[2][2] == 189
# Blue
# ------
data = result[:, :, 2]
assert data[0][0] == 69
assert data[0][1] == 60
assert data[0][2] == 50
assert data[1][0] == 154
assert data[1][1] == 134
assert data[1][2] == 112
assert data[2][0] == 255
assert data[2][1] == 230
assert data[2][2] == 194
# Delete output image
os.remove(output_path)
def map_editor():
mapa, filename = new_map()
tiles = [
map.oTile(0, 25, True),
map.oTile(1, 25, True),
map.oTile(2, 25, True),
map.oTile(3, 25, True),
map.oTile(4, 25, False),
map.oTile(5, 25, False),
map.oTile(6, 25, True)
]
selector = core.load_image("selector.png", directory="gfx")
current_tile = 0
number = 0
op = 0
task = 0
ox = 0
oy = 0
tw, th = mapa.tileSize
while True:
lag = core.clock.tick(core.MAX_FPS)
mx, my = pygame.mouse.get_pos()
ox = int(math.floor( (mx-mapa.x) / tw ))
oy = int(math.floor( (my-mapa.y) / th ))
if ox >= mapa.width:
ox = mapa.width-1
if oy >= mapa.height:
oy = mapa.height-1
if ox < 0:
ox = 0
if oy < 0:
oy = 0
dx, dy = ox, oy
events = pygame.event.get()
for event in events:
if event.type == QUIT:
exit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
return
if event.key == K_LEFT:
if task == 0: # tile
current_tile -= 1
if current_tile < 0:
current_tile = len(tiles)-1
elif task == 1: # number
number -= 1
if number < 0:
number = 9
elif task == 2: # op
op -= 1
if op < 0:
op = 4
if event.key == K_RIGHT:
if task == 0:
current_tile += 1
if current_tile >= len(tiles):
current_tile = 0
if task == 1:
number += 1
if number > 9:
number = 0
if task == 2:
op += 1
if op > 4:
op = 0
if event.key == K_UP:
task -= 1
if task < 0:
task = 3
if event.key == K_DOWN:
task += 1
if task > 3:
task = 0
if event.key == K_F1:
mapa, filename = new_map()
if event.key == K_F2:
mapa.save(filename)
if event.key == K_F3:
mapa, filename = load_map()
if event.key == K_F4:
mapa = edit_map(mapa)
core.handleEvents(events)
if Input.down("MB1"):
p = oy*mapa.width + ox
if task == 0:
if mapa.mapData[p] is None:
mapa.mapData[p] = map.oTile(0,0,False)
mapa.mapData[p].imageID = tiles[current_tile].imageID
mapa.mapData[p].height = tiles[current_tile].height
mapa.mapData[p].walkable = tiles[current_tile].walkable
elif task == 1 and mapa.mapData[p] is not None:
mapa.mapData[p].number = number
elif task == 2 and mapa.mapData[p] is not None:
mapa.mapData[p].op = op
elif task == 3 and mapa.mapData[p] is not None:
mapa.mapData[p].portal = True
if Input.down("MB3"):
p = oy*mapa.width + ox
if task == 0:
mapa.mapData[p] = None
elif task == 1 and mapa.mapData[p] is not None:
mapa.mapData[p].number = -1
elif task == 2 and mapa.mapData[p] is not None:
mapa.mapData[p].op = -1
elif task == 3 and mapa.mapData[p] is not None:
mapa.mapData[p].portal = False
core.screen.fill((180,180,180,255))
mapa.draw(core.screen)
if task == 0:
core.screen.blit( mapa.tileset[tiles[current_tile].imageID], (dx*tw,dy*th), special_flags=BLEND_RGBA_MULT )
elif task == 1:
core.screen.blit(mapa.tileset[10+number], (dx*tw, dy*th-25))
elif task == 2:
core.screen.blit(mapa.tileset[20+op], (dx*tw, dy*th-25))
elif task == 3:
core.screen.blit(mapa.tileset[8], (dx*tw, dy*th-25))
core.screen.blit( selector, (dx*tw,dy*th-25) )
core.fonts.Draw(core.screen, None, 24, 'x, y: ' + str(ox) + ', ' + str(oy), (10, 10), (255,255,255,255))
core.updateScreen()
def main_game():
global mc, tutorial, hints, killed_bugs
# if yesno_prompt("Play tutorial level?"):
# tutorial = True
# hints = 0
core.baddys_group.clear()
core.render_group.clear()
core.attack_group.clear()
# load bg
sky_bg = core.load_image("sky_bg.png", directory="gfx", auto_alpha=False)
exp_bgs = core.load_image("exp_bg.png", directory="gfx")
exp_bg = sprite.oSprite()
exp_bg.x = 10
exp_bg.y = 545
exp_bg.animations = {
"stopped": {
"N": [0, True, [
sprite.oFrame(core.im_crop(exp_bgs, pygame.Rect(0,0,278,33))),
sprite.oFrame(core.im_crop(exp_bgs, pygame.Rect(0,33,278,33))),
sprite.oFrame(core.im_crop(exp_bgs, pygame.Rect(0,66,278,33)))
]]
}
}
exp_bg.changeState("stopped")
core.render_group.add(exp_bg)
# initialize map
core.level = map.oMap()
# current stats
level = 0
level_time = oStatsDisp(core.level.time, (700,20), useNumbers=True, formatValue=format_level_time)
lives = oStatsDisp(3, (10, 20), image=core.load_image("haato.png", directory="gfx"))
score = oStatsDisp(0, (0,20), xalign=0.5, useNumbers=True, formatValue=format_score)
# main character
mc = sprite.oSprite()
mc_sprite = core.load_image("nozomi.png", directory="gfx")
mc_mask = core.load_image("nozomi_mask.png", directory="gfx")
mc.animFromStrip( mc_sprite, [
["stopped","S",1,1,0,True, (23,45), (23,33)],
["stopped","W",4,1,0,True, (23,45), (17,33)],
["stopped","E",7,1,0,True, (23,45), (30,33)],
["stopped","N",10,1,0,True,(23,45), (23,33)],
["walking","S",0,3,.02,True, (23,45), (23,33)],
["walking","W",3,3,.02,True, (23,45), (17,33)],
["walking","E",6,3,.02,True, (23,45), (30,33)],
["walking","N",9,3,.02,True, (23,45), (23,33)],
["dying", "N",12,3,0.01,False, (23,45)]
], 48, 48, mc_mask )
mc.changeState("stopped")
mc.AI = core.handlePlayerControls
core.render_group.add(mc)
available_attacks = [
featheratk.oDoubleAttack(core.load_image("double_feather.png", directory="gfx")),
featheratk.oTriangleAttack(core.load_image("triangle_feather.png", directory="gfx")),
featheratk.oCrossAttack(core.load_image("cross_feather.png", directory="gfx"))
]
mc.attacks = [
featheratk.oBasicAttack(core.load_image("debug_feather.png", directory="gfx"))
]
mc.use_attack = 0
# load map
load_level(level, mc)
killed_bugs = 0
lost_lives = 0
mid_rank = 0
rank_num = 0
forceUpdate = True
while True:
lag = core.clock.tick(core.MAX_FPS)
if lag <= 0:
lag = 1
level_time.update(level_time.value - lag/1000.0)
if level_time.value < 0:
main_char_death(mc)
core.play_sound("mc_dying")
lives.update(lives.value-1)
lost_lives += 1
if core.handleEvents() == "quit":
return
dirty_rects = core.render_group.update(lag)
core.level.updateNests(lag)
exp_bg.animFrame = core.mathExp.state
# check collisions
# bugs
if core.render_group.checkCollision(False, False, mc, core.baddys_group):
main_char_death(mc)
core.play_sound("mc_dying")
lives.update(lives.value-1)
lost_lives += 1
# pickups
picked = core.pickup_group.checkCollision(False, False, mc, core.pickup_group)
for pickup in picked:
pickup = pickup[0]
# new live :D
if isinstance(pickup, sprite.oHeartSprite):
core.play_sound("live_gain")
lives.update(lives.value+1)
pickup.die()
# feather attacks
kills = core.attack_group.checkCollision(False, False, None, core.baddys_group)
score.update(score.value + 100*len(kills))
killed_bugs += len(kills)
for i in kills:
core.play_sound("bug_dying")
if hasattr(i[0], "attackMgr"):
feather, bug = i
if hasattr(i[1], "attackMgr"):
bug, feather = i
feather.attackMgr.kills += 1
feather.die()
bug.OnAnimationEnd = bug.die
bug.direction = "N"
bug.changeState("dying")
if lives.value == 0 and mc.OnAnimationEnd is None:
if rank_num == 0:
_rank = 0
else:
_rank = mid_rank / rank_num
core.next_screen = core.curry(game_over, score.value, _rank)
return
# draw level / sprites
core.screen.blit(sky_bg, (0,0))
dirty_rects.extend( core.level.draw(core.screen) )
core.render_group.draw(core.screen)
# draw stats
# lives
dirty_rects.extend( lives.draw(core.screen) )
# math exp
dirty_rects.extend( core.mathExp.draw(core.screen) )
# time
dirty_rects.extend( level_time.draw(core.screen) )
# score
dirty_rects.extend( score.draw(core.screen) )
# attacks
for i, attack in enumerate(mc.attacks):
attack.update(lag)
dirty_rects.extend( attack.draw(core.screen, i == mc.use_attack) )
# dirty_rects.append( core.fonts.Draw(core.screen, None, 24,
# str(core.clock.get_fps()), (650, 50), (255,255,255,255)))
if forceUpdate:
dirty_rects = None
forceUpdate = False
core.updateScreen(dirty_rects)
# clear level =D
if core.level.portalActive:
_score, rank = level_clear_screen(mc, killed_bugs, level_time.value, lives.value, lost_lives, score.value)
score.update(_score)
mid_rank += rank
rank_num += 1
lost_lives = 0
core.baddys_group.clear()
core.attack_group.clear()
level += 1
if not load_level(level, mc):
core.next_screen = core.curry(game_ending, core.curry(hiscores_screen, score.value, mid_rank/rank_num))
return
if available_attacks:
new_attack = available_attacks.pop(0)
feather_received(new_attack)
mc.attacks.append( new_attack )
level_time.update(core.level.time)
mc.changeState("stopped")
for attack in mc.attacks:
attack.freeze = 0
attack.used = 0
attack.kills = 0
attack.last_rects = []
forceUpdate = True
def main_menu():
core.play_music("main menu")
# load bg
bg = core.load_image("main_menu.png", directory="gfx", auto_alpha=False)
selected = 0
def genButton(images, pos):
button = sprite.oSprite()
button.x = pos[0]
button.y = pos[1]
button.animations = {
"active": {
"N": [0,True,[sprite.oFrame(images[0])]]
},
"inactive": {
"N": [0,True,[sprite.oFrame(images[1])]]
}
}
core.render_group.add(button)
return button
selected = 0
buttons = []
core.render_group.clear()
for i, button in enumerate(["new game","help","credits","exit"]):
y = 180 + i*40
x = 75
buttons.append( genButton(core.game_images[button], (x,y)) )
menu_screens = [
game_intro, # new game
hiscores_screen,# high scores
credits_screen, # credits
exit_screen, # exit
]
forceUpdate = True
last_screen = core.screen.copy().convert()
while True:
lag = core.clock.tick(core.MAX_FPS)
if core.handleEvents() == "quit":
exit()
if Input.up(K_UP):
core.play_sound("cursor_move")
selected -= 1
if selected < 0:
selected = len(buttons)-1
if Input.up(K_DOWN):
core.play_sound("cursor_move")
selected += 1
if selected >= len(buttons):
selected = 0
if Input.up(K_RETURN):
core.next_screen = menu_screens[selected]
core.play_sound("button_click")
return
for i, button in enumerate(buttons):
button.changeState("active" if i == selected else "inactive")
dirty_rects = core.render_group.update(lag)
core.screen.blit(bg, (0,0))
core.render_group.draw(core.screen)
if last_screen is not None:
core.dissolve_transition(last_screen, core.screen.copy().convert(), 1000)
last_screen = None
if forceUpdate:
dirty_rects = None
core.updateScreen(dirty_rects)
def hiscores_screen(score=None, rank=0):
last_screen = core.screen.copy().convert()
scores = []
import xdrlib
if not os.path.exists("high_scores"):
# fill with default scores
default_scores = [(100000,2),(50000,2),(30000,2),(20000,2),(10000,2),(8000,1),
(4000,1),(500,0)]
for i in range(8):
s, r = default_scores[i]
scores.append( ("Nozomi", s, r) )
else:
# load from file
data = open("high_scores", "rb").read()
loader = xdrlib.Unpacker(data)
for i in range(8):
scores.append( (loader.unpack_string(), loader.unpack_int(), loader.unpack_int()) )
# verify if we have a high score =D
if score is not None:
for index, _score in enumerate(scores):
name, _score, _rank = _score
if (score > _score) or (score == _score and rank > _rank):
player_name = core.InputPrompt("Nice timing! You've scored high, Mr/Mrs...", "Player")
scores.insert(index, (player_name, score, rank))
break
# save scores
p = xdrlib.Packer()
for name, score, rank in scores:
p.pack_string(name)
p.pack_int(score)
p.pack_int(rank)
f = open("high_scores", "wb")
f.write(p.get_buffer())
f.close()
# load graphics =D
bg = core.load_image("hiscores.png", directory="gfx")
stars = pygame.transform.smoothscale(core.load_image("rank_star.png", directory="gfx"), (86,40))
stars = [ core.im_crop(stars, pygame.Rect(0,0,43,40)),
core.im_crop(stars, pygame.Rect(43,0,43,40)) ]
core.screen.blit(bg, (0,0))
# render high scores!
for index, score in enumerate(scores):
name, score, rank = score
# 260, 100
y = 100 + 40*index
# name
core.fonts.Draw(core.screen, None, 36, name, pygame.Rect(260,y,200,40),
(255,255,255,255),alignVert='center',antialias=True)
# points
score = str(score)
w = 160-core.numbers.getWidth(score)
core.numbers.draw(core.screen, (470+w,y+8), score)
# rank
if rank > 2:
core.screen.blit(stars[1], (660,y))
else:
core.screen.blit(stars[0], (660,y))
if rank > 1:
core.screen.blit(stars[1], (703,y))
else:
core.screen.blit(stars[0], (703,y))
if rank > 0:
core.screen.blit(stars[1], (746,y))
else:
core.screen.blit(stars[0], (746,y))
core.dissolve_transition(last_screen, core.screen.copy().convert(), 1000)
while True:
events = pygame.event.get()
if core.handleEvents(events) == "quit":
exit()
for event in events:
if event.type == KEYUP:
core.next_screen = main_menu
core.play_sound("button_click")
Input.update()
return
def main():
# pre-initialize sound
pygame.mixer.pre_init(44100,0,0,1024)
# Initializes pygame
pygame.init()
# Verify if we can play sounds
if pygame.mixer and not pygame.mixer.get_init():
print 'Warning, no sound'
pygame.mixer = None
# We need to set up the window too
pygame.display.set_caption('RED -spider lily-')
# Set the display mode
bestdepth = pygame.display.mode_ok(core.SCREENRECT.size, core.SCREEN_FLAGS, 32)
core.screen = pygame.display.set_mode(core.SCREENRECT.size, core.SCREEN_FLAGS, bestdepth)
core.screen.fill((0,0,0,255))
pygame.mixer.music.set_volume(core.MUSIC_VOL/100.0)
pygame.display.update()
core.clock = pygame.time.Clock()
core.initializeFonts()
# load sounds
core.game_sounds["block_activate"] = core.load_sound("sfx", "step_activate.wav")
core.game_sounds["block_deactivate"]= core.load_sound("sfx", "step_deactivate.wav")
core.game_sounds["feather_throw"] = core.load_sound("sfx", "feather_throw.wav")
core.game_sounds["portal_activate"] = core.load_sound("sfx", "portal_activate.wav")
core.game_sounds["button_click"] = core.load_sound("sfx", "button_click.wav")
core.game_sounds["mc_dying"] = core.load_sound("sfx", "mc_dying.wav")
core.game_sounds["bug_dying"] = core.load_sound("sfx", "bug_dying.wav")
core.game_sounds["menu_cancel"] = core.load_sound("sfx", "menu_cancel.wav")
core.game_sounds["cursor_move"] = core.load_sound("sfx", "cursor_move.wav")
core.game_sounds["live_gain"] = core.load_sound("sfx", "live_gain.wav")
# music mappings
core.game_musics = {
"main menu": "bgm/main_menu.ogg",
"game over": "bgm/game_over.ogg",
"stage clear": "bgm/stage_clear.ogg",
"intro" : "bgm/intro.ogg",
"ending" : "bgm/ending.ogg"
}
core.numbers = fontmgr.oSFont(core.load_image("numbers.png", directory="gfx"),
["0","1","2","3","4","5","6","7","8","9","-","+","/","*","%",":","=","?","!"])
# load game buttons
def getButtonImage(surface, button):
y = button * 40
inactive = core.im_crop(surface, pygame.Rect(0, y, 200, 40))
active = core.im_crop(surface, pygame.Rect(200, y, 200, 40))
return active, inactive
buttons = core.load_image("buttons.png", directory="gfx")
core.game_images["new game"] = getButtonImage(buttons, 0)
core.game_images["options"] = getButtonImage(buttons, 1)
core.game_images["help"] = getButtonImage(buttons, 2)
core.game_images["credits"] = getButtonImage(buttons, 3)
core.game_images["exit"] = getButtonImage(buttons, 4)
core.game_images["yes"] = getButtonImage(buttons, 5)
core.game_images["no"] = getButtonImage(buttons, 6)
core.next_screen = game.main_menu
while True:
if core.next_screen is not None:
core.next_screen()
else:
return
