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 __init__(self,game,priority):
super(BankRobbery, self).__init__(game,priority)
self.myID = "Bank Robbery"
self.position = [-49,-4,43]
self.y_pos = 7
self.isActive = [True,True,True]
self.shots = [self.game.left_ramp,self.game.center_ramp,self.game.right_ramp]
self.won = False
self.flashers = [self.game.coils.backLeftFlasher,self.game.coils.backRightFlasher,self.game.coils.middleRightFlasher]
script = []
# set up the text layer
textString = "< SAVE POLLY PAUSED >"
textLayer = ep.EP_TextLayer(128/2, 24, self.game.assets.font_6px_az_inverse, "center", opaque=False).set_text(textString,color=ep.PURPLE)
script.append({'seconds':0.3,'layer':textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds':0.3,'layer':blank})
# make a script layer with the two
self.pauseView = dmd.ScriptedLayer(128,32,script)
self.pauseView.composite_op = "blacksrc"
self.keys_index = {'start':list(range(len(self.game.sound.sounds[self.game.assets.quote_hatbIntro])))}
self.counts_index = {'start':0}
random.shuffle(self.keys_index['start'])
self.valueMultiplier = 1 # shot value multiplier
def __init__(self, game, priority):
super(TAF_Tribute, self).__init__(game, priority)
self.myID = "TAF Tribute"
# switch value to raise if it gets hit
self.bump = 25000
# for timer halting in saloon/jets
self.halted = False
self.running = False
script = []
# set up the pause text layer
textString = "< COUSIN IT PAUSED >"
textLayer = ep.EP_TextLayer(128 / 2,
24,
self.game.assets.font_6px_az_inverse,
"center",
opaque=False).set_text(textString,
color=ep.GREEN)
script.append({'seconds': 0.3, 'layer': textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False,
frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds': 0.3, 'layer': blank})
# make a script layer with the two
self.pauseView = dmd.ScriptedLayer(128, 32, script)
self.pauseView.composite_op = "blacksrc"
self.misses = [
self.game.assets.dmd_tafItMiss1, self.game.assets.dmd_tafItMiss2
]
self.mumbles = [
self.game.assets.sfx_tafIt1, self.game.assets.sfx_tafIt2,
self.game.assets.sfx_tafIt3, self.game.assets.sfx_tafIt4
]
def drone_added_display(self, drone):
# layer without the new drone
layers_off = []
layers_on = []
for n in range(0, 4, 1):
# if the drone is lit
if self.drone_tracking[n]:
# if it matches the one that just got added, its in the on list
if n == drone:
layers_on.append(self.drone_layers[n])
# otherwise it's in both
else:
layers_on.append(self.drone_layers[n])
layers_off.append(self.drone_layers[n])
self.text.set_text("DRONE ADDED")
layers_off.append(self.text)
layers_on.append(self.text)
off = dmd.GroupedLayer(1920, 800, layers_off)
on = dmd.GroupedLayer(1920, 800, layers_on)
self.layer = dmd.ScriptedLayer(1920,
800, [{
'layer': off,
'seconds': 0.2
}, {
'layer': on,
'seconds': 0.2
}],
opaque=True)
self.delay("clear", delay=2, handler=self.clear_layer)
# play the quote for adding the drone
self.game.sound.play_voice('drone_added',
action=procgame.sound.PLAY_FORCE)
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)
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 __init__(self, game, priority):
super(CV_Tribute, self).__init__(game, priority)
self.myID = "CV Tribute"
# for timer halting in saloon/jets
self.halted = False
self.running = False
self.hitsToWin = 4
script = []
# set up the pause text layer
textString = "< RINGMASTER PAUSED >"
textLayer = ep.EP_TextLayer(128 / 2,
24,
self.game.assets.font_6px_az_inverse,
"center",
opaque=False).set_text(textString,
color=ep.GREEN)
script.append({'seconds': 0.3, 'layer': textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False,
frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds': 0.3, 'layer': blank})
# make a script layer with the two
self.pauseView = dmd.ScriptedLayer(128, 32, script)
self.pauseView.composite_op = "blacksrc"
self.titleLine = ep.EP_TextLayer(
64,
1,
self.game.assets.font_5px_bold_AZ_outline,
"center",
opaque=False)
self.titleLine.composite_op = "blacksrc"
self.titleLine.set_text("HIT THE RINGMASTER", color=ep.MAGENTA)
self.leftTimerLine = ep.EP_TextLayer(
0, 1, self.game.assets.font_5px_bold_AZ_outline, "left", False)
self.leftTimerLine.composite_op = "blacksrc"
self.rightTimerLine = ep.EP_TextLayer(
128, 1, self.game.assets.font_5px_bold_AZ_outline, "right", False)
self.rightTimerLine.composite_op = "blacksrc"
self.scoreLine = ep.EP_TextLayer(64,
7,
self.game.assets.font_12px_az_outline,
"center",
opaque=False)
self.scoreLine.composite_op = "blacksrc"
self.infoLine = ep.EP_TextLayer(64,
23,
self.game.assets.font_7px_az,
"center",
opaque=False)
self.infoLine.set_text("{{{{", color=ep.MAGENTA)
self.infoLine.composite_op = "blacksrc"
self.hitLayers = [
self.game.assets.dmd_cvBurst1, self.game.assets.dmd_cvBurst2,
self.game.assets.dmd_cvBurst3
]
def intro_display(self,step=1):
## show some junk about how the mode works
if step == 1:
flippers = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_flippers1.frames[0])
arrow = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_flippers1.frames[0])
elif step == 2 or step == 4 or step == 6 or step == 8 or step == 10:
flippers = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_flippers2.frames[0])
arrowOne = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_rightArrow1.frames[0])
arrowTwo = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_rightArrow2.frames[0])
arrowThree = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_rightArrow3.frames[0])
arrow = dmd.ScriptedLayer(128,32,[{'seconds':0.15,'layer':arrowOne},{'seconds':0.15,'layer':arrowTwo},{'seconds':0.15,'layer':arrowThree}])
arrow.composite_op = "blacksrc"
elif step == 3 or step == 5 or step == 7 or step == 9:
flippers = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_flippers3.frames[0])
arrowOne = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_leftArrow1.frames[0])
arrowTwo = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_leftArrow2.frames[0])
arrowThree = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_leftArrow3.frames[0])
arrow = dmd.ScriptedLayer(128,32,[{'seconds':0.15,'layer':arrowOne},{'seconds':0.15,'layer':arrowTwo},{'seconds':0.15,'layer':arrowThree}])
arrow.composite_op = "blacksrc"
else:
# just to make the syntax checking happy
flippers = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_flippers1.frames[0])
arrow = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_flippers1.frames[0])
flippers.composite_op = "blacksrc"
text = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_reverse.frames[0])
if step == 2:
self.game.base.play_quote(self.game.assets.quote_drunkNeverSeen)
if step == 1:
combined = dmd.GroupedLayer(128,32,[text,flippers])
elif step == 2 or step == 3:
combined = dmd.GroupedLayer(128,32,[text,flippers,arrow])
else:
combined = dmd.GroupedLayer(128,32,[self.underLayer,flippers,arrow])
self.layer=combined
if step <= 5:
self.delay("Operational",delay=1,handler=self.intro_display,param=step+1)
else:
self.delay("Operational",delay=1,handler=self.get_going)
def attract_display(self):
# Banner for attract mode to alert that party mode is on
script = []
# set up the text layer
textString = "< PARTY MODE ENABLED >"
textLayer = ep.EP_TextLayer(64,
0,
self.game.assets.font_6px_az_inverse,
"center",
opaque=False).set_text(textString,
color=ep.MAGENTA)
script.append({'seconds': 1.0, 'layer': textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False,
frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds': 0.5, 'layer': blank})
# set up the type of mode text
if self.game.party_setting == 'Flip Ct':
textString1 = "< LIMITED FLIPS - " + self.game.user_settings[
'Gameplay (Feature)']['Party - Flip Count'] + " >"
elif self.game.party_setting == 'Drunk':
textString1 = "< DRUNK - FLIPS REVERSED >"
# newbie mode - both flippers all the time
elif self.game.party_setting == 'Newbie':
textString1 = "< NEWBIE - BOTH FLIP >"
# lights out mode
elif self.game.party_setting == 'Lights Out':
textString1 = "< LIGHTS OUT >"
# spiked beer
elif self.game.party_setting == 'Spiked':
textString1 = "< SPIKED - BEER TILTS >"
# rectify
elif self.game.party_setting == 'Rectify':
textString1 = "< RECTIFY - NO DUB FLIP >"
# last case is release to flip
else:
textString1 = "< RELEASE TO FLIP >"
textLayer1 = ep.EP_TextLayer(64,
0,
self.game.assets.font_6px_az_inverse,
"center",
opaque=False).set_text(textString1,
color=ep.MAGENTA)
script.append({'seconds': 1.0, 'layer': textLayer1})
# and another blank
script.append({'seconds': 0.5, 'layer': blank})
# make a script layer with the two
infoLine = dmd.ScriptedLayer(128, 32, script)
infoLine.composite_op = "blacksrc"
self.layer = infoLine
def __init__(self,game):
super(Jericho, self).__init__(game=game, priority=52,mode_type=AdvancedMode.Manual)
self.myID = "Jericho"
self.running = False
## Main display bits
title = dmd.HDTextLayer(1920/2,10,self.game.fonts['default'],"center",line_color=(0,0,0),line_width=4,interior_color=(192,192,192))
title.set_text("JERICHO")
shoot = dmd.HDTextLayer(1920/2,200,self.game.fonts['default'],"center",line_color=(0,0,0),line_width=4,interior_color=(192,192,192))
shoot.set_text("SHOOT")
self.im_text_layer = dmd.HDTextLayer(1920/2,400,self.game.fonts['default'],"center",line_color=(0,0,0),line_width=4,interior_color=(192,192,192))
self.im_text_layer.set_text("IRONMAN TARGETS")
self.wl_text_layer = dmd.HDTextLayer(1920/2,400,self.game.fonts['default'],"center",line_color=(0,0,0),line_width=4,interior_color=(192,192,192))
self.wl_text_layer.set_text("WHIPLASH")
self.m_text_layer = dmd.HDTextLayer(1920/2,400,self.game.fonts['default'],"center",line_color=(0,0,0),line_width=4,interior_color=(192,192,192))
self.m_text_layer.set_text("IRON MONGER")
self.wm_text_layer = dmd.HDTextLayer(1920/2,400,self.game.fonts['default'],"center",line_color=(0,0,0),line_width=4,interior_color=(192,192,192))
self.wm_text_layer.set_text("WAR MACHINE")
self.b_text_layer = dmd.HDTextLayer(1920/2,400,self.game.fonts['default'],"center",line_color=(0,0,0),line_width=4,interior_color=(192,192,192))
self.b_text_layer.set_text("BOGEY RAMPS")
self.s_text_layer = dmd.HDTextLayer(1920/2,400,self.game.fonts['default'],"center",line_color=(0,0,0),line_width=4,interior_color=(192,192,192))
self.s_text_layer.set_text("SHIELD LANES")
self.info_lines = [self.im_text_layer,self.wl_text_layer,self.m_text_layer,self.wm_text_layer,self.b_text_layer,self.s_text_layer]
script = [{'layer':self.im_text_layer,'seconds':2},
{'layer':self.wl_text_layer,'seconds':2},
{'layer':self.m_text_layer,'seconds':2},
{'layer':self.wm_text_layer,'seconds':2},
{'layer':self.b_text_layer,'seconds':2},
{'layer':self.s_text_layer, 'seconds':2}]
self.info_line_layer = dmd.ScriptedLayer(1920,800,script)
self.shot_value_layer = dmd.HDTextLayer(1920/2,600,self.game.fonts['default'],"center",line_color=(0,0,0),line_width=4,interior_color=(192,192,192))
self.main_display = dmd.GroupedLayer(1920,800,[title,shoot,self.info_line,self.shot_value_layer],opaque = True)
# Intro display bits
start_title = dmd.HDTextLayer(1920 / 2, 10, self.game.fonts['default'], "center", line_color=(0, 0, 0), line_width=4,interior_color=(192, 192, 192))
start_title.set_text("COMPLETE")
start_for = dmd.HDTextLayer(1920 / 2, 400, self.game.fonts['default'], "center", line_color=(0, 0, 0), line_width=4,interior_color=(192, 192, 192))
start_for.set_text("FOR")
start_points = dmd.HDTextLayer(1920 / 2, 600, self.game.fonts['default'], "center", line_color=(0, 0, 0), line_width=4,interior_color=(192, 192, 192))
start_points.set.text("1,000,000 + ")
self.start_info = dmd.HDTextLayer(1920 / 2, 200, self.game.fonts['default'], "center", line_color=(0, 0, 0), line_width=4,interior_color=(192, 192, 192))
self.start_layer = dmd.GroupedLayer(1920,800,[start_title,start_for,start_points,self.start_info],opaque = True)
start_strings = ["IRONMAN TARGETS", "WAR MACHINE", "WHIPLASH", "IRON MONGER", "BOGEY RAMPS", "SHIELD LANES"]
# title display
card_top = dmd.HDTextLayer(1920 / 2, 10, self.game.fonts['main_score'], "center", line_color=(0, 0, 0), line_width=4,interior_color=(192, 192, 192))
card_top.set_text("JERICHO")
card_bottom = dmd.HDTextLayer(1920 / 2, 400, self.game.fonts['bebas200'], "center", line_color=(0, 0, 0), line_width=4,interior_color=(192, 192, 192))
card_bottom.set_text("MISSILE MAYHEM")
self.title_card = dmd.GroupedLayer(1920,800,[card_top, card_bottom],opaque = True)
# various hit displays - each needs a background?
self.hit_score_layer = dmd.HDTextLayer(1920/2,200,self.game.fonts['main_score'],"center",line_color=(0,0,0),line_width=6,interior_color=(224,224,0))
self.im_hit_layer = dmd.GroupedLayer(1920,800,[self.hit_score_layer],opaque = True)
def mode_started(self):
self.starting = False
self.ending = False
self.startValue = 200000
self.showDub = False
# reload the basemodes for switch help
self.game.base.load_modes()
# kill any extra balls
self.game.set_tracking('extraBallsPending', 0)
# kill the bozo ball if it was on
self.game.set_tracking('bozoBall', False)
self.running = True
# set up the info layer
infoLine1 = ep.EP_TextLayer(128 / 2,
16,
self.game.assets.font_5px_AZ,
"center",
opaque=False).set_text(
"BEER MUG RAISES JACKPOTS",
color=ep.YELLOW)
infoLine2 = ep.EP_TextLayer(128 / 2,
16,
self.game.assets.font_5px_AZ,
"center",
opaque=False).set_text(
"SALOON RESETS JACKPOTS",
color=ep.ORANGE)
infoLine3 = ep.EP_TextLayer(128 / 2,
16,
self.game.assets.font_5px_AZ,
"center",
opaque=False).set_text(
"CENTER RAMP 2X WHEN LIT",
color=ep.MAGENTA)
self.infoLayer = dmd.ScriptedLayer(128, 32, [{
'seconds': 2,
'layer': infoLine1
}, {
'seconds': 2,
'layer': infoLine2
}, {
'seconds': 2,
'layer': infoLine3
}])
self.infoLayer.composite_op = "blacksrc"
self.double = False
# turn on the GI in case of a 3rd ball tilt
self.game.gi_control("ON")
def new_rack_pan(self):
# turn the GI back on here
self.game.gi_control("ON")
# setup the pan script
script =[]
for i in range(0,-52,-1):
showdownStill = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_townPan.frames[0])
showdownStill.set_target_position(0,i)
if i == -51:
time = 1
else:
time = 0.015
script.append({'seconds':time,'layer':showdownStill})
showdownPan = dmd.ScriptedLayer(128,32,script)
self.layer = showdownPan
self.delay("Operational",delay=1.5,handler=self.new_rack_display)
def display(self, step=1):
# banner to announce is first
if step == 1:
textLine1 = ep.EP_TextLayer(64, 0,
self.game.assets.font_12px_az_outline,
"center")
textLine2 = ep.EP_TextLayer(64, 15,
self.game.assets.font_12px_az_outline,
"center")
textLine1.composite_op = "blacksrc"
textLine2.composite_op = "blacksrc"
textLine1.set_text("DOUBLE", color=ep.BLUE)
textLine2.set_text("SCORING")
combined1 = dmd.GroupedLayer(128, 32, [textLine1, textLine2])
combined1.composite_op = "blacksrc"
textLine3 = ep.EP_TextLayer(64, 0,
self.game.assets.font_12px_az_outline,
"center")
textLine4 = ep.EP_TextLayer(64, 15,
self.game.assets.font_12px_az_outline,
"center")
textLine3.composite_op = "blacksrc"
textLine4.composite_op = "blacksrc"
textLine3.set_text("DOUBLE")
textLine4.set_text("SCORING", color=ep.BLUE)
combined2 = dmd.GroupedLayer(128, 32, [textLine3, textLine4])
combined2.composite_op = "blacksrc"
finalproduct = dmd.ScriptedLayer(128, 32, [{
'seconds': 0.2,
'layer': combined1
}, {
'seconds': 0.2,
'layer': combined2
}])
finalproduct.composite_op = "blacksrc"
self.layer = finalproduct
# Delay the change to the simple 2x bar
self.delay("Operational", delay=2, handler=self.display, param=2)
# step 2 puts up a smaller overlay to indicate 2x
if step == 2:
textLine1 = ep.EP_TextLayer(
64, -1, self.game.assets.font_5px_bold_AZ_outline, "center")
textLine1.composite_op = "blacksrc"
textLine1.set_text(
"2X 2X",
color=ep.BLUE)
self.layer = textLine1
def __init__(self, game, priority):
super(MM_Tribute, self).__init__(game, priority)
self.myID = "MM Tribute"
self.halted = False
self.running = False
self.hitsToWin = 3
self.won = False
self.tauntTimer = 8
script = []
# set up the pause text layer
textString = "< TROLLS PAUSED >"
textLayer = ep.EP_TextLayer(128 / 2,
24,
self.game.assets.font_6px_az_inverse,
"center",
opaque=False).set_text(textString,
color=ep.GREEN)
script.append({'seconds': 0.3, 'layer': textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False,
frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds': 0.3, 'layer': blank})
# make a script layer with the two
self.pauseView = dmd.ScriptedLayer(128, 32, script)
self.pauseView.composite_op = "blacksrc"
self.leftTaunts = [
self.game.assets.quote_mmLT1, self.game.assets.quote_mmLT2,
self.game.assets.quote_mmLT3, self.game.assets.quote_mmLT4,
self.game.assets.quote_mmLT5, self.game.assets.quote_mmLT6
]
self.rightTaunts = [
self.game.assets.quote_mmRT1, self.game.assets.quote_mmRT2,
self.game.assets.quote_mmRT3, self.game.assets.quote_mmRT4,
self.game.assets.quote_mmRT5, self.game.assets.quote_mmRT6
]
self.leftSoloTaunts = [
self.game.assets.quote_mmLTS1, self.game.assets.quote_mmLTS2,
self.game.assets.quote_mmLTS3, self.game.assets.quote_mmLTS4,
self.game.assets.quote_mmLTS5, self.game.assets.quote_mmLTS6
]
self.rightSoloTaunts = [
self.game.assets.quote_mmRTS1, self.game.assets.quote_mmRTS2,
self.game.assets.quote_mmRTS3, self.game.assets.quote_mmRTS4,
self.game.assets.quote_mmRTS5, self.game.assets.quote_mmRTS6
]
def __init__(self, game, priority):
super(Quickdraw, self).__init__(game, priority)
self.myID = "QuickDraw"
# default
self.side = 0
self.target = 0
# build the pause view
script = []
# set up the text layer
textString = "< QUICKDRAW PAUSED >"
textLayer = ep.EP_TextLayer(128 / 2,
24,
self.game.assets.font_6px_az_inverse,
"center",
opaque=False).set_text(textString,
color=ep.YELLOW)
script.append({'seconds': 0.3, 'layer': textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False,
frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds': 0.3, 'layer': blank})
# make a script layer with the two
self.pauseView = dmd.ScriptedLayer(128, 32, script)
self.pauseView.composite_op = "blacksrc"
self.eb_wins = self.game.user_settings['Gameplay (Feature)'][
'Quickdraw Wins for EB']
self.taunting = False
self.keys_index = {
'taunt':
list(
range(
len(self.game.sound.sounds[
self.game.assets.quote_quickdrawTaunt]))),
'hit':
list(
range(
len(self.game.sound.sounds[
self.game.assets.quote_quickdrawWin])))
}
self.counts_index = {'taunt': 0, 'hit': 0}
random.shuffle(self.keys_index['hit'])
random.shuffle(self.keys_index['taunt'])
self.running = False
self.paused = False
def display_player_number(self, idle=False):
# if the skillshot display is busy, we don't trample on it
if not self.game.skill_shot.busy:
# for when the ball is sitting in the shooter lane with nothing going on
myNumber = ("ONE", "TWO", "THREE", "FOUR")
# get the current player
p = self.game.current_player_index
# set up the text
textString = "PLAYER> " + myNumber[p]
textLayer = ep.EP_TextLayer(128 / 2,
7,
self.game.assets.font_12px_az_outline,
"center",
opaque=False)
textLayer.composite_op = "blacksrc"
textLayer.set_text(textString)
script = [{
'seconds': 0.3,
'layer': textLayer
}, {
'seconds': 0.3,
'layer': None
}]
display = dmd.ScriptedLayer(128, 32, script)
display.composite_op = "blacksrc"
# turn the display on
self.layer = display
# every fifth time razz them
if self.rotator[0]:
self.game.base.play_quote(
self.game.assets.quote_dontJustStandThere)
# then stick the current value on the end
foo = self.rotator.pop(0)
self.rotator.append(foo)
## then shift 0 to the end
self.delay(name="Display", delay=1.5, handler=self.clear_layer)
# with an idle call, set a repeat
if idle:
self.idle = True
self.delay(name="idle",
delay=15,
handler=self.display_player_number,
param=True)
def intro_banner(self):
# play the sound
self.game.base.priority_quote(self.game.assets.quote_multiball)
# generate a flashing thing
inverse = dmd.FrameLayer(
True, frame=self.game.assets.dmd_multiballBannerInverse.frames[0])
normal = dmd.FrameLayer(
opaque=True, frame=self.game.assets.dmd_multiballBanner.frames[0])
script = [{
'seconds': 0.1,
'layer': inverse
}, {
'seconds': 0.1,
'layer': normal
}]
myLayer = dmd.ScriptedLayer(128, 32, script)
self.layer = myLayer
# show it for a bit - then move on
self.delay(delay=1.5, handler=self.get_going)
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)
def __init__(self, game, priority):
super(RiverChase, self).__init__(game, priority)
self.myID = "River Chase"
self.shotsToWin = self.game.user_settings['Gameplay (Feature)'][
'Save Polly Shots - River']
self.shotsSoFar = 0
self.running = False
self.halted = False
self.won = False
self.distance_value = int(30.0 / self.shotsToWin)
self.valueMultiplier = 1 # shot value multiplier
script = []
# set up the text layer
textString = "< SAVE POLLY PAUSED >"
textLayer = ep.EP_TextLayer(128 / 2,
24,
self.game.assets.font_6px_az_inverse,
"center",
opaque=False).set_text(textString,
color=ep.BLUE)
script.append({'seconds': 0.3, 'layer': textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False,
frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds': 0.3, 'layer': blank})
# make a script layer with the two
self.pauseView = dmd.ScriptedLayer(128, 32, script)
self.pauseView.composite_op = "blacksrc"
self.keys_index = {
'start':
list(
range(
len(self.game.sound.sounds[
self.game.assets.quote_rotrIntro])))
}
self.counts_index = {'start': 0}
random.shuffle(self.keys_index['start'])
def letter_hit(self):
if self.letters < 10:
# stop any display delays
self.cancel_delayed("display")
self.letters += 1
points = self.letters * 10000
# do the display
self.points_layer.set_text(
self.game.score_display.format_score(points))
layer1 = dmd.GroupedLayer(
1920, 800, [self.logo_layers[self.letters], self.points_layer])
self.layer = dmd.ScriptedLayer(
1920,
800, [{
'layer': layer1,
'seconds': 0.2
}, {
'layer': self.logo_layers[self.letters - 1],
'seconds': 0.2
}],
opaque=True)
# if complete follow up with ready message
if self.letters == 10:
self.delay("display",
delay=1.0,
handler=self.monger_ready_display)
self.status = "READY"
# set a clear delay
else:
self.delay("display", delay=1.3, handler=self.clear_layer)
# score the points
self.game.score(points)
# play a delayed quote
self.delay(delay=2, handler=self.spinner_script_quote)
# if we're already at 10 letters raise the monger
self.update_lamps()
# update the recon info
self.game.score_display.update_recon_monger()
def __init__(self,game,priority):
super(SS_Tribute, self).__init__(game,priority)
self.myID = "SS Tribute"
# for timer halting in saloon/jets
self.halted = False
self.running = False
self.hitsToWin = 4
self.hitsSoFar = 0
self.beerHit = False
self.won = False
script = []
# set up the pause text layer
textString = "< LEAPERS PAUSED >"
textLayer = ep.EP_TextLayer(128/2, 24, self.game.assets.font_6px_az_inverse, "center", opaque=False).set_text(textString,color=ep.ORANGE)
script.append({'seconds':0.3,'layer':textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds':0.3,'layer':blank})
# make a script layer with the two
self.pauseView = dmd.ScriptedLayer(128,32,script)
self.pauseView.composite_op = "blacksrc"
self.titleLine = ep.EP_TextLayer(64,0,self.game.assets.font_7px_bold_az, "center", opaque=True).set_text("LEAPER MANIA",color=ep.GREEN)
self.leftTimerLine = ep.EP_TextLayer(0,26,self.game.assets.font_5px_AZ, "left",False)
self.rightTimerLine = ep.EP_TextLayer(128,26,self.game.assets.font_5px_AZ,"right",False)
self.scoreLine = ep.EP_TextLayer(64,8,self.game.assets.font_9px_az,"center",opaque=False)
self.infoLine = ep.EP_TextLayer(0,1,self.game.assets.font_5px_AZ,"center", opaque=False)
# offset position for the frog layers based on index position
self.offsets = [0,-9,-18,-28]
self.keys_index = {'hit':list(range(len(self.game.sound.sounds[self.game.assets.quote_ssHit]))),
'urge':list(range(len(self.game.sound.sounds[self.game.assets.quote_ssUrge])))}
self.counts_index = {'hit':0,
'urge':0}
random.shuffle(self.keys_index['hit'])
random.shuffle(self.keys_index['urge'])
def __init__(self, game):
super(Bogey, self).__init__(game=game,
priority=12,
mode_type=AdvancedMode.Manual)
self.myID = "Bogey"
self.running = False
self.bogey_lamps = [
self.game.lamps['leftRamp100k'], self.game.lamps['leftRamp200k'],
self.game.lamps['leftRamp300k'], self.game.lamps['leftRamp400k'],
self.game.lamps['rightRamp100k'], self.game.lamps['rightRamp200k'],
self.game.lamps['rightRamp300k'], self.game.lamps['rightRamp400k'],
self.game.lamps['leftOrbitArrow'],
self.game.lamps['leftRampArrow'],
self.game.lamps['rightRampArrow'],
self.game.lamps['rightOrbitArrow']
]
self.bogey_clips = [
'bogey_hit_1',
'bogey_hit_2',
'bogey_hit_3',
'bogey_hit_4',
'bogey_hit_5',
'bogey_hit_6',
'bogey_hit_7',
'bogey_hit_8',
'bogey_hit_9',
'bogey_hit_10',
'bogey_hit_11',
'bogey_hit_12',
'bogey_hit_13',
'bogey_hit_14',
'bogey_hit_15',
'bogey_hit_16',
'bogey_hit_17',
'bogey_hit_18',
'bogey_hit_19',
]
back = dmd.FrameLayer(
opaque=True,
frame=self.game.animations['bogey_backdrop'].frames[0])
top1 = dmd.HDTextLayer(930,
110,
self.game.fonts['bebas180'],
"center",
line_color=[64, 64, 64],
line_width=6,
interior_color=[192, 192, 192])
top1.set_text("WE'VE")
top2 = dmd.HDTextLayer(930,
285,
self.game.fonts['bebas180'],
"center",
line_color=[64, 64, 64],
line_width=6,
interior_color=[192, 192, 192])
top2.set_text("GOT A")
top3 = dmd.HDTextLayer(930,
460,
self.game.fonts['bebas180'],
"center",
line_color=[64, 64, 64],
line_width=6,
interior_color=[192, 192, 192])
top3.set_text("BOGEY")
self.timer_layer = dmd.HDTextLayer(1800,
110,
self.game.fonts['bebas500'],
"right",
line_color=[64, 64, 64],
line_width=4,
interior_color=[192, 192, 192])
bottom1 = dmd.HDTextLayer(930,
110,
self.game.fonts['bebas180'],
"center",
line_color=[64, 0, 0],
line_width=6,
interior_color=[192, 0, 0])
bottom1.set_text("SHOOT")
bottom2 = dmd.HDTextLayer(930,
285,
self.game.fonts['bebas180'],
"center",
line_color=[64, 0, 0],
line_width=6,
interior_color=[192, 0, 0])
bottom2.set_text("LIT")
bottom3 = dmd.HDTextLayer(930,
460,
self.game.fonts['bebas180'],
"center",
line_color=[64, 0, 0],
line_width=6,
interior_color=[192, 0, 0])
bottom3.set_text("ARROWS")
page1 = dmd.GroupedLayer(1920, 800,
[back, top1, top2, top3, self.timer_layer])
page2 = dmd.GroupedLayer(1920, 800,
[back, top2, top3, self.timer_layer])
page3 = dmd.GroupedLayer(1920, 800, [back, top3, self.timer_layer])
page4 = dmd.GroupedLayer(1920, 800, [back, self.timer_layer])
page5 = dmd.GroupedLayer(1920, 800, [back, bottom1, self.timer_layer])
page6 = dmd.GroupedLayer(1920, 800,
[back, bottom1, bottom2, self.timer_layer])
page7 = dmd.GroupedLayer(
1920, 800, [back, bottom1, bottom2, bottom3, self.timer_layer])
page8 = dmd.GroupedLayer(1920, 800,
[back, bottom2, bottom3, self.timer_layer])
page9 = dmd.GroupedLayer(1920, 800, [back, bottom3, self.timer_layer])
page10 = dmd.GroupedLayer(1920, 800, [back, top1, self.timer_layer])
page11 = dmd.GroupedLayer(1920, 800,
[back, top1, top2, self.timer_layer])
self.main_layer = dmd.ScriptedLayer(1920, 800, [{
'seconds': 1,
'layer': page1
}, {
'seconds': 0.2,
'layer': page2
}, {
'seconds': 0.2,
'layer': page3
}, {
'seconds': 0.5,
'layer': page4
}, {
'seconds': 0.2,
'layer': page5
}, {
'seconds': 0.2,
'layer': page6
}, {
'seconds': 1,
'layer': page7
}, {
'seconds': 0.2,
'layer': page8
}, {
'seconds': 0.2,
'layer': page9
}, {
'seconds': 0.5,
'layer': page4
}, {
'seconds': 0.2,
'layer': page10
}, {
'seconds': 0.2,
'layer': page11
}])
self.bogey_award_text = dmd.HDTextLayer(1920 / 2,
150,
self.game.fonts['default'],
"center",
line_color=[64, 0, 0],
line_width=6,
interior_color=[192, 0, 0])
self.bogey_award_score = dmd.HDTextLayer(1920 / 2,
300,
self.game.fonts['main_score'],
"center",
line_color=[64, 64, 0],
line_width=6,
interior_color=[192, 192, 0])
self.bogey_award_score_dim = dmd.HDTextLayer(
1920 / 2,
300,
self.game.fonts['main_score'],
"center",
line_color=[16, 16, 0],
line_width=6,
interior_color=[64, 64, 0])
self.flash_text = dmd.ScriptedLayer(
1920, 800, [{
'seconds': 0.2,
'layer': self.bogey_award_score
}, {
'seconds': 0.2,
'layer': self.bogey_award_score_dim
}])
def __init__(self, game, priority, left_text, right_text, entered_handler):
super(HD_InitialEntryMode_ML, self).__init__(game, priority)
self.entered_handler = entered_handler
# self.init_font = dmd.font_named('Font09Bx7.dmd')
# self.font = dmd.font_named('Font07x5.dmd')
# self.letters_font = dmd.font_named('Font07x5.dmd')
## YOU almost CERTAINLY need to change these...
self.init_font = self.game.fonts['large']
self.text_font = self.game.fonts['small']
self.letters_font = self.game.fonts['mono-tiny']
self.letters_font_mini = self.game.fonts['mono-micro']
self.init_font_height = self.init_font.size("Z")[1]
self.text_font_height = self.text_font.size(left_text)[1]
self.layer = dmd.GroupedLayer(self.display_width, self.display_height)
self.layer.opaque = True
self.layer.layers = []
if type(right_text) != list:
right_text = [right_text]
if type(left_text) != list:
left_text = [left_text]
seconds_per_text = 1.5
script = []
mh = 0
for text in left_text:
words = text.split()
h = self.text_font_height*len(words)
mh = max(h, mh)
frame = dmd.Frame(width=self.display_width, height=h)
i = 0
for w in words:
self.text_font.draw(frame, w, 0, i*self.text_font_height)
i+=1
script.append({'seconds':seconds_per_text, 'layer':dmd.FrameLayer(frame=frame)})
topthird_left_layer = dmd.ScriptedLayer(width=self.display_width, height=mh, script=script)
topthird_left_layer.composite_op = 'blacksrc'
topthird_left_layer.target_y = self.display_height/2 - mh/2
topthird_left_layer.target_x = 10
self.layer.layers += [topthird_left_layer]
script = []
mh = 0
for text in right_text:
words = text.split()
h = self.text_font_height*len(words)
mh = max(h, mh)
frame = dmd.Frame(width=self.display_width, height=h)
i = 0
for w in words:
self.text_font.draw(frame, w, self.display_width-(self.text_font.size(w)[0]), i*self.text_font_height)
i+=1
script.append({'seconds':seconds_per_text, 'layer':dmd.FrameLayer(frame=frame)})
topthird_right_layer = dmd.ScriptedLayer(width=self.display_width, height=mh, script=script)
topthird_right_layer.composite_op = 'blacksrc'
topthird_right_layer.target_y = self.display_height/2 - mh/2
topthird_right_layer.target_x = -10
self.layer.layers += [topthird_right_layer]
# the entered initials so far
self.inits_layer = dmd.HDTextLayer(self.display_width/2, self.init_font_height/2+5, self.init_font, "center", vert_justify="center", line_color=(128,128,255), line_width=1, interior_color=(0,0,192),fill_color=(0,0,0)).set_text("")
self.inits_layer.set_target_position(0, self.text_font_height+2)
self.layer.layers += [self.inits_layer]
self.letters = []
for idx in range(26):
self.letters += [chr(ord('A')+idx)]
self.letters += [' ', '.', self.char_back, self.char_done]
self.current_letter_index = 0
self.inits = self.letters[self.current_letter_index]
# Draw my fancy rows
w = self.space_per_char*(self.columns_of_chars_in_palette+1)
h = self.space_per_char*(30/self.columns_of_chars_in_palette+1.5)
print("About to create a frame with w=" + str(w) + "; h=" + str(h))
self.char_optsF = dmd.Frame(width=w, height=h)
for index in range(30):
x = index % self.columns_of_chars_in_palette
y = index / self.columns_of_chars_in_palette
(w,h) = self.letters_font.size(self.letters[index])
if(index<28):
self.letters_font.draw(self.char_optsF, self.letters[index], (x+1) * self.space_per_char - w/2, (y+1) * self.space_per_char - h/2)
elif(index==28):
(w,h) = self.letters_font_mini.size("DEL")
self.letters_font_mini.draw(self.char_optsF, "DEL", (x+1) * self.space_per_char - w/2, (y+1) * self.space_per_char - h/2)
elif(index==29):
(w,h) = self.letters_font_mini.size("END")
self.letters_font_mini.draw(self.char_optsF, "END", (x+1) * self.space_per_char - w/2, (y+1) * self.space_per_char - h/2)
fbox = dmd.Frame(width=self.space_per_char+2, height=self.space_per_char+2)
fbox.fill_rect(0, 0, self.space_per_char+2, self.space_per_char+2, (128,128,255))
fbox.fill_rect(2, 2, self.space_per_char-4+2, self.space_per_char-4+2, (0,64,128))
self.selection_box_layer = dmd.FrameLayer(opaque=False, frame=fbox)
self.selection_box_layer.composite_op = "max"
self.layer.layers += [self.selection_box_layer]
self.char_opts_layer = dmd.FrameLayer(opaque=False, frame=self.char_optsF)
self.char_opts_layer.set_target_position((self.display_width-(self.columns_of_chars_in_palette+1) * self.space_per_char)/2, self.init_font_height)
# self.char_opts_layer.composite_op = "blacksrc"
self.layer.layers += [self.char_opts_layer]
self.animate_to_index(0)
def __init__(self, game, priority, left_text, right_text, entered_handler):
super(HD_InitialEntryMode_ML, self).__init__(game, priority)
self.entered_handler = entered_handler
# self.init_font = dmd.font_named('Font09Bx7.dmd')
# self.font = dmd.font_named('Font07x5.dmd')
# self.letters_font = dmd.font_named('Font07x5.dmd')
self.init_font = self.game.fonts['small']
self.text_font = self.game.fonts['large']
self.letters_font = self.game.fonts['med']
self.init_font_height = self.init_font.size("Z")[1]
self.text_font_height = self.text_font.size("Z")[1]
self.layer = dmd.GroupedLayer(480, 240)
self.layer.opaque = True
self.layer.layers = []
if type(right_text) != list:
right_text = [right_text]
if type(left_text) != list:
left_text = [left_text]
seconds_per_text = 1.5
script = []
for text in left_text:
frame = dmd.Frame(width=450, height=self.text_font_height)
self.text_font.draw(frame, text, 0, 0)
script.append({'seconds':seconds_per_text, 'layer':dmd.FrameLayer(frame=frame)})
topthird_left_layer = dmd.ScriptedLayer(width=480, height=self.text_font_height, script=script)
topthird_left_layer.composite_op = 'blacksrc'
self.layer.layers += [topthird_left_layer]
script = []
for text in right_text:
frame = dmd.Frame(width=480, height=self.text_font_height)
self.text_font.draw(frame, text, 480-(self.text_font.size(text)[0]), 0)
script.append({'seconds':seconds_per_text, 'layer':dmd.FrameLayer(frame=frame)})
topthird_right_layer = dmd.ScriptedLayer(width=480, height=self.text_font_height, script=script)
topthird_right_layer.composite_op = 'blacksrc'
self.layer.layers += [topthird_right_layer]
self.inits_frame = dmd.Frame(width=480, height=self.init_font_height)
inits_layer = dmd.FrameLayer(opaque=False, frame=self.inits_frame)
inits_layer.set_target_position(0, self.text_font_height+2)
self.layer.layers += [inits_layer]
self.lowerhalf_layer = dmd.FrameQueueLayer(opaque=False, hold=True)
self.lowerhalf_layer.set_target_position(0, self.init_font_height+self.text_font_height)
self.layer.layers += [self.lowerhalf_layer]
self.letters = []
for idx in range(26):
self.letters += [chr(ord('A')+idx)]
self.letters += [' ', '.', self.char_back, self.char_done]
self.current_letter_index = 0
self.inits = self.letters[self.current_letter_index]
self.animate_to_index(0)
def end_cva(self):
# kill the taunt delay
self.cancel_delayed("Taunt")
# kill the alien delay if there is one
self.cancel_delayed("Aliens")
# and the display delay
self.cancel_delayed("Display")
# stop the GI lampshow and end the delay if any for the next one
self.game.GI_lampctrl.stop_show()
self.cancel_delayed("Lampshow")
# stop the music
#self.stop_music()
# kill the drop targets
self.game.bad_guys.kill_power()
# do the final display
# ship frame and alien frame
shipBorder = dmd.FrameLayer(opaque=True, frame=self.game.assets.dmd_cvaShipsBorder.frames[0])
alienBorder = dmd.FrameLayer(opaque=True, frame=self.game.assets.dmd_cvaAliensBorder.frames[0])
# blank script
script = []
# Do the saucer bit, if any saucers were destroyed
if self.saucerHits > 0:
# set the saucer title line
if self.saucerHits == 1:
textStringOne = "1 SAUCER"
else:
textStringOne = str(self.saucerHits) + " SAUCERS"
titleLayerOne = ep.EP_TextLayer(64, 3, self.game.assets.font_7px_az, "center", opaque=False)
titleLayerOne.set_text(textStringOne,color=ep.GREEN)
titleTwoLayerOne = ep.EP_TextLayer(64,11, self.game.assets.font_5px_AZ,"center",opaque=False)
titleTwoLayerOne.set_text("DESTROYED",color=ep.GREEN)
# set the saucer score line
scoreLayerOne = ep.pulse_text(self,64,18,ep.format_score(self.saucerPoints),align="center",myOpaque=True,size="9px",timing=0.1,color=ep.RED)
# build the layer
pageOne = dmd.GroupedLayer(128,32,[shipBorder,titleLayerOne,titleTwoLayerOne,scoreLayerOne])
# add it to the script
script.append({'layer':pageOne,'seconds':1.5})
# do the aliens bit if any aliens were destroyed
if self.aliensKilled > 0:
# set the aliens title line
if self.aliensKilled == 1:
textStringTwo = "1 ALIEN"
else:
textStringTwo = str(self.aliensKilled) + " ALIENS"
titleLayerTwo = ep.EP_TextLayer(64, 3, self.game.assets.font_7px_az, "center", opaque=False)
titleLayerTwo.set_text(textStringTwo,color=ep.GREEN)
titleTwoLayerTwo = ep.EP_TextLayer(64,11,self.game.assets.font_5px_AZ, "center",opaque=False)
titleTwoLayerTwo.set_text("KILLED",color=ep.GREEN)
# set the aliens score line
scoreLayerTwo = ep.pulse_text(self,64,18,ep.format_score(self.alienPoints),align="center",myOpaque=True,size="9px",timing=0.1,color=ep.RED)
# build the layer
pageTwo = dmd.GroupedLayer(128,32,[alienBorder,titleLayerTwo,titleTwoLayerTwo,scoreLayerTwo])
# add it to the script
script.append({'layer':pageTwo,'seconds':1.5})
# if either exist, start the script
if script:
# setup the script layer
summary = dmd.ScriptedLayer(128,32,script)
# and activate
self.layer = summary
myDelay = 1.5
# play a cheer noise
self.game.sound.play(self.game.assets.sfx_cvaFinalRiff)
self.delay(delay=0.5,handler=self.game.sound.play,param=self.game.assets.sfx_cheers)
# if we hit both parts - play a second riff
if self.saucerHits > 0 and self.aliensKilled > 0:
self.delay(delay=1.5,handler=self.game.sound.play,param=self.game.assets.sfx_cvaFinalRiff)
self.delay(delay=2,handler=self.game.sound.play,param=self.game.assets.sfx_cheers)
myDelay = 3
self.delay(delay = myDelay,handler=self.finish_up)
# if neither exist - go straight to finishing up
else:
self.finish_up()
def tally(self,title,amount,value,frame_delay,callback,step):
script = []
# set the backdrop and offsets
if title == "JACKPOT":
backdrop = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_moneybagBorderRight.frames[0])
x_offset = 50
elif title == "BAD GUY":
backdrop = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_singleCowboyBorderRight.frames[0])
x_offset = 50
else:
backdrop = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_blank.frames[0])
x_offset = 64
# first just the title
titleLine = ep.EP_TextLayer(x_offset, 10, self.game.assets.font_12px_az, "center", opaque=False).set_text(title + "S",color=ep.ORANGE)
combined = dmd.GroupedLayer(128,32,[backdrop,titleLine])
script.append({"layer":combined,"seconds":0.5})
myWait = 0.5
# have to define pointsLine and TitleLine just in case it's zero
titleString = "0 " + title + "S"
titleLine = ep.EP_TextLayer(x_offset,3,self.game.assets.font_7px_az, "center", opaque=False).set_text(titleString,color=ep.BROWN)
points = 0
pointsLine = ep.EP_TextLayer(x_offset, 12, self.game.assets.font_12px_az, "center", opaque=False).set_text(ep.format_score(points),color=ep.ORANGE)
combined = dmd.GroupedLayer(128,32,[backdrop,titleLine,pointsLine])
script.append({"layer":combined,"seconds":frame_delay})
# then generate frames for each level of title
for i in range(1,amount+1,1):
points = i * value
if i == 1:
titleString = "1 " + title
else:
titleString = str(i) + " " + title + "S"
titleLine = ep.EP_TextLayer(x_offset,3,self.game.assets.font_7px_az, "center", opaque=False).set_text(titleString,color=ep.BROWN)
pointsLine = ep.EP_TextLayer(x_offset, 12, self.game.assets.font_12px_az, "center", opaque=False).set_text(ep.format_score(points),color=ep.ORANGE)
combined = dmd.GroupedLayer(128,32,[backdrop,titleLine,pointsLine])
script.append({"layer":combined,"seconds":frame_delay})
myWait += frame_delay
# set a sound for this point at the start of the wipe
#self.delay(name="Display",delay=myWait,handler=self.game.sound.play,param=self.game.assets.sfx_lightning2)
# employ the burst wipe
anim = self.game.assets.dmd_burstWipe
animWait = len(anim.frames) / 15.0
myWait += animWait
animLayer = ep.EP_AnimatedLayer(anim)
animLayer.hold = True
animLayer.frame_time = 4
animLayer.composite_op = "blacksrc"
# add the burst
burstLayer = dmd.GroupedLayer(128,32,[combined,animLayer])
script.append({"layer":burstLayer,"seconds":animWait})
# then a final total with the second half of the wipe
anim = self.game.assets.dmd_burstWipe2
animLayer = ep.EP_AnimatedLayer(anim)
animLayer.hold = True
animLayer.frame_time = 4
animLayer.composite_op = "blacksrc"
# set another sound to play after the anim
myWait += animWait
#self.delay(name="Display",delay=myWait,handler=self.game.sound.play,param=self.game.assets.sfx_cheers)
if step == 2:
preString = "JACKPOTS "
elif step == 3:
preString = "BAD GUYS "
else:
preString = ""
titleLine = ep.EP_TextLayer(x_offset,3,self.game.assets.font_7px_az, "center", opaque=False).set_text(preString + "TOTAL:",color=ep.BROWN)
combined = dmd.GroupedLayer(128,32,[backdrop,titleLine,pointsLine,animLayer])
script.append({"layer":combined,"seconds":(animWait + 2)})
# tack on that extra second
myWait += 1
# then set off the layer
self.layer = dmd.ScriptedLayer(128,32,script)
# add the points to the grand total
self.grandTotal += points
# and delay the comeback for step 2
print "TALLY LOOP STEP " + str(step)
self.delay(name="Display",delay=myWait+1.5,handler=callback,param=step)
def __init__(self, game):
super(FastScoring, self).__init__(game=game,
priority=9,
mode_type=AdvancedMode.Manual)
self.myID = "FastScoring"
self.running = False
backdrop = dmd.FrameLayer(
frame=self.game.animations['metal_bg'].frames[0])
banner = dmd.PanningLayer(
3840,
800,
self.game.animations['fast_scoring_banner'].frames[0], (0, 0),
(20, 0),
bounce=False,
wrap=True)
#self.explosion = self.game.animations['fast_scoring_explosion']
#self.explosion.composite_op = "blacksrc"
#self.explosion.enabled = False
#self.display = dmd.GroupedLayer(1920, 800, [backdrop, banner, self.explosion], opaque=True)
self.score1 = dmd.HDTextLayer(250,
100,
self.game.fonts['default'],
"center",
line_color=(0, 0, 0),
line_width=3,
interior_color=(255, 255, 0))
self.score2 = dmd.HDTextLayer(300,
250,
self.game.fonts['default'],
"center",
line_color=(0, 0, 0),
line_width=3,
interior_color=(255, 255, 0))
self.score3 = dmd.HDTextLayer(250,
450,
self.game.fonts['default'],
"center",
line_color=(0, 0, 0),
line_width=3,
interior_color=(255, 255, 0))
self.score4 = dmd.HDTextLayer(1700,
100,
self.game.fonts['default'],
"center",
line_color=(0, 0, 0),
line_width=3,
interior_color=(255, 255, 0))
self.score5 = dmd.HDTextLayer(1600,
250,
self.game.fonts['default'],
"center",
line_color=(0, 0, 0),
line_width=3,
interior_color=(255, 255, 0))
self.score6 = dmd.HDTextLayer(1700,
450,
self.game.fonts['default'],
"center",
line_color=(0, 0, 0),
line_width=3,
interior_color=(255, 255, 0))
self.score_layers = [
self.score1, self.score2, self.score3, self.score4, self.score5,
self.score6
]
self.timer_layer = dmd.HDTextLayer(1920 / 2,
120,
self.game.fonts['bebas500'],
"center",
line_color=(0, 0, 0),
line_width=8,
interior_color=(255, 0, 0))
timer_box = self.game.animations['timer_box']
timer_box.set_target_position(731, 164)
title = dmd.HDTextLayer(1920 / 2,
20,
self.game.fonts['default'],
"center",
line_color=(0, 0, 0),
line_width=3,
interior_color=(224, 224, 224))
title.set_text("FAST SCORING")
bottom1 = dmd.HDTextLayer(1920 / 2,
650,
self.game.fonts['default'],
"center",
line_color=(0, 0, 0),
line_width=3,
interior_color=(224, 224, 224))
bottom1.set_text("IRONMAN TARGETS RAISE VALUE")
self.bottom2 = dmd.HDTextLayer(1920 / 2,
650,
self.game.fonts['default'],
"center",
line_color=(0, 0, 0),
line_width=3,
interior_color=(224, 224, 224))
self.bottom2.set_text("ALL SWITCHES SCORE 10,000 POINTS")
info_line = dmd.ScriptedLayer(1920, 800, [{
'layer': bottom1,
'seconds': 2
}, {
'layer': self.bottom2,
'seconds': 2
}])
self.display = dmd.GroupedLayer(
1920,
800, [
backdrop, banner, title, info_line, timer_box,
self.timer_layer, self.score1, self.score2, self.score3,
self.score4, self.score5, self.score6
],
opaque=True)
self.names = ['fast5', 'fast4', 'fast3', 'fast2', 'fast1', 'fast0']
self.timer_start_value = 41
self.fade_index = 0
def __init__(self, game, priority):
super(Ambush, self).__init__(game, priority)
self.myID = "Ambush"
self.posts = [
self.game.coils.leftGunFightPost, self.game.coils.rightGunFightPost
]
self.targetNames = ['Left', 'Left Center', 'Right Center', 'Right']
# setup the standing guys
self.guyLayers = []
self.badGuy0 = dmd.FrameLayer(
opaque=False,
frame=self.game.assets.dmd_dudeShotFullBody.frames[0])
self.badGuy0.set_target_position(-49, 0)
self.badGuy0.composite_op = "blacksrc"
self.guyLayers.append(self.badGuy0)
self.badGuy1 = dmd.FrameLayer(
opaque=False,
frame=self.game.assets.dmd_dudeShotFullBody.frames[0])
self.badGuy1.set_target_position(-16, 0)
self.badGuy1.composite_op = "blacksrc"
self.guyLayers.append(self.badGuy1)
self.badGuy2 = dmd.FrameLayer(
opaque=False,
frame=self.game.assets.dmd_dudeShotFullBody.frames[0])
self.badGuy2.set_target_position(15, 0)
self.badGuy2.composite_op = "blacksrc"
self.guyLayers.append(self.badGuy2)
self.badGuy3 = dmd.FrameLayer(
opaque=False,
frame=self.game.assets.dmd_dudeShotFullBody.frames[0])
self.badGuy3.set_target_position(47, 0)
self.badGuy3.composite_op = "blacksrc"
self.guyLayers.append(self.badGuy3)
## lamps
self.lamps = [
self.game.lamps.badGuyL0, self.game.lamps.badGuyL1,
self.game.lamps.badGuyL2, self.game.lamps.badGuyL3
]
# number of guys that can escape before you lose
self.LOSE = self.game.user_settings['Gameplay (Feature)'][
'Ambush Escapes to Lose']
# how long the bad guys wait before disappearing
self.SECONDS = self.game.user_settings['Gameplay (Feature)'][
'Ambush Target Timer']
self.ball_saver = self.game.user_settings['Gameplay (Feature)'][
'Ambush Ball Saver']
# build the pause view
script = []
# set up the text layer
textString = "< AMBUSH PAUSED >"
textLayer = ep.EP_TextLayer(128 / 2,
24,
self.game.assets.font_6px_az_inverse,
"center",
opaque=False).set_text(textString,
color=ep.BLUE)
script.append({'seconds': 0.3, 'layer': textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False,
frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds': 0.3, 'layer': blank})
# make a script layer with the two
self.pauseView = dmd.ScriptedLayer(128, 32, script)
self.pauseView.composite_op = "blacksrc"
def __init__(self,
game,
priority,
left_text,
right_text,
entered_handler,
max_inits,
extended=False):
super(InitialEntryMode, self).__init__(game, priority)
self.entered_handler = entered_handler
self.init_font = self.game.assets.font_09Bx7
self.font = self.game.assets.font_07x5
self.letters_font = self.game.assets.font_07x5
self.layer = dmd.GroupedLayer(128, 32)
self.layer.opaque = True
self.layer.layers = []
self.knocks = 0
self.max_inits = max_inits
self.extended = extended
if type(right_text) != list:
right_text = [right_text]
if type(left_text) != list:
left_text = [left_text, "MAX " + str(self.max_inits)]
seconds_per_text = 1.5
script = []
for text in left_text:
frame = dmd.Frame(width=128, height=8)
self.font.draw(frame, text, 0, 0, color=ep.YELLOW)
script.append({
'seconds': seconds_per_text,
'layer': dmd.FrameLayer(frame=frame)
})
topthird_left_layer = dmd.ScriptedLayer(width=128,
height=8,
script=script)
topthird_left_layer.composite_op = 'blacksrc'
self.layer.layers += [topthird_left_layer]
script = []
for text in right_text:
frame = dmd.Frame(width=128, height=8)
self.font.draw(frame,
text,
128 - (self.font.size(text)[0]),
0,
color=ep.ORANGE)
script.append({
'seconds': seconds_per_text,
'layer': dmd.FrameLayer(frame=frame)
})
if text == "Grand Champion":
self.knocks += 2
elif text == 'High Score #1' or \
text == 'High Score #2' or \
text == 'High Score #3' or \
text == 'High Score #4':
self.knocks += 1
topthird_right_layer = dmd.ScriptedLayer(width=128,
height=8,
script=script)
topthird_right_layer.composite_op = 'blacksrc'
self.layer.layers += [topthird_right_layer]
self.inits_frame = dmd.Frame(width=128, height=10)
inits_layer = dmd.FrameLayer(opaque=False, frame=self.inits_frame)
inits_layer.set_target_position(0, 11)
self.layer.layers += [inits_layer]
self.lowerhalf_layer = dmd.FrameQueueLayer(opaque=False, hold=True)
self.lowerhalf_layer.set_target_position(0, 24)
self.layer.layers += [self.lowerhalf_layer]
self.letters = []
for idx in range(26):
self.letters += [chr(ord('A') + idx)]
self.letters += [' ', '.']
if self.extended:
self.letters += [
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '(', ')',
'@', '*', '&', '<', '>', '=', '^', '/', '-', '+', '!', '$',
'"', "'"
]
self.letters += [self.char_back, self.char_done]
self.current_letter_index = 0
self.inits = self.letters[self.current_letter_index]
self.animate_to_index(0)
def start_save_polly(self, step=1):
if step == 1:
# audit
self.game.game_data['Feature']['Center Polly Started'] += 1
# set the level 1 stack flag
self.game.stack_level(2, True)
# set the running flag
self.running = True
# clear any running music
#self.stop_music()
# set the center to crazy stage
self.game.set_tracking('centerRampStage', 99)
self.lamp_update()
## TEMP PLAY INTRO
duration = self.game.base.priority_quote(
self.game.assets.quote_ttttDox)
# Secondary intro quote
self.delay("Operational",
delay=duration + 0.1,
handler=self.secondary_intro_quote)
# start the music
self.music_on(self.game.assets.music_pollyPeril)
# reset the train
self.game.train.reset_toy(step=2)
# run the animation
anim = self.game.assets.dmd_pollyIntro
myWait = len(anim.frames) / 30.0
animLayer = dmd.AnimatedLayer(frames=anim.frames,
hold=True,
opaque=True,
repeat=False,
frame_time=2)
self.layer = animLayer
# set the timer for the mode
self.modeTimer = 30
# setup some layers
# alternate lines for the bottom
script = []
shotsLine1 = dmd.TextLayer(34,
11,
self.game.assets.font_5px_AZ,
"center",
opaque=False).set_text("SHOTS WORTH:")
shotsLine2 = ep.EP_TextLayer(
34, 17, self.game.assets.font_7px_az, "center",
opaque=False).set_text(str(ep.format_score(self.shotValue)),
color=ep.MAGENTA)
# group layer of the award lines
textString2 = str(
(self.shotsToWin - self.shotsSoFar)) + " SHOTS FOR"
self.prog_awardLine1 = dmd.TextLayer(
34, 11, self.game.assets.font_7px_az, "center",
opaque=False).set_text(textString2)
page1 = dmd.GroupedLayer(128, 32,
[self.prog_awardLine1, self.awardLine2])
page1.composite_op = "blacksrc"
script.append({"seconds": 2, "layer": page1})
# group layer of the shot value info lines
page2 = dmd.GroupedLayer(128, 32, [shotsLine1, shotsLine2])
page2.composite_op = "blacksrc"
script.append({"seconds": 2, "layer": page2})
# scripted layer alternating between the info and award lines
self.infoLayer = dmd.ScriptedLayer(128, 32, script)
self.infoLayer.composite_op = "blacksrc"
# loop back for the title card
self.delay("Operational",
delay=myWait,
handler=self.start_save_polly,
param=2)
if step == 2:
# set up the title card
titleCard = dmd.FrameLayer(
opaque=False, frame=self.game.assets.dmd_ttttBanner.frames[0])
# transition to the title card
self.transition = ep.EP_Transition(self, self.layer, titleCard,
ep.EP_Transition.TYPE_WIPE,
ep.EP_Transition.PARAM_EAST)
# delay the start process
self.delay("Get Going", delay=2, handler=self.in_progress)
