Exemplo n.º 1
0
    def do_bonus(self):
        # unload the modes
        self.remove_modes()
        self.wipe_delays()

        # do the bonus right up front so it's on the score
        bonus_points = self.game.show_tracking('bonus') * self.game.show_tracking('bonusX')
        # add the points to the score
        self.game.score(bonus_points)
        # set  a flag for interrupting
        self.doingBonus = True
        # turn off the status OK
        self.game.statusOK = False
        # get the bonus multiplier
        times = self.game.show_tracking('bonusX')
        print "BONUS TIMES: " + str(times)
        # then reset it for next time
        self.game.set_tracking('bonusX',1)
        # then loop through the display
        # get the bonus points
        self.bonus = self.game.show_tracking('bonus')
        # and reset it
        self.game.set_tracking('bonus',0)
        # and clear the running total
        self.runningTotal = 0
    # Original Bonus Display
    #    # throw up a  layer that says bonus as an interstitial
    #    self.layer = self.game.showcase.blink_fill(2,2,3,1,0.3,isOpaque=True,text="BONUS")
    #    # then 1.5 seconds later, move on
    #    self.delay("Bonus Display",delay=1.5,handler=self.display_bonus,param=times)
    # End Original Bonus Display

    # New Test version
        # Blank Track
        trackLayer = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_emptyTrack.frames[0])
        trackLayer.composite_op = "blacksrc"
        # Train animation
        anim = self.game.assets.dmd_bonusTrain
        myWait = len(anim.frames) / 30.0
        animLayer = ep.EP_AnimatedLayer(anim)
        animLayer.hold = True
        animLayer.frame_time = 2
        animLayer.composite_op = "blacksrc"
        # Text Placeholders
        self.bonusTopLine = ep.EP_TextLayer(64,1,self.game.assets.font_7px_az, "center",opaque=True)
        self.bonusTopLineText = str(times) + " X " + ep.format_score(self.bonus) + " ="
        self.bonusScoreLine = ep.EP_TextLayer(64,11,self.game.assets.font_13px_score,"center")
        self.bonusScoreLineText = ep.format_score(bonus_points)
        # Play the train whistle
        self.game.sound.play(self.game.assets.sfx_longTrainWhistle)
        # Play the train sound
        self.game.sound.play(self.game.assets.sfx_trainChugLong)
        # setup the layer
        combined = dmd.GroupedLayer(128,32,[self.bonusTopLine, self.bonusScoreLine,trackLayer,animLayer])
        self.layer = combined
        # Delay the setting the text part
        self.delay("Bonus Display",delay=1.5,handler=lambda: self.bonusTopLine.set_text(self.bonusTopLineText,color=ep.ORANGE))
        self.delay("Bonus Display",delay=1.5,handler=lambda: self.bonusScoreLine.set_text(self.bonusScoreLineText,color=ep.YELLOW))
        # Finish the bonus
        self.delay("Bonus Display",delay=myWait+0.3, handler=self.finish_bonus)
 def main_display(self):
     # this is the main score display for stampede - it's got score on it, so we'll have to loop
     # score line
     p = self.game.current_player()
     scoreString = ep.format_score(p.score)
     self.mainScoreLine.set_text(scoreString,color=ep.YELLOW)
     # jackpot info line
     # Center shot
     if self.active == 2:
         string = "JACKPOT = " + ep.format_score(self.centerValue)
         self.jackpotLine.set_text(string,color=ep.PURPLE)
     # One off center is 2x
     if self.active == 1 or self.active == 3:
         string = "JACKPOT = 2 X " + ep.format_score(self.jackpotValue)
         self.jackpotLine.set_text(string,color=ep.PURPLE)
     # two off center is 4x
     if self.active == 0 or self.active == 4:
         string = "JACKPOT = 4 X " + ep.format_score(self.jackpotValue)
         self.jackpotLine.set_text(string,color=ep.PURPLE,blink_frames=4)
     # group with cow layer
     combined = dmd.GroupedLayer(128,32,[self.cowLayer,self.mainScoreLine,self.jackpotLine])
     # set the layer active
     self.layer = combined
     # loop back again in .2 for score update
     self.delay(name="Display",delay=0.2,handler=self.main_display)
 def replay_score_page(self):
     replay_text = ep.format_score(
         self.game.user_settings['Machine (Standard)']['Replay Score'])
     score_text = ep.format_score(self.game.current_player().score)
     textLine1 = ep.EP_TextLayer(64,
                                 1,
                                 self.game.assets.font_5px_bold_AZ,
                                 "center",
                                 opaque=True).set_text("REPLAY SCORE:",
                                                       color=ep.ORANGE)
     textLine2 = ep.EP_TextLayer(64,
                                 7,
                                 self.game.assets.font_7px_az,
                                 "center",
                                 opaque=False).set_text(replay_text,
                                                        color=ep.GREEN)
     textLine3 = ep.EP_TextLayer(64,
                                 17,
                                 self.game.assets.font_5px_bold_AZ,
                                 "center",
                                 opaque=False).set_text("YOUR SCORE:",
                                                        color=ep.ORANGE)
     textLine4 = ep.EP_TextLayer(64,
                                 23,
                                 self.game.assets.font_7px_az,
                                 "center",
                                 opaque=False).set_text(score_text,
                                                        blink_frames=8,
                                                        color=ep.RED)
     layer = dmd.GroupedLayer(128, 32,
                              [textLine1, textLine2, textLine3, textLine4])
     return layer
Exemplo n.º 4
0
 def mode_started(self):
     # fire up the switch block if it's not already loaded
     self.game.switch_blocker('add', self.myID)
     self.index = 0
     # unload the launcher
     self.game.tribute_launcher.unload()
     # switch value to start
     self.value = 100000
     self.total = 500000
     # timer value
     self.modeTimer = 20
     self.running = True
     # set up the default text layers
     self.timerLayer = ep.EP_TextLayer(0, 0, self.game.assets.font_9px_az,
                                       "left", True)
     self.valueTitleLayer = ep.EP_TextLayer(80, 0,
                                            self.game.assets.font_5px_AZ,
                                            "center",
                                            False).set_text("TARGET VALUE")
     self.valueLayer = ep.EP_TextLayer(80, 6, self.game.assets.font_7px_az,
                                       "center", False).set_text(
                                           ep.format_score(self.value))
     self.totalTitleLayer = ep.EP_TextLayer(80, 14,
                                            self.game.assets.font_7px_az,
                                            "center",
                                            False).set_text("IT TOTAL")
     self.totalLayer = ep.EP_TextLayer(80, 22, self.game.assets.font_9px_az,
                                       "center", False).set_text(
                                           ep.format_score(self.total))
     self.intro()
Exemplo n.º 5
0
    def main_display(self,loop = True):
        # cancel any display loop - if there is one
        self.cancel_delayed("Display")
        # set up the display during multiball
        # score line
        p = self.game.current_player()
        scoreString = ep.format_score(p.score)
        scoreLine = ep.EP_TextLayer(64, 4, self.game.assets.font_9px_az, "center", opaque=False).set_text(scoreString,blink_frames=4,color=ep.CYAN)
        scoreLine.composite_op = "blacksrc"

        if self.ending:
            textString = "ENDING LAST CALL"
            infoLine = dmd.TextLayer(128/2,16,self.game.assets.font_5px_AZ, "center", opaque=False).set_text(textString)
        else:
            infoLine = self.infoLayer

        # jackpot value line
        jackString = "JACKPOTS = " + str(ep.format_score(self.shotValue))
        if self.ending:
            jackString = "COLLECTING BALLS"
        self.jackpotLine = dmd.TextLayer(128/2,22,self.game.assets.font_5px_AZ, "center", opaque=False).set_text(jackString)

        combined = dmd.GroupedLayer(128,32,[self.backdrop,scoreLine,infoLine,self.jackpotLine])
        self.layer = combined
        # loop back in .2 to update
        if not loop:
            self.delay(name="Display",delay=0.2,handler=self.main_display)
Exemplo n.º 6
0
 def replay_score_page(self):
     replay_text = ep.format_score(self.game.user_settings['Machine (Standard)']['Replay Score'])
     score_text = ep.format_score(self.game.current_player().score)
     textLine1 = ep.EP_TextLayer(64, 1, self.game.assets.font_5px_bold_AZ, "center", opaque=True).set_text("REPLAY SCORE:",color=ep.ORANGE)
     textLine2 = ep.EP_TextLayer(64, 7, self.game.assets.font_7px_az, "center", opaque=False).set_text(replay_text,color=ep.GREEN)
     textLine3 = ep.EP_TextLayer(64, 17, self.game.assets.font_5px_bold_AZ, "center", opaque=False).set_text("YOUR SCORE:",color=ep.ORANGE)
     textLine4 = ep.EP_TextLayer(64, 23, self.game.assets.font_7px_az, "center", opaque=False).set_text(score_text,blink_frames=8,color=ep.RED)
     layer = dmd.GroupedLayer(128,32,[textLine1,textLine2,textLine3,textLine4])
     return layer
Exemplo n.º 7
0
 def hit_it(self):
     print "Hit IT"
     # on a hit, increase the value, and add the new value to the total and display the hit
     self.value += self.bump
     self.total += self.value
     self.totalLayer.set_text(ep.format_score(self.total))
     self.valueLayer.set_text(ep.format_score(self.value))
     self.game.sound.play(self.game.assets.sfx_tafHitIt)
     self.display_it("hit")
Exemplo n.º 8
0
 def hit_it(self):
     print "Hit IT"
     # on a hit, increase the value, and add the new value to the total and display the hit
     self.value += self.bump
     self.total += self.value
     self.totalLayer.set_text(ep.format_score(self.total))
     self.valueLayer.set_text(ep.format_score(self.value))
     self.game.sound.play(self.game.assets.sfx_tafHitIt)
     self.display_it("hit")
Exemplo n.º 9
0
    def end_ambush(self):
        # kill the taunt timer
        self.cancel_delayed("Taunt Timer")
        # Kill the target timers
        for i in range(0, 4, 1):
            self.cancel_delayed(self.targetNames[i])
        # clear the layer
        self.clear_layer()
        # drop all the targets
        self.game.bad_guys.drop_targets()
        # kill the music - if nothing else is running
        #self.stop_music(slice=2)
        # grab the points before tracking
        totalPoints = self.game.show_tracking('ambushPoints')
        # update all the tracking
        self.update_tracking()
        # update the lamps
        self.lamp_update()
        # start up the main theme again if a higher level mode isn't running
        self.music_on(self.game.assets.music_mainTheme, mySlice=2)
        # turn off the level 1 flag
        self.game.stack_level(1, False)
        # setup a display frame
        backdrop = dmd.FrameLayer(
            opaque=False,
            frame=self.game.assets.dmd_singleCowboySidewaysBorder.frames[0])
        textLine1 = ep.EP_TextLayer(74,
                                    2,
                                    self.game.assets.font_7px_bold_az,
                                    "center",
                                    opaque=False)
        textString = "AMBUSH: " + str(self.deathTally) + " KILLS"
        textLine1.set_text(textString, color=ep.RED)
        textLine1.composite_op = "blacksrc"
        textLine2 = ep.EP_TextLayer(74,
                                    11,
                                    self.game.assets.font_12px_az,
                                    "center",
                                    opaque=False)
        print "TOTAL AMBUSH: " + str(ep.format_score(totalPoints))
        textLine2.set_text(ep.format_score(totalPoints), color=ep.GREEN)
        combined = dmd.GroupedLayer(128, 32, [backdrop, textLine1, textLine2])
        self.layer = combined
        # play a quote
        if self.deathTally == 0:
            self.game.base.play_quote(self.game.assets.quote_gunFail)
        else:
            self.game.base.play_quote(self.game.assets.quote_mobEnd)
        self.delay("Display", delay=2, handler=self.clear_layer)

        self.update_badge()
        # unset the base busy flag
        self.game.base.busy = False
        self.game.base.queued -= 1
        # unload the mode
        self.delay("Ambush", delay=2.1, handler=self.unload)
Exemplo n.º 10
0
    def finish_up(self):
        self.running = False
        self.game.stack_level(6, value=False, lamps=False)
        textLine1 = ep.EP_TextLayer(64, 4, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(
            "FINAL TOTALS:", color=ep.RED
        )
        playerCount = len(self.game.players)
        if playerCount == 1:
            playerLine1 = ep.EP_TextLayer(64, 15, self.game.assets.font_7px_az, "center", opaque=False).set_text(
                str(ep.format_score(self.game.players[0].score)), color=ep.YELLOW
            )
            combined = dmd.GroupedLayer(128, 32, [self.backdrop, textLine1, playerLine1])
        elif playerCount == 2:
            playerLine1 = ep.EP_TextLayer(64, 12, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(
                "1) " + str(ep.format_score(self.game.players[0].score)), color=ep.YELLOW
            )
            playerLine2 = ep.EP_TextLayer(64, 20, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(
                "2) " + str(ep.format_score(self.game.players[1].score)), color=ep.YELLOW
            )
            combined = dmd.GroupedLayer(128, 32, [self.backdrop, textLine1, playerLine1, playerLine2])
        elif playerCount == 3:
            playerLine1 = ep.EP_TextLayer(4, 12, self.game.assets.font_5px_AZ, "left", opaque=False).set_text(
                "1) " + str(ep.format_score(self.game.players[0].score)), color=ep.YELLOW
            )
            playerLine2 = ep.EP_TextLayer(4, 20, self.game.assets.font_5px_AZ, "left", opaque=False).set_text(
                "2) " + str(ep.format_score(self.game.players[1].score)), color=ep.YELLOW
            )
            playerLine3 = ep.EP_TextLayer(68, 12, self.game.assets.font_5px_AZ, "left", opaque=False).set_text(
                "3) " + str(ep.format_score(self.game.players[2].score)), color=ep.YELLOW
            )
            combined = dmd.GroupedLayer(128, 32, [self.backdrop, textLine1, playerLine1, playerLine2, playerLine3])
        else:
            playerLine1 = ep.EP_TextLayer(4, 12, self.game.assets.font_5px_AZ, "left", opaque=False).set_text(
                "1) " + str(ep.format_score(self.game.players[0].score)), color=ep.YELLOW
            )
            playerLine2 = ep.EP_TextLayer(4, 20, self.game.assets.font_5px_AZ, "left", opaque=False).set_text(
                "2) " + str(ep.format_score(self.game.players[1].score)), color=ep.YELLOW
            )
            playerLine3 = ep.EP_TextLayer(68, 12, self.game.assets.font_5px_AZ, "left", opaque=False).set_text(
                "3) " + str(ep.format_score(self.game.players[2].score)), color=ep.YELLOW
            )
            playerLine4 = ep.EP_TextLayer(68, 20, self.game.assets.font_5px_AZ, "left", opaque=False).set_text(
                "4) " + str(ep.format_score(self.game.players[3].score)), color=ep.YELLOW
            )
            combined = dmd.GroupedLayer(
                128, 32, [self.backdrop, textLine1, playerLine1, playerLine2, playerLine3, playerLine4]
            )

        self.layer = combined
        self.delay("Operational", delay=3, handler=self.shutdown)
Exemplo n.º 11
0
 def update_display(self):
     self.overlay.composite_op = "blacksrc"
     p = self.game.current_player()
     scoreString = ep.format_score(p.score)
     scoreLine = ep.EP_TextLayer(80,
                                 8,
                                 self.game.assets.font_7px_az,
                                 "center",
                                 opaque=False).set_text(scoreString,
                                                        blink_frames=8,
                                                        color=ep.YELLOW)
     textLine1 = ep.EP_TextLayer(80,
                                 1,
                                 self.game.assets.font_5px_AZ,
                                 "center",
                                 opaque=False).set_text("DRUNK MULTIBALL",
                                                        color=ep.ORANGE)
     if self.active:
         textLine2 = ep.EP_TextLayer(80,
                                     18,
                                     self.game.assets.font_5px_AZ,
                                     "center",
                                     opaque=False).set_text("JACKPOTS",
                                                            color=ep.BROWN)
         textString = "WORTH " + str(ep.format_score(self.jackpotValue))
         textLine3 = ep.EP_TextLayer(80,
                                     25,
                                     self.game.assets.font_5px_AZ,
                                     "center",
                                     opaque=False).set_text(textString,
                                                            color=ep.BROWN)
     else:
         textLine2 = ep.EP_TextLayer(80,
                                     18,
                                     self.game.assets.font_5px_AZ,
                                     "center",
                                     opaque=False).set_text("HIT BEER MUG",
                                                            color=ep.BROWN)
         textLine3 = ep.EP_TextLayer(80,
                                     25,
                                     self.game.assets.font_5px_AZ,
                                     "center",
                                     opaque=False).set_text(
                                         "TO LIGHT JACKPOTS",
                                         color=ep.BROWN)
     combined = dmd.GroupedLayer(
         128, 32,
         [textLine1, textLine2, textLine3, scoreLine, self.overlay])
     self.layer = combined
     self.delay(name="Display", delay=0.2, handler=self.update_display)
Exemplo n.º 12
0
 def display_win(self,rankTitle):
     textString3 = "YOUR RANK: " + rankTitle
     newrank = self.game.show_tracking('rank')
     values = [str(ep.format_score(500000)),str(ep.format_score(750000)),str(ep.format_score(1000000)),str(ep.format_score(1500000)),str(ep.format_score(2000000))]
     textString4 = "QUICKDRAWS WORTH: " + values[newrank]
     # award some points
     points = 750000
     self.game.score(points)
     self.game.add_bonus(100000)
     # show the win screen
     textLine1 = ep.EP_TextLayer(64, 0, self.game.assets.font_7px_bold_az, "center", opaque=True).set_text("BAD GUY SHOT!",color=ep.YELLOW)
     textLine2 = ep.pulse_text(self,64,9,ep.format_score(points),color=ep.GREEN)
     textLine3 = ep.EP_TextLayer(64, 20, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(textString3,color=ep.BROWN)
     textLine4 = ep.EP_TextLayer(64, 26, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(textString4,color=ep.BROWN)
     self.layer = dmd.GroupedLayer(128,32,[textLine1,textLine2,textLine3,textLine4])
     self.delay("Operational",delay=2,handler=self.end_gunfight)
Exemplo n.º 13
0
 def update_display(self):
     self.cancel_delayed("Display")
     # set up the display during multiball
     # whateve the current bart layer is, default is idle
     backdrop = self.bartLayer
     # title line
     titleLine = ep.EP_TextLayer(46,
                                 -1,
                                 self.game.assets.font_5px_AZ,
                                 "center",
                                 opaque=False).set_text("BIONIC BART",
                                                        color=ep.GREY)
     # score line
     p = self.game.current_player()
     scoreString = ep.format_score(p.score)
     scoreLine = ep.EP_TextLayer(46,
                                 5,
                                 self.game.assets.font_9px_az,
                                 "center",
                                 opaque=False).set_text(scoreString,
                                                        blink_frames=4,
                                                        color=ep.YELLOW)
     scoreLine.composite_op = "blacksrc"
     combined = dmd.GroupedLayer(
         128, 32,
         [backdrop, titleLine, scoreLine, self.actionLine, self.statusLine])
     self.layer = combined
     # loop back in .2 to update
     self.delay(name="Display", delay=0.2, handler=self.update_display)
Exemplo n.º 14
0
    def in_progress(self):
        if self.running:
            # start the train moving
            self.game.train.move()
            # setup the mode screen with the animated train
            # and all the text
            p = self.game.current_player()
            scoreString = ep.format_score(p.score)
            self.scoreLine.set_text(scoreString,blink_frames=999,color=ep.BROWN)
            timeString = "TIME: " + str(int(self.modeTimer))
            timeLine = ep.EP_TextLayer(34, 25, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(timeString,color=ep.DARK_RED)

            # stick together the animation and static text with the dynamic text
            composite = dmd.GroupedLayer(128,32,[self.trainLayer,self.pollyTitle,self.scoreLine,self.infoLayer,timeLine])
            self.layer = composite
            ## tick down the timer
            self.modeTimer -= 0.1
            ## hurry quote at 5 seconds, plead at 15
            if abs(self.modeTimer - 15) < 0.00000001:
                self.game.base.play_quote(self.game.assets.quote_pollyPlead)
            if abs(self.modeTimer - 5) < 0.00000001:
                self.game.base.play_quote(self.game.assets.quote_pollyHurry)
            if self.modeTimer <= 0:
                # go to a grace period
                self.polly_died()
            # otherwise ...
            else:
                # set up a delay to come back in 1 second with the lowered time
                self.delay("Mode Timer",delay=0.1,handler=self.in_progress)
Exemplo n.º 15
0
    def end_round(self):
        # turn off the flippers
        self.game.enable_flippers(enable=False)
        # play a cheer
        self.game.sound.play(self.game.assets.sfx_cheers)
        # stop the music - ifwe're out of players
        # self.game.sound.play_music(self.game.assets.music_lastCallEnd,loops=1)
        if not len(self.playerList) > 1:
            self.game.sound.fadeout_music(4000)
        # new line to reset the volume after fade
        self.delay("Fade", delay=6, handler=self.game.interrupter.reset_volume)

        # show the final score display
        textLine1 = ep.EP_TextLayer(64, 4, self.game.assets.font_9px_az, "center", opaque=False).set_text(
            "LAST CALL TOTAL:", color=ep.CYAN
        )
        totalscore = self.game.show_tracking("lastCallTotal")
        textLine2 = ep.EP_TextLayer(64, 15, self.game.assets.font_9px_az, "center", opaque=False).set_text(
            str(ep.format_score(totalscore)), blink_frames=8, color=ep.GREEN
        )
        combined = dmd.GroupedLayer(128, 32, [self.backdrop, textLine1, textLine2])
        self.layer = combined
        # turn off the playfield lights
        for lamp in self.game.lamps.items_tagged("Playfield"):
            lamp.disable()

        # wait until all the balls are back in the trough
        self.delay("Operational", delay=3, handler=self.ball_collection)
Exemplo n.º 16
0
    def jackpot_score(self, points=0):
        if self.showDub:
            double = True
            self.showDub = False
        else:
            double = False
        self.game.sound.play(self.game.assets.sfx_orchestraSpike)
        scoreString = str(ep.format_score(points))
        print "Score string: " + scoreString
        backdrop = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_dmbJackpot.frames[17])
        if double:
            scoreLine1 = ep.EP_TextLayer(64, 2, self.game.assets.font_12px_az_outline, "center", opaque=False)
            scoreLine1.composite_op = "blacksrc"
            scoreLine1.set_text("DOUBLE", color=ep.GREEN)
            scoreLine2 = ep.EP_TextLayer(64, 15, self.game.assets.font_12px_az_outline, "center", opaque=False)
            scoreLine2.composite_op = "blacksrc"
            scoreLine2.set_text(scoreString, color=ep.GREEN)
            combined = dmd.GroupedLayer(128, 32, [backdrop, scoreLine1, scoreLine2])
        else:
            scoreLine = ep.EP_TextLayer(64, 8, self.game.assets.font_15px_az_outline, "center", opaque=False)
            scoreLine.composite_op = "blacksrc"
            scoreLine.set_text(scoreString, color=ep.GREEN)
            combined = dmd.GroupedLayer(128, 32, [backdrop, scoreLine])

        self.layer = combined
        self.delay(name="Display", delay=1, handler=self.main_display)
Exemplo n.º 17
0
 def final_display(self):
     # kill all the stuff, just in case we went from 2 balls to 0
     self.darken()
     self.ending = False
     # play the closing riff
     self.game.sound.play_music(self.game.assets.music_mmClosing, loops=1)
     titleString = "MOONLIGHT MADNESS TOTAL"
     titleLine = ep.EP_TextLayer(128 / 2,
                                 1,
                                 self.game.assets.font_5px_AZ,
                                 "center",
                                 opaque=False).set_text(titleString,
                                                        color=ep.CYAN)
     points = self.moonlightTotal
     scoreString = ep.format_score(points)
     scoreLine = ep.EP_TextLayer(64,
                                 9,
                                 self.game.assets.font_13px_thin_score,
                                 "center",
                                 opaque=False).set_text(scoreString,
                                                        color=ep.GREEN)
     infoLine = ep.EP_TextLayer(64,
                                24,
                                self.game.assets.font_5px_AZ,
                                "center",
                                opaque=False).set_text(
                                    "NOW BACK TO THE GAME", color=ep.BLUE)
     self.layer = dmd.GroupedLayer(128, 32,
                                   [titleLine, scoreLine, infoLine])
     # delay a bit before starting the real ball
     self.delay(delay=5, handler=self.finish_up)
Exemplo n.º 18
0
    def train_victory(self):
        start_value = self.game.increase_tracking('adventureCompleteValue',5000)
        if self.game.save_polly.won:
            self.awardString = "POLLY SAVED"
            value = start_value
            complete_color = ep.GREEN
            # play the short chug
            self.game.sound.play(self.game.assets.sfx_trainChugShort)
        else:
            self.awardString = "POLLY DIED"
            value = start_value / 10
            self.game.sound.play(self.game.assets.sfx_glumRiffShort)
            complete_color = ep.RED

        anim = self.game.assets.dmd_trainHeadOn
        trainLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True,opaque=True,repeat=True,frame_time=6)
        textLine1 = ep.EP_TextLayer(37,1,self.game.assets.font_7px_az,justify="center",opaque=False).set_text("TIED TO",color=ep.YELLOW)
        textLine2 = ep.EP_TextLayer(37,9,self.game.assets.font_7px_az,justify="center",opaque=False).set_text("THE TRACKS",color=ep.YELLOW)
        textLine3 = ep.EP_TextLayer(37,20,self.game.assets.font_7px_az,justify="center",opaque=False).set_text("COMPLETED",color=complete_color)
        combined = dmd.GroupedLayer(128,32,[trainLayer,textLine1,textLine2,textLine3])
        self.layer = combined

        myWait = 1.5

        self.delay(name="Display",delay=myWait,handler=self.show_award_text)
        self.awardPoints = str(ep.format_score(value))
        self.game.score(value,bonus=True)
Exemplo n.º 19
0
    def finish_it(self):
        self.wipe_delays()
        border = dmd.FrameLayer(
            opaque=True,
            frame=self.game.assets.dmd_singlePixelBorder.frames[0])
        textLayer1 = ep.EP_TextLayer(64,
                                     2,
                                     self.game.assets.font_9px_az,
                                     "center",
                                     opaque=False).set_text("COUSIN IT TOTAL",
                                                            color=ep.BROWN)
        textLayer2 = ep.EP_TextLayer(64,
                                     14,
                                     self.game.assets.font_12px_az,
                                     "center",
                                     opaque=False).set_text(str(
                                         ep.format_score(self.total)),
                                                            color=ep.GREEN)
        combined = dmd.GroupedLayer(128, 32, [border, textLayer1, textLayer2])
        self.layer = combined
        # score the points
        self.game.score(self.total)
        self.running = False
        # turn the level 5 stack flag back off
        self.game.stack_level(5, False)
        # set the music back to the main loop
        self.music_on(self.game.assets.music_mainTheme, mySlice=5)
        # remove the switch blocker
        self.game.switch_blocker('remove', self.myID)

        # then unload
        self.delay(delay=2, handler=self.unload)
Exemplo n.º 20
0
    def award_mootherlode(self, times):
        moo = times + 3
        mooLayer = ep.EP_AnimatedLayer(self.game.assets.dmd_moother)
        mooLayer.frame_time = 4
        mooLayer.opaque = True
        mooLayer.repeat = True
        mooLayer.hold = False
        scoreText = moo * self.displayMotherlodeValue
        self.game.score(scoreText)
        mooText = dmd.TextLayer(70,
                                12,
                                self.game.assets.font_12px_az_outline,
                                "center",
                                opaque=False)
        mooText.composite_op = "blacksrc"
        mooText.set_text(str(ep.format_score(scoreText)), blink_frames=12)
        anim = self.game.assets.dmd_explosionWipe2
        animLayer = dmd.AnimatedLayer(frames=anim.frames,
                                      hold=True,
                                      opaque=False,
                                      repeat=False,
                                      frame_time=6)
        animLayer.composite_op = "blacksrc"

        combined = dmd.GroupedLayer(128, 32, [mooLayer, mooText, animLayer])
        self.game.sound.play(self.game.assets.sfx_cow3)
        self.layer = combined
        self.delay("Display", delay=3, handler=self.main_display)
        self.game.mountain.kick()
        self.bandits = False
Exemplo n.º 21
0
 def jackpot_wiff(self,step=1):
     if step == 1:
         layerCopy = self.layer
         # load the animation based on which was last played
         anim = self.anims[0]
         banner = self.banners[0]
         myWait = len(banner.frames) / 12.0
         # reverse them for next time
         self.anims.reverse()
         self.banners.reverse()
         # play an animation
         animLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True,opaque=False,repeat=False,frame_time=5)
         animLayer.composite_op = "blacksrc"
         bannerLayer = dmd.AnimatedLayer(frames=banner.frames,hold=True, opaque=False,repeat=False,frame_time=5)
         textLayer = ep.EP_TextLayer(64,13,self.game.assets.font_13px_score,"center",opaque=False)
         textLayer.composite_op = "blacksrc"
         # frame listener to set the text on the score display
         animLayer.add_frame_listener(19, lambda: textLayer.set_text(ep.format_score(self.game.show_tracking('Stampede Value')),color=ep.MAGENTA,blink_frames=8))
         #bannerLayer.composite_op = "blacksrc"
         if layerCopy:
             combined = dmd.GroupedLayer(128,32,[layerCopy,bannerLayer,textLayer,animLayer])
         else:
             combined = dmd.GroupedLayer(128,32,[bannerLayer,textLayer,animLayer])
         combined.composite_op = "blacksrc"
         self.layer = combined
         # and some sounds
         self.game.sound.play(self.game.assets.sfx_flyByNoise)
         self.delay(delay=1,handler=self.game.base.play_quote,param=self.game.assets.quote_stampedeWiff)
         self.delay(name="Display", delay=myWait, handler=self.main_display)
Exemplo n.º 22
0
 def intro(self, step=1):
     if step == 1:
         self.stop_music()
         anim = self.game.assets.dmd_tafItIntro
         myWait = len(anim.frames) / 10.0
         animLayer = dmd.AnimatedLayer(frames=anim.frames,
                                       hold=True,
                                       opaque=True,
                                       repeat=False,
                                       frame_time=6)
         self.game.sound.play(self.game.assets.sfx_tafDitty)
         self.layer = animLayer
         self.delay(delay=myWait + 1, handler=self.intro, param=2)
     if step == 2:
         textLayer1 = ep.EP_TextLayer(64, 1, self.game.assets.font_9px_az,
                                      "center",
                                      False).set_text("HIT COUSIN IT")
         textLayer2 = ep.EP_TextLayer(
             64, 11, self.game.assets.font_7px_az, "center",
             False).set_text("ALL SHOTS = " +
                             str(ep.format_score(self.value)))
         textLayer3 = ep.EP_TextLayer(
             64, 20, self.game.assets.font_9px_az, "center",
             False).set_text("'IT' INCREASES VALUE")
         border = dmd.FrameLayer(
             opaque=True,
             frame=self.game.assets.dmd_singlePixelBorder.frames[0])
         combined = dmd.GroupedLayer(
             128, 32, [border, textLayer1, textLayer2, textLayer3])
         current = self.layer
         transition = ep.EP_Transition(self, current, combined,
                                       ep.EP_Transition.TYPE_CROSSFADE)
         self.game.sound.play(self.game.assets.quote_itsCousinIt)
         self.delay(delay=3, handler=self.get_going)
Exemplo n.º 23
0
 def update_display(self):
     self.overlay.composite_op = "blacksrc"
     p = self.game.current_player()
     scoreString = ep.format_score(p.score)
     scoreLine = ep.EP_TextLayer(80, 8, self.game.assets.font_7px_az, "center", opaque=False).set_text(scoreString,blink_frames=8,color=ep.YELLOW)
     textLine1 = ep.EP_TextLayer(80, 1, self.game.assets.font_5px_AZ, "center", opaque=False).set_text("DRUNK MULTIBALL",color=ep.ORANGE)
     if self.active:
         textLine2 = ep.EP_TextLayer(80, 18, self.game.assets.font_5px_AZ, "center", opaque=False).set_text("JACKPOTS",color=ep.BROWN)
         textString = "WORTH " + str(ep.format_score(self.jackpotValue))
         textLine3 = ep.EP_TextLayer(80, 25, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(textString,color=ep.BROWN)
     else:
         textLine2 = ep.EP_TextLayer(80, 18, self.game.assets.font_5px_AZ, "center", opaque=False).set_text("HIT BEER MUG",color=ep.BROWN)
         textLine3 = ep.EP_TextLayer(80, 25, self.game.assets.font_5px_AZ, "center", opaque=False).set_text("TO LIGHT JACKPOTS",color=ep.BROWN)
     combined = dmd.GroupedLayer(128,32,[textLine1,textLine2,textLine3,scoreLine,self.overlay])
     self.layer = combined
     self.delay(name="Display",delay=0.2,handler=self.update_display)
Exemplo n.º 24
0
 def display_win(self,rankTitle):
     textString3 = "YOUR RANK: " + rankTitle
     newrank = self.game.show_tracking('rank')
     values = [str(ep.format_score(500000)),str(ep.format_score(750000)),str(ep.format_score(1000000)),str(ep.format_score(1500000)),str(ep.format_score(2000000))]
     textString4 = "QUICKDRAWS WORTH: " + values[newrank]
     # award some points
     points = 750000
     self.game.score(points)
     self.game.add_bonus(100000)
     # show the win screen
     textLine1 = ep.EP_TextLayer(64, 0, self.game.assets.font_7px_bold_az, "center", opaque=True).set_text("BAD GUY SHOT!",color=ep.YELLOW)
     textLine2 = ep.pulse_text(self,64,9,ep.format_score(points),color=ep.GREEN)
     textLine3 = ep.EP_TextLayer(64, 20, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(textString3,color=ep.BROWN)
     textLine4 = ep.EP_TextLayer(64, 26, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(textString4,color=ep.BROWN)
     self.layer = dmd.GroupedLayer(128,32,[textLine1,textLine2,textLine3,textLine4])
     self.delay("Operational",delay=2,handler=self.end_gunfight)
Exemplo n.º 25
0
    def award_motherlode(self,times,overlay=None):
        # tick the counter up
        self.counter += 1
        # tick the times down
        times -= 1
        # setup the display
        awardTextTop = ep.EP_TextLayer(128/2,5,self.game.assets.font_5px_bold_AZ,justify="center",opaque=True)
        awardTextTop.set_text(str(self.counter) + "X" + " = " + ep.format_score(self.displayMotherlodeValue * self.counter),color=ep.GREEN)
        motherLayer = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_motherlode.frames[0])
        motherLayer.composite_op = "blacksrc"

        # if we're on the first counter, finish the wipe
        if self.counter == 1:
            # set up the second part of the wipe
            anim = self.game.assets.dmd_explosionWipe2
            animLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True, opaque = False,repeat = False, frame_time=6)
            animLayer.composite_op = "blacksrc"
            combined = dmd.GroupedLayer(128,32,[awardTextTop,motherLayer,animLayer])
        # otherwise just update the view
        else:
            combined = dmd.GroupedLayer(128,32,[awardTextTop, motherLayer])

        self.layer = combined
        # loop through the multiplier again if times is not zero
        if times == 0:
            # then go back to the main display
            self.delay(name="Display",delay=1.5,handler=self.main_display)
            # and kick the ball out
            self.game.mountain.kick()
            # false the bandits flag in case it's on
            self.bandits = False
        else:
            self.delay(delay=1,handler=self.award_motherlode,param=times)
Exemplo n.º 26
0
 def tumbleweed_display(self, value, combo):
     banner = dmd.FrameLayer(
         opaque=True, frame=self.game.assets.dmd_tumbleweedBanner.frames[0])
     scoreLayer = ep.EP_TextLayer(64,
                                  22,
                                  self.game.assets.font_9px_az,
                                  justify="center",
                                  opaque=False).set_text(str(
                                      ep.format_score(value)),
                                                         blink_frames=6,
                                                         color=ep.YELLOW)
     # load up the animation
     anim = self.game.assets.dmd_tumbleweedRight
     # start the full on animation
     myWait = len(anim.frames) / 15.0 + 0.5
     # setup the animated layer
     animLayer = ep.EP_AnimatedLayer(anim)
     animLayer.hold = True
     animLayer.frame_time = 4
     animLayer.opaque = False
     animLayer.composite_op = "blacksrc"
     combined = dmd.GroupedLayer(128, 32, [banner, scoreLayer, animLayer])
     self.layer = combined
     self.game.sound.play(self.game.assets.sfx_tumbleWind)
     self.delay(name="Display", delay=myWait, handler=self.clear_layer)
     if combo:
         self.delay(name="Display",
                    delay=myWait,
                    handler=self.game.combos.display)
Exemplo n.º 27
0
 def finish_trolls(self):
     # kill the delays
     self.wipe_delays()
     # drop the targets
     self.game.bad_guys.drop_targets()
     border = dmd.FrameLayer(opaque=True, frame=self.game.assets.dmd_mmTrollFinalFrame.frames[0])
     textLayer1 = ep.EP_TextLayer(64, 8, self.game.assets.font_5px_AZ, "center", opaque=False)
     if self.won:
         textLayer1.set_text("TROLLS DESTROYED", color=ep.DARK_GREEN)
         # add some extra points if won - to make it a cool 1.5 million
         self.game.score(450000)
         self.totalPoints += 450000
     else:
         textLayer1.set_text("TROLLS ESCAPED", color=ep.DARK_GREEN)
     textLayer2 = ep.EP_TextLayer(64, 14, self.game.assets.font_9px_az, "center", opaque=False).set_text(
         str(ep.format_score(self.totalPoints)), color=ep.GREEN
     )
     combined = dmd.GroupedLayer(128, 32, [border, textLayer1, textLayer2])
     self.layer = combined
     # play a final quote ?
     if self.won:
         self.delay(delay=1, handler=self.game.base.priority_quote, param=self.game.assets.quote_mmFatality)
     elif self.leftHitsSoFar == 0 and self.rightHitsSoFar == 0:
         self.game.base.priority_quote(self.game.assets.quote_mmYouSuck)
     else:
         self.game.sound.play(self.game.assets.sfx_cheers)
     myWait = 2
     self.delay(delay=myWait, handler=self.done)
Exemplo n.º 28
0
 def update_display(self):
     self.cancel_delayed("Display")
     titleString = "MOONLIGHT MADNESS"
     titleLine = ep.EP_TextLayer(128/2, 0, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(titleString,color=ep.CYAN)
     # score line
     points = self.moonlightTotal
     scoreString = ep.format_score(points)
     if self.bonanza:
         scoreLine = ep.EP_TextLayer(64, 9, self.game.assets.font_13px_thin_score, "center", opaque = False).set_text(scoreString,blink_frames=4,color=ep.GREEN)
         if self.ending:
             textString = "FINISHING UP"
         else:
             textString = "ALL SWITCHES = 3 MILLION"
         infoLine = ep.EP_TextLayer(64,25, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(textString,color=ep.BLUE)
         layers = [titleLine, scoreLine, infoLine]
     else:
         scoreLine = ep.EP_TextLayer(64, 7, self.game.assets.font_9px_az, "center", opaque=False).set_text(scoreString,blink_frames=4,color=ep.GREEN)
         infoLine = ep.EP_TextLayer(64,18,self.game.assets.font_5px_AZ, "center", opaque=False).set_text("SHOOT LIT ITEMS",color=ep.BLUE)
         amount = 9 - len(self.liveShots)
         textString = str(amount) + " MORE FOR BONANZA"
         infoLine2 = ep.EP_TextLayer(64,24,self.game.assets.font_5px_AZ, "center", opaque=False).set_text(textString,color=ep.BLUE)
         layers = [titleLine, scoreLine, infoLine, infoLine2]
     self.layer = dmd.GroupedLayer(128,32,layers)
     # loop back to update the score and whatnot
     self.delay("Display", delay=0.5, handler=self.update_display)
Exemplo n.º 29
0
 def jackpot_wiff(self,step=1):
     if step == 1:
         layerCopy = self.layer
         # load the animation based on which was last played
         anim = self.anims[0]
         banner = self.banners[0]
         myWait = len(banner.frames) / 12.0
         # reverse them for next time
         self.anims.reverse()
         self.banners.reverse()
         # play an animation
         animLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True,opaque=False,repeat=False,frame_time=5)
         animLayer.composite_op = "blacksrc"
         bannerLayer = dmd.AnimatedLayer(frames=banner.frames,hold=True, opaque=False,repeat=False,frame_time=5)
         textLayer = ep.EP_TextLayer(64,13,self.game.assets.font_13px_score,"center",opaque=False)
         textLayer.composite_op = "blacksrc"
         # frame listener to set the text on the score display
         animLayer.add_frame_listener(19, lambda: textLayer.set_text(ep.format_score(self.game.show_tracking('Stampede Value')),color=ep.MAGENTA,blink_frames=8))
         #bannerLayer.composite_op = "blacksrc"
         if layerCopy:
             combined = dmd.GroupedLayer(128,32,[layerCopy,bannerLayer,textLayer,animLayer])
         else:
             combined = dmd.GroupedLayer(128,32,[bannerLayer,textLayer,animLayer])
         combined.composite_op = "blacksrc"
         self.layer = combined
         # and some sounds
         self.game.sound.play(self.game.assets.sfx_flyByNoise)
         self.delay(delay=1,handler=self.game.base.play_quote,param=self.game.assets.quote_stampedeWiff)
         self.delay(name="Display", delay=myWait, handler=self.main_display)
Exemplo n.º 30
0
 def win(self):
     self.won = True
     duration = self.game.sound.play(self.game.assets.sfx_longTrainWhistle)
     self.delay(delay=duration, handler=self.game.sound.play, param=self.game.assets.sfx_cheers)
     textString = "TRAIN MOVED IN " + str(self.shots) + " SHOTS"
     textLine = ep.EP_TextLayer(64, 1, self.game.assets.font_5px_AZ, "center", opaque=True).set_text(
         textString, color=ep.BROWN
     )
     # calculate the score
     # four shots is a perfect score - so we take off 4 shots
     if self.shots == 4:
         # a perfect score is 1 million - every additional shot costs 50,000, which makes a 100,000 loss for each due to the 2x nature of it - with a floor of 200,000
         score = 1000000
     else:
         # if they finish, but not in perfectly, then it's 750
         score = 750000
     pointsLine = ep.EP_TextLayer(64, 10, self.game.assets.font_17px_score, "center", opaque=False).set_text(
         str(ep.format_score(score)), blink_frames=8, color=ep.RED
     )
     self.game.score(score)
     combined = dmd.GroupedLayer(128, 32, [textLine, pointsLine])
     self.layer = combined
     self.game.base.priority_quote(self.game.assets.quote_mytWin, squelch=True)
     # end after 2 seconds
     self.delay(delay=2, handler=self.end)
Exemplo n.º 31
0
 def display(self):
     self.cancel_delayed("Display")
     backdrop = dmd.FrameLayer(opaque=True, frame=self.game.assets.dmd_cactusBorder.frames[0])
     # build and show the display of combos made & left
     combos = self.game.show_tracking('combos')
     # if we've got a chain going, that affects display
     #print "CHAIN VALUE: " + str(self.chain)
     if self.chain > 1:
         if ep.last_shot == "center":
             textString = str(self.chain) + "-WAY SUPER COMBO"
             points = 25000 * self.chain
         else:
             textString = str(self.chain) + "-WAY COMBO"
             points = 50000
         textString2 = str(ep.format_score(points)) + " POINTS"
     else:
         textString = "COMBO AWARDED"
         textString2 = str(combos) + " COMBOS"
     textLine1 = ep.EP_TextLayer(64,3,self.game.assets.font_5px_bold_AZ,justify="center",opaque=False).set_text(textString,color=ep.BROWN)
     textLine2 = ep.EP_TextLayer(64,11,self.game.assets.font_9px_az,justify="center",opaque=False)
     textLine3 = ep.EP_TextLayer(64,25,self.game.assets.font_5px_bold_AZ,justify="center",opaque=False)
     textLine2.set_text(textString2,blink_frames=10,color=ep.GREEN)
     combosForStar = self.game.user_settings['Gameplay (Feature)']['Combos for Star']
     diff = combosForStar - combos
     if combos > combosForStar:
         comboString = "BADGE COMPLETE!"
     elif combos == combosForStar:
         comboString = "BADGE AWARDED"
     else:
         comboString = str(diff) + " MORE FOR BADGE!"
     textLine3.set_text(comboString,color=ep.BROWN)
     combined = dmd.GroupedLayer(128,32,[backdrop,textLine1,textLine2,textLine3])
     self.layer = combined
     #print "I MADE IT THROUGH COMBO DISPLAY"
     self.delay(name="Display",delay=2,handler=self.clear_layer)
Exemplo n.º 32
0
    def timer(self, target):
        # ok, so this has to control the score and display?
        # for now stepping in 1/5 second
        self.runtime -= 0.2
        if self.runtime <= 0:
            # timer runs out - player lost
            self.lost(target)
        else:
            # every 3 seconds, play a taunt quote
            if int(self.runtime % 5.0) == 0 and self.runtime >= 6:
                self.taunt_player()
            # play a hurry quote if we're at 2 seconds.
            if self.runtime == 2:
                self.game.base.play_quote(self.game.assets.quote_hurry)
            # take points off the score
            self.points -= self.portion
            # update the score text layer
            if self.runtime < self.third:
                color = ep.RED
            elif self.runtime < (self.third * 2):
                color = ep.ORANGE
            else:
                color = ep.YELLOW
            scoreLayer = ep.EP_TextLayer(84, 4, self.game.assets.font_12px_az, "center", opaque=False).set_text(
                ep.format_score(self.points), color=color
            )
            if self.layer == None:
                self.layer = self.no_layer()

            self.layer = dmd.GroupedLayer(128, 32, [self.layer, scoreLayer])
            # update the group layer
            # make it active
            self.layer = dmd.GroupedLayer(128, 32, [self.animLayer, scoreLayer])
            # delay the next iteration
            self.delay("Timer Delay", delay=0.2, handler=self.timer, param=target)
Exemplo n.º 33
0
 def lose(self):
     # if the train is dead center, nothing
     if self.trainOffset == 0:
         textString = "TRAIN NOT MOVED!"
         points = 0
     # one shift off center
     elif self.trainOffset == 20 or self.trainOffset == -20:
         textString = "TRAIN MOVED A BIT"
         points = 50000
     # two shifts off center
     elif self.trainOffset == 40 or self.trainOffset == -40:
         textString = "TRAIN MOVED SOME"
         points = 100000
     # three shifts off center
     else:
         textString = "TRAIN MOSTLY MOVED"
         points = 250000
     # play the glum riff
     self.game.base.play_quote(self.game.assets.quote_mytEnd, squelch=True)
     textLine = ep.EP_TextLayer(64, 1, self.game.assets.font_5px_AZ, "center", opaque=True).set_text(
         textString, color=ep.BROWN
     )
     pointsLine = ep.EP_TextLayer(64, 10, self.game.assets.font_17px_score, "center", opaque=False).set_text(
         str(ep.format_score(points)), blink_frames=8, color=ep.RED
     )
     self.game.score(points)
     combined = dmd.GroupedLayer(128, 32, [textLine, pointsLine])
     self.layer = combined
     # end after 2 seconds
     self.delay(delay=2, handler=self.end)
Exemplo n.º 34
0
 def mad_cow(self,step=1):
     backdrop = ep.EP_AnimatedLayer(self.game.assets.dmd_cows)
     backdrop.hold = False
     backdrop.repeat = True
     backdrop.frame_time = 6
     backdrop.opaque = True
     if step == 1:
         noises = [self.game.assets.sfx_cow1,self.game.assets.sfx_cow2]
         sound = random.choice(noises)
         self.game.sound.play(sound)
         textLine1 = dmd.TextLayer(64,1,self.game.assets.font_12px_az_outline, "center", opaque=False)
         textLine2 = dmd.TextLayer(64,16,self.game.assets.font_12px_az_outline, "center", opaque=False)
         textLine1.composite_op = "blacksrc"
         textLine2.composite_op = "blacksrc"
         textLine1.set_text("MAD",blink_frames=15)
         textLine2.set_text("COW",blink_frames=15)
         combined = dmd.GroupedLayer(128,32,[backdrop,textLine1,textLine2])
         self.layer = combined
         self.delay("Display",delay=1.5,handler=self.mad_cow,param=2)
     elif step == 2:
         textLine1 = dmd.TextLayer(64,9,self.game.assets.font_12px_az_outline, "center",opaque=False)
         textLine1.composite_op = "blacksrc"
         textLine1.set_text(str(ep.format_score(50000)))
         combined = dmd.GroupedLayer(128,32,[backdrop,textLine1])
         self.layer = combined
         self.delay("Display",delay=1.5,handler=self.clear_layer)
     else:
         pass
Exemplo n.º 35
0
 def mode_started(self):
     # log the hit in audits
     self.game.game_data['Feature']['Stampede Started'] += 1
     # which jackpot is active
     self.active = 2
     self.jackpots = 0
     # cancel any other displays
     for mode in self.game.ep_modes:
         if getattr(mode, "abort_display", None):
             mode.abort_display()
     # fire up the switch block if it's not already loaded
     self.game.switch_blocker('add',self.myID)
     # add the stampede value and addon to get the points for this round
     self.jackpotValue = (self.game.show_tracking('Stampede Value') * 2) + self.game.show_tracking('Stampede Addon')
     # base value
     self.baseValue = self.game.show_tracking('Stampede Value')
     # set the total to 0
     self.game.set_tracking('Stampede Total',0)
     # The first center shot is a jackpot - but it has to be able to be lowered
     self.centerValue = self.jackpotValue
     # timers for pulling the jackpot back to center
     self.longTimer = 9
     self.shortTimer = 6
     self.time = 0
     self.halted = False
     # set up some display bits
     # title line
     self.titleLine = ep.EP_TextLayer(128/2, 1, self.game.assets.font_5px_AZ, "center", opaque=False).set_text("STAMPEDE MULTIBALL",color=ep.PURPLE)
     # score line
     p = self.game.current_player()
     scoreString = ep.format_score(p.score)
     self.mainScoreLine = ep.EP_TextLayer(64, 7, self.game.assets.font_9px_az, "center", opaque=False).set_text(scoreString,color=ep.YELLOW)
     self.mainScoreLine.composite_op = "blacksrc"
     # jackpot info line
     self.jackpotLine = ep.EP_TextLayer(64,1, self.game.assets.font_5px_AZ, "center", opaque=False)
Exemplo n.º 36
0
    def pause_display(self):
        # set up the display
        p = self.game.current_player()
        scoreString = ep.format_score(p.score)
        scoreLine = ep.EP_TextLayer(34,
                                    6,
                                    self.game.assets.font_5px_bold_AZ,
                                    "center",
                                    opaque=False).set_text(scoreString,
                                                           blink_frames=8,
                                                           color=ep.BROWN)
        timeString = "TIME: PAUSED"
        timeLine = ep.EP_TextLayer(34,
                                   25,
                                   self.game.assets.font_5px_AZ,
                                   "center",
                                   opaque=False).set_text(timeString,
                                                          blink_frames=10,
                                                          color=ep.DARK_RED)
        textString2 = str((self.shotsToWin - self.shotsSoFar)) + " SHOTS FOR"
        awardLine1 = dmd.TextLayer(34,
                                   11,
                                   self.game.assets.font_7px_az,
                                   "center",
                                   opaque=False).set_text(textString2)

        # stick together the animation and static text with the dynamic text
        composite = dmd.GroupedLayer(128, 32, [
            self.cowLayer, self.pollyTitle, scoreLine, awardLine1,
            self.awardLine2, timeLine
        ])
        self.layer = composite
Exemplo n.º 37
0
    def end_ambush(self):
        # kill the taunt timer
        self.cancel_delayed("Taunt Timer")
        # Kill the target timers
        for i in range(0,4,1):
            self.cancel_delayed(self.targetNames[i])
        # clear the layer
        self.clear_layer()
        # drop all the targets
        self.game.bad_guys.drop_targets()
        # kill the music - if nothing else is running
        #self.stop_music(slice=2)
        # grab the points before tracking
        totalPoints = self.game.show_tracking('ambushPoints')
        # update all the tracking
        self.update_tracking()
        # update the lamps
        self.lamp_update()
        # start up the main theme again if a higher level mode isn't running
        self.music_on(self.game.assets.music_mainTheme,mySlice=2)
        # turn off the level 1 flag
        self.game.stack_level(1,False)
        # setup a display frame
        backdrop = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_singleCowboySidewaysBorder.frames[0])
        textLine1 = ep.EP_TextLayer(74, 2, self.game.assets.font_7px_bold_az, "center", opaque=False)
        textString = "AMBUSH: " + str(self.deathTally) + " KILLS"
        textLine1.set_text(textString,color=ep.RED)
        textLine1.composite_op = "blacksrc"
        textLine2 = ep.EP_TextLayer(74,11, self.game.assets.font_12px_az, "center", opaque=False)
        print "TOTAL AMBUSH: " + str(ep.format_score(totalPoints))
        textLine2.set_text(ep.format_score(totalPoints),color=ep.GREEN)
        combined = dmd.GroupedLayer(128,32,[backdrop,textLine1,textLine2])
        self.layer = combined
        # play a quote
        if self.deathTally == 0:
            self.game.base.play_quote(self.game.assets.quote_gunFail)
        else:
            self.game.base.play_quote(self.game.assets.quote_mobEnd)
        self.delay("Display",delay=2,handler=self.clear_layer)

        self.update_badge()
        # unset the base busy flag
        self.game.base.busy = False
        self.game.base.queued -= 1
        # unload the mode
        self.delay("Ambush",delay=2.1,handler=self.unload)
Exemplo n.º 38
0
 def miss_it(self):
     print "Miss IT"
     # on a miss award the current value and display the miss
     self.total += self.value
     self.totalLayer.set_text(ep.format_score(self.total))
     self.game.sound.play(self.game.assets.sfx_tafMissIt)
     self.delay(delay=0.5, handler=self.mumble_it)
     self.display_it("miss")
Exemplo n.º 39
0
 def showdown_hit(self,points):
     pointString = str(ep.format_score(points)) + "#"
     textLine1 = ep.EP_TextLayer(128/2, 2, self.game.assets.font_9px_AZ_outline, "center", opaque=False).set_text("<BAD> <GUY> <SHOT!>",color=ep.ORANGE)
     textLine2 = ep.EP_TextLayer(128/2, 14, self.game.assets.font_12px_az_outline, "center", opaque=False).set_text(pointString,blink_frames=8,color=ep.RED)
     combined = dmd.GroupedLayer(128,32,[textLine1,textLine2])
     combined.composite_op = "blacksrc"
     self.layer = combined
     self.delay(name="Display",delay=1.5,handler=self.clear_layer)
Exemplo n.º 40
0
 def miss_it(self):
     print "Miss IT"
     # on a miss award the current value and display the miss
     self.total += self.value
     self.totalLayer.set_text(ep.format_score(self.total))
     self.game.sound.play(self.game.assets.sfx_tafMissIt)
     self.delay(delay=0.5,handler=self.mumble_it)
     self.display_it("miss")
Exemplo n.º 41
0
    def wipe_transition(self,multiplier):
        # set up the display during multiball
        backdrop = dmd.FrameLayer(opaque=True, frame=self.game.assets.dmd_multiballFrame.frames[0])
        # title line
        titleString = "GOLD MINE MULTIBALL"
        if self.game.drunk_multiball.running:
            titleString = "DRUNK MINE MULTIBALL"
        titleLine = ep.EP_TextLayer(128/2, -1, self.game.assets.font_5px_AZ, "center", opaque=False).set_text(titleString,color=ep.YELLOW)
        # score line
        p = self.game.current_player()
        scoreString = ep.format_score(p.score)
        scoreLine = ep.EP_TextLayer(64, 5, self.game.assets.font_9px_az, "center", opaque=False).set_text(scoreString,blink_frames=4,color=ep.DARK_BROWN)
        scoreLine.composite_op = "blacksrc"
        # motherlode line
        # if no motherlode is lit
        if self.game.show_tracking('motherlodeLit') and not self.bandits:
            textString = "MOTHERLODE " + ep.format_score(self.motherlodeValue) + " X " + str(self.game.show_tracking('motherlodeMultiplier'))
        # if the bandits showed up
        elif self.bandits:
            textString = "SHOOT THE BANDITS!"
        else:
            textString = "JACKPOTS LIGHT MOTHERLODE"

        motherLine = ep.EP_TextLayer(128/2,16,self.game.assets.font_5px_AZ, "center", opaque=False).set_text(textString,color=ep.YELLOW)
        # jackpot value line
        if self.bandits:
            jackString = "TIME REMAINING: " + str(self.banditTimer)
        else:
            if self.game.drunk_multiball.running:
                jackString = "JACKPOTS = " + str(ep.format_score(1000000))
            else:
                jackString = "JACKPOTS = " + str(ep.format_score(500000))
        jackpotLine = ep.EP_TextLayer(128/2,22,self.game.assets.font_5px_AZ, "center", opaque=False).set_text(jackString,color=ep.DARK_BROWN)

        anim = self.game.assets.dmd_explosionWipe1
        animLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True,opaque=False,repeat=False,frame_time=6)
        animLayer.composite_op = "blacksrc"
        myWait = len(anim.frames) / 10.0
        combined = dmd.GroupedLayer(128,32,[backdrop,titleLine,scoreLine,motherLine,jackpotLine,animLayer])
        self.layer = combined
        self.game.sound.play(self.game.assets.sfx_lockTwoExplosion)
        if self.moo:
            self.moo = False
            self.delay(delay=myWait,handler=self.award_mootherlode,param=multiplier)
        else:
            self.delay(delay=myWait,handler=self.award_motherlode,param=multiplier)
Exemplo n.º 42
0
 def update_display(self):
     self.cancel_delayed("Display")
     titleString = "MOONLIGHT MADNESS"
     titleLine = ep.EP_TextLayer(128 / 2,
                                 0,
                                 self.game.assets.font_5px_AZ,
                                 "center",
                                 opaque=False).set_text(titleString,
                                                        color=ep.CYAN)
     # score line
     points = self.moonlightTotal
     scoreString = ep.format_score(points)
     if self.bonanza:
         scoreLine = ep.EP_TextLayer(64,
                                     9,
                                     self.game.assets.font_13px_thin_score,
                                     "center",
                                     opaque=False).set_text(scoreString,
                                                            blink_frames=4,
                                                            color=ep.GREEN)
         if self.ending:
             textString = "FINISHING UP"
         else:
             textString = "ALL SWITCHES = 3 MILLION"
         infoLine = ep.EP_TextLayer(64,
                                    25,
                                    self.game.assets.font_5px_AZ,
                                    "center",
                                    opaque=False).set_text(textString,
                                                           color=ep.BLUE)
         layers = [titleLine, scoreLine, infoLine]
     else:
         scoreLine = ep.EP_TextLayer(64,
                                     7,
                                     self.game.assets.font_9px_az,
                                     "center",
                                     opaque=False).set_text(scoreString,
                                                            blink_frames=4,
                                                            color=ep.GREEN)
         infoLine = ep.EP_TextLayer(64,
                                    18,
                                    self.game.assets.font_5px_AZ,
                                    "center",
                                    opaque=False).set_text(
                                        "SHOOT LIT ITEMS", color=ep.BLUE)
         amount = 9 - len(self.liveShots)
         textString = str(amount) + " MORE FOR BONANZA"
         infoLine2 = ep.EP_TextLayer(64,
                                     24,
                                     self.game.assets.font_5px_AZ,
                                     "center",
                                     opaque=False).set_text(textString,
                                                            color=ep.BLUE)
         layers = [titleLine, scoreLine, infoLine, infoLine2]
     self.layer = dmd.GroupedLayer(128, 32, layers)
     # loop back to update the score and whatnot
     self.delay("Display", delay=0.5, handler=self.update_display)
Exemplo n.º 43
0
    def end_stampede(self):
        print "ENDING S T A M P E D E"
        # stop the music
        #self.stop_music(slice=5)
        # do a final display
        # setup a display frame
        backdrop = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_skullsBorder.frames[0])
        textLine1 = dmd.TextLayer(128/2, 1, self.game.assets.font_7px_bold_az, "center", opaque=False)
        textString = "STAMPEDE TOTAL"
        textLine1.set_text(textString)
        textLine1.composite_op = "blacksrc"
        textLine2 = dmd.TextLayer(128/2,11, self.game.assets.font_12px_az, "center", opaque=False)
        totalPoints = self.game.show_tracking('Stampede Total')
        textLine2.set_text(ep.format_score(totalPoints))
        # if the total is higher than best, set best
        if self.game.show_tracking('Stampede Best') < totalPoints:
            self.game.set_tracking('Stampede Best',totalPoints)
        combined = dmd.GroupedLayer(128,32,[backdrop,textLine1,textLine2])
        self.layer = combined
        self.delay(name="Display",delay=2,handler=self.clear_layer)

        # set the active jackpot out of range
        self.active = 9
        # kill the timer loop that moves the jackpot
        self.cancel_delayed("Timer")
        # set some tracking?
        # reset the ramp status
        for each in self.shots:
            self.game.set_tracking(each,1)
        # set the values for the ramp shots back down
        self.game.set_tracking('leftRampValue',2000)
        self.game.set_tracking('rightRampValue',2000)
        self.game.set_tracking('centerRampValue',2000)
        # unset the base busy flag
        self.game.base.busy = False
        self.game.base.queued -= 1
        # clear the stack layer - if goldmine isn't running. This covers balls draining while the gold mine starts. Rare, but possible.
        if self.game.show_tracking('mineStatus') == "RUNNING":
            print "Goldmine is running"
            pass
        else:
            print "Gold mine is not running"
            self.game.stack_level(4,False)
            # turn the main music back on
            self.music_on(self.game.assets.music_mainTheme,mySlice=5)
            # remove the switch blocker
            self.game.switch_blocker('remove',self.myID)
            self.lamp_update()

        # Reset the stampede value
        self.game.set_tracking('Stampede Value', 250000)
        self.game.set_tracking('Stamepde Addon', 0)
        self.running = False
        # badge light - stampede is 4
        self.game.badge.update(4)
        # unload the mode
        self.delay(delay=2,handler=self.unload)
Exemplo n.º 44
0
 def jackpot_score(self):
     self.game.sound.play(self.game.assets.sfx_orchestraSpike)
     scoreString = str(ep.format_score(self.jackpotEarned)) + "*"
     scoreLine = ep.EP_TextLayer(64, 8, self.game.assets.font_15px_az_outline, "center", opaque=False).set_text(scoreString,color=ep.YELLOW)
     scoreLine.composite_op = "blacksrc"
     backdrop = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_dmbJackpot.frames[17])
     combined = dmd.GroupedLayer(128,32,[backdrop,scoreLine])
     self.layer = combined
     self.delay(name="Display",delay=1,handler=self.update_display)
Exemplo n.º 45
0
 def hit_banner(self):
     print "HIT BANNER GOES HERE"
     # turn off the banner flag
     self.banner = False
     # cancel the mode timer during the display
     self.cancel_delayed("Mode Timer")
     shotsLeftText = str(self.shotsToWin - self.shotsSoFar) + " MORE TO GO"
     display = self.build_display(shotsLeftText,str(ep.format_score(100000)))
     transition = ep.EP_Transition(self,self.layer,display,ep.EP_Transition.TYPE_CROSSFADE)
     self.delay("Display",delay=1.5,handler=self.in_progress)
Exemplo n.º 46
0
 def jackpot_score(self):
     self.game.sound.play(self.game.assets.sfx_orchestraSpike)
     scoreString = str(ep.format_score(self.jackpotEarned))
     scoreLine = ep.EP_TextLayer(64, 8, self.game.assets.font_15px_az_outline, "center", opaque=False)
     scoreLine.composite_op = "blacksrc"
     scoreLine.set_text(scoreString,color=ep.YELLOW)
     backdrop = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_dmbJackpot.frames[17])
     combined = dmd.GroupedLayer(128,32,[backdrop,scoreLine])
     self.layer = combined
     self.delay(name="Display",delay=1,handler=self.update_display)
Exemplo n.º 47
0
 def mini_display(self):
     if self.chain > 1:
         string = "CHAIN COMBO " + str(self.chain) + " - " + ep.format_score(25000 * self.chain)
         backdrop = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_status_banner_magenta.frames[0])
         backdrop.composite_op = "blacksrc"
         textLayer = dmd.TextLayer(128/2, 26, self.game.assets.font_5px_AZ_inverted, "center", opaque=False).set_text(string)
         textLayer.composite_op = "blacksrc"
         combined = dmd.GroupedLayer(128,32, [backdrop,textLayer])
         combined.composite_op = "blacksrc"
         self.game.interrupter.broadcast(combined,1.5)
Exemplo n.º 48
0
    def main_display(self, loop=True):
        # cancel any display loop - if there is one
        self.cancel_delayed("Display")
        # set up the display during multiball
        # score line
        p = self.game.current_player()
        scoreString = ep.format_score(p.score)
        scoreLine = ep.EP_TextLayer(64,
                                    4,
                                    self.game.assets.font_9px_az,
                                    "center",
                                    opaque=False).set_text(scoreString,
                                                           blink_frames=4,
                                                           color=ep.CYAN)
        scoreLine.composite_op = "blacksrc"

        if self.ending:
            textString = "ENDING LAST CALL"
            infoLine = dmd.TextLayer(128 / 2,
                                     16,
                                     self.game.assets.font_5px_AZ,
                                     "center",
                                     opaque=False).set_text(textString)
        else:
            infoLine = self.infoLayer

        # jackpot value line
        jackString = "JACKPOTS = " + str(ep.format_score(self.shotValue))
        if self.ending:
            jackString = "COLLECTING BALLS"
        self.jackpotLine = dmd.TextLayer(128 / 2,
                                         22,
                                         self.game.assets.font_5px_AZ,
                                         "center",
                                         opaque=False).set_text(jackString)

        combined = dmd.GroupedLayer(
            128, 32, [self.backdrop, scoreLine, infoLine, self.jackpotLine])
        self.layer = combined
        # loop back in .2 to update
        if not loop:
            self.delay(name="Display", delay=0.2, handler=self.main_display)
Exemplo n.º 49
0
    def in_progress(self):
        if self.running:
            #print "IN PROGRESS " + str(self.modeTimer)
            #print "Shooter info: Target - " + str(self.shotTarget) + " Timer - " + str(self.shotTimer)
            # and all the text
            p = self.game.current_player()
            scoreString = ep.format_score(p.score)
            scoreLine = dmd.TextLayer(34, 6, self.game.assets.font_5px_bold_AZ, "center", opaque=False).set_text(scoreString,blink_frames=8)
            timeString = str(int(self.modeTimer))
            self.timeLine = dmd.TextLayer(128,26, self.game.assets.font_5px_AZ, "right", opaque=False).set_text(timeString)

            # stick together the animation and static text with the dynamic text
            composite = dmd.GroupedLayer(128,32,[self.dude0Layer,self.dude1Layer,self.dude2Layer,self.foreground,self.timeLine])
            self.layer = composite

            # increment the shot timer
            self.shotTimer += 1
            # check if time to shoot
            if self.shotTimer == self.shotTarget:
                # if it is that time, generate a firing guy
                self.dude_shoots()

            # did we just kill the last guy?
            if self.have_won:
#                self.have_won = False
                # delay for the dude getting shot animation to finish
                self.delay("Mode Timer",delay=self.deathWait,handler=self.polly_saved)
            # how about any guy?
            if self.banner:
                self.banner = False
                # if we need to show a dude killed banner, do that
                self.delay("Mode Timer",delay=self.deathWait,handler=self.banner_display)
            # is a guy shooting?
            if self.shooting:
                self.shooting = False
                # set a delay to put the plain guy back after
                self.delay("Mode Timer",delay=self.shotWait,handler=self.end_shot_sequence)
            # both of those bail before ticking down the timer and looping back

            ## tick down the timer
            self.modeTimer -= 0.1
            ## hurry quote at 5 seconds, plead at 15
            if abs(self.modeTimer - 15) < 0.00000001:
                self.game.base.play_quote(self.game.assets.quote_pollyPlead)
            if abs(self.modeTimer - 5) < 0.00000001:
                self.game.base.play_quote(self.game.assets.quote_pollyHurry)
            if self.modeTimer <= 0:
                # go to a grace period
                self.polly_died()
            # otherwise ...
            else:
                if not self.have_won:
                    # set up a delay to come back in 1 second with the lowered time
                    self.delay(name="Mode Timer",delay=0.1,handler=self.in_progress)
Exemplo n.º 50
0
    def in_progress(self):
        if self.running:
            # and all the text
            p = self.game.current_player()
            scoreString = ep.format_score(p.score)
            scoreLine = dmd.TextLayer(34,
                                      6,
                                      self.game.assets.font_5px_bold_AZ,
                                      "center",
                                      opaque=False).set_text(scoreString,
                                                             blink_frames=8)
            timeString = "TIME: " + str(int(self.modeTimer))
            self.timeLine = dmd.TextLayer(128,
                                          26,
                                          self.game.assets.font_5px_AZ,
                                          "right",
                                          opaque=False).set_text(timeString)

            # moving the horse
            if self.distance > 0:
                # change the x_position
                self.x_pos -= 2
                # tick down the distance
                self.distance -= 1
            if self.banner and self.distance == 0:
                print "I SHOULD DO THE BANNER MON"
                self.hit_banner()
            else:
                # set the horse layer position
                self.horse.set_target_position(self.x_pos, 0)
                # stick together the animation and static text with the dynamic text
                composite = dmd.GroupedLayer(
                    128, 32,
                    [self.backdrop, self.horse, self.boat, self.timeLine])
                self.layer = composite
                ## tick down the timer
                self.modeTimer -= 0.1
                ## hurry quote at 5 seconds, plead at 15
                if abs(self.modeTimer - 15) < 0.00000001:
                    self.game.base.play_quote(
                        self.game.assets.quote_pollyPlead)
                if abs(self.modeTimer - 5) < 0.00000001:
                    self.game.base.play_quote(
                        self.game.assets.quote_pollyHurry)
                if self.modeTimer <= 0:
                    # go to a grace period
                    self.polly_died()
                # otherwise ...
                else:
                    # set up a delay to come back in 1 second with the lowered time
                    self.delay("Mode Timer",
                               delay=0.1,
                               handler=self.in_progress)
Exemplo n.º 51
0
 def hit_banner(self):
     print "HIT BANNER GOES HERE"
     # turn off the banner flag
     self.banner = False
     # cancel the mode timer during the display
     self.cancel_delayed("Mode Timer")
     shotsLeftText = str(self.shotsToWin - self.shotsSoFar) + " MORE TO GO"
     display = self.build_display(shotsLeftText,
                                  str(ep.format_score(self.lastPoints)))
     transition = ep.EP_Transition(self, self.layer, display,
                                   ep.EP_Transition.TYPE_CROSSFADE)
     self.delay("Display", delay=1.5, handler=self.in_progress)
Exemplo n.º 52
0
    def update_display(self):
        if self.time < 5:
            color = ep.RED
        elif self.time < 15:
            color = ep.ORANGE
        else:
            color = ep.YELLOW

        self.timeLine.set_text("TIME: " + str(self.time), color)
        p = self.game.current_player()
        scoreString = ep.format_score(p.score)
        self.scoreLine.set_text(scoreString, color=ep.BROWN)
Exemplo n.º 53
0
    def shift(self,direction):
        # move the active shot
        # Going right
        if direction == 1:
            self.active += 1
            # just in case
            if self.active > 4:
                self.active = 4
        # going Left
        else:
            self.active -= 1
            # just in case
            if self.active < 0:
                self.active = 0

        # update the lamps
        self.lamp_update()
        # now we need to start a timer for pulling back to center
        # If we're in the One away, set the long timer
        if self.is_near():
            self.time = self.longTimer + 1
            self.shift_timer()
        # If we're two away, set the short timer
        if self.is_far():
            self.time = self.shortTimer + 1
            self.shift_timer()

        layerCopy = self.layer
        # Set the cow animation
        anim = self.anims[direction]
        banner = self.banners[direction]
        myWait = len(banner.frames) / 12.0
        # play an animation
        animLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True,opaque=False,repeat=False,frame_time=5)
        animLayer.composite_op = "blacksrc"
        bannerLayer = dmd.AnimatedLayer(frames=banner.frames,hold=True, opaque=False,repeat=False,frame_time=5)
        textLayer = ep.EP_TextLayer(64,13,self.game.assets.font_13px_score,"center",opaque=False)
        textLayer.composite_op = "blacksrc"
        # frame listener to set the text on the score display
        animLayer.add_frame_listener(19, lambda: textLayer.set_text(ep.format_score(self.baseValue),color=ep.MAGENTA,blink_frames=8))
        #bannerLayer.composite_op = "blacksrc"
        if layerCopy:
            combined = dmd.GroupedLayer(128,32,[layerCopy,bannerLayer,textLayer,animLayer])
        else:
            combined = dmd.GroupedLayer(128,32,[bannerLayer,textLayer,animLayer])
        combined.composite_op = "blacksrc"
        self.layer = combined
        # and some sounds
        self.game.sound.play(self.game.assets.sfx_flyByNoise)
        self.delay(delay=1,handler=self.game.base.play_quote,param=self.game.assets.quote_stampedeWiff)
        self.delay(name="Display", delay=myWait, handler=self.main_display)
Exemplo n.º 54
0
 def display(self):
     self.cancel_delayed("Display")
     backdrop = dmd.FrameLayer(
         opaque=True, frame=self.game.assets.dmd_cactusBorder.frames[0])
     # build and show the display of combos made & left
     combos = self.game.show_tracking('combos')
     # if we've got a chain going, that affects display
     print "CHAIN VALUE: " + str(self.chain)
     if self.chain > 1:
         if ep.last_shot == "center":
             textString = str(self.chain) + "-WAY SUPER COMBO"
             points = 25000 * self.chain
         else:
             textString = str(self.chain) + "-WAY COMBO"
             points = 50000
         textString2 = str(ep.format_score(points)) + " POINTS"
     else:
         textString = "COMBO AWARDED"
         textString2 = str(combos) + " COMBOS"
     textLine1 = ep.EP_TextLayer(64,
                                 3,
                                 self.game.assets.font_5px_bold_AZ,
                                 justify="center",
                                 opaque=False).set_text(textString,
                                                        color=ep.BROWN)
     textLine2 = ep.EP_TextLayer(64,
                                 11,
                                 self.game.assets.font_9px_az,
                                 justify="center",
                                 opaque=False)
     textLine3 = ep.EP_TextLayer(64,
                                 25,
                                 self.game.assets.font_5px_bold_AZ,
                                 justify="center",
                                 opaque=False)
     textLine2.set_text(textString2, blink_frames=10, color=ep.GREEN)
     combosForStar = self.game.user_settings['Gameplay (Feature)'][
         'Combos for Star']
     diff = combosForStar - combos
     if combos > combosForStar:
         comboString = "BADGE COMPLETE!"
     elif combos == combosForStar:
         comboString = "BADGE AWARDED"
     else:
         comboString = str(diff) + " MORE FOR BADGE!"
     textLine3.set_text(comboString, color=ep.BROWN)
     combined = dmd.GroupedLayer(
         128, 32, [backdrop, textLine1, textLine2, textLine3])
     self.layer = combined
     print "I MADE IT THROUGH COMBO DISPLAY"
     self.delay(name="Display", delay=2, handler=self.clear_layer)
Exemplo n.º 55
0
 def score_overlay(self, points, multiplier, textColor):
     # points is the shot value, multiplier is the active combo multiplier
     textLayer = ep.EP_TextLayer(128 / 2,
                                 24,
                                 self.game.assets.font_6px_az_inverse,
                                 "center",
                                 opaque=False)
     string = "< " + str(ep.format_score(points))
     if multiplier > 1:
         string = string + " X " + str(multiplier)
     string = string + " >"
     textLayer.set_text(string, color=textColor)
     self.layer = textLayer
     self.delay("Display", delay=1.5, handler=self.clear_layer)
Exemplo n.º 56
0
    def hit_ringmaster(self):
        print "Hit Ringmaster"
        # stop the timer
        self.cancel_delayed("Mode Timer")
        # stop the movement for now
        self.cancel_delayed("Move Timer")
        # on a hit, increase the value, and add the new value to the total and display the hit
        self.value += self.bump
        # score the points
        self.game.score(self.value)
        self.totalPoints += self.value
        # register the hit
        self.hitsSoFar += 1
        remain = self.hitsToWin - self.hitsSoFar
        if remain <= 0 and not self.won:
            # flag so this only happens once
            self.won = True
            # end this sucker
            self.infoLine.set_text("}}}}", color=ep.MAGENTA)
            self.finish_ringmaster()
        elif remain == 1:
            self.infoLine.set_text("}}}{", color=ep.MAGENTA)
        elif remain == 2:
            self.infoLine.set_text("}}{{", color=ep.MAGENTA)
        elif remain == 3:
            self.infoLine.set_text("}{{{", color=ep.MAGENTA)
        else:
            pass
        self.titleLine.set_text(ep.format_score(self.value), color=ep.CYAN)

        self.modeTimer = 21
        # display the hit
        anim = random.choice(self.hitLayers)
        myWait = len(anim.frames) / 10.0
        animLayer = ep.EP_AnimatedLayer(anim)
        animLayer.hold = True
        animLayer.frame_time = 6
        animLayer.repeat = False
        animLayer.opaque = False
        animLayer.composite_op = "blacksrc"
        mainLayer = self.display_main()
        self.layer = dmd.GroupedLayer(128, 32, [mainLayer, animLayer])
        # play the hit sound
        myWait = self.game.sound.play(self.game.assets.sfx_cvHit)
        self.delay(delay=0.5,
                   handler=self.game.base.priority_quote,
                   param=self.game.assets.quote_cvHit)
        self.delay(delay=0.5, handler=self.game.bart.animate, param=2)
        self.delay(delay=1, handler=self.post_hit)