Ejemplo n.º 1
0
def dissolve_transition(old_screen, new_screen, time, rect=None):
    # initialize values
    alpha = 0
    # calculate how much we will increase alpha
    incAlpha = 255/float(time)

   
    while alpha < 255:        
        lag = clock.tick(MAX_FPS)
                
        if handleEvents() == "quit":
            exit()
        
        if Input.up(K_ESCAPE):
            new_screen.set_alpha(None)
            screen.blit(new_screen, (0,0))
            updateScreen()
            return
                
        # blit the old and new screens
        screen.blit(old_screen, (0,0))
        new_screen.set_alpha(int(alpha))
        screen.blit(new_screen, (0,0))
        updateScreen()
                
        # increase alpha
        alpha += incAlpha * lag
                
    # blit the new screen with full opacity
    new_screen.set_alpha(None)
    screen.blit(new_screen, (0,0))
    updateScreen()
Ejemplo n.º 2
0
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()
Ejemplo n.º 3
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()
Ejemplo n.º 4
0
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)
Ejemplo n.º 5
0
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
Ejemplo n.º 6
0
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)
Ejemplo n.º 7
0
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)
Ejemplo n.º 8
0
def handlePlayerControls(char, lag):
    if char.animState == "dying":
        return
    
    d = ""
    ly = char.y
    lx = char.x
    if Input.motion(CONTROLS["up"]):
        char.y -= char.speed*char.speedMul * lag
        d += "N"
    if Input.motion(CONTROLS["down"]):
        char.y += char.speed*char.speedMul * lag
        d += "S"
    if Input.motion(CONTROLS["left"]):
        char.x -= char.speed*char.speedMul * lag
        d += "W"
    if Input.motion(CONTROLS["right"]):
        char.x += char.speed*char.speedMul * lag
        d += "E"
    
    if d == "":
        char.changeState("stopped")
    else:
        char.changeState("walking")
        char.changeDirection(d)
    
    if not char.canWalk():
        char.x = lx
        char.y = ly
    
    if Input.motion(CONTROLS["attack"]):
        char.attacks[char.use_attack].attack(char)
        
    if Input.up(CONTROLS["prev_feather"]):
        char.use_attack -= 1
        if char.use_attack < 0:
            char.use_attack = len(char.attacks)-1
            
    if Input.up(CONTROLS["next_feather"]):
        char.use_attack += 1
        if char.use_attack >= len(char.attacks):
            char.use_attack = 0
    
#    if Input.motion(CONTROLS["run"]):
#        char.speedMul = 2
#    else:
#        char.speedMul = 1
    
    if Input.up(CONTROLS["action"]):
        w, h = level.tileSize
        x = int( math.floor( char.x / w ) )
        y = int( math.floor( (char.y-33) / h ) )# fix tiles have a blank area on top o.o
        tile = level.getTile(x, y)
        
        if tile.portal and tile.active:
            play_sound("portal_activate")
            level.portalActive = True
        
        if tile.op > -1:
            tile.active = not tile.active
            if tile.active:
                play_sound("block_activate")
            else:
                play_sound("block_deactivate")
                
            tile.changed = True
            mathExp.activateTerm(x, y)
            level.activateTiles(mathExp.getResult())
            level.genBitmask()
Ejemplo n.º 9
0
def handleEvents(events=None, escape_exits=True):
    global next_screen, forceUpdate, quitPrompt
    
    # update last events
    Input.update()
    
    # Update our mouse position and 3 button state
    Input.update_mouse(pygame.mouse.get_pressed(), pygame.mouse.get_pos())
        
    # Add all events from the event queue to the input module
    # for this loop cycle.
    if events is None:
        events = pygame.event.get()
        
    Input.add_events(events)
    
    if (Input.down(K_ESCAPE) and escape_exits) or Input.isset("QUIT"):
        if not quitPrompt:
            quitPrompt = True
            if game.yesno_prompt("Exit RED -spider lily-?"):
                next_screen = None
                return "quit"
            quitPrompt = False
            
            forceUpdate = True
            Input.update()
    
#    if Input.up(K_F9):
#        level = int(getInput("Goto level #:", pygame.Rect(0, 550, 800, 50), default="0"))
#        forceUpdate = True
#        game.load_level(level, game.mc)
    
    if Input.up(K_F8):
        mapeditor.map_editor()
        forceUpdate = True
Ejemplo n.º 10
0
 def show_texts(self, texts, char=0):
     rv = True
     self.char = char
     x, y = self.x, self.y
     if self.background is not None:
         last_screen = core.screen.copy().convert()
         ls = last_screen.copy().convert()
         core.screen.blit( self.background, self.bg_pos )
         core.dissolve_transition( last_screen, core.screen.copy().convert(), self.intime )
         
     last_screen = core.screen.copy().convert()
      
     try:
         for text in texts:
             text = "\n".join( self.wrap_multi_line(text, self.font, self.width) ) + ' '
             self.dismissed = False
             
             start = 0
                        
             while not self.dismissed:
                 lag = core.clock.tick(core.MAX_FPS)
                 if lag <= 0:
                     lag = 1
         
                 if core.handleEvents(escape_exits = not K_ESCAPE in self.skip_keys) == "quit":
                     exit()
                 
                 
                 core.screen.blit(last_screen, (0,0))
                 
                 for skip_key in self.skip_keys:
                     if Input.up(skip_key):
                         rv = False
                         raise eSkipText
                 
                 if start < len(text):
                     for dismiss in self.dismiss_keys:
                         if Input.up(dismiss):
                             self.char = len(text)
                            
                     self.char += self.speed * lag
                     chars = text[start:int(self.char)]
                     start += len(chars)
                     update_rects = []
                     for char in chars:
                         if char in ["\r","\n"]:
                             y += self.font.size("W")[1] + self.line_spacing
                             x  = self.x
                         else:
                             text_surf = self.font.render( char, True, self.color )
                             update_rects.append( last_screen.blit(text_surf, (x,y)) )
                             x += text_surf.get_width()                            
                     core.updateScreen()
                                         
                 else:
                     if self.ctc is not None:
                         self.ctc.x = x
                         self.ctc.y = y
                         ctc_rect = self.ctc.update(lag)
                         self.ctc.draw(core.screen)
                         ctc_rect.extend(update_rects)
                         core.updateScreen(ctc_rect)
                         
                         
                     for dismiss in self.dismiss_keys:
                         if Input.up(dismiss):
                             self.dismissed = True
                             self.char -= len(text)
                             x  = self.x
                             y += self.font.size("W")[1] + self.line_spacing                                
     
     except eSkipText:
         pass
     
     core.dissolve_transition( core.screen.copy().convert(), ls, self.intime )
     return rv
Ejemplo n.º 11
0
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()