Beispiel #1
0
 def party_started(self):
     # Turn the music on
     self.music_on("music_party")
     # Show the current party mode activated
     background = dmd.FrameLayer(
         opaque=True, frame=self.game.assets.dmd_starsBorder.frames[0])
     textLayer1 = ep.EP_TextLayer(64,
                                  1,
                                  self.game.assets.font_7px_bold_az,
                                  "center",
                                  opaque=False).set_text("PARTY MODE START",
                                                         color=ep.MAGENTA)
     self.ptextLayer2 = ep.EP_TextLayer(64,
                                        12,
                                        self.game.assets.font_10px_AZ,
                                        "center",
                                        opaque=False).set_text(
                                            self.game.party_setting.upper(),
                                            color=ep.YELLOW)
     instructions = dmd.TextLayer(
         64, 23, self.game.assets.font_5px_AZ,
         "center").set_text("HOLD L. FLIPPER TO CONFIRM")
     instructions2 = dmd.TextLayer(
         64, 23, self.game.assets.font_5px_AZ,
         "center").set_text("HOLD R. FLIPPER TO DISABLE")
     script = []
     script.append({'seconds': 2, 'layer': instructions})
     script.append({'seconds': 2, 'layer': instructions2})
     instruction_duo = dmd.ScriptedLayer(128, 32, script)
     instruction_duo.composite_op = "blacksrc"
     self.layer = dmd.GroupedLayer(
         128, 32,
         [background, textLayer1, self.ptextLayer2, instruction_duo])
     # start a bail delay
     self.reset_party_timeout()
    def bionic_failed(self):
        # Lose the balls during a bionic fight and you lose
        # show some display
        line1 = dmd.TextLayer(64,
                              3,
                              self.game.assets.font_15px_bionic,
                              "center",
                              opaque=True).set_text("FAILED")
        line2 = dmd.TextLayer(64,
                              22,
                              self.game.assets.font_5px_AZ,
                              "center",
                              opaque=False).set_text("BIONIC BART ESCAPED!")
        combined = dmd.GroupedLayer(128, 32, [line1, line2])
        self.layer = combined

        # play the fail quote
        duration = self.game.base.play_quote(
            self.game.assets.quote_failBionicBart)
        # reset all the star status
        self.game.badge.reset()

        self.delay(delay=duration,
                   handler=self.leader_final_quote,
                   param="fail")
 def volume_display(self, volume):
     # cancel any previous delay
     self.cancel_delayed("Volume")
     # start a song if one isn't already playing
     if not self.playing and self.game.base not in self.game.modes:
         self.playing = True
         self.game.sound.play_music(
             self.game.assets.music_shooterLaneGroove, loops=-1)
     # throw some display action
     topLine = dmd.TextLayer(64,
                             3,
                             self.game.assets.font_7px_az,
                             "center",
                             opaque=True)
     string = "VOLUME: " + str(volume)
     topLine.set_text(string)
     volumeLine = dmd.TextLayer(64,
                                13,
                                self.game.assets.font_13px_score,
                                "center",
                                opaque=False)
     volumeString = ""
     while len(volumeString) < volume:
         volumeString += "A"
     while len(volumeString) < 10:
         volumeString += "B"
     volumeString += "C"
     volumeLine.set_text(volumeString)
     self.layer = dmd.GroupedLayer(128, 32, [topLine, volumeLine])
     # set a delay to cancel
     self.delay("Volume", delay=2, handler=self.clear_volume_display)
    def switch_warning(self, switches):
        script = []
        switchCount = len(switches)
        # set up the text layer
        textString = "< CHECK SWITCHES >"
        textLayer = dmd.TextLayer(128 / 2,
                                  24,
                                  self.game.assets.font_6px_az_inverse,
                                  "center",
                                  opaque=False).set_text(textString)
        textLayer.composite_op = 'blacksrc'
        script.append({'seconds': 1.8, 'layer': textLayer})

        # then loop through the bad switches
        for i in range(0, switchCount, 1):
            name = switches[i]['switchName']
            count = switches[i]['count']
            textString = "< " + name + " >"
            textLayer = dmd.TextLayer(128 / 2,
                                      24,
                                      self.game.assets.font_6px_az_inverse,
                                      "center",
                                      opaque=False).set_text(textString)
            textLayer.composite_op = 'blacksrc'
            script.append({'seconds': 1.8, 'layer': textLayer})
        display = dmd.ScriptedLayer(128, 32, script)
        display.composite_op = "blacksrc"
        self.layer = display
 def restart_hold_display(self):
     backdrop = dmd.FrameLayer(
         opaque=True,
         frame=self.game.assets.dmd_mineEntranceBorder.frames[0])
     awardTextTop = dmd.TextLayer(128 / 2,
                                  5,
                                  self.game.assets.font_5px_bold_AZ,
                                  justify="center",
                                  opaque=False)
     awardTextBottom = dmd.TextLayer(128 / 2,
                                     11,
                                     self.game.assets.font_5px_AZ,
                                     justify="center",
                                     opaque=False)
     timeText = dmd.TextLayer(64,
                              17,
                              self.game.assets.font_9px_az,
                              justify="center",
                              opaque=False)
     timeText.composite_op = "blacksrc"
     awardTextTop.set_text("SHOOT THE MINE")
     awardTextBottom.set_text("TO RESTART MULTIBALL")
     textLine = "PAUSED"
     timeText.set_text(textLine, blink_frames=4)
     combined = dmd.GroupedLayer(
         128, 32, [backdrop, awardTextTop, awardTextBottom, timeText])
     self.layer = combined
Beispiel #6
0
 def mine_update(self, hitStatus):
     # award some points ?
     print str(hitStatus) + " shots left to light lock"
     # display a "shots left to light lock type thing
     textLine = str(hitStatus) + " MORE TO"
     textLine2 = "LIGHT LOCK"
     backdrop = dmd.FrameLayer(
         opaque=True,
         frame=self.game.assets.dmd_mineEntranceBorder.frames[0])
     textLayer = dmd.TextLayer(56,
                               2,
                               self.game.assets.font_9px_az,
                               "center",
                               opaque=False).set_text(textLine)
     textLayer2 = dmd.TextLayer(56,
                                13,
                                self.game.assets.font_9px_az,
                                "center",
                                opaque=False).set_text(textLine2)
     textLayer2.composite_op = "blacksrc"
     composite = dmd.GroupedLayer(128, 32,
                                  [backdrop, textLayer, textLayer2])
     self.layer = composite
     # then kick the ball
     self.game.mountain.eject()
     # clear layer in 2
     self.delay(name="Display", delay=2, handler=self.clear_layer)
    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)
 def __init__(self, game, priority, font):
     super(ServiceModeSkeleton, self).__init__(game, priority)
     self.name = ""
     self.title_layer = dmd.TextLayer(1, 1, font, "left")
     self.item_layer = dmd.TextLayer(128 / 2, 12, font, "center")
     self.instruction_layer = dmd.TextLayer(1, 25, font, "left")
     self.layer = dmd.GroupedLayer(
         128, 32,
         [self.title_layer, self.item_layer, self.instruction_layer])
     self.no_exit_switch = game.machine_type == 'sternWhitestar'
    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)
Beispiel #10
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)
 def restarting(self):
     line1 = dmd.TextLayer(128 / 2,
                           3,
                           self.game.assets.font_9px_az,
                           "center",
                           opaque=False).set_text("NEW")
     line2 = dmd.TextLayer(128 / 2,
                           15,
                           self.game.assets.font_9px_az,
                           "center",
                           opaque=False).set_text("GAME")
     self.layer = dmd.GroupedLayer(128, 32, [line1, line2])
     self.game.base.repeat_ding(3)
     self.delay(delay=2, handler=self.clear_layer)
 def sw_coinDoorClosed_inactive(self, sw):
     line1 = dmd.TextLayer(128 / 2,
                           3,
                           self.game.assets.font_7px_az,
                           "center",
                           opaque=True).set_text("COIN DOOR OPEN")
     line2 = dmd.TextLayer(128 / 2,
                           15,
                           self.game.assets.font_7px_az,
                           "center",
                           opaque=False).set_text("HIGH VOLTAGE DISABLED")
     self.layer = dmd.GroupedLayer(128, 32, [line1, line2])
     self.game.base.repeat_ding(3)
     self.delay(delay=3, handler=self.clear_layer)
 def train_disabled(self):
     line1 = dmd.TextLayer(128 / 2,
                           3,
                           self.game.assets.font_9px_az,
                           "center",
                           opaque=False).set_text("TRAIN DISABLED")
     line2 = dmd.TextLayer(128 / 2,
                           15,
                           self.game.assets.font_9px_az,
                           "center",
                           opaque=False).set_text("CHECK ENCODER SWITCH")
     self.layer = dmd.GroupedLayer(128, 32, [line1, line2])
     self.game.base.repeat_ding(3)
     self.delay(delay=2, handler=self.clear_layer)
Beispiel #14
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
Beispiel #15
0
 def shift_right(self):
     ## routine to slide the prize display to the right
     # blank script and a counter
     script = []
     count = 0
     for i in range(4, 20, 4):
         # math out the new origin based on the step
         setX = 126 + i
         # generate the new prize layer with the shifted origin and store it in a list spot
         prizeList = dmd.TextLayer(setX,
                                   1,
                                   self.game.assets.font_skillshot,
                                   "right",
                                   opaque=True).set_text(
                                       self.selectedPrizes)
         # combine with the lasso layer
         combined = dmd.GroupedLayer(128, 32,
                                     [prizeList, self.mask, self.lasso])
         # stick those mothers in a script list
         script.append({'seconds': 0.05, 'layer': combined})
         count += 1
     # delay 0.2 seconds before updating to the 'new' prize list at the post shifted position
     self.delay(delay=0.2, handler=self.update_layer)
     # put the scripted shift in place!
     self.layer = dmd.ScriptedLayer(128, 32, script)
Beispiel #16
0
 def generate_layer(self):
     prizeList = dmd.TextLayer(self.x,
                               1,
                               self.game.assets.font_skillshot,
                               "right",
                               opaque=True).set_text(self.selectedPrizes)
     return dmd.GroupedLayer(128, 32, [prizeList, self.mask, self.lasso])
Beispiel #17
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
Beispiel #18
0
    def update_layer(self):
        """Called by the layer to update the score layer for the present game state."""
        self.layer.layers = []
        if len(self.game.players) <= 1:
            self.update_layer_1p()
        else:
            self.update_layer_4p()
        # Common: Add the "BALL X ... FREE PLAY" footer.
        common = dmd.TextLayer(128 / 2, 32 - 6, self.font_common, "center")

        if self.game.tournament:
            credit_str = 'TOURNAMENT'
        elif self.game.party_setting != 'Disabled':
            credit_str = 'PARTY MODE'
        else:
            credit_str = 'FREE PLAY'

        if self.credit_string_callback:
            credit_str = self.credit_string_callback()
        if self.game.ball == 0:
            common.set_text(credit_str)
        elif len(credit_str) > 0:
            common.set_text("BALL %d      %s" % (self.game.ball, credit_str))
        else:
            common.set_text("BALL %d" % (self.game.ball))
        self.layer.layers += [common]
 def weapon_loaded(self, prompt=False):
     # show some display
     line1 = dmd.TextLayer(64,
                           3,
                           self.game.assets.font_15px_bionic,
                           "center",
                           opaque=True).set_text("LOADED")
     line2 = ep.EP_TextLayer(64,
                             22,
                             self.game.assets.font_5px_AZ,
                             "center",
                             opaque=False).set_text("SHOOT BIONIC BART",
                                                    color=ep.YELLOW)
     combined = dmd.GroupedLayer(128, 32, [line1, line2])
     self.layer = combined
     if prompt:
         duration = self.game.base.play_quote(
             self.game.assets.quote_bionicUrge)
     else:
         duration = self.game.sound.play(
             self.game.assets.sfx_orchestraSpike)
     self.delay(name="Display", delay=1.5, handler=self.update_display)
     if duration < 1.5:
         duration = 1.5
     self.delay(delay=duration, handler=self.game.restore_music)
 def main_display(self):
     scoreLayer = dmd.TextLayer(100,
                                17,
                                self.game.assets.font_marshallScore,
                                "right",
                                opaque=False).set_text(str(self.pointTotal))
     combined = dmd.GroupedLayer(128, 32, [self.backdrop, scoreLayer])
     self.layer = combined
 def restart_option(self):
     # this loops while we wait for a restart, if there is one
     self.restartTimer -= 1
     if self.restartTimer <= 0:
         self.restartFlag = False
         self.end_multiball()
     else:
         if self.restartTimer == 2:
             self.game.sound.play_music(self.game.assets.music_tensePiano2,
                                        loops=-1)
         print "RESTART DISPLAY"
         backdrop = dmd.FrameLayer(
             opaque=True,
             frame=self.game.assets.dmd_mineEntranceBorder.frames[0])
         awardTextTop = dmd.TextLayer(128 / 2,
                                      5,
                                      self.game.assets.font_5px_bold_AZ,
                                      justify="center",
                                      opaque=False)
         awardTextBottom = dmd.TextLayer(128 / 2,
                                         11,
                                         self.game.assets.font_5px_AZ,
                                         justify="center",
                                         opaque=False)
         timeText = dmd.TextLayer(64,
                                  17,
                                  self.game.assets.font_9px_az,
                                  justify="center",
                                  opaque=False)
         timeText.composite_op = "blacksrc"
         awardTextTop.set_text("SHOOT THE MINE")
         awardTextBottom.set_text("TO RESTART MULTIBALL")
         if self.restartTimer == 1:
             textLine = "1 SECOND"
         else:
             textLine = str(self.restartTimer) + " SECONDS"
         timeText.set_text(textLine, blink_frames=4)
         combined = dmd.GroupedLayer(
             128, 32, [backdrop, awardTextTop, awardTextBottom, timeText])
         self.layer = combined
         self.delay(name="Restart Timer",
                    delay=1.0,
                    handler=self.restart_option)
 def ball_added(self):
     textLine = dmd.TextLayer(64,
                              12,
                              self.game.assets.font_9px_AZ_outline,
                              "center",
                              opaque=False).set_text("<BALL> <ADDED>",
                                                     blink_frames=8)
     textLine.composite_op = "blacksrc"
     self.layer = textLine
     self.delay(name="Display", delay=1.5, handler=self.clear_layer)
Beispiel #23
0
 def __init__(self, game, priority, font, name, itemlist):
     super(StatsDisplay, self).__init__(game, priority, font)
     self.name = name
     self.value_layer = dmd.TextLayer(128 / 2, 22, font, "center")
     self.items = []
     #print itemlist
     for item in sorted(itemlist.iterkeys()):
         self.items.append(StatsItem(str(item), itemlist[item]))
     self.layer = dmd.GroupedLayer(
         128, 32, [self.title_layer, self.item_layer, self.value_layer])
Beispiel #24
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)
Beispiel #25
0
 def update_layer_1p(self):
     if self.game.current_player() == None:
         score = 0  # Small hack to make *something* show up on startup.
     else:
         score = self.game.current_player().score
     layer = dmd.TextLayer(128 / 2, 5, self.font_for_score_single(score),
                           "center")
     layer.set_text(self.format_score(score))
     self.layer.layers += [layer]
     ## add the burn layer
     self.layer.layers += [self.burnLayer1p]
 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
 def bumpers_increased(self, value):
     backdrop = dmd.FrameLayer(
         opaque=True,
         frame=self.game.assets.dmd_singleCactusBorder.frames[0])
     topLine = dmd.TextLayer(60,
                             1,
                             self.game.assets.font_5px_AZ,
                             "center",
                             opaque=False).set_text("JET BUMPERS VALUE")
     increasedLine1 = dmd.TextLayer(60,
                                    8,
                                    self.game.assets.font_12px_az,
                                    "center",
                                    opaque=False).set_text("INCREASED")
     increasedLine2 = dmd.TextLayer(60,
                                    8,
                                    self.game.assets.font_15px_az_outline,
                                    "center",
                                    opaque=False)
     increasedLine1.composite_op = "blacksrc"
     increasedLine2.composite_op = "blacksrc"
     increasedLine2.set_text("INCREASED")
     pointsLine = dmd.TextLayer(60,
                                18,
                                self.game.assets.font_12px_az_outline,
                                "center",
                                opaque=False)
     pointsLine.composite_op = "blacksrc"
     pointsLine.set_text(str(ep.format_score(value)))
     script = []
     layer1 = dmd.GroupedLayer(
         128, 32, [backdrop, topLine, increasedLine1, pointsLine])
     layer2 = dmd.GroupedLayer(
         128, 32, [backdrop, topLine, pointsLine, increasedLine2])
     script.append({'seconds': 0.3, 'layer': layer1})
     script.append({'seconds': 0.3, 'layer': layer2})
     self.game.base.play_quote(self.game.assets.quote_yippie)
     self.layer = dmd.ScriptedLayer(128, 32, script)
     self.delay("Display", delay=2, handler=self.clear_layer)
Beispiel #28
0
 def __init__(self, font, font_path, text):
     super(DmdFontWidthsGame, self).__init__(pinproc.MachineTypeCustom)
     self.reset()
     w = 128
     h = 32
     self.font = font
     self.font_path = font_path
     self.text = text
     self.text_layer = dmd.TextLayer(0, 0, font)
     self.text_layer.set_text(text)
     mode = game.Mode(game=self, priority=9)
     mode.layer = dmd.GroupedLayer(
         w, h, [dmd.FrameLayer(frame=dmd.Frame(w, h)), self.text_layer])
     self.modes.add(mode)
     self.dirty = False
Beispiel #29
0
 def __init__(self, game, priority, font, name, itemlist):
     super(SettingsEditor, self).__init__(game, priority, font)
     self.title_layer = dmd.TextLayer(1, 1, font, "left")
     self.item_layer = dmd.TextLayer(128 / 2, 12, font, "center")
     self.instruction_layer = dmd.TextLayer(1, 25, font, "left")
     self.no_exit_switch = game.machine_type == 'sternWhitestar'
     #self.title_layer.set_text('Settings')
     self.name = name
     self.items = []
     self.value_layer = dmd.TextLayer(128 / 2, 19, font, "center")
     self.layer = dmd.GroupedLayer(128, 32, [
         self.title_layer, self.item_layer, self.value_layer,
         self.instruction_layer
     ])
     for item in sorted(itemlist.iterkeys()):
         #self.items.append( EditItem(str(item), itemlist[item]['options'], itemlist[item]['value'] ) )
         if 'increments' in itemlist[item]:
             num_options = (itemlist[item]['options'][1] -
                            itemlist[item]['options'][0]
                            ) / itemlist[item]['increments']
             option_list = []
             for i in range(0, num_options):
                 option_list.append(itemlist[item]['options'][0] +
                                    (i * itemlist[item]['increments']))
             self.items.append(
                 EditItem(str(item), option_list,
                          self.game.user_settings[self.name][item]))
         else:
             self.items.append(
                 EditItem(str(item), itemlist[item]['options'],
                          self.game.user_settings[self.name][item]))
     self.state = 'nav'
     self.stop_blinking = True
     self.item = self.items[0]
     self.value_layer.set_text(str(self.item.value))
     self.option_index = self.item.options.index(self.item.value)
 def high_noon_lit(self):
     line1 = dmd.TextLayer(64,
                           3,
                           self.game.assets.font_15px_bionic,
                           "center",
                           opaque=True).set_text("HIGH NOON LIT")
     line2 = ep.EP_TextLayer(64,
                             22,
                             self.game.assets.font_5px_AZ,
                             "center",
                             opaque=False).set_text("SHOOT THE MINE!",
                                                    color=ep.ORANGE)
     combined = dmd.GroupedLayer(128, 32, [line1, line2])
     self.layer = combined
     self.repeat_ding(3)
     self.delay(delay=1.2, handler=self.finish_up)