def draw(self):
"""
Sets up main menu and draws GUI to screen.
Only supports aspect ratios >= 1 (where width is at least height)
"""
# Set background color to black to cover any possible incorrect scaling:
#base.setBackgroundColor(0,0,0)
winWidth = base.getAspectRatio() * 2
winHeight = 2
backgroundFrame = DirectFrame(
parent=base.a2dTopLeft,
frameSize=(0, winWidth, -winHeight, 0),
frameTexture=TITLE_SCREEN_BACKGROUND_PATH)
bCStartX, bCStartY = winWidth * (2 / 3), winHeight * (1 / 3)
bCSizeX, bCSizeY = winWidth - bCStartX, winHeight - bCStartY
buttonContainer = DirectFrame(parent=backgroundFrame,
pos=(bCStartX, 0, -bCStartY),
frameSize=(0, bCSizeX, -bCSizeY, 0),
frameTexture=TITLE_SCREEN_CONTAINER_PATH)
buttonContainer.setTransparency(TransparencyAttrib.MAlpha)
buttonContainer.setColor(0.5, 1, 0.5,
1) # TODO Set this to favorite color
# Draw Title:
titleSize = winHeight - bCSizeY - TITLE_MARGIN * 2
title = DirectFrame(parent=backgroundFrame,
pos=(bCStartX, 0, -TITLE_MARGIN),
frameSize=(0, bCSizeX, -titleSize, 0),
frameTexture=TITLE_PATH)
title.setTransparency(TransparencyAttrib.MAlpha)
buttons = [("Host Game", self._onButtonHostGame),
("Join Party", self._onButtonJoinGame),
("Guide", self._onButtonGuide),
("Exit", self._onButtonExit)]
textColor = (1, 1, 1, 1)
topAndBottomMargin = 0.155
sidesMargin = 0.0275
buttonHeight = 0.25
buttonBackgroundColor = (0, 0, 0, 1)
# Create buttons:
index = 0
for button in buttons:
newButton = DirectButton(
parent=buttonContainer,
pos=(0.5, 0, -topAndBottomMargin - buttonHeight * index),
frameColor=buttonBackgroundColor,
frameSize=(-0.5 + sidesMargin, 0.5 - sidesMargin,
-buttonHeight / 2, buttonHeight / 2),
text=button[0],
text_font=self._buttonFont,
text_scale=(0.15, 0.15),
text_fg=textColor,
text_pos=PIERCEROMAN_OFFSET_MC,
text_align=TextNode.ACenter,
command=button[1],
frameTexture=IMG_GRADIENT_1)
index += 1
self._elements.extend([backgroundFrame])
class Transitions:
# These may be reassigned before the fade or iris transitions are
# actually invoked to change the models that will be used.
IrisModelName = "models/misc/iris"
FadeModelName = "models/misc/fade"
def __init__(self, loader,
model=None,
scale=3.0,
pos=Vec3(0, 0, 0)):
self.transitionIval = None
self.letterboxIval = None
self.iris = None
self.fade = None
self.letterbox = None
self.fadeModel = model
self.imagePos = pos
if model:
self.alphaOff = Vec4(1, 1, 1, 0)
self.alphaOn = Vec4(1, 1, 1, 1)
model.setTransparency(1)
self.lerpFunc = LerpColorScaleInterval
else:
self.alphaOff = Vec4(0, 0, 0, 0)
self.alphaOn = Vec4(0, 0, 0, 1)
self.lerpFunc = LerpColorInterval
self.irisTaskName = "irisTask"
self.fadeTaskName = "fadeTask"
self.letterboxTaskName = "letterboxTask"
def __del__(self):
if self.fadeModel:
self.fadeModel.removeNode()
self.fadeModel = None
##################################################
# Fade
##################################################
# We can set a custom model for the fade before using it for the first time
def setFadeModel(self, model, scale=1.0):
self.fadeModel = model
# We have to change some default parameters for a custom fadeModel
self.alphaOn = Vec4(1, 1, 1, 1)
# Reload fade if its already been created
if self.fade:
self.fade.destroy()
self.fade = None
self.loadFade()
def loadFade(self):
if self.fade is None:
# We create a DirectFrame for the fade polygon, instead of
# simply loading the polygon model and using it directly,
# so that it will also obscure mouse events for objects
# positioned behind it.
self.fade = DirectFrame(
parent = hidden,
guiId = 'fade',
relief = None,
image = self.fadeModel,
image_scale = (4, 2, 2),
state = DGG.NORMAL,
)
if not self.fadeModel:
# No fade model was given, so we make this the fade model.
self.fade["relief"] = DGG.FLAT
self.fade["frameSize"] = (-2, 2, -1, 1)
self.fade["frameColor"] = (0, 0, 0, 1)
self.fade.setTransparency(TransparencyAttrib.MAlpha)
self.fade.setBin('unsorted', 0)
self.fade.setColor(0,0,0,0)
def getFadeInIval(self, t=0.5, finishIval=None):
"""
Returns an interval without starting it. This is particularly useful in
cutscenes, so when the cutsceneIval is escaped out of we can finish the fade immediately
"""
#self.noTransitions() masad: this creates a one frame pop, is it necessary?
self.loadFade()
transitionIval = Sequence(Func(self.fade.reparentTo, aspect2d, DGG.FADE_SORT_INDEX),
Func(self.fade.showThrough), # in case aspect2d is hidden for some reason
self.lerpFunc(self.fade, t,
self.alphaOff,
# self.alphaOn,
),
Func(self.fade.detachNode),
name = self.fadeTaskName,
)
if finishIval:
transitionIval.append(finishIval)
return transitionIval
def getFadeOutIval(self, t=0.5, finishIval=None):
"""
Create a sequence that lerps the color out, then
parents the fade to hidden
"""
self.noTransitions()
self.loadFade()
transitionIval = Sequence(Func(self.fade.reparentTo,aspect2d,DGG.FADE_SORT_INDEX),
Func(self.fade.showThrough), # in case aspect2d is hidden for some reason
self.lerpFunc(self.fade, t,
self.alphaOn,
# self.alphaOff,
),
name = self.fadeTaskName,
)
if finishIval:
transitionIval.append(finishIval)
return transitionIval
def fadeIn(self, t=0.5, finishIval=None):
"""
Play a fade in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from black to transparent. When the color lerp is finished, it
parents the fade polygon to hidden.
"""
gsg = base.win.getGsg()
if gsg:
# If we're about to fade in from black, go ahead and
# preload all the textures etc.
base.graphicsEngine.renderFrame()
render.prepareScene(gsg)
render2d.prepareScene(gsg)
if (t == 0):
# Fade in immediately with no lerp
#print "transitiosn: fadeIn 0.0"
self.noTransitions()
self.loadFade()
self.fade.detachNode()
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
self.transitionIval = self.getFadeInIval(t, finishIval)
self.transitionIval.start()
def fadeOut(self, t=0.5, finishIval=None):
"""
Play a fade out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from transparent to full black. When the color lerp is finished,
it leaves the fade polygon covering the aspect2d plane until you
fadeIn or call noFade.
lerp
"""
if (t == 0):
# Fade out immediately with no lerp
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(self.alphaOn)
elif ConfigVariableBool('no-loading-screen', False):
if finishIval:
self.transitionIval = finishIval
self.transitionIval.start()
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
self.transitionIval = self.getFadeOutIval(t,finishIval)
self.transitionIval.start()
def fadeOutActive(self):
return self.fade and self.fade.getColor()[3] > 0
def fadeScreen(self, alpha=0.5):
"""
Put a semitransparent screen over the camera plane
to darken out the world. Useful for drawing attention to
a dialog box for instance
"""
#print "transitiosn: fadeScreen"
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(self.alphaOn[0],
self.alphaOn[1],
self.alphaOn[2],
alpha)
def fadeScreenColor(self, color):
"""
Put a semitransparent screen over the camera plane
to darken out the world. Useful for drawing attention to
a dialog box for instance
"""
#print "transitiosn: fadeScreenColor"
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(color)
def noFade(self):
"""
Removes any current fade tasks and parents the fade polygon away
"""
#print "transitiosn: noFade"
if self.transitionIval:
self.transitionIval.pause()
self.transitionIval = None
if self.fade:
# Make sure to reset the color, since fadeOutActive() is looking at it
self.fade.setColor(self.alphaOff)
self.fade.detachNode()
def setFadeColor(self, r, g, b):
self.alphaOn.set(r, g, b, 1)
self.alphaOff.set(r, g, b, 0)
##################################################
# Iris
##################################################
def loadIris(self):
if self.iris == None:
self.iris = loader.loadModel(self.IrisModelName)
self.iris.setPos(0, 0, 0)
def irisIn(self, t=0.5, finishIval=None):
"""
Play an iris in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris polygon up so it looks like we iris in. When the
scale lerp is finished, it parents the iris polygon to hidden.
"""
self.noTransitions()
self.loadIris()
if (t == 0):
self.iris.detachNode()
else:
self.iris.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.transitionIval = Sequence(LerpScaleInterval(self.iris, t,
scale = 0.18,
startScale = 0.01),
Func(self.iris.detachNode),
name = self.irisTaskName,
)
if finishIval:
self.transitionIval.append(finishIval)
self.transitionIval.start()
def irisOut(self, t=0.5, finishIval=None):
"""
Play an iris out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris down so it looks like we iris out. When the scale
lerp is finished, it leaves the iris polygon covering the
aspect2d plane until you irisIn or call noIris.
"""
self.noTransitions()
self.loadIris()
self.loadFade() # we need this to cover up the hole.
if (t == 0):
self.iris.detachNode()
self.fadeOut(0)
else:
self.iris.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.transitionIval = Sequence(LerpScaleInterval(self.iris, t,
scale = 0.01,
startScale = 0.18),
Func(self.iris.detachNode),
# Use the fade to cover up the hole that the iris would leave
Func(self.fadeOut, 0),
name = self.irisTaskName,
)
if finishIval:
self.transitionIval.append(finishIval)
self.transitionIval.start()
def noIris(self):
"""
Removes any current iris tasks and parents the iris polygon away
"""
if self.transitionIval:
self.transitionIval.pause()
self.transitionIval = None
if self.iris != None:
self.iris.detachNode()
# Actually we need to remove the fade too,
# because the iris effect uses it.
self.noFade()
def noTransitions(self):
"""
This call should immediately remove any and all transitions running
"""
self.noFade()
self.noIris()
# Letterbox is not really a transition, it is a screen overlay
# self.noLetterbox()
##################################################
# Letterbox
##################################################
def loadLetterbox(self):
if not self.letterbox:
# We create a DirectFrame for the fade polygon, instead of
# simply loading the polygon model and using it directly,
# so that it will also obscure mouse events for objects
# positioned behind it.
self.letterbox = NodePath("letterbox")
# Allow fade in and out of the bars
self.letterbox.setTransparency(1)
# Allow DirectLabels to be parented to the letterbox sensibly
self.letterbox.setBin('unsorted', 0)
# Allow a custom look to the letterbox graphic.
# TODO: This model isn't available everywhere. We should
# pass it in as a parameter.
button = loader.loadModel('models/gui/toplevel_gui',
okMissing = True)
barImage = None
if button:
barImage = button.find('**/generic_button')
self.letterboxTop = DirectFrame(
parent = self.letterbox,
guiId = 'letterboxTop',
relief = DGG.FLAT,
state = DGG.NORMAL,
frameColor = (0, 0, 0, 1),
borderWidth = (0, 0),
frameSize = (-1, 1, 0, 0.2),
pos = (0, 0, 0.8),
image = barImage,
image_scale = (2.25,1,.5),
image_pos = (0,0,.1),
image_color = (0.3,0.3,0.3,1),
sortOrder = 0,
)
self.letterboxBottom = DirectFrame(
parent = self.letterbox,
guiId = 'letterboxBottom',
relief = DGG.FLAT,
state = DGG.NORMAL,
frameColor = (0, 0, 0, 1),
borderWidth = (0, 0),
frameSize = (-1, 1, 0, 0.2),
pos = (0, 0, -1),
image = barImage,
image_scale = (2.25,1,.5),
image_pos = (0,0,.1),
image_color = (0.3,0.3,0.3,1),
sortOrder = 0,
)
# masad: always place these at the bottom of render
self.letterboxTop.setBin('sorted',0)
self.letterboxBottom.setBin('sorted',0)
self.letterbox.reparentTo(render2d, -1)
self.letterboxOff(0)
def noLetterbox(self):
"""
Removes any current letterbox tasks and parents the letterbox polygon away
"""
if self.letterboxIval:
self.letterboxIval.pause()
self.letterboxIval = None
if self.letterbox:
self.letterbox.stash()
def letterboxOn(self, t=0.25, finishIval=None):
"""
Move black bars in over t seconds.
"""
self.noLetterbox()
self.loadLetterbox()
self.letterbox.unstash()
if (t == 0):
self.letterboxBottom.setPos(0, 0, -1)
self.letterboxTop.setPos(0, 0, 0.8)
else:
self.letterboxIval = Sequence(Parallel(
LerpPosInterval(self.letterboxBottom,
t,
pos = Vec3(0, 0, -1),
#startPos = Vec3(0, 0, -1.2),
),
LerpPosInterval(self.letterboxTop,
t,
pos = Vec3(0, 0, 0.8),
# startPos = Vec3(0, 0, 1),
),
),
name = self.letterboxTaskName,
)
if finishIval:
self.letterboxIval.append(finishIval)
self.letterboxIval.start()
def letterboxOff(self, t=0.25, finishIval=None):
"""
Move black bars away over t seconds.
"""
self.noLetterbox()
self.loadLetterbox()
self.letterbox.unstash()
if (t == 0):
self.letterbox.stash()
else:
self.letterboxIval = Sequence(Parallel(
LerpPosInterval(self.letterboxBottom,
t,
pos = Vec3(0, 0, -1.2),
# startPos = Vec3(0, 0, -1),
),
LerpPosInterval(self.letterboxTop,
t,
pos = Vec3(0, 0, 1),
# startPos = Vec3(0, 0, 0.8),
),
),
Func(self.letterbox.stash),
Func(messenger.send,'letterboxOff'),
name = self.letterboxTaskName,
)
if finishIval:
self.letterboxIval.append(finishIval)
self.letterboxIval.start()
class CannonGui(DirectObject):
notify = directNotify.newCategory('CannonGui')
FIRE_KEY = base.JUMP
UP_KEY = base.MOVE_UP
DOWN_KEY = base.MOVE_DOWN
LEFT_KEY = base.MOVE_LEFT
RIGHT_KEY = base.MOVE_RIGHT
FIRE_PRESSED = 'cannongui_fire_pressed'
def __init__(self):
self.__loaded = False
self.leftPressed = 0
self.rightPressed = 0
self.upPressed = 0
self.downPressed = 0
self.__aimPad = None
self.__timerPad = None
return
def load(self):
if self.__loaded:
return
self.__timerPad = PartyUtils.getNewToontownTimer()
guiModel = 'phase_4/models/gui/cannon_game_gui'
guiNode = loader.loadModel(guiModel)
self.__aimPad = DirectFrame(image=guiNode.find('**/CannonFire_PAD'), relief=None, pos=(0.7, 0, -0.553333), scale=0.8)
guiNode.removeNode()
self.fireButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Fire_Btn_UP'), (guiModel, '**/Fire_Btn_DN'), (guiModel, '**/Fire_Btn_RLVR')), relief=None, pos=(0.0115741, 0, 0.00505051), scale=1.0, command=self.__firePressed)
self.upButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(0.0115741, 0, 0.221717))
self.downButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(0.0136112, 0, -0.210101), image_hpr=(0, 0, 180))
self.leftButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(-0.199352, 0, -0.000505269), image_hpr=(0, 0, -90))
self.rightButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(0.219167, 0, -0.00101024), image_hpr=(0, 0, 90))
self.__aimPad.setColor(1, 1, 1, 0.9)
def bindButton(button, upHandler, downHandler):
button.bind(DGG.B1PRESS, lambda x, handler = upHandler: handler())
button.bind(DGG.B1RELEASE, lambda x, handler = downHandler: handler())
bindButton(self.upButton, self.__upPressed, self.__upReleased)
bindButton(self.downButton, self.__downPressed, self.__downReleased)
bindButton(self.leftButton, self.__leftPressed, self.__leftReleased)
bindButton(self.rightButton, self.__rightPressed, self.__rightReleased)
self.__loaded = True
return
def unload(self):
self.ignoreAll()
if not self.__loaded:
return
self.disable()
self.upButton.unbind(DGG.B1PRESS)
self.upButton.unbind(DGG.B1RELEASE)
self.downButton.unbind(DGG.B1PRESS)
self.downButton.unbind(DGG.B1RELEASE)
self.leftButton.unbind(DGG.B1PRESS)
self.leftButton.unbind(DGG.B1RELEASE)
self.rightButton.unbind(DGG.B1PRESS)
self.rightButton.unbind(DGG.B1RELEASE)
self.fireButton.destroy()
self.__aimPad.destroy()
del self.__aimPad
del self.fireButton
del self.upButton
del self.downButton
del self.leftButton
del self.rightButton
self.__timerPad.destroy()
del self.__timerPad
self.__loaded = False
def enable(self, timer = 0):
self.__aimPad.show()
base.setCellsAvailable([base.bottomCells[3], base.bottomCells[4]], 0)
base.setCellsAvailable([base.rightCells[1]], 0)
if timer > 0:
self.__timerPad.setTime(timer)
self.__timerPad.countdown(timer)
self.__timerPad.show()
self.enableKeys()
def disable(self):
self.__aimPad.hide()
base.setCellsAvailable([base.bottomCells[3], base.bottomCells[4]], 1)
base.setCellsAvailable([base.rightCells[1]], 1)
self.__timerPad.hide()
self.disableKeys()
def enableKeys(self):
self.enableAimKeys()
self.enableFireKey()
def disableKeys(self):
self.__aimPad.hide()
self.disableAimKeys()
self.disableFireKey()
def enableAimKeys(self):
self.leftPressed = 0
self.rightPressed = 0
self.upPressed = 0
self.downPressed = 0
self.accept(self.UP_KEY, self.__upKeyPressed)
self.accept(self.DOWN_KEY, self.__downKeyPressed)
self.accept(self.LEFT_KEY, self.__leftKeyPressed)
self.accept(self.RIGHT_KEY, self.__rightKeyPressed)
def disableAimKeys(self):
self.ignore(self.UP_KEY)
self.ignore(self.DOWN_KEY)
self.ignore(self.LEFT_KEY)
self.ignore(self.RIGHT_KEY)
messenger.send(self.UP_KEY + '-up')
messenger.send(self.DOWN_KEY + '-up')
messenger.send(self.LEFT_KEY + '-up')
messenger.send(self.RIGHT_KEY + '-up')
self.ignore(self.UP_KEY + '-up')
self.ignore(self.DOWN_KEY + '-up')
self.ignore(self.LEFT_KEY + '-up')
self.ignore(self.RIGHT_KEY + '-up')
def enableFireKey(self):
self.accept(self.FIRE_KEY, self.__fireKeyPressed)
def disableFireKey(self):
self.ignore(self.FIRE_KEY)
self.ignore(self.FIRE_KEY + '-up')
def __fireKeyPressed(self):
self.ignore(self.FIRE_KEY)
self.accept(self.FIRE_KEY + '-up', self.__fireKeyReleased)
self.__firePressed()
def __upKeyPressed(self):
self.ignore(self.UP_KEY)
self.accept(self.UP_KEY + '-up', self.__upKeyReleased)
self.__upPressed()
def __downKeyPressed(self):
self.ignore(self.DOWN_KEY)
self.accept(self.DOWN_KEY + '-up', self.__downKeyReleased)
self.__downPressed()
def __leftKeyPressed(self):
self.ignore(self.LEFT_KEY)
self.accept(self.LEFT_KEY + '-up', self.__leftKeyReleased)
self.__leftPressed()
def __rightKeyPressed(self):
self.ignore(self.RIGHT_KEY)
self.accept(self.RIGHT_KEY + '-up', self.__rightKeyReleased)
self.__rightPressed()
def __fireKeyReleased(self):
self.ignore(self.FIRE_KEY + '-up')
self.accept(self.FIRE_KEY, self.__fireKeyPressed)
def __leftKeyReleased(self):
self.ignore(self.LEFT_KEY + '-up')
self.accept(self.LEFT_KEY, self.__leftKeyPressed)
self.__leftReleased()
def __rightKeyReleased(self):
self.ignore(self.RIGHT_KEY + '-up')
self.accept(self.RIGHT_KEY, self.__rightKeyPressed)
self.__rightReleased()
def __upKeyReleased(self):
self.ignore(self.UP_KEY + '-up')
self.accept(self.UP_KEY, self.__upKeyPressed)
self.__upReleased()
def __downKeyReleased(self):
self.ignore(self.DOWN_KEY + '-up')
self.accept(self.DOWN_KEY, self.__downKeyPressed)
self.__downReleased()
def __upPressed(self):
self.notify.debug('up pressed')
self.upPressed = self.__enterControlActive(self.upPressed)
def __downPressed(self):
self.notify.debug('down pressed')
self.downPressed = self.__enterControlActive(self.downPressed)
def __leftPressed(self):
self.notify.debug('left pressed')
self.leftPressed = self.__enterControlActive(self.leftPressed)
def __rightPressed(self):
self.notify.debug('right pressed')
self.rightPressed = self.__enterControlActive(self.rightPressed)
def __upReleased(self):
self.notify.debug('up released')
self.upPressed = self.__exitControlActive(self.upPressed)
def __downReleased(self):
self.notify.debug('down released')
self.downPressed = self.__exitControlActive(self.downPressed)
def __leftReleased(self):
self.notify.debug('left released')
self.leftPressed = self.__exitControlActive(self.leftPressed)
def __rightReleased(self):
self.notify.debug('right released')
self.rightPressed = self.__exitControlActive(self.rightPressed)
def __firePressed(self):
self.notify.debug('fire pressed')
messenger.send(CannonGui.FIRE_PRESSED)
def __enterControlActive(self, control):
return control + 1
def __exitControlActive(self, control):
return max(0, control - 1)
class CannonGui(DirectObject):
notify = directNotify.newCategory('CannonGui')
FIRE_KEY = 'control'
UP_KEY = 'arrow_up'
DOWN_KEY = 'arrow_down'
LEFT_KEY = 'arrow_left'
RIGHT_KEY = 'arrow_right'
FIRE_PRESSED = 'cannongui_fire_pressed'
def __init__(self):
self.__loaded = False
self.leftPressed = 0
self.rightPressed = 0
self.upPressed = 0
self.downPressed = 0
self.__aimPad = None
self.__timerPad = None
return
def load(self):
if self.__loaded:
return
self.__timerPad = PartyUtils.getNewToontownTimer()
guiModel = 'phase_4/models/gui/cannon_game_gui'
guiNode = loader.loadModel(guiModel)
self.__aimPad = DirectFrame(image=guiNode.find('**/CannonFire_PAD'), relief=None, pos=(0.7, 0, -0.553333), scale=0.8)
guiNode.removeNode()
self.fireButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Fire_Btn_UP'), (guiModel, '**/Fire_Btn_DN'), (guiModel, '**/Fire_Btn_RLVR')), relief=None, pos=(0.0115741, 0, 0.00505051), scale=1.0, command=self.__firePressed)
self.upButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(0.0115741, 0, 0.221717))
self.downButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(0.0136112, 0, -0.210101), image_hpr=(0, 0, 180))
self.leftButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(-0.199352, 0, -0.000505269), image_hpr=(0, 0, -90))
self.rightButton = DirectButton(parent=self.__aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(0.219167, 0, -0.00101024), image_hpr=(0, 0, 90))
self.__aimPad.setColor(1, 1, 1, 0.9)
def bindButton(button, upHandler, downHandler):
button.bind(DGG.B1PRESS, lambda x, handler = upHandler: handler())
button.bind(DGG.B1RELEASE, lambda x, handler = downHandler: handler())
bindButton(self.upButton, self.__upPressed, self.__upReleased)
bindButton(self.downButton, self.__downPressed, self.__downReleased)
bindButton(self.leftButton, self.__leftPressed, self.__leftReleased)
bindButton(self.rightButton, self.__rightPressed, self.__rightReleased)
self.__loaded = True
return
def unload(self):
self.ignoreAll()
if not self.__loaded:
return
self.disable()
self.upButton.unbind(DGG.B1PRESS)
self.upButton.unbind(DGG.B1RELEASE)
self.downButton.unbind(DGG.B1PRESS)
self.downButton.unbind(DGG.B1RELEASE)
self.leftButton.unbind(DGG.B1PRESS)
self.leftButton.unbind(DGG.B1RELEASE)
self.rightButton.unbind(DGG.B1PRESS)
self.rightButton.unbind(DGG.B1RELEASE)
self.fireButton.destroy()
self.__aimPad.destroy()
del self.__aimPad
del self.fireButton
del self.upButton
del self.downButton
del self.leftButton
del self.rightButton
self.__timerPad.destroy()
del self.__timerPad
self.__loaded = False
def enable(self, timer = 0):
self.__aimPad.show()
base.setCellsAvailable([base.bottomCells[3], base.bottomCells[4]], 0)
base.setCellsAvailable([base.rightCells[1]], 0)
if timer > 0:
self.__timerPad.setTime(timer)
self.__timerPad.countdown(timer)
self.__timerPad.show()
self.enableKeys()
def disable(self):
self.__aimPad.hide()
base.setCellsAvailable([base.bottomCells[3], base.bottomCells[4]], 1)
base.setCellsAvailable([base.rightCells[1]], 1)
self.__timerPad.hide()
self.disableKeys()
def enableKeys(self):
self.enableAimKeys()
self.enableFireKey()
def disableKeys(self):
self.__aimPad.hide()
self.disableAimKeys()
self.disableFireKey()
def enableAimKeys(self):
self.leftPressed = 0
self.rightPressed = 0
self.upPressed = 0
self.downPressed = 0
self.accept(self.UP_KEY, self.__upKeyPressed)
self.accept(self.DOWN_KEY, self.__downKeyPressed)
self.accept(self.LEFT_KEY, self.__leftKeyPressed)
self.accept(self.RIGHT_KEY, self.__rightKeyPressed)
def disableAimKeys(self):
self.ignore(self.UP_KEY)
self.ignore(self.DOWN_KEY)
self.ignore(self.LEFT_KEY)
self.ignore(self.RIGHT_KEY)
messenger.send(self.UP_KEY + '-up')
messenger.send(self.DOWN_KEY + '-up')
messenger.send(self.LEFT_KEY + '-up')
messenger.send(self.RIGHT_KEY + '-up')
self.ignore(self.UP_KEY + '-up')
self.ignore(self.DOWN_KEY + '-up')
self.ignore(self.LEFT_KEY + '-up')
self.ignore(self.RIGHT_KEY + '-up')
def enableFireKey(self):
self.accept(self.FIRE_KEY, self.__fireKeyPressed)
def disableFireKey(self):
self.ignore(self.FIRE_KEY)
self.ignore(self.FIRE_KEY + '-up')
def __fireKeyPressed(self):
self.ignore(self.FIRE_KEY)
self.accept(self.FIRE_KEY + '-up', self.__fireKeyReleased)
self.__firePressed()
def __upKeyPressed(self):
self.ignore(self.UP_KEY)
self.accept(self.UP_KEY + '-up', self.__upKeyReleased)
self.__upPressed()
def __downKeyPressed(self):
self.ignore(self.DOWN_KEY)
self.accept(self.DOWN_KEY + '-up', self.__downKeyReleased)
self.__downPressed()
def __leftKeyPressed(self):
self.ignore(self.LEFT_KEY)
self.accept(self.LEFT_KEY + '-up', self.__leftKeyReleased)
self.__leftPressed()
def __rightKeyPressed(self):
self.ignore(self.RIGHT_KEY)
self.accept(self.RIGHT_KEY + '-up', self.__rightKeyReleased)
self.__rightPressed()
def __fireKeyReleased(self):
self.ignore(self.FIRE_KEY + '-up')
self.accept(self.FIRE_KEY, self.__fireKeyPressed)
def __leftKeyReleased(self):
self.ignore(self.LEFT_KEY + '-up')
self.accept(self.LEFT_KEY, self.__leftKeyPressed)
self.__leftReleased()
def __rightKeyReleased(self):
self.ignore(self.RIGHT_KEY + '-up')
self.accept(self.RIGHT_KEY, self.__rightKeyPressed)
self.__rightReleased()
def __upKeyReleased(self):
self.ignore(self.UP_KEY + '-up')
self.accept(self.UP_KEY, self.__upKeyPressed)
self.__upReleased()
def __downKeyReleased(self):
self.ignore(self.DOWN_KEY + '-up')
self.accept(self.DOWN_KEY, self.__downKeyPressed)
self.__downReleased()
def __upPressed(self):
self.notify.debug('up pressed')
self.upPressed = self.__enterControlActive(self.upPressed)
def __downPressed(self):
self.notify.debug('down pressed')
self.downPressed = self.__enterControlActive(self.downPressed)
def __leftPressed(self):
self.notify.debug('left pressed')
self.leftPressed = self.__enterControlActive(self.leftPressed)
def __rightPressed(self):
self.notify.debug('right pressed')
self.rightPressed = self.__enterControlActive(self.rightPressed)
def __upReleased(self):
self.notify.debug('up released')
self.upPressed = self.__exitControlActive(self.upPressed)
def __downReleased(self):
self.notify.debug('down released')
self.downPressed = self.__exitControlActive(self.downPressed)
def __leftReleased(self):
self.notify.debug('left released')
self.leftPressed = self.__exitControlActive(self.leftPressed)
def __rightReleased(self):
self.notify.debug('right released')
self.rightPressed = self.__exitControlActive(self.rightPressed)
def __firePressed(self):
self.notify.debug('fire pressed')
messenger.send(CannonGui.FIRE_PRESSED)
def __enterControlActive(self, control):
return control + 1
def __exitControlActive(self, control):
return max(0, control - 1)
class Transitions:
# These may be reassigned before the fade or iris transitions are
# actually invoked to change the models that will be used.
IrisModelName = "models/misc/iris"
FadeModelName = "models/misc/fade"
def __init__(self, loader, model=None, scale=3.0, pos=Vec3(0, 0, 0)):
self.transitionIval = None
self.letterboxIval = None
self.iris = None
self.fade = None
self.letterbox = None
self.fadeModel = model
self.imagePos = pos
if model:
self.alphaOff = Vec4(1, 1, 1, 0)
self.alphaOn = Vec4(1, 1, 1, 1)
model.setTransparency(1)
self.lerpFunc = LerpColorScaleInterval
else:
self.alphaOff = Vec4(0, 0, 0, 0)
self.alphaOn = Vec4(0, 0, 0, 1)
self.lerpFunc = LerpColorInterval
self.irisTaskName = "irisTask"
self.fadeTaskName = "fadeTask"
self.letterboxTaskName = "letterboxTask"
def __del__(self):
if self.fadeModel:
self.fadeModel.removeNode()
self.fadeModel = None
##################################################
# Fade
##################################################
# We can set a custom model for the fade before using it for the first time
def setFadeModel(self, model, scale=1.0):
self.fadeModel = model
# We have to change some default parameters for a custom fadeModel
self.alphaOn = Vec4(1, 1, 1, 1)
# Reload fade if its already been created
if self.fade:
self.fade.destroy()
self.fade = None
self.loadFade()
def loadFade(self):
if self.fade is None:
# We create a DirectFrame for the fade polygon, instead of
# simply loading the polygon model and using it directly,
# so that it will also obscure mouse events for objects
# positioned behind it.
self.fade = DirectFrame(
parent=hidden,
guiId='fade',
relief=None,
image=self.fadeModel,
image_scale=(4, 2, 2),
state=DGG.NORMAL,
)
if not self.fadeModel:
# No fade model was given, so we make this the fade model.
self.fade["relief"] = DGG.FLAT
self.fade["frameSize"] = (-2, 2, -1, 1)
self.fade["frameColor"] = (0, 0, 0, 1)
self.fade.setTransparency(TransparencyAttrib.MAlpha)
self.fade.setBin('unsorted', 0)
self.fade.setColor(0, 0, 0, 0)
def getFadeInIval(self, t=0.5, finishIval=None):
"""
Returns an interval without starting it. This is particularly useful in
cutscenes, so when the cutsceneIval is escaped out of we can finish the fade immediately
"""
#self.noTransitions() masad: this creates a one frame pop, is it necessary?
self.loadFade()
transitionIval = Sequence(
Func(self.fade.reparentTo, aspect2d, DGG.FADE_SORT_INDEX),
Func(self.fade.showThrough
), # in case aspect2d is hidden for some reason
self.lerpFunc(
self.fade,
t,
self.alphaOff,
# self.alphaOn,
),
Func(self.fade.detachNode),
name=self.fadeTaskName,
)
if finishIval:
transitionIval.append(finishIval)
return transitionIval
def getFadeOutIval(self, t=0.5, finishIval=None):
"""
Create a sequence that lerps the color out, then
parents the fade to hidden
"""
self.noTransitions()
self.loadFade()
transitionIval = Sequence(
Func(self.fade.reparentTo, aspect2d, DGG.FADE_SORT_INDEX),
Func(self.fade.showThrough
), # in case aspect2d is hidden for some reason
self.lerpFunc(
self.fade,
t,
self.alphaOn,
# self.alphaOff,
),
name=self.fadeTaskName,
)
if finishIval:
transitionIval.append(finishIval)
return transitionIval
def fadeIn(self, t=0.5, finishIval=None):
"""
Play a fade in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from black to transparent. When the color lerp is finished, it
parents the fade polygon to hidden.
"""
gsg = base.win.getGsg()
if gsg:
# If we're about to fade in from black, go ahead and
# preload all the textures etc.
base.graphicsEngine.renderFrame()
render.prepareScene(gsg)
render2d.prepareScene(gsg)
if (t == 0):
# Fade in immediately with no lerp
#print "transitiosn: fadeIn 0.0"
self.noTransitions()
self.loadFade()
self.fade.detachNode()
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
self.transitionIval = self.getFadeInIval(t, finishIval)
self.transitionIval.start()
def fadeOut(self, t=0.5, finishIval=None):
"""
Play a fade out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from transparent to full black. When the color lerp is finished,
it leaves the fade polygon covering the aspect2d plane until you
fadeIn or call noFade.
lerp
"""
if (t == 0):
# Fade out immediately with no lerp
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(self.alphaOn)
elif ConfigVariableBool('no-loading-screen', False):
if finishIval:
self.transitionIval = finishIval
self.transitionIval.start()
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
self.transitionIval = self.getFadeOutIval(t, finishIval)
self.transitionIval.start()
def fadeOutActive(self):
return self.fade and self.fade.getColor()[3] > 0
def fadeScreen(self, alpha=0.5):
"""
Put a semitransparent screen over the camera plane
to darken out the world. Useful for drawing attention to
a dialog box for instance
"""
#print "transitiosn: fadeScreen"
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(self.alphaOn[0], self.alphaOn[1], self.alphaOn[2],
alpha)
def fadeScreenColor(self, color):
"""
Put a semitransparent screen over the camera plane
to darken out the world. Useful for drawing attention to
a dialog box for instance
"""
#print "transitiosn: fadeScreenColor"
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(color)
def noFade(self):
"""
Removes any current fade tasks and parents the fade polygon away
"""
#print "transitiosn: noFade"
if self.transitionIval:
self.transitionIval.pause()
self.transitionIval = None
if self.fade:
# Make sure to reset the color, since fadeOutActive() is looking at it
self.fade.setColor(self.alphaOff)
self.fade.detachNode()
def setFadeColor(self, r, g, b):
self.alphaOn.set(r, g, b, 1)
self.alphaOff.set(r, g, b, 0)
##################################################
# Iris
##################################################
def loadIris(self):
if self.iris == None:
self.iris = loader.loadModel(self.IrisModelName)
self.iris.setPos(0, 0, 0)
def irisIn(self, t=0.5, finishIval=None):
"""
Play an iris in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris polygon up so it looks like we iris in. When the
scale lerp is finished, it parents the iris polygon to hidden.
"""
self.noTransitions()
self.loadIris()
if (t == 0):
self.iris.detachNode()
else:
self.iris.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.transitionIval = Sequence(
LerpScaleInterval(self.iris, t, scale=0.18, startScale=0.01),
Func(self.iris.detachNode),
name=self.irisTaskName,
)
if finishIval:
self.transitionIval.append(finishIval)
self.transitionIval.start()
def irisOut(self, t=0.5, finishIval=None):
"""
Play an iris out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris down so it looks like we iris out. When the scale
lerp is finished, it leaves the iris polygon covering the
aspect2d plane until you irisIn or call noIris.
"""
self.noTransitions()
self.loadIris()
self.loadFade() # we need this to cover up the hole.
if (t == 0):
self.iris.detachNode()
self.fadeOut(0)
else:
self.iris.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.transitionIval = Sequence(
LerpScaleInterval(self.iris, t, scale=0.01, startScale=0.18),
Func(self.iris.detachNode),
# Use the fade to cover up the hole that the iris would leave
Func(self.fadeOut, 0),
name=self.irisTaskName,
)
if finishIval:
self.transitionIval.append(finishIval)
self.transitionIval.start()
def noIris(self):
"""
Removes any current iris tasks and parents the iris polygon away
"""
if self.transitionIval:
self.transitionIval.pause()
self.transitionIval = None
if self.iris != None:
self.iris.detachNode()
# Actually we need to remove the fade too,
# because the iris effect uses it.
self.noFade()
def noTransitions(self):
"""
This call should immediately remove any and all transitions running
"""
self.noFade()
self.noIris()
# Letterbox is not really a transition, it is a screen overlay
# self.noLetterbox()
##################################################
# Letterbox
##################################################
def loadLetterbox(self):
if not self.letterbox:
# We create a DirectFrame for the fade polygon, instead of
# simply loading the polygon model and using it directly,
# so that it will also obscure mouse events for objects
# positioned behind it.
self.letterbox = NodePath("letterbox")
# Allow fade in and out of the bars
self.letterbox.setTransparency(1)
# Allow DirectLabels to be parented to the letterbox sensibly
self.letterbox.setBin('unsorted', 0)
# Allow a custom look to the letterbox graphic.
# TODO: This model isn't available everywhere. We should
# pass it in as a parameter.
button = loader.loadModel('models/gui/toplevel_gui',
okMissing=True)
barImage = None
if button:
barImage = button.find('**/generic_button')
self.letterboxTop = DirectFrame(
parent=self.letterbox,
guiId='letterboxTop',
relief=DGG.FLAT,
state=DGG.NORMAL,
frameColor=(0, 0, 0, 1),
borderWidth=(0, 0),
frameSize=(-1, 1, 0, 0.2),
pos=(0, 0, 0.8),
image=barImage,
image_scale=(2.25, 1, .5),
image_pos=(0, 0, .1),
image_color=(0.3, 0.3, 0.3, 1),
sortOrder=0,
)
self.letterboxBottom = DirectFrame(
parent=self.letterbox,
guiId='letterboxBottom',
relief=DGG.FLAT,
state=DGG.NORMAL,
frameColor=(0, 0, 0, 1),
borderWidth=(0, 0),
frameSize=(-1, 1, 0, 0.2),
pos=(0, 0, -1),
image=barImage,
image_scale=(2.25, 1, .5),
image_pos=(0, 0, .1),
image_color=(0.3, 0.3, 0.3, 1),
sortOrder=0,
)
# masad: always place these at the bottom of render
self.letterboxTop.setBin('sorted', 0)
self.letterboxBottom.setBin('sorted', 0)
self.letterbox.reparentTo(render2d, -1)
self.letterboxOff(0)
def noLetterbox(self):
"""
Removes any current letterbox tasks and parents the letterbox polygon away
"""
if self.letterboxIval:
self.letterboxIval.pause()
self.letterboxIval = None
if self.letterbox:
self.letterbox.stash()
def letterboxOn(self, t=0.25, finishIval=None):
"""
Move black bars in over t seconds.
"""
self.noLetterbox()
self.loadLetterbox()
self.letterbox.unstash()
if (t == 0):
self.letterboxBottom.setPos(0, 0, -1)
self.letterboxTop.setPos(0, 0, 0.8)
else:
self.letterboxIval = Sequence(
Parallel(
LerpPosInterval(
self.letterboxBottom,
t,
pos=Vec3(0, 0, -1),
#startPos = Vec3(0, 0, -1.2),
),
LerpPosInterval(
self.letterboxTop,
t,
pos=Vec3(0, 0, 0.8),
# startPos = Vec3(0, 0, 1),
),
),
name=self.letterboxTaskName,
)
if finishIval:
self.letterboxIval.append(finishIval)
self.letterboxIval.start()
def letterboxOff(self, t=0.25, finishIval=None):
"""
Move black bars away over t seconds.
"""
self.noLetterbox()
self.loadLetterbox()
self.letterbox.unstash()
if (t == 0):
self.letterbox.stash()
else:
self.letterboxIval = Sequence(
Parallel(
LerpPosInterval(
self.letterboxBottom,
t,
pos=Vec3(0, 0, -1.2),
# startPos = Vec3(0, 0, -1),
),
LerpPosInterval(
self.letterboxTop,
t,
pos=Vec3(0, 0, 1),
# startPos = Vec3(0, 0, 0.8),
),
),
Func(self.letterbox.stash),
Func(messenger.send, 'letterboxOff'),
name=self.letterboxTaskName,
)
if finishIval:
self.letterboxIval.append(finishIval)
self.letterboxIval.start()
class CannonGui(DirectObject):
notify = directNotify.newCategory("CannonGui")
# keyboard controls
FIRE_KEY = "control"
UP_KEY = "arrow_up"
DOWN_KEY = "arrow_down"
LEFT_KEY = "arrow_left"
RIGHT_KEY = "arrow_right"
FIRE_PRESSED = "cannongui_fire_pressed"
def __init__(self):
self.__loaded = False
# since there are multiple inputs tied to each
# of these (buttons and keypresses), they are
# incremented for every button or keypress
# that is active
self.leftPressed = 0
self.rightPressed = 0
self.upPressed = 0
self.downPressed = 0
self.__aimPad = None
self.__timerPad = None
def load(self):
if self.__loaded:
return
# Load Timer
self.__timerPad = PartyUtils.getNewToontownTimer()
# set up the cannon aiming/firing gui
guiModel = "phase_4/models/gui/cannon_game_gui"
guiNode = loader.loadModel(guiModel)
self.__aimPad = DirectFrame(image = guiNode.find("**/CannonFire_PAD"),
relief = None,
pos = (0.7, 0, -0.553333),
scale = 0.8,
)
guiNode.removeNode()
# Set up the fire and arrow buttons
self.fireButton = DirectButton(parent = self.__aimPad,
image = ((guiModel, "**/Fire_Btn_UP"),
(guiModel, "**/Fire_Btn_DN"),
(guiModel, "**/Fire_Btn_RLVR"),
),
relief = None,
pos = (0.0115741,0,0.00505051),
scale = 1.,
command = self.__firePressed,
)
self.upButton = DirectButton(parent = self.__aimPad,
image = ((guiModel, "**/Cannon_Arrow_UP"),
(guiModel, "**/Cannon_Arrow_DN"),
(guiModel, "**/Cannon_Arrow_RLVR"),
),
relief = None,
pos = (0.0115741,0,0.221717),
)
self.downButton = DirectButton(parent = self.__aimPad,
image = ((guiModel, "**/Cannon_Arrow_UP"),
(guiModel, "**/Cannon_Arrow_DN"),
(guiModel, "**/Cannon_Arrow_RLVR"),
),
relief = None,
pos = (0.0136112,0,-0.210101),
image_hpr = (0,0,180),
)
self.leftButton = DirectButton(parent = self.__aimPad,
image = ((guiModel, "**/Cannon_Arrow_UP"),
(guiModel, "**/Cannon_Arrow_DN"),
(guiModel, "**/Cannon_Arrow_RLVR"),
),
relief = None,
pos = (-0.199352,0,-0.000505269),
image_hpr = (0,0,-90),
)
self.rightButton = DirectButton(parent = self.__aimPad,
image = ((guiModel, "**/Cannon_Arrow_UP"),
(guiModel, "**/Cannon_Arrow_DN"),
(guiModel, "**/Cannon_Arrow_RLVR"),
),
relief = None,
pos = (0.219167,0,-0.00101024),
image_hpr = (0,0,90),
)
# Make the aim pad semi transparent
self.__aimPad.setColor(1,1,1, 0.9)
# Set up the button press/release handlers
# Buttons have the ability send signal as long as they're pressed.
def bindButton(button, upHandler, downHandler):
button.bind(DGG.B1PRESS, lambda x, handler=upHandler : handler())
button.bind(DGG.B1RELEASE, lambda x, handler=downHandler : handler())
bindButton(self.upButton, self.__upPressed, self.__upReleased)
bindButton(self.downButton, self.__downPressed, self.__downReleased)
bindButton(self.leftButton, self.__leftPressed, self.__leftReleased)
bindButton(self.rightButton, self.__rightPressed, self.__rightReleased)
self.__loaded = True
def unload(self):
self.ignoreAll()
if not self.__loaded:
return
self.disable()
# Do we need to unbind?
self.upButton.unbind(DGG.B1PRESS)
self.upButton.unbind(DGG.B1RELEASE)
self.downButton.unbind(DGG.B1PRESS)
self.downButton.unbind(DGG.B1RELEASE)
self.leftButton.unbind(DGG.B1PRESS)
self.leftButton.unbind(DGG.B1RELEASE)
self.rightButton.unbind(DGG.B1PRESS)
self.rightButton.unbind(DGG.B1RELEASE)
self.fireButton.destroy()
self.__aimPad.destroy()
del self.__aimPad
del self.fireButton
del self.upButton
del self.downButton
del self.leftButton
del self.rightButton
self.__timerPad.destroy()
del self.__timerPad
self.__loaded = False
def enable(self, timer=0):
self.__aimPad.show()
# Free up two of the nametag cells on the bottom edge
# of the screen to leave room for the cannon gui.
base.setCellsAvailable([base.bottomCells[3], base.bottomCells[4]], 0)
base.setCellsAvailable([base.rightCells[1]], 0)
if timer > 0:
self.__timerPad.setTime(timer)
self.__timerPad.countdown(timer)
self.__timerPad.show()
self.enableKeys()
def disable(self):
self.__aimPad.hide()
# Restore the normal nametag cells.
base.setCellsAvailable([base.bottomCells[3], base.bottomCells[4]], 1)
base.setCellsAvailable([base.rightCells[1]], 1)
self.__timerPad.hide()
self.disableKeys()
def enableKeys(self):
self.enableAimKeys()
self.enableFireKey()
def disableKeys(self):
self.__aimPad.hide()
self.disableAimKeys()
self.disableFireKey()
def enableAimKeys(self):
self.leftPressed = 0
self.rightPressed = 0
self.upPressed = 0
self.downPressed = 0
self.accept(self.UP_KEY, self.__upKeyPressed)
self.accept(self.DOWN_KEY, self.__downKeyPressed)
self.accept(self.LEFT_KEY, self.__leftKeyPressed)
self.accept(self.RIGHT_KEY, self.__rightKeyPressed)
def disableAimKeys(self):
self.ignore(self.UP_KEY)
self.ignore(self.DOWN_KEY)
self.ignore(self.LEFT_KEY)
self.ignore(self.RIGHT_KEY)
messenger.send(self.UP_KEY + "-up")
messenger.send(self.DOWN_KEY + "-up")
messenger.send(self.LEFT_KEY + "-up")
messenger.send(self.RIGHT_KEY + "-up")
self.ignore(self.UP_KEY + "-up")
self.ignore(self.DOWN_KEY + "-up")
self.ignore(self.LEFT_KEY + "-up")
self.ignore(self.RIGHT_KEY + "-up")
def enableFireKey(self):
self.accept(self.FIRE_KEY, self.__fireKeyPressed)
def disableFireKey(self):
self.ignore(self.FIRE_KEY)
self.ignore(self.FIRE_KEY + "-up")
#===============================================================================
# Button / Key Handlers
#===============================================================================
# KEYS PRESSED
def __fireKeyPressed(self):
self.ignore(self.FIRE_KEY)
self.accept(self.FIRE_KEY+"-up", self.__fireKeyReleased)
self.__firePressed()
def __upKeyPressed(self):
self.ignore(self.UP_KEY)
self.accept(self.UP_KEY+"-up", self.__upKeyReleased)
self.__upPressed()
def __downKeyPressed(self):
self.ignore(self.DOWN_KEY)
self.accept(self.DOWN_KEY+"-up", self.__downKeyReleased)
self.__downPressed()
def __leftKeyPressed(self):
self.ignore(self.LEFT_KEY)
self.accept(self.LEFT_KEY+"-up", self.__leftKeyReleased)
self.__leftPressed()
def __rightKeyPressed(self):
self.ignore(self.RIGHT_KEY)
self.accept(self.RIGHT_KEY+"-up", self.__rightKeyReleased)
self.__rightPressed()
# KEYS RELEASED
def __fireKeyReleased(self):
self.ignore(self.FIRE_KEY+"-up")
self.accept(self.FIRE_KEY, self.__fireKeyPressed)
#self.__fireReleased()
def __leftKeyReleased(self):
self.ignore(self.LEFT_KEY+"-up")
self.accept(self.LEFT_KEY, self.__leftKeyPressed)
self.__leftReleased()
def __rightKeyReleased(self):
self.ignore(self.RIGHT_KEY+"-up")
self.accept(self.RIGHT_KEY, self.__rightKeyPressed)
self.__rightReleased()
def __upKeyReleased(self):
self.ignore(self.UP_KEY+"-up")
self.accept(self.UP_KEY, self.__upKeyPressed)
self.__upReleased()
def __downKeyReleased(self):
self.ignore(self.DOWN_KEY+"-up")
self.accept(self.DOWN_KEY, self.__downKeyPressed)
self.__downReleased()
# GENERAL HANDLERS
def __upPressed(self):
self.notify.debug("up pressed")
self.upPressed = self.__enterControlActive(self.upPressed)
def __downPressed(self):
self.notify.debug("down pressed")
self.downPressed = self.__enterControlActive(self.downPressed)
def __leftPressed(self):
self.notify.debug("left pressed")
self.leftPressed = self.__enterControlActive(self.leftPressed)
def __rightPressed(self):
self.notify.debug("right pressed")
self.rightPressed = self.__enterControlActive(self.rightPressed)
def __upReleased(self):
self.notify.debug("up released")
self.upPressed = self.__exitControlActive(self.upPressed)
def __downReleased(self):
self.notify.debug("down released")
self.downPressed = self.__exitControlActive(self.downPressed)
def __leftReleased(self):
self.notify.debug("left released")
self.leftPressed = self.__exitControlActive(self.leftPressed)
def __rightReleased(self):
self.notify.debug("right released")
self.rightPressed = self.__exitControlActive(self.rightPressed)
# Unlike the other modes, fire only sends an event. It can not be held down.
def __firePressed(self):
self.notify.debug("fire pressed")
messenger.send(CannonGui.FIRE_PRESSED)
# __enterControlActive and __exitControlActive are used
# to update the cannon control 'press reference counts'
# leftPressed, rightPressed, upPressed, and downPressed
# are all counts of how many devices (button, keys) are
# activating that particular cannon control -- so if
# someone is pressing 'right' on the keyboard and also
# pressing on the 'right' button with the mouse,
# rightPressed would be set to 2. A value of zero means
# that the cannon control is inactive.
def __enterControlActive(self, control):
return control + 1
def __exitControlActive(self, control):
return max(0, control-1)
class LaffMeter(DirectFrame):
deathColor = Vec4(0.58039216, 0.80392157, 0.34117647, 1.0)
def __init__(self, avdna, hp, maxHp):
DirectFrame.__init__(self, relief=None, sortOrder=50)
self.initialiseoptions(LaffMeter)
self.container = DirectFrame(parent=self, relief=None)
self.style = avdna
self.av = None
self.hp = hp
self.maxHp = maxHp
self.__obscured = 0
if self.style.type == 't':
self.isToon = 1
else:
self.isToon = 0
self.magicRainbow = Sequence()
self.load()
return
def obscure(self, obscured):
self.__obscured = obscured
if self.__obscured:
self.hide()
def isObscured(self):
return self.__obscured
def load(self):
gui = loader.loadModel('phase_3/models/gui/laff_o_meter')
if self.isToon:
hType = self.style.getType()
if hType == 'dog':
headModel = gui.find('**/doghead')
elif hType == 'cat':
headModel = gui.find('**/cathead')
elif hType == 'mouse':
headModel = gui.find('**/mousehead')
elif hType == 'horse':
headModel = gui.find('**/horsehead')
elif hType == 'rabbit':
headModel = gui.find('**/bunnyhead')
elif hType in ('duck', 'gyro', 'scrooge'):
headModel = gui.find('**/duckhead')
elif hType == 'monkey':
headModel = gui.find('**/monkeyhead')
elif hType == 'bear':
headModel = gui.find('**/bearhead')
elif hType == 'pig':
headModel = gui.find('**/pighead')
else:
raise StandardError('unknown toon species: ', hType)
self.color = self.style.getHeadColor()
self.resetFrameSize()
self.setScale(0.1)
self.image = DirectFrame(parent=self.container,
relief=None,
image=headModel)
self.image.setColor(self.color)
self.magicRainbow = Sequence(
LerpColorInterval(self.image,
duration=1,
color=VBase4(0.996094, 0.898438, 0.320312,
1.0)),
LerpColorInterval(self.image,
duration=1,
color=VBase4(0.304688, 0.96875, 0.402344,
1.0)),
LerpColorInterval(self.image,
duration=1,
color=VBase4(0.191406, 0.5625, 0.773438,
1.0)),
LerpColorInterval(self.image,
duration=0.5,
color=VBase4(0.546875, 0.28125, 0.75, 1.0)),
LerpColorInterval(self.image,
duration=0.5,
color=VBase4(0.933594, 0.265625, 0.28125,
1.0)))
if self.style.headColor == 27 and self.magicRainbow.isStopped():
self.magicRainbow.loop()
self.frown = DirectFrame(parent=self.container,
relief=None,
image=gui.find('**/frown'))
self.smile = DirectFrame(parent=self.container,
relief=None,
image=gui.find('**/smile'))
self.eyes = DirectFrame(parent=self.container,
relief=None,
image=gui.find('**/eyes'))
self.openSmile = DirectFrame(parent=self.container,
relief=None,
image=gui.find('**/open_smile'))
self.tooth1 = DirectFrame(parent=self.openSmile,
relief=None,
image=gui.find('**/tooth_1'))
self.tooth2 = DirectFrame(parent=self.openSmile,
relief=None,
image=gui.find('**/tooth_2'))
self.tooth3 = DirectFrame(parent=self.openSmile,
relief=None,
image=gui.find('**/tooth_3'))
self.tooth4 = DirectFrame(parent=self.openSmile,
relief=None,
image=gui.find('**/tooth_4'))
self.tooth5 = DirectFrame(parent=self.openSmile,
relief=None,
image=gui.find('**/tooth_5'))
self.tooth6 = DirectFrame(parent=self.openSmile,
relief=None,
image=gui.find('**/tooth_6'))
self.maxLabel = DirectLabel(
parent=self.eyes,
relief=None,
pos=(0.442, 0, 0.051),
text='120',
text_scale=0.4,
text_font=ToontownGlobals.getInterfaceFont())
self.hpLabel = DirectLabel(
parent=self.eyes,
relief=None,
pos=(-0.398, 0, 0.051),
text='120',
text_scale=0.4,
text_font=ToontownGlobals.getInterfaceFont())
self.teeth = [
self.tooth6, self.tooth5, self.tooth4, self.tooth3,
self.tooth2, self.tooth1
]
self.fractions = [0.0, 0.166666, 0.333333, 0.5, 0.666666, 0.833333]
gui.removeNode()
return
def destroy(self):
if self.magicRainbow.isPlaying():
self.magicRainbow.finish()
del self.magicRainbow
if self.av:
ToontownIntervals.cleanup(
self.av.uniqueName('laffMeterBoing') + '-' + str(self.this))
ToontownIntervals.cleanup(
self.av.uniqueName('laffMeterBoing') + '-' + str(self.this) +
'-play')
self.ignore(self.av.uniqueName('hpChange'))
del self.style
del self.av
del self.hp
del self.maxHp
if self.isToon:
del self.frown
del self.smile
del self.openSmile
del self.tooth1
del self.tooth2
del self.tooth3
del self.tooth4
del self.tooth5
del self.tooth6
del self.teeth
del self.fractions
del self.maxLabel
del self.hpLabel
DirectFrame.destroy(self)
def adjustTeeth(self):
if self.isToon:
for i in xrange(len(self.teeth)):
if self.hp > self.maxHp * self.fractions[i]:
self.teeth[i].show()
else:
self.teeth[i].hide()
def adjustText(self):
if self.isToon:
if self.maxLabel['text'] != str(
self.maxHp) or self.hpLabel['text'] != str(self.hp):
self.maxLabel['text'] = str(self.maxHp)
self.hpLabel['text'] = str(self.hp)
def animatedEffect(self, delta):
if delta == 0 or self.av == None:
return
name = self.av.uniqueName('laffMeterBoing') + '-' + str(self.this)
ToontownIntervals.cleanup(name)
if delta > 0:
ToontownIntervals.start(
ToontownIntervals.getPulseLargerIval(self.container, name))
else:
ToontownIntervals.start(
ToontownIntervals.getPulseSmallerIval(self.container, name))
return
def adjustFace(self, hp, maxHp, quietly=0):
if self.isToon and self.hp != None:
self.frown.hide()
self.smile.hide()
self.openSmile.hide()
self.eyes.hide()
for tooth in self.teeth:
tooth.hide()
delta = hp - self.hp
self.hp = hp
self.maxHp = maxHp
if self.hp < 1:
self.frown.show()
if self.magicRainbow.isPlaying():
self.magicRainbow.finish()
self.image.setColor(self.deathColor)
elif self.hp >= self.maxHp:
self.smile.show()
self.eyes.show()
self.image.setColor(self.color)
if self.style.headColor == 27 and self.magicRainbow.isStopped(
):
self.magicRainbow.loop()
else:
self.openSmile.show()
self.eyes.show()
self.maxLabel.show()
self.hpLabel.show()
self.image.setColor(self.color)
if self.style.headColor == 27 and self.magicRainbow.isStopped(
):
self.magicRainbow.loop()
self.adjustTeeth()
self.adjustText()
if not quietly:
self.animatedEffect(delta)
return
def adjustToonColor(self, style):
if self.magicRainbow.isPlaying():
self.magicRainbow.finish()
self.style = style
self.color = self.style.getHeadColor()
if self.hp >= 1:
self.image.setColor(self.color)
if self.style.headColor == 27:
self.magicRainbow.loop()
def start(self):
if self.av:
self.hp = self.av.hp
self.maxHp = self.av.maxHp
if self.isToon:
if not self.__obscured:
self.show()
self.adjustFace(self.hp, self.maxHp, 1)
if self.av:
self.accept(self.av.uniqueName('hpChange'), self.adjustFace)
def stop(self):
if self.isToon:
self.hide()
if self.av:
self.ignore(self.av.uniqueName('hpChange'))
def setAvatar(self, av):
if self.av:
self.ignore(self.av.uniqueName('hpChange'))
self.av = av
