示例#1
0
def build():
  def call(env):
    return lambda func, arg: curry(func)(interpret(env, arg))

  def interpret(env, x):
    funcs = {int:   lambda a, b: env[x],
             list:  plumb,
             tuple: chain}
    if type(x) in funcs:
      return funcs[type(x)](env, x)
    return x

  def chain(env, calls):
    return reduce(call(env), calls, lambda x: x)

  def plumb_(env, expr, arg):
    if len(expr) is 0:
      return arg
    return chain([arg] + env, expr)

  plumb = curry(plumb_)

  return curry(lambda expr: plumb([], expr))
示例#2
0
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()
示例#3
0
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
示例#4
0
 def call(env):
   return lambda func, arg: curry(func)(interpret(env, arg))