class ChatBubble:
def __init__(self, text, unit):
self.creation_time = datetime.now()
font = MainFont()
frame_padding = 0.3
half_frame_length = len(text) * 0.1 + frame_padding
self.bubble_text = DirectLabel(
text=text,
pos=(0, 0, 0.66),
scale=0.04,
parent=unit.base_node,
text_bg=(0, 0, 0, 0),
text_fg=(1, 1, 1, 1),
frameColor=(0, 0, 0, 0),
text_font=font,
)
self.bubble_frame = DirectFrame(pos=(0, 0.01, 0.67),
scale=0.1,
parent=unit.base_node,
frameColor=(0, 0, 0, 0.5),
frameSize=(-half_frame_length,
half_frame_length, -0.5,
0.5))
self.bubble_text.set_compass(core.instance.camera)
self.bubble_frame.set_compass(core.instance.camera)
def destroy(self):
self.bubble_text.destroy()
self.bubble_frame.destroy()
class DistributedBattleShop(DistributedShop):
notify = directNotify.newCategory("DistributedBattleShop")
def __init__(self, cr):
try:
self.DistributedBattleShop_initialized
return
except:
self.DistributedBattleShop_initialized = 1
DistributedShop.__init__(self, cr)
self.shopStateData = BattleShop(self, 'battleShopDone')
self.stand = None
self.standText = None
def enterAccepted(self):
if not self.inShop:
self.acceptOnce(self.shopStateData.doneEvent, self.handleShopDone)
self.shopStateData.load()
self.shopStateData.enter()
self.inShop = True
def handleShopDone(self):
self.shopStateData.exit()
self.shopStateData.unload()
self.d_requestExit()
def setupClerk(self):
self.clerk = Toon(self.cr)
self.clerk.setDNAStrand(NPC_DNA['Coach'])
self.clerk.setName('Coach')
self.clerk.generateToon()
self.clerk.reparentTo(self)
self.clerk.setupNameTag()
self.clerk.animFSM.request('neutral')
self.clerk.setH(180)
self.clerk.setY(2.2)
self.clerk.setZ(1)
self.stand = loader.loadModel("phase_4/models/props/bubblestand.egg")
self.stand.reparentTo(self)
self.stand.setScale(1.1)
self.standText = DirectLabel(text="Coach's Battle Shop",
text_fg=(0.6, 0, 0, 1),
text_decal=True,
relief=None,
parent=self.stand,
pos=(0, -0.875, 5.2),
scale=0.45,
text_font=CIGlobals.getMickeyFont())
self.snp.setY(-1)
def removeClerk(self):
DistributedShop.removeClerk(self)
self.standText.destroy()
self.standText = None
self.stand.removeNode()
self.stand = None
class DistributedBattleShop(DistributedShop):
notify = directNotify.newCategory('DistributedBattleShop')
def __init__(self, cr):
DistributedShop.__init__(self, cr)
self.shop = BattleShop(self, 'battleShopDone')
self.stand = None
self.standText = None
return
def setupClerk(self):
self.clerk = Toon(self.cr)
self.clerk.setName('Coach')
self.clerk.setDNAStrand(NPC_DNA['Coach'])
self.clerk.reparentTo(self)
self.clerk.animFSM.request('neutral')
self.clerk.setH(180)
self.clerk.setPos(0, 2.2, 1)
self.stand = loader.loadModel('phase_4/models/props/bubblestand.egg')
self.stand.reparentTo(self)
self.stand.setScale(1.1)
self.standText = DirectLabel(text="Coach's Battle Shop", text_fg=(0.6, 0, 0, 1), text_decal=True, relief=None, parent=self.stand, pos=(0, -0.875, 5.2), scale=0.45, text_font=CIGlobals.getMickeyFont())
return
def deleteClerk(self):
DistributedShop.deleteClerk(self)
if hasattr(self, 'standText'):
self.standText.destroy()
self.stand.removeNode()
del self.standText
del self.stand
def enterAccepted(self):
if not self.inShop:
self.shop.load()
self.shop.enter()
self.acceptOnce(self.shop.doneEvent, self.handleShopDone)
self.inShop = True
def handleShopDone(self):
self.shop.exit()
self.shop.unload()
self.d_requestExit()
def disable(self):
DistributedShop.disable(self)
self.ignore(self.shop.doneEvent)
if self.inShop:
self.handleShopDone()
def delete(self):
DistributedShop.delete(self)
self.shop = None
return
class FloatingBar:
def __init__(self, unit):
self.unit = unit
self.node = unit.base_node.attach_new_node("floating bar node")
self.node.set_pos(0, 0, unit.actor.HEIGHT)
self.health_bar = DirectWaitBar(
value=unit.health,
parent=self.node,
frameColor=(1, 0, 0, 0.3),
barColor=(0, 1, 0, 1),
)
self.health_bar.reparent_to(self.node)
self.health_bar.set_scale(0.13)
self.health_bar.set_compass(core.instance.camera)
self.mana_bar = DirectWaitBar(value=unit.mana,
pos=(0, 0, -0.03),
parent=self.node,
frameColor=(0, 0, 0, 0.3),
barColor=(0, 0, 1, 1),
frameSize=(-1, 1, 0.05, 0.15))
self.mana_bar.reparent_to(self.node)
self.mana_bar.set_scale(0.13)
self.mana_bar.set_compass(core.instance.camera)
font = MainFont()
self.name_label = DirectLabel(
text=unit.name,
pos=(0, 0, 0.03),
scale=0.04,
parent=self.node,
text_bg=(0, 0, 0, 0),
text_fg=(1, 1, 1, 1),
frameColor=(0, 0, 0, 0),
text_font=font,
)
self.name_label.set_compass(core.instance.camera)
def update_vertical_position(self):
self.node.set_pos(0, 0, self.unit.actor.HEIGHT)
def destroy(self):
self.mana_bar.destroy()
self.health_bar.destroy()
self.name_label.destroy()
class MoneyGUI:
def createGui(self):
self.deleteGui()
self.root = base.a2dBottomLeft.attachNewNode('moneyroot')
self.root.setScale(0.8)
self.root.setBin('gui-popup', 60)
self.frame = DirectFrame(parent=self.root, pos=(0.43, 0, 0.16))
gui = loader.loadModel("phase_3.5/models/gui/jar_gui.bam")
self.jar = OnscreenImage(image=gui, scale=0.5, parent=self.frame)
mf = loader.loadFont("phase_3/models/fonts/MickeyFont.bam")
self.money_lbl = DirectLabel(text="", text_font=mf, text_fg=(1,1,0,1), parent=self.jar, text_scale=0.2, relief=None, pos=(0, 0, -0.1))
gui.remove_node()
def deleteGui(self):
if hasattr(self, 'jar'):
self.jar.destroy()
del self.jar
if hasattr(self, 'money_lbl'):
self.money_lbl.destroy()
del self.money_lbl
if hasattr(self, 'frame'):
self.frame.destroy()
del self.frame
def update(self, newMoney, oldMoney = 0):
delta = newMoney - oldMoney
if delta != 0:
CIGlobals.makeDeltaTextEffect(delta, base.a2dBottomLeft, (0.173, 0, 0.12))
if delta > 0:
ToontownIntervals.start(ToontownIntervals.getPulseLargerIval(self.frame, 'money-effect'))
else:
ToontownIntervals.start(ToontownIntervals.getPulseSmallerIval(self.frame, 'money-effect'))
if hasattr(self, 'money_lbl'):
if newMoney <= 0:
self.money_lbl['text_fg'] = (1, 0, 0, 1)
else:
self.money_lbl['text_fg'] = (1, 1, 0, 1)
self.money_lbl['text'] = str(newMoney)
class MoneyGui:
def createGui(self):
self.deleteGui()
self.frame = DirectFrame(parent=base.a2dBottomLeft,
pos=(0.45, 0, 0.155))
gui = loader.loadModel("phase_3.5/models/gui/jar_gui.bam")
self.jar = OnscreenImage(image=gui, scale=0.5, parent=self.frame)
mf = loader.loadFont("phase_3/models/fonts/MickeyFont.bam")
self.money_lbl = DirectLabel(text="",
text_font=mf,
text_fg=(1, 1, 0, 1),
parent=self.jar,
text_scale=0.2,
relief=None,
pos=(0, 0, -0.1))
gui.remove_node()
def deleteGui(self):
if hasattr(self, 'jar'):
self.jar.destroy()
del self.jar
if hasattr(self, 'money_lbl'):
self.money_lbl.destroy()
del self.money_lbl
if hasattr(self, 'frame'):
self.frame.destroy()
del self.frame
return
def update(self, moneyAmt):
if hasattr(self, 'money_lbl'):
if moneyAmt <= 0:
self.money_lbl['text_fg'] = (0.9, 0, 0, 1)
else:
self.money_lbl['text_fg'] = (1, 1, 0, 1)
self.money_lbl['text'] = str(moneyAmt)
class DistributedCannonDefenseShip(DistributedNPCSimpleShip):
__module__ = __name__
specialHitSfx = {}
coldShotHitSfx = None
sharkChompSfx = {}
def __init__(self, cr):
DistributedNPCSimpleShip.__init__(self, cr)
self.goldStolenlbl = None
self.hasGoldlbl = None
self.hasBNote = None
self.textureCard = None
self.goldIcon = None
self.flameEffects = []
self.isSinkingWhileOnFire = False
self.healthModifier = 0
self.modifierSet = False
self.shipStatsSet = False
self.shipStatIndex = None
self.initHealthBar()
self.initIndicatorIcons()
self.sinkTimeScale = CannonDefenseGlobals.SHIP_SINK_DURATION_SCALE
self.sharkActor = Actor(
'models/char/pir_r_gam_fsh_lgComTshark.bam',
{'attack': 'models/char/pir_a_gam_fsh_lgComTshark_attack.bam'})
self.sharkParallel = None
self.fader = None
if not self.coldShotHitSfx:
DistributedCannonDefenseShip.specialHitSfx = {
InventoryType.DefenseCannonMineInWater:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_MINE_HIT),
InventoryType.DefenseCannonBomb:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_BOMB_HIT),
InventoryType.DefenseCannonHotShot:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_HOTSHOT_HIT),
InventoryType.DefenseCannonFireStorm:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_FIRESTORM_HIT),
InventoryType.DefenseCannonChumShot:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_SHARK)
}
DistributedCannonDefenseShip.coldShotHitSfx = loadSfx(
SoundGlobals.SFX_MINIGAME_CANNON_ICE_HIT)
DistributedCannonDefenseShip.sharkChompSfxs = [
loadSfx(SoundGlobals.SFX_MONSTER_SMASH_01),
loadSfx(SoundGlobals.SFX_MONSTER_SMASH_02),
loadSfx(SoundGlobals.SFX_MONSTER_SMASH_03)
]
return
def buildShip(self):
DistributedNPCSimpleShip.buildShip(self)
self.model.sfxAlternativeStyle = True
def setupLocalStats(self):
DistributedNPCSimpleShip.setupLocalStats(self)
def setShipStatIndex(self, statIndex):
self.shipStatsSet = True
self.shipStatIndex = statIndex
self.maxHp = CannonDefenseGlobals.shipStats[
self.shipStatIndex]['shipHp']
self.maxMastHealth = CannonDefenseGlobals.shipStats[
self.shipStatIndex]['mastHp']
self.healthBar.setPos(
0.0, 0.0, CannonDefenseGlobals.shipStats[self.shipStatIndex]
['healthBarHeight'])
if self.modifierSet:
self.calcModifiedHealth()
def setHealthModifier(self, modifier):
self.modifierSet = True
self.healthModifier = modifier
if self.shipStatsSet:
self.calcModifiedHealth()
def calcModifiedHealth(self):
if self.healthModifier == 0:
return
self.maxHp += self.healthModifier * (
self.maxHp * CannonDefenseGlobals.ENEMY_DIFFICULTY_INCREASE)
mastList = CannonDefenseGlobals.shipStats[self.shipStatIndex]['mastHp']
mastFinalHp = []
for mastHealth in mastList:
hp = mastHealth
hp += self.healthModifier * (
mastHealth * CannonDefenseGlobals.ENEMY_DIFFICULTY_INCREASE)
mastFinalHp.append(hp)
self.maxMastHealth = mastFinalHp
def setLogo(self, logo):
self.logo = logo
def setStyle(self, style):
self.style = style
def announceGenerate(self):
DistributedNPCSimpleShip.announceGenerate(self)
rad = (self.model.dimensions / 2.0).length()
cn = NodePath(CollisionNode('c'))
cs = CollisionSphere(0, 0, 0, rad)
cn.node().addSolid(cs)
cn.reparentTo(self.model.modelCollisions)
cn.setTransform(self.model.center.getTransform(self))
cn.node().setIntoCollideMask(PiratesGlobals.GenericShipBitmask)
self.model.defendSphere = cn
self.model.modelRoot.setScale(CannonDefenseGlobals.SHIP_SCALE)
self.fadeIn(CannonDefenseGlobals.SHIP_FADEIN)
self.smoother.setExpectedBroadcastPeriod(0.3)
self.smoother.setDelay(2)
self.healthBar.reparentTo(self.model.modelRoot)
def initHealthBar(self):
self.healthBar = DirectWaitBar(frameSize=(-0.35, 0.35, -0.04, 0.04),
relief=DGG.FLAT,
frameColor=(0.0, 0.0, 0.0, 0.0),
borderWidth=(0.0, 0.0),
barColor=(0.0, 1.0, 0.0, 1.0),
scale=100)
self.healthBar.setBillboardPointEye()
self.healthBar['value'] = 100
self.healthBar.hide(OTPRender.ReflectionCameraBitmask)
self.healthBar.setLightOff()
def initIndicatorIcons(self):
self.textureCard = loader.loadModel(
'models/textureCards/pir_m_gam_can_ship_icons')
if self.textureCard:
self.goldIcon = self.textureCard.find('**/pir_t_shp_can_gold*')
self.goldStolenlbl = DirectLabel(
parent=self.healthBar,
relief=None,
pos=(0, 0, 0.2),
text_align=TextNode.ACenter,
text_scale=0.5,
textMayChange=0,
text='!',
text_fg=PiratesGuiGlobals.TextFG23,
text_shadow=PiratesGuiGlobals.TextShadow,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
sortOrder=2)
self.goldStolenlbl.setTransparency(1)
self.goldStolenlbl.hide()
self.hasGoldlbl = DirectLabel(parent=self.healthBar,
relief=None,
pos=(0, 0, 0.35),
image=self.goldIcon,
image_scale=0.5,
image_pos=(0, 0, 0),
sortOrder=2)
self.hasGoldlbl.setTransparency(1)
self.hasGoldlbl.hide()
self.hasBNote = self.healthBar.attachNewNode('noteIndicator')
self.bnoteBack = loader.loadModel(
'models/textureCards/skillIcons').find(
'**/pir_t_gui_can_moneyIcon').copyTo(self.hasBNote)
self.hasBNote.setZ(0.35)
self.hasBNote.setScale(0.6)
self.hasBNote.hide()
return
def getHealthBarColor(self, health):
return CannonDefenseGlobals.SHIP_HEALTH_COLORS[int(
health / 100.0 *
(len(CannonDefenseGlobals.SHIP_HEALTH_COLORS) - 1))]
def setHealthState(self, health):
DistributedNPCSimpleShip.setHealthState(self, health)
self.healthBar['value'] = health
self.healthBar['barColor'] = self.getHealthBarColor(health)
def setCurrentState(self, state):
if state == CannonDefenseGlobals.SHIP_STATE_STEALING:
self.goldStolenlbl.show()
else:
if state == CannonDefenseGlobals.SHIP_STATE_HASTREASURE:
self.hasGoldlbl.show()
self.goldStolenlbl.hide()
else:
if state == CannonDefenseGlobals.SHIP_STATE_HASBNOTES:
self.hasBNote.show()
self.goldStolenlbl.hide()
else:
self.hasGoldlbl.hide()
self.hasBNote.hide()
self.goldStolenlbl.hide()
rad = (self.model.dimensions / 2.0).length()
cn = NodePath(CollisionNode('c'))
cs = CollisionSphere(0, 0, 0, rad)
cn.node().addSolid(cs)
cn.reparentTo(self.model.modelCollisions)
cn.setTransform(self.model.center.getTransform(self))
cn.node().setIntoCollideMask(PiratesGlobals.GenericShipBitmask)
self.model.defendSphere = cn
self.model.modelRoot.setScale(CannonDefenseGlobals.SHIP_SCALE)
self.fadeIn(CannonDefenseGlobals.SHIP_FADEIN)
self.smoother.setExpectedBroadcastPeriod(0.3)
self.smoother.setDelay(2)
self.healthBar.reparentTo(self.model.modelRoot)
def initHealthBar(self):
self.healthBar = DirectWaitBar(frameSize=(-0.35, 0.35, -0.04, 0.04),
relief=DGG.FLAT,
frameColor=(0.0, 0.0, 0.0, 0.0),
borderWidth=(0.0, 0.0),
barColor=(0.0, 1.0, 0.0, 1.0),
scale=100)
self.healthBar.setBillboardPointEye()
self.healthBar['value'] = 100
self.healthBar.hide(OTPRender.ReflectionCameraBitmask)
self.healthBar.setLightOff()
def initIndicatorIcons(self):
self.textureCard = loader.loadModel(
'models/textureCards/pir_m_gam_can_ship_icons')
if self.textureCard:
self.goldIcon = self.textureCard.find('**/pir_t_shp_can_gold*')
self.goldStolenlbl = DirectLabel(
parent=self.healthBar,
relief=None,
pos=(0, 0, 0.2),
text_align=TextNode.ACenter,
text_scale=0.5,
textMayChange=0,
text='!',
text_fg=PiratesGuiGlobals.TextFG23,
text_shadow=PiratesGuiGlobals.TextShadow,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
sortOrder=2)
self.goldStolenlbl.setTransparency(1)
self.goldStolenlbl.hide()
self.hasGoldlbl = DirectLabel(parent=self.healthBar,
relief=None,
pos=(0, 0, 0.35),
image=self.goldIcon,
image_scale=0.5,
image_pos=(0, 0, 0),
sortOrder=2)
self.hasGoldlbl.setTransparency(1)
self.hasGoldlbl.hide()
self.hasBNote = self.healthBar.attachNewNode('noteIndicator')
self.bnoteBack = loader.loadModel(
'models/textureCards/skillIcons').find(
'**/pir_t_gui_can_moneyIcon').copyTo(self.hasBNote)
self.hasBNote.setZ(0.35)
self.hasBNote.setScale(0.6)
self.hasBNote.hide()
return
def getHealthBarColor(self, health):
return CannonDefenseGlobals.SHIP_HEALTH_COLORS[int(
health / 100.0 *
(len(CannonDefenseGlobals.SHIP_HEALTH_COLORS) - 1))]
def setHealthState(self, health):
DistributedNPCSimpleShip.setHealthState(self, health)
self.healthBar['value'] = health
self.healthBar['barColor'] = self.getHealthBarColor(health)
def setCurrentState(self, state):
if state == CannonDefenseGlobals.SHIP_STATE_STEALING:
self.goldStolenlbl.show()
else:
if state == CannonDefenseGlobals.SHIP_STATE_HASTREASURE:
self.hasGoldlbl.show()
self.goldStolenlbl.hide()
else:
if state == CannonDefenseGlobals.SHIP_STATE_HASBNOTES:
self.hasBNote.show()
self.goldStolenlbl.hide()
else:
self.hasGoldlbl.hide()
self.hasBNote.hide()
self.goldStolenlbl.hide()
def calculateLook(self):
pass
def playProjectileHitSfx(self, ammoSkillId, hitSail):
if ammoSkillId in [
InventoryType.DefenseCannonColdShotInWater,
InventoryType.DefenseCannonSmokePowder
]:
return
if ammoSkillId in self.specialHitSfx:
sfx = self.specialHitSfx[ammoSkillId]
base.playSfx(sfx, node=self, cutoff=2000)
return
DistributedNPCSimpleShip.playProjectileHitSfx(self, ammoSkillId,
hitSail)
def projectileWeaponHit(self,
skillId,
ammoSkillId,
skillResult,
targetEffects,
pos,
normal,
codes,
attacker,
itemEffects=[]):
DistributedNPCSimpleShip.projectileWeaponHit(self, skillId,
ammoSkillId, skillResult,
targetEffects, pos,
normal, codes, attacker,
itemEffects)
def sinkingBegin(self):
self.healthBar.reparentTo(hidden)
if len(self.flameEffects) > 0:
self.isSinkingWhileOnFire = True
DistributedNPCSimpleShip.sinkingBegin(self)
def sinkingEnd(self):
while len(self.flameEffects) > 0:
effect = self.flameEffects.pop()
effect.stopLoop()
DistributedNPCSimpleShip.sinkingEnd(self)
def addStatusEffect(self,
effectId,
attackerId,
duration=0,
timeLeft=0,
timestamp=0,
buffData=[0]):
if effectId == WeaponGlobals.C_CANNON_DEFENSE_FIRE:
self.addFireEffect(self.getModelRoot().getPos())
if effectId == WeaponGlobals.C_CANNON_DEFENSE_ICE:
base.playSfx(self.coldShotHitSfx, node=self, cutoff=2000)
DistributedNPCSimpleShip.addStatusEffect(self, effectId, attackerId,
duration, timeLeft, timestamp,
buffData)
def removeStatusEffect(self, effectId, attackerId):
DistributedNPCSimpleShip.removeStatusEffect(self, effectId, attackerId)
if effectId == WeaponGlobals.C_CANNON_DEFENSE_FIRE:
if not self.isSinkingWhileOnFire:
while len(self.flameEffects) > 0:
effect = self.flameEffects.pop()
effect.stopLoop()
def addFireEffect(self, pos):
fireEffect = ShipFire.getEffect()
if fireEffect:
fireEffect.reparentTo(self.getModelRoot())
fireEffect.setPos(pos)
fireEffect.setHpr(90, -15, 0)
fireEffect.startLoop()
fireEffect.setEffectScale(20.0)
self.flameEffects.append(fireEffect)
def playSharkAttack(self, pos):
if self.sharkActor.getCurrentAnim() == None:
self.sharkActor.wrtReparentTo(self.getModelRoot())
self.sharkActor.setPos(self, pos)
self.sharkActor.setScale(20)
self.sharkActor.play('attack')
sharkAttackEffect = None
if base.options.getSpecialEffectsSetting(
) >= base.options.SpecialEffectsLow:
effect = CannonSplash.getEffect()
if effect:
effect.reparentTo(base.effectsRoot)
effect.setPos(self, pos)
effect.setZ(1)
effect.play()
sharkAttackEffect = Func(self.playAttackEffect, pos)
hprIvalShip = LerpHprInterval(self.getModelRoot(),
duration=3,
hpr=(0, 0, -180))
s1 = Sequence(Wait(0.75), hprIvalShip,
Func(self.getModelRoot().stash))
s2 = Sequence(Wait(0.75), sharkAttackEffect, Wait(0.5),
sharkAttackEffect)
self.sharkParallel = Parallel(s1, s2)
self.sharkParallel.start()
taskMgr.doMethodLater(self.sharkActor.getDuration('attack'),
self.detachShark,
self.uniqueName('playSharkAttack'),
extraArgs=[])
return
def playAttackEffect(self, pos):
effect = BulletEffect.getEffect()
if effect:
effect.reparentTo(base.effectsRoot)
effect.setPos(self, pos)
effect.loadObjects(6)
effect.play()
sfx = random.choice(self.sharkChompSfxs)
base.playSfx(sfx, node=self.getModelRoot(), cutoff=2000)
def detachShark(self):
self.sharkActor.detachNode()
def delete(self):
if self.fader:
self.fader.pause()
self.fader = None
DistributedNPCSimpleShip.delete(self)
return
def destroy(self):
if self.goldStolenlbl:
self.goldStolenlbl.destroy()
self.goldStolenlbl = None
if self.hasGoldlbl:
self.hasGoldlbl.destroy()
self.hasGoldlbl = None
if self.textureCard:
self.textureCard.removeNode()
self.textureCard = None
self.goldIcon = None
if self.healthBar:
self.healthBar.destroy()
if self.sharkActor:
self.sharkActor.cleanUp()
self.sharkActor.removeNode()
if self.sharkParallel:
self.sharkParallel.pause()
self.sharkParallel = None
DistributedNPCSimpleShip.destroy(self)
return
def fadeIn(self, length):
if self.fader:
self.fader.finish()
self.fader = None
self.setTransparency(1)
self.fader = Sequence(
self.colorScaleInterval(length, Vec4(1, 1, 1, 1), Vec4(1, 1, 1,
0)),
Func(self.clearTransparency))
self.fader.start()
return
def fadeOut(self, length):
if self.fader:
self.fader.finish()
self.fader = None
self.setTransparency(1)
self.fader = Sequence(
self.colorScaleInterval(length, Vec4(1, 1, 1, 0), Vec4(1, 1, 1,
1)),
Func(self.hide), Func(self.clearTransparency))
self.fader.start()
return
class CalendarGuiDay(DirectFrame):
notify = directNotify.newCategory('CalendarGuiDay')
ScrollListTextSize = 0.03
def __init__(self,
parent,
myDate,
startDate,
dayClickCallback=None,
onlyFutureDaysClickable=False):
self.origParent = parent
self.startDate = startDate
self.myDate = myDate
self.dayClickCallback = dayClickCallback
self.onlyFutureDaysClickable = onlyFutureDaysClickable
DirectFrame.__init__(self, parent=parent)
self.timedEvents = []
self.partiesInvitedToToday = []
self.hostedPartiesToday = []
self.yearlyHolidaysToday = []
self.showMarkers = base.config.GetBool('show-calendar-markers', 0)
self.filter = ToontownGlobals.CalendarFilterShowAll
self.load()
self.createGuiObjects()
self.update()
def createDummyLocators(self):
self.dayButtonLocator = self.attachNewNode('dayButtonLocator')
self.dayButtonLocator.setX(0.1)
self.dayButtonLocator.setZ(-0.05)
self.numberLocator = self.attachNewNode('numberLocator')
self.numberLocator.setX(0.09)
self.scrollLocator = self.attachNewNode('scrollLocator')
self.selectedLocator = self.attachNewNode('selectedLocator')
self.selectedLocator.setX(0.11)
self.selectedLocator.setZ(-0.06)
def load(self):
dayAsset = loader.loadModel(
'phase_4/models/parties/tt_m_gui_sbk_calendar_box')
dayAsset.reparentTo(self)
self.dayButtonLocator = self.find('**/loc_origin')
self.numberLocator = self.find('**/loc_number')
self.scrollLocator = self.find('**/loc_topLeftList')
self.selectedLocator = self.find('**/loc_origin')
self.todayBox = self.find('**/boxToday')
self.todayBox.hide()
self.selectedFrame = self.find('**/boxHover')
self.selectedFrame.hide()
self.defaultBox = self.find('**/boxBlank')
self.scrollBottomRightLocator = self.find('**/loc_bottomRightList')
self.scrollDownLocator = self.find('**/loc_scrollDown')
self.attachMarker(self.scrollDownLocator)
self.scrollUpLocator = self.find('**/loc_scrollUp')
self.attachMarker(self.scrollUpLocator)
def attachMarker(self, parent, scale=0.005, color=(1, 0, 0)):
if self.showMarkers:
marker = loader.loadModel('phase_3/models/misc/sphere')
marker.reparentTo(parent)
marker.setScale(scale)
marker.setColor(*color)
def createGuiObjects(self):
self.dayButton = DirectButton(parent=self.dayButtonLocator,
image=self.selectedFrame,
relief=None,
command=self.__clickedOnDay,
pressEffect=1,
rolloverSound=None,
clickSound=None)
self.numberWidget = DirectLabel(
parent=self.numberLocator,
relief=None,
text=str(self.myDate.day),
text_scale=0.04,
text_align=TextNode.ACenter,
text_font=ToontownGlobals.getInterfaceFont(),
text_fg=Vec4(110 / 255.0, 126 / 255.0, 255 / 255.0, 1))
self.attachMarker(self.numberLocator)
self.listXorigin = 0
self.listFrameSizeX = self.scrollBottomRightLocator.getX(
) - self.scrollLocator.getX()
self.scrollHeight = self.scrollLocator.getZ(
) - self.scrollBottomRightLocator.getZ()
self.listZorigin = self.scrollBottomRightLocator.getZ()
self.listFrameSizeZ = self.scrollLocator.getZ(
) - self.scrollBottomRightLocator.getZ()
self.arrowButtonXScale = 1
self.arrowButtonZScale = 1
self.itemFrameXorigin = 0
self.itemFrameZorigin = 0
self.buttonXstart = self.itemFrameXorigin + 0.21
self.gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui')
buttonOffSet = -0.01
incButtonPos = (0.0, 0, 0)
decButtonPos = (0.0, 0, 0)
itemFrameMinZ = self.listZorigin
itemFrameMaxZ = self.listZorigin + self.listFrameSizeZ
arrowUp = self.find('**/downScroll_up')
arrowDown = self.find('**/downScroll_down')
arrowHover = self.find('**/downScroll_hover')
self.scrollList = DirectScrolledList(
parent=self.scrollLocator,
relief=None,
pos=(0, 0, 0),
incButton_image=(arrowUp, arrowDown, arrowHover, arrowUp),
incButton_relief=None,
incButton_scale=(self.arrowButtonXScale, 1,
self.arrowButtonZScale),
incButton_pos=incButtonPos,
incButton_image3_color=Vec4(1, 1, 1, 0.2),
decButton_image=(arrowUp, arrowDown, arrowHover, arrowUp),
decButton_relief=None,
decButton_scale=(self.arrowButtonXScale, 1,
-self.arrowButtonZScale),
decButton_pos=decButtonPos,
decButton_image3_color=Vec4(1, 1, 1, 0.2),
itemFrame_pos=(self.itemFrameXorigin, 0, -0.03),
numItemsVisible=4,
incButtonCallback=self.scrollButtonPressed,
decButtonCallback=self.scrollButtonPressed)
itemFrameParent = self.scrollList.itemFrame.getParent()
self.scrollList.incButton.reparentTo(self.scrollDownLocator)
self.scrollList.decButton.reparentTo(self.scrollUpLocator)
arrowUp.removeNode()
arrowDown.removeNode()
arrowHover.removeNode()
clipper = PlaneNode('clipper')
clipper.setPlane(Plane(Vec3(-1, 0, 0), Point3(0.23, 0, 0)))
clipNP = self.scrollList.component('itemFrame').attachNewNode(clipper)
self.scrollList.component('itemFrame').setClipPlane(clipNP)
return
def scrollButtonPressed(self):
self.__clickedOnDay()
def adjustForMonth(self):
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.onlyFutureDaysClickable:
if self.myDate.year < curServerDate.year or self.myDate.year == curServerDate.year and self.myDate.month < curServerDate.month or self.myDate.year == curServerDate.year and self.myDate.month == curServerDate.month and self.myDate.day < curServerDate.day:
self.numberWidget.setColorScale(0.5, 0.5, 0.5, 0.5)
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.numberWidget.setColorScale(1, 1, 1, 1)
if self.myDate.month != self.startDate.month:
self.setColorScale(0.75, 0.75, 0.75, 1.0)
if self.dayClickCallback is not None:
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.setColorScale(1, 1, 1, 1)
if self.myDate.date() == curServerDate.date():
self.defaultBox.hide()
self.todayBox.show()
else:
self.defaultBox.show()
self.todayBox.hide()
return
def destroy(self):
if self.dayClickCallback is not None:
self.numberWidget.destroy()
self.dayClickCallback = None
self.notify.debug('desroying %s' % self.myDate)
try:
for item in self.scrollList['items']:
if hasattr(item,
'description') and item.description and hasattr(
item.description, 'destroy'):
self.notify.debug('desroying description of item %s' %
item)
item.unbind(DGG.ENTER)
item.unbind(DGG.EXIT)
item.description.destroy()
except e:
self.notify.debug('pass %s' % self.myDate)
self.scrollList.removeAndDestroyAllItems()
self.scrollList.destroy()
self.dayButton.destroy()
DirectFrame.destroy(self)
return
def addWeeklyHolidays(self):
if not self.filter == ToontownGlobals.CalendarFilterShowAll and not self.filter == ToontownGlobals.CalendarFilterShowOnlyHolidays:
return
if base.cr.newsManager:
holidays = base.cr.newsManager.getHolidaysForWeekday(
self.myDate.weekday())
holidayName = ''
holidayDesc = ''
for holidayId in holidays:
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[
holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[
holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
self.scrollList.refresh()
if base.config.GetBool('calendar-test-items', 0):
if self.myDate.date() + datetime.timedelta(
days=-1
) == base.cr.toontownTimeManager.getCurServerDateTime().date():
testItems = ('1:00 AM Party', '2:00 AM CEO', '11:15 AM Party',
'5:30 PM CJ', '11:00 PM Party',
'Really Really Long String')
for text in testItems:
newItem = DirectLabel(relief=None,
text=text,
text_scale=self.ScrollListTextSize,
text_align=TextNode.ALeft)
self.scrollList.addItem(newItem)
if self.myDate.date() + datetime.timedelta(
days=-2
) == base.cr.toontownTimeManager.getCurServerDateTime().date():
testItems = ('1:00 AM Party', '3:00 AM CFO', '11:00 AM Party')
textSize = self.ScrollListTextSize
for text in testItems:
newItem = DirectLabel(relief=None,
text=text,
text_scale=textSize,
text_align=TextNode.ALeft)
self.scrollList.addItem(newItem)
def updateArrowButtons(self):
numItems = 0
try:
numItems = len(self.scrollList['items'])
except e:
numItems = 0
if numItems <= self.scrollList.numItemsVisible:
self.scrollList.incButton.hide()
self.scrollList.decButton.hide()
else:
self.scrollList.incButton.show()
self.scrollList.decButton.show()
def collectTimedEvents(self):
self.timedEvents = []
if self.filter == ToontownGlobals.CalendarFilterShowAll or self.filter == ToontownGlobals.CalendarFilterShowOnlyParties:
for party in localAvatar.partiesInvitedTo:
if party.startTime.date() == self.myDate.date():
self.partiesInvitedToToday.append(party)
self.timedEvents.append((party.startTime.time(), party))
for party in localAvatar.hostedParties:
if party.startTime.date() == self.myDate.date():
self.hostedPartiesToday.append(party)
self.timedEvents.append((party.startTime.time(), party))
if base.cr.newsManager and (
self.filter == ToontownGlobals.CalendarFilterShowAll or
self.filter == ToontownGlobals.CalendarFilterShowOnlyHolidays):
yearlyHolidays = base.cr.newsManager.getYearlyHolidaysForDate(
self.myDate)
for holiday in yearlyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.month and holidayStart[
1] == self.myDate.day:
myTime = datetime.time(holidayStart[2], holidayStart[3])
elif holidayEnd[0] == self.myDate.month and holidayEnd[
1] == self.myDate.day:
myTime = datetime.time(holidayEnd[2], holidayEnd[3])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
oncelyHolidays = base.cr.newsManager.getOncelyHolidaysForDate(
self.myDate)
for holiday in oncelyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.year and holidayStart[
1] == self.myDate.month and holidayStart[
2] == self.myDate.day:
myTime = datetime.time(holidayStart[3], holidayStart[4])
elif holidayEnd[0] == self.myDate.year and holidayEnd[
1] == self.myDate.month and holidayEnd[
2] == self.myDate.day:
myTime = datetime.time(holidayEnd[3], holidayEnd[4])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
multipleStartHolidays = base.cr.newsManager.getMultipleStartHolidaysForDate(
self.myDate)
for holiday in multipleStartHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.year and holidayStart[
1] == self.myDate.month and holidayStart[
2] == self.myDate.day:
myTime = datetime.time(holidayStart[3], holidayStart[4])
elif holidayEnd[0] == self.myDate.year and holidayEnd[
1] == self.myDate.month and holidayEnd[
2] == self.myDate.day:
myTime = datetime.time(holidayEnd[3], holidayEnd[4])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
relativelyHolidays = base.cr.newsManager.getRelativelyHolidaysForDate(
self.myDate)
for holiday in relativelyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.month and holidayStart[
1] == self.myDate.day:
myTime = datetime.time(holidayStart[2], holidayStart[3])
elif holidayEnd[0] == self.myDate.month and holidayEnd[
1] == self.myDate.day:
myTime = datetime.time(holidayEnd[2], holidayEnd[3])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
def timedEventCompare(te1, te2):
if te1[0] < te2[0]:
return -1
elif te1[0] == te2[0]:
return 0
else:
return 1
self.timedEvents.sort(cmp=timedEventCompare)
for timedEvent in self.timedEvents:
if isinstance(timedEvent[1], PartyInfo):
self.addPartyToScrollList(timedEvent[1])
elif isinstance(
timedEvent[1], tuple
) and timedEvent[1][0] == NewsManager.YearlyHolidayType:
self.addYearlyHolidayToScrollList(timedEvent[1])
elif isinstance(
timedEvent[1], tuple
) and timedEvent[1][0] == NewsManager.OncelyHolidayType:
self.addOncelyHolidayToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][
0] == NewsManager.OncelyMultipleStartHolidayType:
self.addOncelyMultipleStartHolidayToScrollList(timedEvent[1])
elif isinstance(
timedEvent[1], tuple
) and timedEvent[1][0] == NewsManager.RelativelyHolidayType:
self.addRelativelyHolidayToScrollList(timedEvent[1])
def addYearlyHolidayToScrollList(self, holiday):
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ''
startTime = datetime.time(holidayStart[2], holidayStart[3])
endTime = datetime.time(holidayEnd[2], holidayEnd[3])
startDate = datetime.date(self.myDate.year, holidayStart[0],
holidayStart[1])
endDate = datetime.date(self.myDate.year, holidayEnd[0], holidayEnd[1])
if endDate < startDate:
endDate = datetime.date(endDate.year + 1, endDate.month,
endDate.day)
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = TTLocalizer.UnknownHoliday % holidayId
if holidayStart[0] == holidayEnd[0] and holidayStart[1] == holidayEnd[
1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + myStrftime(
endTime)
elif self.myDate.month == holidayStart[
0] and self.myDate.day == holidayStart[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + endDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.month == holidayEnd[
0] and self.myDate.day == holidayEnd[1]:
holidayText = myStrftime(endTime)
holidayText += ' ' + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += '. ' + TTLocalizer.CalendarStartedOn + startDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addOncelyHolidayToScrollList(self, holiday):
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ''
startTime = datetime.time(holidayStart[3], holidayStart[4])
endTime = datetime.time(holidayEnd[3], holidayEnd[4])
startDate = datetime.date(holidayStart[0], holidayStart[1],
holidayStart[2])
endDate = datetime.date(holidayStart[0], holidayEnd[1], holidayEnd[2])
if endDate < startDate:
endDate = datetime.date(endDate.year + 1, endDate.month,
endDate.day)
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = ''
if holidayStart[1] == holidayEnd[1] and holidayStart[2] == holidayEnd[
2]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + myStrftime(
endTime)
elif self.myDate.year == holidayStart[
0] and self.myDate.month == holidayStart[
1] and self.myDate.day == holidayStart[2]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + endDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.year == holidayEnd[
0] and self.myDate.month == holidayEnd[
1] and self.myDate.day == holidayEnd[2]:
holidayText = myStrftime(endTime)
holidayText += ' ' + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += '. ' + TTLocalizer.CalendarStartedOn + startDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addOncelyMultipleStartHolidayToScrollList(self, holiday):
self.addOncelyHolidayToScrollList(holiday)
def addRelativelyHolidayToScrollList(self, holiday):
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ''
startTime = datetime.time(holidayStart[2], holidayStart[3])
endTime = datetime.time(holidayEnd[2], holidayEnd[3])
startDate = datetime.date(self.myDate.year, holidayStart[0],
holidayStart[1])
endDate = datetime.date(self.myDate.year, holidayEnd[0], holidayEnd[1])
if endDate < startDate:
endDate.year += 1
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = ''
if holidayStart[0] == holidayEnd[0] and holidayStart[1] == holidayEnd[
1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + myStrftime(
endTime)
elif self.myDate.month == holidayStart[
0] and self.myDate.day == holidayStart[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + endDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.month == holidayEnd[
0] and self.myDate.day == holidayEnd[1]:
holidayText = myStrftime(endTime)
holidayText += ' ' + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += '. ' + TTLocalizer.CalendarStartedOn + startDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addTitleAndDescToScrollList(self, title, desc):
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(relief=None,
text=title,
text_scale=textSize,
text_align=TextNode.ALeft,
rolloverSound=None,
clickSound=None,
pressEffect=0,
command=self.__clickedOnScrollItem)
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = scrollItemHeight * descTextSize / textSize
descUnderItemZAdjust = max(0.0534, descUnderItemZAdjust)
descUnderItemZAdjust = -descUnderItemZAdjust
descZAdjust = descUnderItemZAdjust
newItem.description = DirectLabel(parent=newItem,
pos=(0.115, 0, descZAdjust),
text='',
text_wordwrap=15,
pad=(0.02, 0.02),
text_scale=descTextSize,
text_align=TextNode.ACenter,
textMayChange=0)
newItem.description.checkedHeight = False
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(DGG.ENTER,
self.enteredTextItem,
extraArgs=[newItem, desc, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
self.scrollList.addItem(newItem)
return
def exitedTextItem(self, newItem, mousepos):
newItem.description.hide()
def enteredTextItem(self, newItem, descText, descUnderItemZAdjust,
mousePos):
if not newItem.description.checkedHeight:
newItem.description.checkedHeight = True
newItem.description['text'] = descText
bounds = newItem.description.getBounds()
descHeight = newItem.description.getHeight()
scrollItemHeight = newItem.getHeight()
descOverItemZAdjust = descHeight - scrollItemHeight / 2.0
descZPos = self.getPos(
aspect2d)[2] + descUnderItemZAdjust - descHeight
if descZPos < -1.0:
newItem.description.setZ(descOverItemZAdjust)
descWidth = newItem.description.getWidth()
brightFrame = loader.loadModel(
'phase_4/models/parties/tt_m_gui_sbk_calendar_popUp_bg')
newItem.description['geom'] = brightFrame
newItem.description['geom_scale'] = (descWidth, 1, descHeight)
descGeomZ = (bounds[2] - bounds[3]) / 2.0
descGeomZ += bounds[3]
newItem.description['geom_pos'] = (0, 0, descGeomZ)
newItem.description.show()
def addPartyToScrollList(self, party):
textSize = self.ScrollListTextSize
descTextSize = 0.05
partyTitle = myStrftime(party.startTime)
partyTitle = partyTitle + ' ' + TTLocalizer.EventsPageCalendarTabParty
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(relief=None,
text=partyTitle,
text_scale=textSize,
text_align=TextNode.ALeft,
rolloverSound=None,
clickSound=None,
pressEffect=0,
command=self.__clickedOnScrollItem)
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = scrollItemHeight * descTextSize / textSize
descUnderItemZAdjust = max(0.0534, descUnderItemZAdjust)
descUnderItemZAdjust = -descUnderItemZAdjust
descZAdjust = descUnderItemZAdjust
self.scrollList.addItem(newItem)
newItem.description = MiniInviteVisual(newItem, party)
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(
DGG.ENTER,
self.enteredTextItem,
extraArgs=[newItem, newItem.description, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
return
def __clickedOnScrollItem(self):
self.__clickedOnDay()
def __clickedOnDay(self):
acceptClick = True
if self.onlyFutureDaysClickable:
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.myDate.date() < curServerDate.date():
acceptClick = False
if not acceptClick:
return
if self.dayClickCallback:
self.dayClickCallback(self)
self.notify.debug('we got clicked on %s' % self.myDate.date())
messenger.send('clickedOnDay', [self.myDate.date()])
def updateSelected(self, selected):
multiplier = 1.1
if selected:
self.selectedFrame.show()
self.setScale(multiplier)
self.setPos(-0.01, 0, 0.01)
grandParent = self.origParent.getParent()
self.origParent.reparentTo(grandParent)
else:
self.selectedFrame.hide()
self.setScale(1.0)
self.setPos(0, 0, 0)
def changeDate(self, startDate, myDate):
self.startDate = startDate
self.myDate = myDate
self.scrollList.removeAndDestroyAllItems()
self.update()
def update(self):
self.numberWidget['text'] = str(self.myDate.day)
self.adjustForMonth()
self.addWeeklyHolidays()
self.collectTimedEvents()
self.updateArrowButtons()
def changeFilter(self, filter):
oldFilter = self.filter
self.filter = filter
if self.filter != oldFilter:
self.scrollList.removeAndDestroyAllItems()
self.update()
class RepairSawingGame(RepairMincroGame):
sawSounds = None
boardComplet = None
boardDestroyed = None
def __init__(self, repairGame):
self.config = RepairGlobals.Sawing
notify = DirectNotifyGlobal.directNotify.newCategory(
'RepairSawingGame')
RepairMincroGame.__init__(self, repairGame, 'sawing',
PLocalizer.Minigame_Repair_Sawing_Start)
def _initVars(self):
RepairMincroGame._initVars(self)
self.boardsPool = {}
self.currentBoard = None
self.currentBoardIndex = 0
self.onDeckBoard = None
self.onDeckBoardIndex = 0
self.totalScore = 0.0
self.hitZone1Penalty = False
self.hitZone2Penalty = False
self.hitBoardPenalty = False
self.moveDiffForSound = 0.0
self.startPositions = (Point3(0.0, 0.0, 0.0), )
self.currentStartIndex = 0
self.lastMousePos = None
self.board_left = None
self.board_right = None
self.cut = None
self.zone1_right = None
self.zone1_left = None
self.zone2_right = None
self.zone2_left = None
self.piece1 = None
self.piece2 = None
self.lastHitIndex = -1
self.sawWaypoints = []
def _initAudio(self):
RepairMincroGame._initAudio(self)
if not self.sawSounds:
RepairSawingGame.sawSounds = (
loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT01),
loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT02),
loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT03),
loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT04))
RepairSawingGame.boardComplete = loadSfx(
SoundGlobals.SFX_MINIGAME_REPAIR_SAW_COMPLETE)
RepairSawingGame.boardDestroyed = loadSfx(
SoundGlobals.SFX_MINIGAME_REPAIR_SAW_FAIL)
def _initVisuals(self):
RepairMincroGame._initVisuals(self)
self.setBin('fixed', 36)
self.model = loader.loadModel('models/gui/pir_m_gui_srp_sawing_main')
sawModel = self.model.find('**/saw')
sawModel.setR(193)
sawModel.setPos(0.90000000000000002, 0.0, -0.16500000000000001)
sawModel.setBin('gui-popup', 0)
self.sawButton = RepairSaw(
parent=self,
clickDownCommand=self.sawAttachedToMouse,
clickUpCommand=self.sawRemovedFromMouse,
geom=sawModel,
text_pos=(0.20000000000000001, -0.29999999999999999),
text_fg=(1, 0, 0, 1),
scale=(0.29999999999999999, 0.29999999999999999,
0.29999999999999999),
relief=None,
pressEffect=0,
frameSize=(-0.050000000000000003, 1.05, -0.29999999999999999,
0.050000000000000003),
rolloverSound=None,
clickSound=None)
self.sawingLine = RepairSawingLine(self,
self.config.sawlineLineThickness,
self.config.sawlineColor,
self.config.sawlineLinespawnDist)
self.progressDescriptionLabel = DirectLabel(
text=PLocalizer.Minigame_Repair_Sawing_Description,
text_fg=(1.0, 1.0, 1.0, 1.0),
text_pos=(0.0, 0.0),
text_shadow=(0.0, 0.0, 0.0, 1.0),
text_font=PiratesGlobals.getPirateFont(),
text_align=TextNode.ARight,
relief=None,
scale=(0.080000000000000002, 0.080000000000000002,
0.080000000000000002),
pos=(-0.20000000000000001, 0.0, 0.5),
parent=self)
self.progressLabel = DirectLabel(
text=PLocalizer.Minigame_Repair_Sawing_Thresholds[3],
text_fg=(1.0, 1.0, 1.0, 1.0),
text_pos=(0.0, 0.0),
text_shadow=(0.0, 0.0, 0.0, 1.0),
text_font=PiratesGlobals.getPirateFont(),
text_align=TextNode.ALeft,
relief=None,
scale=(0.080000000000000002, 0.080000000000000002,
0.080000000000000002),
pos=(-0.17999999999999999, 0.0, 0.5),
parent=self)
self.boardDestroyedLabel = DirectLabel(
text=PLocalizer.Minigame_Repair_Sawing_Board_Destroyed,
text_fg=(1.0, 0.0, 0.0, 1.0),
text_pos=(0.0, 0.0),
text_font=PiratesGlobals.getPirateFont(),
text_shadow=(0.0, 0.0, 0.0, 1.0),
relief=None,
scale=(0.10000000000000001, 0.10000000000000001,
0.10000000000000001),
pos=(0.0, 0.0, 0.10000000000000001),
parent=self)
self.boardDestroyedLabel.setBin('fixed', 38)
self.boardDestroyedLabel.stash()
def _initIntervals(self):
RepairMincroGame._initIntervals(self)
self.newBoardSequence = Sequence(
name='RepairSawingGame.newBoardSequence')
self.splitBoardSequence = Sequence(
name='RepairSawGame.splitBoardSequence')
self.dropBoardSequence = Sequence(
name='RepairSawGame.dropBoardSequence')
def getNewBoard(self, boardIndex):
board = self.model.find('**/wood%i' % boardIndex).copyTo(
NodePath('board%i' % len(self.boardsPool)))
board.reparentTo(self)
piece1 = board.find('**/piece_1')
piece1.setPythonTag('piece_1', self.piece1)
piece1.setY(self.config.boardYDist)
piece2 = board.find('**/piece_2')
piece2.setPythonTag('piece_2', self.piece2)
piece2.setY(self.config.boardYDist)
pieceCut = board.find('**/piece_cut')
pieceCut.setPythonTag('cut', self.cut)
pieceCut.setColor(self.config.cutColor)
pieceCut.setY(self.config.boardYDist)
board_left = piece1.find('**/board')
board_left.setPythonTag('left', self.board_left)
board_right = piece2.find('**/board')
board_right.setPythonTag('right', self.board_right)
zone1_right = piece2.find('**/zone_1')
zone1_right.setPythonTag('zone1_right', self.zone1_right)
zone1_right.setColor(self.config.zone1Color)
zone1_left = piece1.find('**/zone_1')
zone1_left.setPythonTag('zone1_left', self.zone1_left)
zone1_left.setColor(self.config.zone1Color)
zone2_right = piece2.find('**/zone_2')
zone2_right.setPythonTag('zone2_right', self.zone2_right)
zone2_right.setColor(self.config.zone2Color)
zone2_left = piece1.find('**/zone_2')
zone2_left.setPythonTag('zone2_left', self.zone2_left)
zone2_left.setColor(self.config.zone2Color)
board.stash()
return board
def reset(self):
for key in self.boardsPool.keys():
board = self.boardsPool[key]
board.removeNode()
self.boardsPool.clear()
if self.currentBoard:
self.currentBoard.removeNode()
self.currentBoard = None
if self.onDeckBoard:
self.onDeckBoard.removeNode()
self.onDeckBoard = None
for boardIndex in self.currentDifficultySet:
boardIndex -= 1
if 'copy1_%s' % boardIndex not in self.boardsPool:
board = self.getNewBoard(boardIndex)
self.boardsPool['copy1_%s' % boardIndex] = board
if 'copy2_%s' % boardIndex not in self.boardsPool:
board = self.getNewBoard(boardIndex)
self.boardsPool['copy2_%s' % boardIndex] = board
continue
self.currentBoardIndex = 0
self.currentBoard = None
self.moveNewBoardOnDeck()
self.onDeckBoard.unstash()
self.totalScore = 0
self.startPositions = (Point3(0.0, 0.0, 0.0), )
self.sawButton.stash()
self.sawButton.reparentTo(self)
self.lastHitIndex = -1
self.moveDiffForSound = 0.0
RepairMincroGame.reset(self)
self.repairGame.gui.setTutorial(self.name)
self.repairGame.gui.setTitle(self.name)
def destroy(self):
RepairMincroGame.destroy(self)
taskMgr.remove('SawingGame.updateSawTask')
self.sawButton.destroy()
self.sawButton.removeNode()
del self.sawButton
if self.currentBoard:
self.currentBoard.removeNode()
self.currentBoard = None
if self.onDeckBoard:
self.onDeckBoard.removeNode()
self.onDeckBoard = None
self.sawingLine = None
self.progressDescriptionLabel.destroy()
self.progressDescriptionLabel = None
self.progressLabel.destroy()
self.progressLabel = None
self.boardDestroyedLabel.destroy()
self.boardDestroyedLabel = None
for key in self.boardsPool.keys():
board = self.boardsPool[key]
if not board.isEmpty():
board.removeNode()
continue
self.boardsPool.clear()
self.newBoardSequence.clearToInitial()
del self.newBoardSequence
self.splitBoardSequence.clearToInitial()
del self.splitBoardSequence
self.dropBoardSequence.clearToInitial()
del self.dropBoardSequence
def setDifficulty(self, difficulty):
RepairMincroGame.setDifficulty(self, difficulty)
percent = difficulty / self.repairGame.difficultyMax
difIndex = int(
math.floor(percent * (len(self.config.difficultySets) - 1)))
self.currentDifficultySet = self.config.difficultySets[difIndex]
def splitBoard(self):
self.sawingLine.reset()
board = self.currentBoard
boardIndex = self.currentBoardIndex
if self.hitZone2Penalty:
boardSplitAnim = Parallel(
LerpPosInterval(self.board_left,
duration=self.config.splitBoardAnimTime,
pos=Point3(-2.0, 0.0, 0.0)),
LerpPosInterval(self.board_right,
duration=self.config.splitBoardAnimTime,
pos=Point3(2.0, 0.0, 0.0)),
LerpFunc(self.zone2_left.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.zone2_right.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.zone1_left.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.zone1_right.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.cut.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0))
elif self.hitZone1Penalty:
boardSplitAnim = Parallel(
LerpPosInterval(self.board_left,
duration=self.config.splitBoardAnimTime,
pos=Point3(-2.0, 0.0, 0.0)),
LerpPosInterval(self.board_right,
duration=self.config.splitBoardAnimTime,
pos=Point3(2.0, 0.0, 0.0)),
LerpPosInterval(self.zone2_left,
duration=self.config.splitBoardAnimTime,
pos=Point3(-2.0, 0.0, 0.0)),
LerpPosInterval(self.zone2_right,
duration=self.config.splitBoardAnimTime,
pos=Point3(2.0, 0.0, 0.0)),
LerpFunc(self.zone1_left.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.zone1_right.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.cut.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0))
else:
boardSplitAnim = Parallel(
LerpPosInterval(self.piece1,
duration=self.config.splitBoardAnimTime,
pos=Point3(-2.0, self.config.boardYDist, 0.0)),
LerpPosInterval(self.piece2,
duration=self.config.splitBoardAnimTime,
pos=Point3(2.0, self.config.boardYDist, 0.0)),
LerpFunc(self.cut.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0))
self.splitBoardSequence = Sequence(
Func(self.updateScore),
Func(self.boardComplete.play),
boardSplitAnim,
Func(board.stash),
Func(self.piece1.setPos, self.piece1.getPos()),
Func(self.piece2.setPos, self.piece2.getPos()),
Func(self.board_right.setPos, self.board_right.getPos()),
Func(self.board_left.setPos, self.board_left.getPos()),
Func(self.zone2_right.setPos, self.zone2_right.getPos()),
Func(self.zone2_left.setPos, self.zone2_left.getPos()),
Func(self.zone1_right.setPos, self.zone1_right.getPos()),
Func(self.zone1_left.setPos, self.zone1_left.getPos()),
Func(self.cut.setSa, 1.0),
Func(self.zone1_right.setSa, 1.0),
Func(self.zone1_left.setSa, 1.0),
Func(self.zone2_right.setSa, 1.0),
Func(self.zone2_left.setSa, 1.0),
Func(self.board_right.setSa, 1.0),
Func(self.board_left.setSa, 1.0),
Func(self.loadNewBoard),
Func(self.addBoardBackToPool, board, boardIndex),
name='RepairSawGame.splitBoardSequence')
self.splitBoardSequence.start()
def dropBoard(self):
board = self.currentBoard
boardIndex = self.currentBoardIndex
self.dropBoardSequence = Sequence(
Parallel(
Sequence(Func(self.boardDestroyedLabel.unstash), Wait(1.5),
Func(self.boardDestroyedLabel.stash)),
Sequence(
Wait(0.5), Func(self.boardDestroyed.play),
Func(self.sawingLine.reset),
LerpPosInterval(board,
duration=self.config.splitBoardAnimTime,
pos=Point3(0.0, 0.0, -2.0)),
Func(board.stash), Wait(0.5), Func(self.loadNewBoard),
Func(self.addBoardBackToPool, board, boardIndex))),
name='RepairSawGame.dropBoardSequence')
self.dropBoardSequence.start()
def addBoardBackToPool(self, board, boardIndex):
if 'copy1_%s' % boardIndex not in self.boardsPool:
self.boardsPool['copy1_%s' % boardIndex] = board
elif 'copy2_%s' % boardIndex not in self.boardsPool:
self.boardsPool['copy2_%s' % boardIndex] = board
else:
self.notify.error(
'Two copies of board type %i already in the boardsPool!' %
boardIndex)
def updateScoreText(self):
self.progressLabel.unstash()
self.progressDescriptionLabel.unstash()
if self.hitBoardPenalty:
self.progressLabel[
'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[0]
self.progressLabel['text_fg'] = Vec4(1.0, 0.0, 0.0, 1.0)
self.progressLabel.setText()
elif self.hitZone2Penalty:
self.progressLabel[
'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[1]
self.progressLabel['text_fg'] = Vec4(1.0, 0.5, 0.0, 1.0)
self.progressLabel.setText()
elif self.hitZone1Penalty:
self.progressLabel[
'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[2]
self.progressLabel['text_fg'] = Vec4(1.0, 1.0, 0.0, 1.0)
self.progressLabel.setText()
else:
self.progressLabel[
'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[3]
self.progressLabel['text_fg'] = Vec4(0.0, 1.0, 0.0, 1.0)
self.progressLabel.setText()
def moveNewBoardOnDeck(self):
boardIndex = random.randint(0, len(self.currentDifficultySet) - 1)
boardType = self.currentDifficultySet[boardIndex]
boardType -= 1
if 'copy1_%s' % boardType in self.boardsPool:
self.onDeckBoard = self.boardsPool['copy1_%s' % boardType]
del self.boardsPool['copy1_%s' % boardType]
elif 'copy2_%s' % boardType in self.boardsPool:
self.onDeckBoard = self.boardsPool['copy2_%s' % boardType]
del self.boardsPool['copy2_%s' % boardType]
else:
self.notify.error('No copies of board type %i in the boardsPool!' %
boardType)
self.onDeckBoardIndex = boardType
self.onDeckBoard.setScale(0.25)
self.onDeckBoard.setPos(0.5, -2.0, 0.56000000000000005)
self.onDeckBoard.unstash()
def loadNewBoard(self):
self.progressLabel.stash()
self.progressDescriptionLabel.stash()
if self.totalScore >= self.config.totalPoints:
if self.onDeckBoard:
self.onDeckBoard.stash()
self.progressDescriptionLabel.stash()
taskMgr.remove('SawingGame.updateSawTask')
self.request('Outro')
return None
self.currentBoard = self.onDeckBoard
self.currentBoardIndex = self.onDeckBoardIndex
self.piece1 = self.currentBoard.find('**/piece_1')
self.piece1.setTransparency(1)
self.piece2 = self.currentBoard.find('**/piece_2')
self.piece2.setTransparency(1)
self.cut = self.currentBoard.find('**/piece_cut')
self.cut.setColor(self.config.cutColor)
self.cut.setTransparency(1)
self.board_left = self.piece1.find('**/board')
self.board_left.setTransparency(1)
self.zone1_left = self.piece1.find('**/zone_1')
self.zone1_left.setTransparency(1)
self.zone2_left = self.piece1.find('**/zone_2')
self.zone2_left.setTransparency(1)
self.board_right = self.piece2.find('**/board')
self.board_right.setTransparency(1)
self.zone1_right = self.piece2.find('**/zone_1')
self.zone1_right.setTransparency(1)
self.zone2_right = self.piece2.find('**/zone_2')
self.zone2_right.setTransparency(1)
self.board_left.setCollideMask(SAW_COLLIDE_MASK)
self.board_right.setCollideMask(SAW_COLLIDE_MASK)
self.cut.setCollideMask(SAW_COLLIDE_MASK)
self.zone1_right.setCollideMask(SAW_COLLIDE_MASK)
self.zone1_left.setCollideMask(SAW_COLLIDE_MASK)
self.zone2_right.setCollideMask(SAW_COLLIDE_MASK)
self.zone2_left.setCollideMask(SAW_COLLIDE_MASK)
self.startPositions = (
self.currentBoard.find('**/locator_start_0').getPos() +
Point3(*self.config.activeBoardPosition),
self.currentBoard.find('**/locator_start_1').getPos() +
Point3(*self.config.activeBoardPosition))
self.currentStartIndex = 0
for waypoint in self.sawWaypoints:
waypoint.removeNode()
self.sawWaypoints = []
locator = self.currentBoard.find('**/locator_0')
index = 0
while not locator.isEmpty():
self.sawWaypoints.append(
SawWaypoint(index, self.currentBoard, locator.getPos()))
locator = self.currentBoard.find('**/locator_%i' % (index + 1))
index += 1
self.sawButton.deactivate()
self.sawButton.setPos(self.startPositions[self.currentStartIndex])
self.hitBoardPenalty = False
self.hitZone1Penalty = False
self.hitZone2Penalty = False
self.lastMousePos = None
self.moveDiffForSound = self.config.playSawingSoundDelta + 0.10000000000000001
self.newBoardSequence = Sequence(
Parallel(
self.currentBoard.posInterval(
self.config.newBoardAnimTime,
Point3(*self.config.activeBoardPosition)),
self.currentBoard.scaleInterval(self.config.newBoardAnimTime,
1.0)),
name='RepairSawingGame.newBoardSequence')
if self.state in ['Game']:
self.newBoardSequence.append(Func(self.sawButton.activate))
self.newBoardSequence.append(Wait(0.5))
self.newBoardSequence.append(Func(self.moveNewBoardOnDeck))
self.newBoardSequence.start()
def updateSawTask(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
relative = Point3(mpos.getX(), 0.0, mpos.getY())
relative = self.getRelativePoint(render2d, relative)
moveDiff = 0.0
if self.lastMousePos != None:
moveDiff = (relative - self.lastMousePos).length()
pickedObjects = self.repairGame.mousePicker.getCollisions(
self.currentBoard, useIntoNodePaths=True)
self.updateWaypoints()
if len(pickedObjects) > 0:
self.moveDiffForSound += moveDiff
if self.moveDiffForSound > self.config.playSawingSoundDelta:
sawSoundPlaying = False
for sound in self.sawSounds:
if sound.status() == 2:
sawSoundPlaying = True
break
continue
if sawSoundPlaying == False:
sound = random.choice(self.sawSounds)
sound.play()
self.moveDiffForSound = 0.0
if self.board_right in pickedObjects or self.board_left in pickedObjects:
for waypoint in self.sawWaypoints:
waypoint.hit = False
self.hitBoardPenalty = True
self.dropBoard()
self.sawButton.deactivate()
elif self.cut in pickedObjects:
self.updateWaypoints()
elif self.zone1_right in pickedObjects or self.zone1_left in pickedObjects:
self.updateWaypoints()
if self.hitZone1Penalty == False:
self.hitZone1Penalty = True
elif self.zone2_right in pickedObjects or self.zone2_left in pickedObjects:
self.updateWaypoints()
if self.hitZone2Penalty == False:
self.hitZone2Penalty = True
self.updateScoreText()
else:
boardComplete = True
for waypoint in self.sawWaypoints:
if not waypoint.hit:
boardComplete = False
break
continue
if boardComplete:
self.splitBoard()
self.sawButton.deactivate()
self.lastMousePos = self.sawButton.getPos()
return Task.cont
def updateScore(self):
if not self.hitBoardPenalty:
currBoardScore = self.config.pointsPerBoard
if not self.hitZone1Penalty:
pass
currBoardScore -= self.config.pointsLostForZone1 * self.hitZone2Penalty
currBoardScore -= self.config.pointsLostForZone2 * self.hitZone2Penalty
rating = 4 - 1 * self.hitZone2Penalty - 3 * self.hitZone1Penalty
self.totalScore += currBoardScore
self.totalScore = min(self.totalScore, self.config.totalPoints)
percent = int((self.totalScore / self.config.totalPoints) * 100.0)
self.repairGame.d_reportMincroGameProgress(percent, rating)
def resetWaypoints(self):
for waypoint in self.sawWaypoints:
waypoint.hit = False
def updateWaypoints(self):
waypointList = self.getHitWaypoints()
for waypointIndex in waypointList:
self.lastHitIndex = waypointIndex
self.sawWaypoints[waypointIndex].hit = True
if waypointIndex == 0 and not (self.sawWaypoints[-1].hit):
self.currentStartIndex = 0
continue
if waypointIndex == len(
self.sawWaypoints) - 1 and not (self.sawWaypoints[0].hit):
self.currentStartIndex = 1
continue
def getHitWaypoints(self):
waypointsHit = []
testDelta = self.config.testWaypointDelta
for i in range(len(self.sawWaypoints)):
waypointPos = self.sawWaypoints[i].getPos(self)
closestDistance = 9999
if self.lastMousePos != None:
currMousePos = self.sawButton.getPos()
lastMousePos = self.lastMousePos
totalLength = (currMousePos - lastMousePos).length()
testLength = testDelta
while testLength < totalLength:
testPos = (currMousePos - lastMousePos) * (
testLength / totalLength) + lastMousePos
self.updateSawLine(testPos)
testDistance = (testPos - waypointPos).length()
closestDistance = min(testDistance, closestDistance)
testLength += testDelta
self.updateSawLine(self.sawButton.getPos())
testDistance = (self.sawButton.getPos() - waypointPos).length()
closestDistance = min(testDistance, closestDistance)
if closestDistance < self.config.waypointRange[
self.currentBoardIndex]:
waypointsHit.append(i)
continue
return waypointsHit
def updateSawLine(self, pos):
if pos.getX() < -0.63300000000000001 or pos.getX(
) > 0.63300000000000001:
self.sawingLine.reset()
return None
if pos.getZ() < -0.183 or pos.getZ() > 0.375:
self.sawingLine.reset()
return None
self.sawingLine.update(pos)
def getClosestPosition(self, positions):
closestIndex = -1
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
relative = Point3(mpos.getX(), 0.0, mpos.getY())
relative = self.getRelativePoint(base.a2dBackground, relative)
bestDistance = 99999.0
for i in range(len(positions)):
dX = relative.getX() - positions[i].getX()
dZ = relative.getZ() - positions[i].getZ()
newDistance = dX * dX + dZ * dZ
if newDistance < bestDistance:
bestDistance = newDistance
closestIndex = i
continue
return closestIndex
def sawAttachedToMouse(self):
self.lastHitIndex = -1
if not taskMgr.hasTaskNamed('SawingGame.updateSawTask'):
taskMgr.add(self.updateSawTask,
'SawingGame.updateSawTask',
priority=2)
def sawRemovedFromMouse(self):
if not self.sawButton.isStashed():
self.sawButton.setPos(self.startPositions[self.currentStartIndex])
self.lastHitIndex = -1
self.resetWaypoints()
self.lastMousePos = None
self.progressLabel.stash()
self.progressDescriptionLabel.stash()
self.sawingLine.reset()
self.hitBoardPenalty = False
self.hitZone1Penalty = False
self.hitZone2Penalty = False
taskMgr.remove('SawingGame.updateSawTask')
def enterIntro(self):
RepairMincroGame.enterIntro(self)
self.loadNewBoard()
def enterGame(self):
RepairMincroGame.enterGame(self)
self.repairGame.mousePicker.setCollisionMask(SAW_COLLIDE_MASK)
self.sawButton.activate()
def exitGame(self):
RepairMincroGame.exitGame(self)
self.sawButton.deactivate()
self.repairGame.mousePicker.clearCollisionMask()
taskMgr.remove('SawingGame.updateSawTask')
self.splitBoardSequence.clearToInitial()
self.dropBoardSequence.clearToInitial()
localAvatar.guiMgr._showCursor()
def enterOutro(self):
RepairMincroGame.enterOutro(self)
self.repairGame.d_reportMincroGameScore(150)
class GroupTrackerPage(ShtikerPage.ShtikerPage):
notify = directNotify.newCategory('GroupTrackerPage')
def __init__(self):
ShtikerPage.ShtikerPage.__init__(self)
self.groupWidgets = []
self.playerWidgets = []
self.images = [] # image nodes: Possible images to apply on groups
self.scrollList = None # DirectScrolledList: Holds the GroupTrackerGroup widgets
self.scrollTitle = None # DirectLabel: Title of the list that holds the groups
self.playerList = None # DirectScrolledList: Holds players when showing a specific group details
self.playerListTitle = None # DirectLabel: Title of the playerList
self.groupInfoTitle = None # DirectLabel: holds the group detail title to show on the right
self.groupInfoDistrict = None # DirectLabel: shows group detail district on the right
self.statusMessage = None # DirectLabel: Shows important messages like Loading... or "No boarding groups available"
self.groupIcon = None # DirectButton: Icon to associate with the group ex. sellbot icon or cashbot icon depending on group info
self.wantGroupToggle = None # DirectButton: Allows the toon to toggle his listing
def load(self):
self.listXorigin = -0.02
self.listFrameSizeX = 0.67
self.listZorigin = -0.96
self.listFrameSizeZ = 1.04
self.arrowButtonScale = 1.3
self.itemFrameXorigin = -0.237
self.itemFrameZorigin = 0.365
self.buttonXstart = self.itemFrameXorigin + 0.293
self.gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui')
guiButton = loader.loadModel('phase_3/models/gui/quit_button')
self.scrollList = DirectScrolledList(parent=self,
relief=None,
pos=(-0.5, 0, 0),
incButton_image=(self.gui.find('**/FndsLst_ScrollUp'),
self.gui.find('**/FndsLst_ScrollDN'),
self.gui.find('**/FndsLst_ScrollUp_Rllvr'),
self.gui.find('**/FndsLst_ScrollUp')
),
incButton_relief=None,
incButton_scale=(self.arrowButtonScale, self.arrowButtonScale, -self.arrowButtonScale),
incButton_pos=(self.buttonXstart, 0, self.itemFrameZorigin - 0.999),
incButton_image3_color=Vec4(1, 1, 1, 0.2),
decButton_image=(self.gui.find('**/FndsLst_ScrollUp'),
self.gui.find('**/FndsLst_ScrollDN'),
self.gui.find('**/FndsLst_ScrollUp_Rllvr'),
self.gui.find('**/FndsLst_ScrollUp')
),
decButton_relief=None,
decButton_scale=(self.arrowButtonScale, self.arrowButtonScale, self.arrowButtonScale),
decButton_pos=(self.buttonXstart, 0, self.itemFrameZorigin + 0.227),
decButton_image3_color=Vec4(1, 1, 1, 0.2),
itemFrame_pos=(self.itemFrameXorigin, 0, self.itemFrameZorigin),
itemFrame_scale=1.0,
itemFrame_relief=DGG.SUNKEN,
itemFrame_frameSize=(self.listXorigin, self.listXorigin + self.listFrameSizeX,
self.listZorigin, self.listZorigin + self.listFrameSizeZ
),
itemFrame_frameColor=(0.85, 0.95, 1, 1),
itemFrame_borderWidth=(0.01, 0.01),
numItemsVisible=15,
forceHeight=0.065,
items=self.groupWidgets
)
self.scrollTitle = DirectFrame(parent=self.scrollList,
text=TTLocalizer.GroupTrackerListTitle,
text_scale=0.06,
text_align=TextNode.ACenter,
relief=None,
pos=(self.buttonXstart, 0, self.itemFrameZorigin + 0.127)
)
self.playerList = DirectScrolledList(parent=self,
relief=None,
pos=(0.45, 0, 0.1),
incButton_image=(self.gui.find('**/FndsLst_ScrollUp'),
self.gui.find('**/FndsLst_ScrollDN'),
self.gui.find('**/FndsLst_ScrollUp_Rllvr'),
self.gui.find('**/FndsLst_ScrollUp')
),
incButton_relief=None,
incButton_scale=(1.0, 1.0, -1.0),
incButton_pos=(0, 0, -0.28),
incButton_image3_color=Vec4(1, 1, 1, 0.05),
decButton_image=(self.gui.find('**/FndsLst_ScrollUp'),
self.gui.find('**/FndsLst_ScrollDN'),
self.gui.find('**/FndsLst_ScrollUp_Rllvr'),
self.gui.find('**/FndsLst_ScrollUp')
),
decButton_relief=None,
decButton_scale=(1.0, 1.0, 1.0),
decButton_pos=(0.0, 0, 0.04),
decButton_image3_color=Vec4(1, 1, 1, 0.25),
itemFrame_pos=(0, 0, -0.05),
itemFrame_scale=1.0,
itemFrame_relief=DGG.SUNKEN,
itemFrame_frameSize=(-0.3, 0.3, #x
-0.2, 0.06), #z
itemFrame_frameColor=(0.85, 0.95, 1, 1),
itemFrame_borderWidth=(0.01, 0.01),
numItemsVisible=4,
forceHeight=0.05,
items=self.playerWidgets
)
self.playerListTitle = DirectFrame(parent=self.playerList,
text='',
text_scale=0.05,
text_align=TextNode.ACenter,
relief=None,
pos=(0, 0, 0.08)
)
self.groupInfoTitle = DirectLabel(parent=self, text='',
text_scale=0.080, text_align=TextNode.ACenter,
text_wordwrap=15, relief=None, pos=(0.45, 0, 0.5))
self.groupInfoDistrict = DirectLabel(parent=self,
text='',
text_scale=0.050,
text_align=TextNode.ACenter,
text_wordwrap=15,
relief=None,
pos=(0.45, 0, 0.4)
)
self.statusMessage = DirectLabel(parent=self, text='', text_scale=0.060, text_align=TextNode.ACenter, text_wordwrap=5, relief=None, pos=(0.45,0,0.1))
# Group Image:
self.groupIcon = DirectButton(parent=self, relief=None, state=DGG.DISABLED, image=None, image_scale=(0.35, 1, 0.35), image_color=Vec4(1.0, 1.0, 1.0, 0.75), pos=(0.45, 10, -0.45), command=self.doNothing)
# Group Toggle:
self.wantGroupToggle = DirectButton(parent=self, relief=None, image=(guiButton.find('**/QuitBtn_UP'), guiButton.find('**/QuitBtn_DN'), guiButton.find('**/QuitBtn_RLVR')), image_scale=(0.7, 1, 1), text='', text_scale=0.052, text_pos=(0, -0.02), pos=(0.2, 0, -0.65), command=self.toggleWantGroup)
self.updateWantGroupButton()
# Loading possible group icons
suitIcons = loader.loadModel('phase_3/models/gui/cog_icons')
bossbotIcon = suitIcons.find('**/CorpIcon')
bossbotIcon.setColor(SUIT_ICON_COLORS[0])
self.images.append(bossbotIcon)
lawbotIcon = suitIcons.find('**/LegalIcon')
lawbotIcon.setColor(SUIT_ICON_COLORS[1])
self.images.append(lawbotIcon)
cashbotIcon = suitIcons.find('**/MoneyIcon')
cashbotIcon.setColor(SUIT_ICON_COLORS[2])
self.images.append(cashbotIcon)
sellbotIcon = suitIcons.find('**/SalesIcon')
sellbotIcon.setColor(SUIT_ICON_COLORS[3])
self.images.append(sellbotIcon)
# Clean up
self.clearGroupInfo()
self.statusMessage.hide()
suitIcons.removeNode()
self.gui.removeNode()
guiButton.removeNode()
self.accept('GroupTrackerResponse', self.updatePage)
def unload(self):
self.scrollList.destroy()
self.groupInfoDistrict.destroy()
self.playerList.destroy()
self.groupInfoTitle.destroy()
self.groupIcon.destroy()
self.wantGroupToggle.destroy()
for widget in self.playerWidgets:
widget.destroy()
for widget in self.groupWidgets:
widget.destroy()
self.playerWidgets = []
del self.scrollList
del self.groupInfoDistrict
del self.playerList
del self.groupInfoTitle
del self.groupIcon
del self.wantGroupToggle
ShtikerPage.ShtikerPage.unload(self)
def enter(self):
ShtikerPage.ShtikerPage.enter(self)
self.setGroups([]) # CLEAR IT ALL
self.setPlayers() # CLEAR IT ALL
if(self.scrollList['items'] == []):
self.statusMessage['text'] = TTLocalizer.GroupTrackerLoading
self.statusMessage.show()
base.cr.globalGroupTracker.requestGroups()
taskMgr.doMethodLater(3, self.displayNoGroupsTaskHandler, self.uniqueName('timeout'))
def displayNoGroups(self):
self.statusMessage['text'] = TTLocalizer.GroupTrackerEmpty
self.statusMessage.show()
self.clearGroupInfo()
def displayNoGroupsTaskHandler(self, task):
self.displayNoGroups()
return task.done
def updatePage(self):
taskMgr.remove(self.uniqueName('timeout'))
groups = base.cr.globalGroupTracker.getGroupInfo()
self.setGroups(groups)
def exit(self):
self.clearGroupInfo()
ShtikerPage.ShtikerPage.exit(self)
base.cr.globalGroupTracker.doneRequesting()
def updateGroupInfoEventHandle(self, groupWidget, mouseEvent):
self.updateGroupInfo(groupWidget)
def updateGroupInfo(self, groupWidget):
''' Updates the Right Page of the Group Tracker Page with new Info '''
self.statusMessage.hide()
# Update the Player List
self.setPlayers(groupWidget)
self.playerList.show()
# Update the Player List Title
self.playerListTitle['text'] = ('Players ' + str(groupWidget.getCurrentPlayers()) + '/' + str(groupWidget.getMaxPlayers()) + ':')
self.playerListTitle.show()
# Update the District
self.groupInfoDistrict['text'] = TTLocalizer.BoardingGroupDistrictInformation % { 'district' : groupWidget.getDistrict() }
self.groupInfoDistrict.show()
# Update the Title
self.groupInfoTitle['text'] = groupWidget.getTitle()
self.groupInfoTitle.show()
# Update the Image
self.groupIcon['image'] = self.images[GroupTrackerGlobals.CATEGORY_TO_IMAGE_ID[groupWidget.getCategory()]]
self.groupIcon['image_scale'] = (0.35, 1, 0.35)
self.groupIcon.show()
def clearGroupInfo(self):
self.playerList.hide()
self.playerListTitle.hide()
self.groupInfoDistrict.hide()
self.groupInfoTitle.hide()
self.groupIcon.hide()
def setPlayers(self, groupWidget=None):
''' Calls updatePlayerList '''
# Clear the Widgets that were held in the listings
for playerWidget in self.playerWidgets:
playerWidget.destroy()
self.playerWidgets = []
# Make a player widget for each player
# TODO: Edit this stuff when avIds come from players
if groupWidget:
leaderId = groupWidget.getLeaderId()
playerNames = groupWidget.getMemberNames()
playerIds = groupWidget.getMemberIds()
for playerName in playerNames:
playerId = playerIds[playerNames.index(playerName)]
isLeader = playerId == leaderId
self.playerWidgets.append(GroupTrackerPlayer(parent=self, avId=playerId, name=playerName, isLeader=isLeader))
self.updatePlayerList()
def reconsiderGroupInfo(self, groupWidget):
''' If someone is viewing this info and it was updated, we also want to update the info being viewed '''
if self.playerWidgets is None or self.playerList['items'] == []:
return # No Info is being viewed at the moment since you cant have an empty group
# We have to update if this group's leader is the leader in the playerlist being viewed right now
leaderId = groupWidget.getLeaderId()
# Check all the players in the playerList being viewed for the same leader
for playerWidget in self.playerWidgets:
if playerWidget.getLeader():
if leaderId == playerWidget.getId():
self.updateGroupInfo(groupWidget)
return False
return True
def setGroups(self, groups):
''' Calls updateGroupList '''
# Clear our Group Widgets
for group in self.groupWidgets:
group.destroy()
self.groupWidgets = []
wantReconsiderInfo = True
# Create a new group widget for each group
for group in groups:
if not group[GroupTrackerGlobals.SHOW] or len(group[GroupTrackerGlobals.MEMBER_IDS]) == 0:
continue # We are using this to see if this group is dead or if someone doesnt want it up
leaderId = 0
for i, g in base.cr.globalGroupTracker.leader2Group.items():
if g == group:
leaderId = i
if not leaderId:
continue
leaderName = group[GroupTrackerGlobals.LEADER_NAME]
shardName = group[GroupTrackerGlobals.SHARD_NAME]
category = group[GroupTrackerGlobals.CATEGORY]
memberIds = group[GroupTrackerGlobals.MEMBER_IDS]
memberNames = group[GroupTrackerGlobals.MEMBER_NAMES]
groupWidget = GroupTrackerGroup(parent=self, leaderId=leaderId, leaderName=leaderName, shardName=shardName, category=category, memberIds=memberIds, memberNames=memberNames)
groupWidget.bind(DGG.WITHIN, self.updateGroupInfoEventHandle, extraArgs=[groupWidget])
self.groupWidgets.append(groupWidget)
if wantReconsiderInfo:
wantReconsiderInfo = self.reconsiderGroupInfo(groupWidget)
# Edge case where a group that was removed, info might remain on the screen if it didn't exist any more
if wantReconsiderInfo:
self.clearGroupInfo()
# There are no groups, hide the information
if len(self.groupWidgets) == 0:
self.displayNoGroups()
self.updateGroupList()
def updateGroupList(self):
self.statusMessage.hide()
if self.scrollList is None:
return
# Clear the Group Listing
for item in self.scrollList['items']:
if item:
self.scrollList.removeItem(item, refresh=True)
self.scrollList['items'] = []
# Re-populate the Group Listing
for groupWidget in self.groupWidgets:
self.scrollList.addItem(groupWidget, refresh=True)
if len(self.groupWidgets) == 0:
self.displayNoGroups()
def updatePlayerList(self):
if self.playerList is None:
return
# Clear the Player Listing
for item in self.playerList['items']:
if item:
self.playerList.removeItem(item)
self.playerList['items'] = []
# Re-Populate the List
for playerWidget in self.playerWidgets:
self.playerList.addItem(playerWidget)
def toggleWantGroup(self):
if settings.get('grouptracker', False):
settings['grouptracker'] = False
base.cr.globalGroupTracker.showMe(False)
else:
settings['grouptracker'] = True
base.cr.globalGroupTracker.showMe(True)
base.localAvatar.wantGroupTracker()
base.localAvatar.wantGroupTracker() # Updates the ai toon so the boarding group AI could know what he wants
self.updateWantGroupButton()
def updateWantGroupButton(self):
if settings.get('grouptracker', False):
self.wantGroupToggle['text'] = 'Hide Me'
else:
self.wantGroupToggle['text'] = 'Show Me'
def doNothing(self):
pass
class DistributedMaze(DistributedNodePathEntity):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedMaze')
ScheduleTaskName = 'mazeScheduler'
RemoveBlocksDict = {
2: ('HedgeBlock_0_1', ),
4: (('HedgeBlock_0_1', 'HedgeBlock_1_3', 'HedgeBlock_2_3'),
('HedgeBlock_0_2', 'HedgeBlock_2_3',
'HedgeBlock_1_3'), ('HedgeBlock_0_1', 'HedgeBlock_0_2',
'HedgeBlock_1_3', 'HedgeBlock_2_3'))
}
def __init__(self, cr):
DistributedNodePathEntity.__init__(self, cr)
self.numSections = 0
self.GameDuration = 35.0 + self.numSections * 15.0
self.timer = None
self.frame2D = None
self.gameLabel = None
self.gameStarted = 0
self.finished = 0
self.timedOut = 0
self.toonFinishedText = TTLocalizer.toonFinishedHedgeMaze
self.toonEnteredText = TTLocalizer.enterHedgeMaze
return
def announceGenerate(self):
DistributedNodePathEntity.announceGenerate(self)
self.addHints(self.roomHold)
self.loadGui()
def disable(self):
DistributedNodePathEntity.disable(self)
self.unloadGui()
self.cleanupTimer()
self.ignoreAll()
def delete(self):
self.cleanupTimer()
DistributedNodePathEntity.delete(self)
def setRoomDoId(self, roomDoId):
self.roomDoId = roomDoId
room = self.cr.doId2do.get(roomDoId)
if room:
self.gotRoom([room])
else:
self.roomRequest = self.cr.relatedObjectMgr.requestObjects(
[roomDoId], allCallback=self.gotRoom, timeout=5)
def gotRoom(self, rooms):
self.roomRequest = None
room = rooms[0]
self.roomHold = room
rotations = [0, 0, 90, 90, 180, 180, 270, 270]
self.getRng().shuffle(rotations)
self.numSections = 0
for i in xrange(0, 4):
maze = room.getGeom().find('**/Maze_Inside_%d' % i)
if not maze.isEmpty():
self.numSections += 1
if rotations:
maze.setH(rotations.pop())
self.GameDuration = 35.0 + self.numSections * 15.0
self.removeHedgeBlocks(room)
return
def addHints(self, room):
self.focusPoint = self.attachNewNode('GolfGreenGameFrame')
hintList = room.getGeom().findAllMatches('**/dead*')
for hint in hintList:
self.actSphere = CollisionSphere(0, 0, 0, 7.0)
self.actSphereNode = CollisionNode(
'mazegame_hint-%s-%s' % (self.level.getLevelId(), self.entId))
self.actSphereNode.addSolid(self.actSphere)
self.actSphereNodePath = hint.attachNewNode(self.actSphereNode)
self.actSphereNode.setCollideMask(WallBitmask)
self.actSphere.setTangible(0)
self.enterEvent = 'enter' + self.actSphereNode.getName()
self.accept(self.enterEvent, self.__handleToonEnterHint)
self.exitEvent = 'exit' + self.actSphereNode.getName()
self.accept(self.exitEvent, self.__handleToonExitHint)
enterance = room.getGeom().find('**/ENTRANCE')
self.enterSphere = CollisionSphere(0, 0, 0, 8.0)
self.enterSphereNode = CollisionNode(
'mazegame_enter-%s-%s' % (self.level.getLevelId(), self.entId))
self.enterSphereNode.addSolid(self.enterSphere)
self.enterSphereNodePath = enterance.attachNewNode(
self.enterSphereNode)
self.enterSphereNode.setCollideMask(WallBitmask)
self.enterSphere.setTangible(0)
self.enteranceEvent = 'enter' + self.enterSphereNode.getName()
self.accept(self.enteranceEvent, self.__handleToonEnterance)
finish = room.getGeom().find('**/finish')
self.finishSphere = CollisionSphere(0, 0, 0, 15.0)
self.finishSphereNode = CollisionNode(
'mazegame_finish-%s-%s' % (self.level.getLevelId(), self.entId))
self.finishSphereNode.addSolid(self.finishSphere)
self.finishSphereNodePath = finish.attachNewNode(self.finishSphereNode)
self.finishSphereNode.setCollideMask(WallBitmask)
self.finishSphere.setTangible(0)
self.finishEvent = 'enter' + self.finishSphereNode.getName()
self.accept(self.finishEvent, self.__handleToonFinish)
def __handleToonEnterance(self, collEntry):
if not self.gameStarted:
self.notify.debug('sending clientTriggered for %d' % self.doId)
self.sendUpdate('setClientTriggered', [])
self.level.countryClub.showInfoText(self.toonEnteredText)
def __handleToonFinish(self, collEntry):
self.sendUpdate('setFinishedMaze', [])
self.finished = 1
def __handleToonEnterHint(self, collEntry):
camHeight = base.localAvatar.getClampedAvatarHeight()
heightScaleFactor = camHeight * 0.3333333333
defLookAt = Point3(0.0, 1.5, camHeight)
cameraPoint = Point3(0.0, -22.0 * heightScaleFactor, camHeight + 54.0)
base.localAvatar.stopUpdateSmartCamera()
base.localAvatar.startUpdateSmartCamera(push=0)
base.localAvatar.setIdealCameraPos(cameraPoint)
def __handleToonExitHint(self, collEntry):
base.localAvatar.stopUpdateSmartCamera()
base.localAvatar.startUpdateSmartCamera()
base.localAvatar.setCameraPositionByIndex(base.localAvatar.cameraIndex)
self.cameraHold = None
return
def getRng(self):
return random.Random(self.entId * self.doId)
def removeHedgeBlocks(self, room):
if self.numSections in self.RemoveBlocksDict:
blocksToRemove = self.getRng().choice(
self.RemoveBlocksDict[self.numSections])
for blockName in blocksToRemove:
block = room.getGeom().find('**/%s' % blockName)
if not block.isEmpty():
block.removeNode()
def setGameStart(self, timestamp):
self.notify.debug('%d setGameStart: Starting game' % self.doId)
self.gameStartTime = globalClockDelta.networkToLocalTime(timestamp)
self.gameStarted = True
curGameTime = self.getCurrentGameTime()
timeLeft = self.GameDuration - curGameTime
self.cleanupTimer()
self.timer = ToontownTimer.ToontownTimer()
self.timer.posBelowTopRightCorner()
self.timer.setTime(timeLeft)
self.timer.countdown(timeLeft, self.timerExpired)
self.startScheduleTask()
self.frame2D.show()
def setGameOver(self):
self.timedOut = 1
if not self.finished:
self.sendUpdate('damageMe', [])
roomNum = self.level.roomNum
club = self.level.countryClub
self.gameOverTrack = Sequence()
self.gameOverTrack.append(localAvatar.getTeleportOutTrack())
self.gameOverTrack.append(
Func(localAvatar.setPos,
self.finishSphereNodePath.getPos(render)))
self.gameOverTrack.append(Func(localAvatar.play, 'jump'))
self.gameOverTrack.append(
Func(self.level.countryClub.camEnterRoom, roomNum))
self.gameOverTrack.start()
self.timerExpired()
def local2GameTime(self, timestamp):
return timestamp - self.gameStartTime
def game2LocalTime(self, timestamp):
return timestamp + self.gameStartTime
def getCurrentGameTime(self):
return self.local2GameTime(globalClock.getFrameTime())
def startScheduleTask(self):
taskMgr.add(self.scheduleTask, self.ScheduleTaskName)
def stopScheduleTask(self):
taskMgr.remove(self.ScheduleTaskName)
def scheduleTask(self, task):
curTime = self.getCurrentGameTime()
def cleanupTimer(self):
if self.timer:
self.timer.stop()
self.timer.destroy()
self.timer = None
return
def timerExpired(self):
self.cleanupTimer()
self.unloadGui()
def loadGui(self):
self.frame2D = DirectFrame(scale=1.0,
pos=(0.0, 0, 0.9),
relief=DGG.FLAT,
parent=aspect2d,
frameSize=(-0.3, 0.3, -0.05, 0.05),
frameColor=(0.737, 0.573, 0.345, 0.3))
self.frame2D.hide()
self.gameLabel = DirectLabel(parent=self.frame2D,
relief=None,
pos=(0, 0, 0),
scale=1.0,
text=TTLocalizer.mazeLabel,
text_font=ToontownGlobals.getSignFont(),
text0_fg=(1, 1, 1, 1),
text_scale=0.075,
text_pos=(0, -0.02))
return
def unloadGui(self):
if self.frame2D:
self.frame2D.destroy()
self.frame2D = None
if self.gameLabel:
self.gameLabel.destroy()
self.gameLabel = None
return
def toonFinished(self, avId, place, lastToon):
toon = base.cr.doId2do.get(avId)
if toon and not self.timedOut:
self.level.countryClub.showInfoText(
self.toonFinishedText %
(toon.getName(), TTLocalizer.hedgeMazePlaces[place]))
if lastToon:
self.setGameOver()
class DistributedBanquetTable(DistributedObject.DistributedObject, FSM.FSM, BanquetTableBase.BanquetTableBase):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedBanquetTable')
rotationsPerSeatIndex = [90,
90,
0,
0,
-90,
-90,
180,
180]
pitcherMinH = -360
pitcherMaxH = 360
rotateSpeed = 30
waterPowerSpeed = base.config.GetDouble('water-power-speed', 15)
waterPowerExponent = base.config.GetDouble('water-power-exponent', 0.75)
useNewAnimations = True
TugOfWarControls = False
OnlyUpArrow = True
if OnlyUpArrow:
BASELINE_KEY_RATE = 3
else:
BASELINE_KEY_RATE = 6
UPDATE_KEY_PRESS_RATE_TASK = 'BanquetTableUpdateKeyPressRateTask'
YELLOW_POWER_THRESHOLD = 0.75
RED_POWER_THRESHOLD = 0.97
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
FSM.FSM.__init__(self, 'DistributedBanquetTable')
self.boss = None
self.index = -1
self.diners = {}
self.dinerStatus = {}
self.serviceLocs = {}
self.chairLocators = {}
self.sitLocators = {}
self.activeIntervals = {}
self.dinerStatusIndicators = {}
self.preparedForPhaseFour = False
self.avId = 0
self.toon = None
self.pitcherSmoother = SmoothMover()
self.pitcherSmoother.setSmoothMode(SmoothMover.SMOn)
self.smoothStarted = 0
self.__broadcastPeriod = 0.2
self.changeSeq = 0
self.lastChangeSeq = 0
self.pitcherAdviceLabel = None
self.fireLength = 250
self.fireTrack = None
self.hitObject = None
self.setupPowerBar()
self.aimStart = None
self.toonPitcherPosition = Point3(0, -2, 0)
self.allowLocalRequestControl = True
self.fadeTrack = None
self.grabTrack = None
self.gotHitByBoss = False
self.keyTTL = []
self.keyRate = 0
self.buttons = [0, 1]
self.lastPowerFired = 0
self.moveSound = None
self.releaseTrack = None
return
def disable(self):
DistributedObject.DistributedObject.disable(self)
taskMgr.remove(self.triggerName)
taskMgr.remove(self.smoothName)
taskMgr.remove(self.watchControlsName)
taskMgr.remove(self.pitcherAdviceName)
taskMgr.remove(self.posHprBroadcastName)
taskMgr.remove(self.waterPowerTaskName)
if self.releaseTrack:
self.releaseTrack.finish()
self.releaseTrack = None
if self.fireTrack:
self.fireTrack.finish()
self.fireTrack = None
self.cleanupIntervals()
return
def delete(self):
DistributedObject.DistributedObject.delete(self)
self.boss = None
self.ignoreAll()
for indicator in list(self.dinerStatusIndicators.values()):
indicator.delete()
self.dinerStatusIndicators = {}
for diner in list(self.diners.values()):
diner.delete()
self.diners = {}
self.powerBar.destroy()
self.powerBar = None
self.pitcherMoveSfx.stop()
return
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
self.loadAssets()
self.smoothName = self.uniqueName('pitcherSmooth')
self.pitcherAdviceName = self.uniqueName('pitcherAdvice')
self.posHprBroadcastName = self.uniqueName('pitcherBroadcast')
self.waterPowerTaskName = self.uniqueName('updateWaterPower')
self.triggerName = self.uniqueName('trigger')
self.watchControlsName = self.uniqueName('watchControls')
def setBossCogId(self, bossCogId):
self.bossCogId = bossCogId
self.boss = base.cr.doId2do[bossCogId]
self.boss.setTable(self, self.index)
def setIndex(self, index):
self.index = index
def setState(self, state, avId, extraInfo):
self.gotHitByBoss = extraInfo
if state == 'F':
self.demand('Off')
elif state == 'N':
self.demand('On')
elif state == 'I':
self.demand('Inactive')
elif state == 'R':
self.demand('Free')
elif state == 'C':
self.demand('Controlled', avId)
elif state == 'L':
self.demand('Flat', avId)
else:
self.notify.error('Invalid state from AI: %s' % state)
def setNumDiners(self, numDiners):
self.numDiners = numDiners
def setDinerInfo(self, hungryDurations, eatingDurations, dinerLevels):
self.dinerInfo = {}
for i in range(len(hungryDurations)):
hungryDur = hungryDurations[i]
eatingDur = eatingDurations[i]
dinerLevel = dinerLevels[i]
self.dinerInfo[i] = (hungryDur, eatingDur, dinerLevel)
def loadAssets(self):
self.tableGroup = loader.loadModel('phase_12/models/bossbotHQ/BanquetTableChairs')
tableLocator = self.boss.geom.find('**/TableLocator_%d' % (self.index + 1))
if tableLocator.isEmpty():
self.tableGroup.reparentTo(render)
self.tableGroup.setPos(0, 75, 0)
else:
self.tableGroup.reparentTo(tableLocator)
self.tableGeom = self.tableGroup.find('**/Geometry')
self.setupDiners()
self.setupChairCols()
self.squirtSfx = loader.loadSfx('phase_4/audio/sfx/AA_squirt_seltzer_miss.ogg')
self.hitBossSfx = loader.loadSfx('phase_5/audio/sfx/SA_watercooler_spray_only.ogg')
self.hitBossSoundInterval = SoundInterval(self.hitBossSfx, node=self.boss, volume=1.0)
self.serveFoodSfx = loader.loadSfx('phase_4/audio/sfx/MG_sfx_travel_game_bell_for_trolley.ogg')
self.pitcherMoveSfx = base.loader.loadSfx('phase_4/audio/sfx/MG_cannon_adjust.ogg')
def setupDiners(self):
for i in range(self.numDiners):
newDiner = self.createDiner(i)
self.diners[i] = newDiner
self.dinerStatus[i] = self.HUNGRY
def createDiner(self, i):
diner = Suit.Suit()
diner.dna = SuitDNA.SuitDNA()
level = self.dinerInfo[i][2]
level -= 4
diner.dna.newSuitRandom(level=level, dept='c')
diner.setDNA(diner.dna)
diner.nametag.setNametag2d(None)
diner.nametag.setNametag3d(None)
if self.useNewAnimations:
diner.loop('sit', fromFrame=i)
else:
diner.pose('landing', 0)
locator = self.tableGroup.find('**/chair_%d' % (i + 1))
locatorScale = locator.getNetTransform().getScale()[0]
correctHeadingNp = locator.attachNewNode('correctHeading')
self.chairLocators[i] = correctHeadingNp
heading = self.rotationsPerSeatIndex[i]
correctHeadingNp.setH(heading)
sitLocator = correctHeadingNp.attachNewNode('sitLocator')
base.sitLocator = sitLocator
pos = correctHeadingNp.getPos(render)
if SuitDNA.getSuitBodyType(diner.dna.name) == 'c':
sitLocator.setPos(0.5, 3.65, -3.75)
else:
sitLocator.setZ(-2.4)
sitLocator.setY(2.5)
sitLocator.setX(0.5)
self.sitLocators[i] = sitLocator
diner.setScale(1.0 / locatorScale)
diner.reparentTo(sitLocator)
newLoc = NodePath('serviceLoc-%d-%d' % (self.index, i))
newLoc.reparentTo(correctHeadingNp)
newLoc.setPos(0, 3.0, 1)
self.serviceLocs[i] = newLoc
base.serviceLoc = newLoc
head = diner.find('**/joint_head')
newIndicator = DinerStatusIndicator.DinerStatusIndicator(parent=head, pos=Point3(0, 0, 3.5), scale=5.0)
newIndicator.wrtReparentTo(diner)
self.dinerStatusIndicators[i] = newIndicator
return diner
def setupChairCols(self):
for i in range(self.numDiners):
chairCol = self.tableGroup.find('**/collision_chair_%d' % (i + 1))
colName = 'ChairCol-%d-%d' % (self.index, i)
chairCol.setTag('chairIndex', str(i))
chairCol.setName(colName)
chairCol.setCollideMask(ToontownGlobals.WallBitmask)
self.accept('enter' + colName, self.touchedChair)
def touchedChair(self, colEntry):
chairIndex = int(colEntry.getIntoNodePath().getTag('chairIndex'))
if chairIndex in self.dinerStatus:
status = self.dinerStatus[chairIndex]
if status in (self.HUNGRY, self.ANGRY):
self.boss.localToonTouchedChair(self.index, chairIndex)
def serveFood(self, food, chairIndex):
self.removeFoodModel(chairIndex)
serviceLoc = self.serviceLocs.get(chairIndex)
if not food or food.isEmpty():
foodModel = loader.loadModel('phase_12/models/bossbotHQ/canoffood')
foodModel.setScale(ToontownGlobals.BossbotFoodModelScale)
foodModel.reparentTo(serviceLoc)
else:
food.wrtReparentTo(serviceLoc)
tray = food.find('**/tray')
if not tray.isEmpty():
tray.hide()
ivalDuration = 1.5
foodMoveIval = Parallel(SoundInterval(self.serveFoodSfx, node=food), ProjectileInterval(food, duration=ivalDuration, startPos=food.getPos(serviceLoc), endPos=serviceLoc.getPos(serviceLoc)), LerpHprInterval(food, ivalDuration, Point3(0, -360, 0)))
intervalName = 'serveFood-%d-%d' % (self.index, chairIndex)
foodMoveIval.start()
self.activeIntervals[intervalName] = foodMoveIval
def setDinerStatus(self, chairIndex, status):
if chairIndex in self.dinerStatus:
oldStatus = self.dinerStatus[chairIndex]
self.dinerStatus[chairIndex] = status
if oldStatus != status:
if status == self.EATING:
self.changeDinerToEating(chairIndex)
elif status == self.HUNGRY:
self.changeDinerToHungry(chairIndex)
elif status == self.ANGRY:
self.changeDinerToAngry(chairIndex)
elif status == self.DEAD:
self.changeDinerToDead(chairIndex)
elif status == self.HIDDEN:
self.changeDinerToHidden(chairIndex)
def removeFoodModel(self, chairIndex):
serviceLoc = self.serviceLocs.get(chairIndex)
if serviceLoc:
for i in range(serviceLoc.getNumChildren()):
serviceLoc.getChild(0).removeNode()
def changeDinerToEating(self, chairIndex):
indicator = self.dinerStatusIndicators.get(chairIndex)
eatingDuration = self.dinerInfo[chairIndex][1]
if indicator:
indicator.request('Eating', eatingDuration)
diner = self.diners[chairIndex]
intervalName = 'eating-%d-%d' % (self.index, chairIndex)
eatInTime = 32.0 / 24.0
eatOutTime = 21.0 / 24.0
eatLoopTime = 19 / 24.0
rightHand = diner.getRightHand()
waitTime = 5
loopDuration = eatingDuration - eatInTime - eatOutTime - waitTime
serviceLoc = self.serviceLocs[chairIndex]
def foodAttach(self = self, diner = diner):
if self.serviceLocs[chairIndex].getNumChildren() < 1:
return
foodModel = self.serviceLocs[chairIndex].getChild(0)
(foodModel.reparentTo(diner.getRightHand()),)
(foodModel.setHpr(Point3(0, -94, 0)),)
(foodModel.setPos(Point3(-0.15, -0.7, -0.4)),)
scaleAdj = 1
if SuitDNA.getSuitBodyType(diner.dna.name) == 'c':
scaleAdj = 0.6
(foodModel.setPos(Point3(0.1, -0.25, -0.31)),)
else:
scaleAdj = 0.8
(foodModel.setPos(Point3(-0.25, -0.85, -0.34)),)
oldScale = foodModel.getScale()
newScale = oldScale * scaleAdj
foodModel.setScale(newScale)
def foodDetach(self = self, diner = diner):
if diner.getRightHand().getNumChildren() < 1:
return
foodModel = diner.getRightHand().getChild(0)
(foodModel.reparentTo(serviceLoc),)
(foodModel.setPosHpr(0, 0, 0, 0, 0, 0),)
scaleAdj = 1
if SuitDNA.getSuitBodyType(diner.dna.name) == 'c':
scaleAdj = 0.6
else:
scakeAdj = 0.8
oldScale = foodModel.getScale()
newScale = oldScale / scaleAdj
foodModel.setScale(newScale)
eatIval = Sequence(ActorInterval(diner, 'sit', duration=waitTime), ActorInterval(diner, 'sit-eat-in', startFrame=0, endFrame=6), Func(foodAttach), ActorInterval(diner, 'sit-eat-in', startFrame=6, endFrame=32), ActorInterval(diner, 'sit-eat-loop', duration=loopDuration, loop=1), ActorInterval(diner, 'sit-eat-out', startFrame=0, endFrame=12), Func(foodDetach), ActorInterval(diner, 'sit-eat-out', startFrame=12, endFrame=21))
eatIval.start()
self.activeIntervals[intervalName] = eatIval
def changeDinerToHungry(self, chairIndex):
intervalName = 'eating-%d-%d' % (self.index, chairIndex)
if intervalName in self.activeIntervals:
self.activeIntervals[intervalName].finish()
self.removeFoodModel(chairIndex)
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request('Hungry', self.dinerInfo[chairIndex][0])
diner = self.diners[chairIndex]
if random.choice([0, 1]):
diner.loop('sit-hungry-left')
else:
diner.loop('sit-hungry-right')
def changeDinerToAngry(self, chairIndex):
self.removeFoodModel(chairIndex)
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request('Angry')
diner = self.diners[chairIndex]
diner.loop('sit-angry')
def changeDinerToDead(self, chairIndex):
def removeDeathSuit(suit, deathSuit):
if not deathSuit.isEmpty():
deathSuit.detachNode()
suit.cleanupLoseActor()
self.removeFoodModel(chairIndex)
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request('Dead')
diner = self.diners[chairIndex]
deathSuit = diner
locator = self.tableGroup.find('**/chair_%d' % (chairIndex + 1))
deathSuit = diner.getLoseActor()
ival = Sequence(Func(self.notify.debug, 'before actorinterval sit-lose'), ActorInterval(diner, 'sit-lose'), Func(self.notify.debug, 'before deathSuit.setHpr'), Func(deathSuit.setHpr, diner.getHpr()), Func(self.notify.debug, 'before diner.hide'), Func(diner.hide), Func(self.notify.debug, 'before deathSuit.reparentTo'), Func(deathSuit.reparentTo, self.chairLocators[chairIndex]), Func(self.notify.debug, 'befor ActorInterval lose'), ActorInterval(deathSuit, 'lose', duration=MovieUtil.SUIT_LOSE_DURATION), Func(self.notify.debug, 'before remove deathsuit'), Func(removeDeathSuit, diner, deathSuit, name='remove-death-suit-%d-%d' % (chairIndex, self.index)), Func(self.notify.debug, 'diner.stash'), Func(diner.stash))
spinningSound = base.loader.loadSfx('phase_3.5/audio/sfx/Cog_Death.ogg')
deathSound = base.loader.loadSfx('phase_3.5/audio/sfx/ENC_cogfall_apart.ogg')
deathSoundTrack = Sequence(Wait(0.8), SoundInterval(spinningSound, duration=1.2, startTime=1.5, volume=0.2, node=deathSuit), SoundInterval(spinningSound, duration=3.0, startTime=0.6, volume=0.8, node=deathSuit), SoundInterval(deathSound, volume=0.32, node=deathSuit))
intervalName = 'dinerDie-%d-%d' % (self.index, chairIndex)
deathIval = Parallel(ival, deathSoundTrack)
deathIval.start()
self.activeIntervals[intervalName] = deathIval
def changeDinerToHidden(self, chairIndex):
self.removeFoodModel(chairIndex)
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request('Inactive')
diner = self.diners[chairIndex]
diner.hide()
def setAllDinersToSitNeutral(self):
startFrame = 0
for diner in list(self.diners.values()):
if not diner.isHidden():
diner.loop('sit', fromFrame=startFrame)
startFrame += 1
def cleanupIntervals(self):
for interval in list(self.activeIntervals.values()):
interval.finish()
self.activeIntervals = {}
def clearInterval(self, name, finish = 1):
if name in self.activeIntervals:
ival = self.activeIntervals[name]
if finish:
ival.finish()
else:
ival.pause()
if name in self.activeIntervals:
del self.activeIntervals[name]
else:
self.notify.debug('interval: %s already cleared' % name)
def finishInterval(self, name):
if name in self.activeIntervals:
interval = self.activeIntervals[name]
interval.finish()
def getNotDeadInfo(self):
notDeadList = []
for i in range(self.numDiners):
if self.dinerStatus[i] != self.DEAD:
notDeadList.append((self.index, i, 12))
return notDeadList
def enterOn(self):
pass
def exitOn(self):
pass
def enterInactive(self):
for chairIndex in range(self.numDiners):
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request('Inactive')
self.removeFoodModel(chairIndex)
def exitInactive(self):
pass
def enterFree(self):
self.resetPowerBar()
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.prepareForPhaseFour()
if self.avId == localAvatar.doId:
self.tableGroup.setAlphaScale(0.3)
self.tableGroup.setTransparency(1)
taskMgr.doMethodLater(5, self.__allowDetect, self.triggerName)
self.fadeTrack = Sequence(Func(self.tableGroup.setTransparency, 1), self.tableGroup.colorScaleInterval(0.2, VBase4(1, 1, 1, 0.3)))
self.fadeTrack.start()
self.allowLocalRequestControl = False
else:
self.allowLocalRequestControl = True
self.avId = 0
return
def exitFree(self):
pass
def touchedTable(self, colEntry):
tableIndex = int(colEntry.getIntoNodePath().getTag('tableIndex'))
if self.state == 'Free' and self.avId == 0 and self.allowLocalRequestControl:
self.d_requestControl()
def prepareForPhaseFour(self):
if not self.preparedForPhaseFour:
for i in range(8):
chair = self.tableGroup.find('**/chair_%d' % (i + 1))
if not chair.isEmpty():
chair.hide()
colChairs = self.tableGroup.findAllMatches('**/ChairCol*')
for i in range(colChairs.getNumPaths()):
col = colChairs.getPath(i)
col.stash()
colChairs = self.tableGroup.findAllMatches('**/collision_chair*')
for i in range(colChairs.getNumPaths()):
col = colChairs.getPath(i)
col.stash()
tableCol = self.tableGroup.find('**/collision_table')
colName = 'TableCol-%d' % self.index
tableCol.setTag('tableIndex', str(self.index))
tableCol.setName(colName)
tableCol.setCollideMask(ToontownGlobals.WallBitmask | ToontownGlobals.BanquetTableBitmask)
self.accept('enter' + colName, self.touchedTable)
self.preparedForPhaseFour = True
self.waterPitcherModel = loader.loadModel('phase_12/models/bossbotHQ/tt_m_ara_bhq_seltzerBottle')
lampNode = self.tableGroup.find('**/lamp_med_5')
pos = lampNode.getPos(self.tableGroup)
lampNode.hide()
bottleLocator = self.tableGroup.find('**/bottle_locator')
pos = bottleLocator.getPos(self.tableGroup)
self.waterPitcherNode = self.tableGroup.attachNewNode('pitcherNode')
self.waterPitcherNode.setPos(pos)
self.waterPitcherModel.reparentTo(self.waterPitcherNode)
self.nozzle = self.waterPitcherModel.find('**/nozzle_tip')
self.handLocator = self.waterPitcherModel.find('**/hand_locator')
self.handPos = self.handLocator.getPos()
def d_requestControl(self):
self.sendUpdate('requestControl')
def d_requestFree(self, gotHitByBoss):
self.sendUpdate('requestFree', [gotHitByBoss])
def enterControlled(self, avId):
self.prepareForPhaseFour()
self.avId = avId
toon = base.cr.doId2do.get(avId)
if not toon:
return
self.toon = toon
self.grabTrack = self.makeToonGrabInterval(toon)
self.notify.debug('grabTrack=%s' % self.grabTrack)
self.pitcherCamPos = Point3(0, -50, 40)
self.pitcherCamHpr = Point3(0, -21, 0)
if avId == localAvatar.doId:
self.boss.toMovieMode()
self.__enableControlInterface()
self.startPosHprBroadcast()
self.grabTrack = Sequence(self.grabTrack, Func(camera.wrtReparentTo, localAvatar), LerpPosHprInterval(camera, 1, self.pitcherCamPos, self.pitcherCamHpr), Func(self.boss.toCraneMode))
if self.TugOfWarControls:
self.__spawnUpdateKeyPressRateTask()
self.accept('exitCrane', self.gotBossZapped)
else:
self.startSmooth()
toon.stopSmooth()
self.grabTrack.start()
def exitControlled(self):
self.ignore('exitCrane')
if self.grabTrack:
self.grabTrack.finish()
self.grabTrack = None
nextState = self.getCurrentOrNextState()
self.notify.debug('nextState=%s' % nextState)
if nextState == 'Flat':
place = base.cr.playGame.getPlace()
self.notify.debug('%s' % place.fsm)
if self.avId == localAvatar.doId:
self.__disableControlInterface()
else:
if self.toon and not self.toon.isDisabled():
self.toon.loop('neutral')
self.toon.startSmooth()
self.releaseTrack = self.makeToonReleaseInterval(self.toon)
self.stopPosHprBroadcast()
self.stopSmooth()
if self.avId == localAvatar.doId:
localAvatar.wrtReparentTo(render)
self.__disableControlInterface()
camera.reparentTo(base.localAvatar)
camera.setPos(base.localAvatar.cameraPositions[0][0])
camera.setHpr(0, 0, 0)
self.goToFinalBattle()
self.safeBossToFinalBattleMode()
else:
toon = base.cr.doId2do.get(self.avId)
if toon:
toon.wrtReparentTo(render)
self.releaseTrack.start()
return
def safeBossToFinalBattleMode(self):
if self.boss:
self.boss.toFinalBattleMode()
def goToFinalBattle(self):
if self.cr:
place = self.cr.playGame.getPlace()
if place and hasattr(place, 'fsm'):
if place.fsm.getCurrentState().getName() == 'crane':
place.setState('finalBattle')
def makeToonGrabInterval(self, toon):
toon.pose('leverNeutral', 0)
toon.update()
rightHandPos = toon.rightHand.getPos(toon)
self.toonPitcherPosition = Point3(self.handPos[0] - rightHandPos[0], self.handPos[1] - rightHandPos[1], 0)
destZScale = rightHandPos[2] / self.handPos[2]
grabIval = Sequence(Func(toon.wrtReparentTo, self.waterPitcherNode), Func(toon.loop, 'neutral'), Parallel(ActorInterval(toon, 'jump'), Sequence(Wait(0.43), Parallel(ProjectileInterval(toon, duration=0.9, startPos=toon.getPos(self.waterPitcherNode), endPos=self.toonPitcherPosition), LerpHprInterval(toon, 0.9, Point3(0, 0, 0)), LerpScaleInterval(self.waterPitcherModel, 0.9, Point3(1, 1, destZScale))))), Func(toon.setPos, self.toonPitcherPosition), Func(toon.loop, 'leverNeutral'))
return grabIval
def makeToonReleaseInterval(self, toon):
temp1 = self.waterPitcherNode.attachNewNode('temp1')
temp1.setPos(self.toonPitcherPosition)
temp2 = self.waterPitcherNode.attachNewNode('temp2')
temp2.setPos(0, -10, -self.waterPitcherNode.getZ())
startPos = temp1.getPos(render)
endPos = temp2.getPos(render)
temp1.removeNode()
temp2.removeNode()
def getSlideToPos(toon = toon):
return render.getRelativePoint(toon, Point3(0, -10, 0))
if self.gotHitByBoss:
self.notify.debug('creating zap interval instead')
grabIval = Sequence(Func(toon.loop, 'neutral'), Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'slip-backward'), toon.posInterval(0.5, getSlideToPos, fluid=1)))
else:
grabIval = Sequence(Func(toon.loop, 'neutral'), Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'jump'), Sequence(Wait(0.43), ProjectileInterval(toon, duration=0.9, startPos=startPos, endPos=endPos))))
return grabIval
def b_clearSmoothing(self):
self.d_clearSmoothing()
self.clearSmoothing()
def d_clearSmoothing(self):
self.sendUpdate('clearSmoothing', [0])
def clearSmoothing(self, bogus = None):
self.pitcherSmoother.clearPositions(1)
def doSmoothTask(self, task):
self.pitcherSmoother.computeAndApplySmoothHpr(self.waterPitcherNode)
return Task.cont
def startSmooth(self):
if not self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.reloadPosition()
taskMgr.add(self.doSmoothTask, taskName)
self.smoothStarted = 1
def stopSmooth(self):
if self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.forceToTruePosition()
self.smoothStarted = 0
def __enableControlInterface(self):
gui = loader.loadModel('phase_3.5/models/gui/avatar_panel_gui')
self.closeButton = DirectButton(image=(gui.find('**/CloseBtn_UP'),
gui.find('**/CloseBtn_DN'),
gui.find('**/CloseBtn_Rllvr'),
gui.find('**/CloseBtn_UP')), relief=None, scale=2, text=TTLocalizer.BossbotPitcherLeave, text_scale=0.04, text_pos=(0, -0.07), text_fg=VBase4(1, 1, 1, 1), pos=(1.05, 0, -0.82), command=self.__exitPitcher)
self.accept('escape', self.__exitPitcher)
self.accept(base.JUMP, self.__controlPressed)
self.accept('control-up', self.__controlReleased)
self.accept('InputState-forward', self.__upArrow)
self.accept('InputState-reverse', self.__downArrow)
self.accept('InputState-turnLeft', self.__leftArrow)
self.accept('InputState-turnRight', self.__rightArrow)
self.accept(base.MOVE_UP, self.__upArrowKeyPressed)
self.accept(base.MOVE_DOWN, self.__downArrowKeyPressed)
taskMgr.add(self.__watchControls, self.watchControlsName)
taskMgr.doMethodLater(5, self.__displayPitcherAdvice, self.pitcherAdviceName)
self.arrowVert = 0
self.arrowHorz = 0
self.powerBar.show()
return
def __disableControlInterface(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = None
self.__cleanupPitcherAdvice()
self.ignore('escape')
self.ignore(base.JUMP)
self.ignore('control-up')
self.ignore('InputState-forward')
self.ignore('InputState-reverse')
self.ignore('InputState-turnLeft')
self.ignore('InputState-turnRight')
self.ignore(base.MOVE_UP)
self.ignore(base.MOVE_DOWN)
self.arrowVert = 0
self.arrowHorz = 0
taskMgr.remove(self.watchControlsName)
taskMgr.remove(self.waterPowerTaskName)
self.resetPowerBar()
self.aimStart = None
self.powerBar.hide()
if self.TugOfWarControls:
self.__killUpdateKeyPressRateTask()
self.keyTTL = []
self.__setMoveSound(None)
return
def __displayPitcherAdvice(self, task):
if self.pitcherAdviceLabel == None:
self.pitcherAdviceLabel = DirectLabel(text=TTLocalizer.BossbotPitcherAdvice, text_fg=VBase4(1, 1, 1, 1), text_align=TextNode.ACenter, relief=None, pos=(0, 0, 0.69), scale=0.1)
return
def __cleanupPitcherAdvice(self):
if self.pitcherAdviceLabel:
self.pitcherAdviceLabel.destroy()
self.pitcherAdviceLabel = None
taskMgr.remove(self.pitcherAdviceName)
return
def showExiting(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = DirectLabel(relief=None, text=TTLocalizer.BossbotPitcherLeaving, pos=(1.05, 0, -0.88), text_pos=(0, 0), text_scale=0.06, text_fg=VBase4(1, 1, 1, 1))
self.__cleanupPitcherAdvice()
return
def __exitPitcher(self):
self.showExiting()
self.d_requestFree(False)
def __controlPressed(self):
self.__cleanupPitcherAdvice()
if self.TugOfWarControls:
if self.power:
self.aimStart = 1
self.__endFireWater()
elif self.state == 'Controlled':
self.__beginFireWater()
def __controlReleased(self):
if self.TugOfWarControls:
pass
elif self.state == 'Controlled':
self.__endFireWater()
def __upArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupPitcherAdvice()
if pressed:
self.arrowVert = 1
elif self.arrowVert > 0:
self.arrowVert = 0
def __downArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupPitcherAdvice()
if pressed:
self.arrowVert = -1
elif self.arrowVert < 0:
self.arrowVert = 0
def __rightArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupPitcherAdvice()
if pressed:
self.arrowHorz = 1
elif self.arrowHorz > 0:
self.arrowHorz = 0
def __leftArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupPitcherAdvice()
if pressed:
self.arrowHorz = -1
elif self.arrowHorz < 0:
self.arrowHorz = 0
def __incrementChangeSeq(self):
self.changeSeq = self.changeSeq + 1 & 255
def stopPosHprBroadcast(self):
taskName = self.posHprBroadcastName
taskMgr.remove(taskName)
def startPosHprBroadcast(self):
taskName = self.posHprBroadcastName
self.b_clearSmoothing()
self.d_sendPitcherPos()
taskMgr.remove(taskName)
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast, taskName)
def __posHprBroadcast(self, task):
self.d_sendPitcherPos()
taskName = self.posHprBroadcastName
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast, taskName)
return Task.done
def d_sendPitcherPos(self):
timestamp = globalClockDelta.getFrameNetworkTime()
self.sendUpdate('setPitcherPos', [self.changeSeq, self.waterPitcherNode.getH(), timestamp])
def setPitcherPos(self, changeSeq, h, timestamp):
self.changeSeq = changeSeq
if self.smoothStarted:
now = globalClock.getFrameTime()
local = globalClockDelta.networkToLocalTime(timestamp, now)
self.pitcherSmoother.setH(h)
self.pitcherSmoother.setTimestamp(local)
self.pitcherSmoother.markPosition()
else:
self.waterPitcherNode.setH(h)
def __watchControls(self, task):
if self.arrowHorz:
self.__movePitcher(self.arrowHorz)
else:
self.__setMoveSound(None)
return Task.cont
def __movePitcher(self, xd):
dt = globalClock.getDt()
h = self.waterPitcherNode.getH() - xd * self.rotateSpeed * dt
h %= 360
self.notify.debug('rotSpeed=%.2f curH=%.2f xd =%.2f, dt = %.2f, h=%.2f' % (self.rotateSpeed,
self.waterPitcherNode.getH(),
xd,
dt,
h))
limitH = h
self.waterPitcherNode.setH(limitH)
if xd:
self.__setMoveSound(self.pitcherMoveSfx)
def reloadPosition(self):
self.pitcherSmoother.clearPositions(0)
self.pitcherSmoother.setHpr(self.waterPitcherNode.getHpr())
self.pitcherSmoother.setPhonyTimestamp()
def forceToTruePosition(self):
if self.pitcherSmoother.getLatestPosition():
self.pitcherSmoother.applySmoothHpr(self.waterPitcherNode)
self.pitcherSmoother.clearPositions(1)
def getSprayTrack(self, color, origin, target, dScaleUp, dHold, dScaleDown, horizScale = 1.0, vertScale = 1.0, parent = render):
track = Sequence()
SPRAY_LEN = 1.5
sprayProp = MovieUtil.globalPropPool.getProp('spray')
sprayScale = hidden.attachNewNode('spray-parent')
sprayRot = hidden.attachNewNode('spray-rotate')
spray = sprayRot
spray.setColor(color)
if color[3] < 1.0:
spray.setTransparency(1)
def showSpray(sprayScale, sprayRot, sprayProp, origin, target, parent):
if callable(origin):
origin = origin()
if callable(target):
target = target()
sprayRot.reparentTo(parent)
sprayRot.clearMat()
sprayScale.reparentTo(sprayRot)
sprayScale.clearMat()
sprayProp.reparentTo(sprayScale)
sprayProp.clearMat()
sprayRot.setPos(origin)
sprayRot.lookAt(Point3(target))
track.append(Func(showSpray, sprayScale, sprayRot, sprayProp, origin, target, parent))
def calcTargetScale(target = target, origin = origin, horizScale = horizScale, vertScale = vertScale):
if callable(target):
target = target()
if callable(origin):
origin = origin()
distance = Vec3(target - origin).length()
yScale = distance / SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale, yScale * vertScale)
return targetScale
track.append(LerpScaleInterval(sprayScale, dScaleUp, calcTargetScale, startScale=Point3(0.01, 0.01, 0.01)))
track.append(Func(self.checkHitObject))
track.append(Wait(dHold))
def prepareToShrinkSpray(spray, sprayProp, origin, target):
if callable(target):
target = target()
if callable(origin):
origin = origin()
sprayProp.setPos(Point3(0.0, -SPRAY_LEN, 0.0))
spray.setPos(target)
track.append(Func(prepareToShrinkSpray, spray, sprayProp, origin, target))
track.append(LerpScaleInterval(sprayScale, dScaleDown, Point3(0.01, 0.01, 0.01)))
def hideSpray(spray, sprayScale, sprayRot, sprayProp, propPool):
sprayProp.detachNode()
MovieUtil.removeProp(sprayProp)
sprayRot.removeNode()
sprayScale.removeNode()
track.append(Func(hideSpray, spray, sprayScale, sprayRot, sprayProp, MovieUtil.globalPropPool))
return track
def checkHitObject(self):
if not self.hitObject:
return
if self.avId != base.localAvatar.doId:
return
tag = self.hitObject.getNetTag('pieCode')
pieCode = int(tag)
if pieCode == ToontownGlobals.PieCodeBossCog:
self.hitBossSoundInterval.start()
self.sendUpdate('waterHitBoss', [self.index])
if self.TugOfWarControls:
damage = 1
if self.lastPowerFired < self.YELLOW_POWER_THRESHOLD:
damage = 1
elif self.lastPowerFired < self.RED_POWER_THRESHOLD:
damage = 2
else:
damage = 3
self.boss.d_hitBoss(damage)
else:
damage = 1
if self.lastPowerFired < self.YELLOW_POWER_THRESHOLD:
damage = 1
elif self.lastPowerFired < self.RED_POWER_THRESHOLD:
damage = 2
else:
damage = 3
self.boss.d_hitBoss(damage)
def waterHitBoss(self, tableIndex):
if self.index == tableIndex:
self.hitBossSoundInterval.start()
def setupPowerBar(self):
self.powerBar = DirectWaitBar(pos=(0.0, 0, -0.94), relief=DGG.SUNKEN, frameSize=(-2.0,
2.0,
-0.2,
0.2), borderWidth=(0.02, 0.02), scale=0.25, range=1, sortOrder=50, frameColor=(0.5, 0.5, 0.5, 0.5), barColor=(0.75, 0.75, 1.0, 0.8), text='', text_scale=0.26, text_fg=(1, 1, 1, 1), text_align=TextNode.ACenter, text_pos=(0, -0.05))
self.power = 0
self.powerBar['value'] = self.power
self.powerBar.hide()
def resetPowerBar(self):
self.power = 0
self.powerBar['value'] = self.power
self.powerBar['text'] = ''
self.keyTTL = []
def __beginFireWater(self):
if self.fireTrack and self.fireTrack.isPlaying():
return
if self.aimStart != None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
time = globalClock.getFrameTime()
self.aimStart = time
messenger.send('wakeup')
taskMgr.add(self.__updateWaterPower, self.waterPowerTaskName)
return
def __endFireWater(self):
if self.aimStart == None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
taskMgr.remove(self.waterPowerTaskName)
messenger.send('wakeup')
self.aimStart = None
origin = self.nozzle.getPos(render)
target = self.boss.getPos(render)
angle = deg2Rad(self.waterPitcherNode.getH() + 90)
x = math.cos(angle)
y = math.sin(angle)
fireVector = Point3(x, y, 0)
if self.power < 0.001:
self.power = 0.001
self.lastPowerFired = self.power
fireVector *= self.fireLength * self.power
target = origin + fireVector
segment = CollisionSegment(origin[0], origin[1], origin[2], target[0], target[1], target[2])
fromObject = render.attachNewNode(CollisionNode('pitcherColNode'))
fromObject.node().addSolid(segment)
fromObject.node().setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask)
fromObject.node().setIntoCollideMask(BitMask32.allOff())
queue = CollisionHandlerQueue()
base.cTrav.addCollider(fromObject, queue)
base.cTrav.traverse(render)
queue.sortEntries()
self.hitObject = None
if queue.getNumEntries():
entry = queue.getEntry(0)
target = entry.getSurfacePoint(render)
self.hitObject = entry.getIntoNodePath()
base.cTrav.removeCollider(fromObject)
fromObject.removeNode()
self.d_firingWater(origin, target)
self.fireWater(origin, target)
self.resetPowerBar()
return
def __updateWaterPower(self, task):
if not self.powerBar:
print('### no power bar!!!')
return task.done
newPower = self.__getWaterPower(globalClock.getFrameTime())
self.power = newPower
self.powerBar['value'] = newPower
if self.power < self.YELLOW_POWER_THRESHOLD:
self.powerBar['barColor'] = VBase4(0.75, 0.75, 1.0, 0.8)
elif self.power < self.RED_POWER_THRESHOLD:
self.powerBar['barColor'] = VBase4(1.0, 1.0, 0.0, 0.8)
else:
self.powerBar['barColor'] = VBase4(1.0, 0.0, 0.0, 0.8)
return task.cont
def __getWaterPower(self, time):
elapsed = max(time - self.aimStart, 0.0)
t = elapsed / self.waterPowerSpeed
exponent = self.waterPowerExponent
if t > 1:
t = t % 1
power = 1 - math.pow(1 - t, exponent)
if power > 1.0:
power = 1.0
return power
def d_firingWater(self, origin, target):
self.sendUpdate('firingWater', [origin[0],
origin[1],
origin[2],
target[0],
target[1],
target[2]])
def firingWater(self, startX, startY, startZ, endX, endY, endZ):
origin = Point3(startX, startY, startZ)
target = Point3(endX, endY, endZ)
self.fireWater(origin, target)
def fireWater(self, origin, target):
color = VBase4(0.75, 0.75, 1, 0.8)
dScaleUp = 0.1
dHold = 0.3
dScaleDown = 0.1
horizScale = 0.1
vertScale = 0.1
sprayTrack = self.getSprayTrack(color, origin, target, dScaleUp, dHold, dScaleDown, horizScale, vertScale)
duration = self.squirtSfx.length()
if sprayTrack.getDuration() < duration:
duration = sprayTrack.getDuration()
soundTrack = SoundInterval(self.squirtSfx, node=self.waterPitcherModel, duration=duration)
self.fireTrack = Parallel(sprayTrack, soundTrack)
self.fireTrack.start()
def getPos(self, wrt = render):
return self.tableGroup.getPos(wrt)
def getLocator(self):
return self.tableGroup
def enterFlat(self, avId):
self.prepareForPhaseFour()
self.resetPowerBar()
self.notify.debug('enterFlat %d' % self.index)
if self.avId:
toon = base.cr.doId2do.get(self.avId)
if toon:
toon.wrtReparentTo(render)
toon.setZ(0)
self.tableGroup.setScale(1, 1, 0.01)
if self.avId and self.avId == localAvatar.doId:
localAvatar.b_squish(ToontownGlobals.BossCogDamageLevels[ToontownGlobals.BossCogMoveAttack])
def exitFlat(self):
self.tableGroup.setScale(1.0)
if self.avId:
toon = base.cr.doId2do.get(self.avId)
if toon:
if toon == localAvatar:
self.boss.toCraneMode()
toon.b_setAnimState('neutral')
toon.setAnimState('neutral')
toon.loop('leverNeutral')
def __allowDetect(self, task):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = Sequence(self.tableGroup.colorScaleInterval(0.2, VBase4(1, 1, 1, 1)), Func(self.tableGroup.clearColorScale), Func(self.tableGroup.clearTransparency))
self.fadeTrack.start()
self.allowLocalRequestControl = True
def gotBossZapped(self):
self.showExiting()
self.d_requestFree(True)
def __upArrowKeyPressed(self):
if self.TugOfWarControls:
self.__pressHandler(0)
def __downArrowKeyPressed(self):
if self.TugOfWarControls:
self.__pressHandler(1)
def __pressHandler(self, index):
if index == self.buttons[0]:
self.keyTTL.insert(0, 1.0)
if not self.OnlyUpArrow:
self.buttons.reverse()
def __spawnUpdateKeyPressRateTask(self):
taskMgr.remove(self.taskName(self.UPDATE_KEY_PRESS_RATE_TASK))
taskMgr.doMethodLater(0.1, self.__updateKeyPressRateTask, self.taskName(self.UPDATE_KEY_PRESS_RATE_TASK))
def __killUpdateKeyPressRateTask(self):
taskMgr.remove(self.taskName(self.UPDATE_KEY_PRESS_RATE_TASK))
def __updateKeyPressRateTask(self, task):
if self.state not in 'Controlled':
return Task.done
for i in range(len(self.keyTTL)):
self.keyTTL[i] -= 0.1
for i in range(len(self.keyTTL)):
if self.keyTTL[i] <= 0:
a = self.keyTTL[0:i]
del self.keyTTL
self.keyTTL = a
break
self.keyRate = len(self.keyTTL)
keyRateDiff = self.keyRate - self.BASELINE_KEY_RATE
diffPower = keyRateDiff / 300.0
if self.power < 1 and diffPower > 0:
diffPower = diffPower * math.pow(1 - self.power, 1.25)
newPower = self.power + diffPower
if newPower > 1:
newPower = 1
elif newPower < 0:
newPower = 0
self.notify.debug('diffPower=%.2f keyRate = %d, newPower=%.2f' % (diffPower, self.keyRate, newPower))
self.power = newPower
self.powerBar['value'] = newPower
if self.power < self.YELLOW_POWER_THRESHOLD:
self.powerBar['barColor'] = VBase4(0.75, 0.75, 1.0, 0.8)
elif self.power < self.RED_POWER_THRESHOLD:
self.powerBar['barColor'] = VBase4(1.0, 1.0, 0.0, 0.8)
else:
self.powerBar['barColor'] = VBase4(1.0, 0.0, 0.0, 0.8)
self.__spawnUpdateKeyPressRateTask()
return Task.done
def __setMoveSound(self, sfx):
if sfx != self.moveSound:
if self.moveSound:
self.moveSound.stop()
self.moveSound = sfx
if self.moveSound:
base.playSfx(self.moveSound, looping=1, volume=0.5)
class DistCogdoGame(DistCogdoGameBase, DistributedObject):
notify = directNotify.newCategory('DistCogdoGame')
def __init__(self, cr):
DistributedObject.__init__(self, cr)
base.cogdoGame = self
cr.cogdoGame = self
self._waitingStartLabel = DirectLabel(
text=TTL.MinigameWaitingForOtherPlayers,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.6, 0, -0.75),
scale=0.075)
self._waitingStartLabel.hide()
self.loadFSM = ClassicFSM.ClassicFSM('DistCogdoGame.loaded', [
State.State('NotLoaded', self.enterNotLoaded, self.exitNotLoaded,
['Loaded']),
State.State('Loaded', self.enterLoaded, self.exitLoaded,
['NotLoaded'])
], 'NotLoaded', 'NotLoaded')
self.loadFSM.enterInitialState()
self.fsm = ClassicFSM.ClassicFSM('DistCogdoGame', [
State.State('Visible', self.enterVisible, self.exitVisible,
['Intro']),
State.State('Intro', self.enterIntro, self.exitIntro,
['WaitServerStart']),
State.State('WaitServerStart', self.enterWaitServerStart,
self.exitWaitServerStart, ['Game']),
State.State('Game', self.enterGame, self.exitGame, ['Finish']),
State.State('Finish', self.enterFinish, self.exitFinish, ['Off']),
State.State('Off', self.enterOff, self.exitOff, ['Visible'])
], 'Off', 'Off')
self.fsm.enterInitialState()
self.difficultyOverride = None
self.exteriorZoneOverride = None
self._gotInterior = StateVar(False)
self._toonsInEntranceElev = StateVar(False)
self._wantStashElevator = StateVar(False)
self._stashElevatorFC = FunctionCall(self._doStashElevator,
self._toonsInEntranceElev,
self._gotInterior,
self._wantStashElevator)
return
def getTitle(self):
pass
def getInstructions(self):
pass
def setInteriorId(self, interiorId):
self._interiorId = interiorId
def setExteriorZone(self, exteriorZone):
self.exteriorZone = exteriorZone
def setDifficultyOverrides(self, difficultyOverride, exteriorZoneOverride):
if difficultyOverride != CogdoGameConsts.NoDifficultyOverride:
self.difficultyOverride = difficultyOverride / float(
CogdoGameConsts.DifficultyOverrideMult)
if exteriorZoneOverride != CogdoGameConsts.NoExteriorZoneOverride:
self.exteriorZoneOverride = exteriorZoneOverride
def getInterior(self):
return self.cr.getDo(self._interiorId)
def getEntranceElevator(self, callback):
return self.getInterior().getEntranceElevator(callback)
def getToonIds(self):
interior = self.getInterior()
if interior is not None:
return interior.getToonIds()
else:
return []
return
def getToon(self, toonId):
if self.cr.doId2do.has_key(toonId):
return self.cr.doId2do[toonId]
else:
return None
return None
def getNumPlayers(self):
return len(self.getToonIds())
def isSinglePlayer(self):
if self.getNumPlayers() == 1:
return 1
else:
return 0
def announceGenerate(self):
DistributedObject.announceGenerate(self)
self.loadFSM.request('Loaded')
self._requestInterior()
self.notify.info('difficulty: %s, safezoneId: %s' %
(self.getDifficulty(), self.getSafezoneId()))
def _requestInterior(self):
self.cr.relatedObjectMgr.requestObjects(
[self._interiorId], allCallback=self._handleGotInterior)
def _handleGotInterior(self, objs):
self._gotInterior.set(True)
self.getEntranceElevator(self.placeEntranceElev)
def stashEntranceElevator(self):
self._wantStashElevator.set(True)
def placeEntranceElev(self, elev):
pass
def _doStashElevator(self, toonsInEntranceElev, gotInterior,
wantStashElevator):
if gotInterior:
interior = self.getInterior()
if interior:
if not toonsInEntranceElev and wantStashElevator:
interior.stashElevatorIn()
else:
interior.stashElevatorIn(False)
def disable(self):
base.cogdoGame = None
self.cr.cogdoGame = None
self.fsm.requestFinalState()
self.loadFSM.requestFinalState()
self.fsm = None
self.loadFSM = None
DistributedObject.disable(self)
return
def delete(self):
self._stashElevatorFC.destroy()
self._wantStashElevator.destroy()
self._toonsInEntranceElev.destroy()
self._gotInterior.destroy()
self._waitingStartLabel.destroy()
self._waitingStartLabel = None
DistributedObject.delete(self)
return
def getDifficulty(self):
if self.difficultyOverride is not None:
return self.difficultyOverride
if hasattr(base, 'cogdoGameDifficulty'):
return float(base.cogdoGameDifficulty)
return CogdoGameConsts.getDifficulty(self.getSafezoneId())
def getSafezoneId(self):
if self.exteriorZoneOverride is not None:
return self.exteriorZoneOverride
if hasattr(base, 'cogdoGameSafezoneId'):
return CogdoGameConsts.getSafezoneId(base.cogdoGameSafezoneId)
return CogdoGameConsts.getSafezoneId(self.exteriorZone)
def enterNotLoaded(self):
pass
def exitNotLoaded(self):
pass
def enterLoaded(self):
pass
def exitLoaded(self):
pass
def enterOff(self):
pass
def exitOff(self):
pass
def setVisible(self):
self.fsm.request('Visible')
def setIntroStart(self):
self.fsm.request('Intro')
def enterVisible(self):
self._toonsInEntranceElev.set(True)
def exitVisible(self):
pass
def enterIntro(self, duration=MinigameGlobals.rulesDuration):
base.cr.playGame.getPlace().fsm.request('Game')
self._rulesDoneEvent = self.uniqueName('cogdoGameRulesDone')
self.accept(self._rulesDoneEvent, self._handleRulesDone)
self._rulesPanel = CogdoGameRulesPanel('CogdoGameRulesPanel',
self.getTitle(),
'',
self._rulesDoneEvent,
timeout=duration)
self._rulesPanel.load()
self._rulesPanel.enter()
def exitIntro(self):
self._toonsInEntranceElev.set(False)
self.ignore(self._rulesDoneEvent)
if self._rulesPanel:
self._rulesPanel.exit()
self._rulesPanel.unload()
self._rulesPanel = None
return
def _handleRulesDone(self):
self.ignore(self._rulesDoneEvent)
self._rulesPanel.exit()
self._rulesPanel.unload()
self._rulesPanel = None
self.fsm.request('WaitServerStart')
self.d_setAvatarReady()
return
def d_setAvatarReady(self):
self.sendUpdate('setAvatarReady', [])
def enterWaitServerStart(self):
numToons = 1
interior = self.getInterior()
if interior:
numToons = len(interior.getToonIds())
if numToons > 1:
msg = TTL.MinigameWaitingForOtherPlayers
else:
msg = TTL.MinigamePleaseWait
self._waitingStartLabel['text'] = msg
self._waitingStartLabel.show()
def exitWaitServerStart(self):
self._waitingStartLabel.hide()
def setGameStart(self, timestamp):
self._startTime = globalClockDelta.networkToLocalTime(timestamp)
self.fsm.request('Game')
def getStartTime(self):
return self._startTime
#def enterGame(self):
#if SCHELLGAMES_DEV:
#self.acceptOnce('escape', messenger.send, ['magicWord', ['~endMaze']])
def exitGame(self):
if SCHELLGAMES_DEV:
self.ignore('escape')
def setGameFinish(self, timestamp):
self._finishTime = globalClockDelta.networkToLocalTime(timestamp)
self.fsm.request('Finish')
def getFinishTime(self):
return self._finishTime
def enterFinish(self):
pass
def exitFinish(self):
pass
def setToonSad(self, toonId):
pass
def setToonDisconnect(self, toonId):
pass
class RepairBarnacle(DirectFrame, FSM.FSM):
barnacleFallSounds = None
def __init__(self, name, barnacleGeom):
self.config = RepairGlobals.Careening
DirectFrame.__init__(self, parent = None, relief = None)
self.barnacleGeom = barnacleGeom
FSM.FSM.__init__(self, 'Barnacle_%sFSM' % name)
self._initAudio()
self._initVars()
self._initGUI()
def _initVars(self):
self.heat = 0.0
self.hp = 100
self.maxHP = 100
self.currentShake = None
self.fallingAnim = None
def _initAudio(self):
if not self.barnacleFallSounds:
RepairBarnacle.barnacleFallSounds = (loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE1), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE2), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE3), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE4), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE5))
def _initGUI(self):
self.barnacleGeom.reparentTo(self)
self.barnacleGeom.setScale(0.59999999999999998)
self.barnacleGeom.setR(random.random() * 360)
if self.config.showBarnacleHP:
self.hpLabel = DirectLabel(text = '', scale = (0.025000000000000001, 0.025000000000000001, 0.025000000000000001), pos = (0.0, 0.0, -0.01), textMayChange = 1, parent = self)
def destroy(self):
if self.currentShake is not None:
self.currentShake.clearToInitial()
self.currentShake = None
del self.currentShake
if self.fallingAnim is not None:
self.fallingAnim.clearToInitial()
self.fallingAnim = None
del self.fallingAnim
self.cleanup()
if self.config.showBarnacleHP:
self.hpLabel.destroy()
del self.hpLabel
DirectFrame.destroy(self)
self.barnacleGeom.removeNode()
del self.barnacleGeom
def setMaxHP(self, newMaxHP, globalMaxHP):
self.maxHP = newMaxHP
self.globalMaxHP = globalMaxHP
def setHP(self, newHP):
self.hp = newHP
if self.config.showBarnacleHP:
self.hpLabel['text'] = '%i' % self.hp
self.hpLabel.setText()
if self.hp <= 0.0:
self.hp = 0.0
self.request('Falling')
self.setScale(self.hp * MAX_SCALE_ADD / self.globalMaxHP + MIN_SCALE)
def reduceHP(self, pushDir, powerScale):
amount = pushDir.length()
pushDir.normalize()
self.heat = min(1.0, self.heat + amount)
amount *= 50
if amount > MAX_SCRUB_AMT:
amount = MAX_SCRUB_AMT
amount *= powerScale
newHP = self.hp - amount
self.setHP(newHP)
if self.currentShake is None:
self.currentShake = Sequence(LerpPosInterval(self, duration = 0.029999999999999999, pos = (self.getX() - pushDir[0] * (0.01 + amount / 1000.0), self.getY(), self.getZ() - pushDir[1] * (0.01 + amount / 1000.0)), blendType = 'easeIn'), LerpPosInterval(self, duration = 0.059999999999999998, pos = (self.getX(), self.getY(), self.getZ()), blendType = 'easeOut'), LerpPosInterval(self, duration = 0.040000000000000001, pos = (self.getX() + pushDir[0] * (0.0074999999999999997 + amount / 2000.0), self.getY(), self.getZ() + pushDir[1] * (0.0050000000000000001 + amount / 2000.0)), blendType = 'easeIn'), LerpPosInterval(self, duration = 0.080000000000000002, pos = (self.getX(), self.getY(), self.getZ()), blendType = 'easeOut'), Func(self.clearCurrentShake))
self.currentShake.start()
def checkCollision(self, mousePosition):
sld = Point3(mousePosition.getX(), 0.0, mousePosition.getY()) - self.getPos(render2d)
if self.getCurrentOrNextState() == 'Idle':
pass
return sld.length() < self.config.barnacleRadius * self.getScale().getX()
def clearCurrentShake(self):
self.currentShake = None
def enterIdle(self):
visibleIndex = random.uniform(0, self.barnacleGeom.getNumChildren() - 1)
for i in range(self.barnacleGeom.getNumChildren() - 1):
self.barnacleGeom.getChild(i).unstash()
newHP = self.maxHP
self.heat = 0.0
self.setHP(newHP)
self.unstash()
def exitIdle(self):
pass
def enterFalling(self):
if self.currentShake is not None:
self.currentShake.finish()
sound = random.choice(self.barnacleFallSounds)
sound.play()
self.fallingAnim = Sequence(LerpPosInterval(self, duration = 2.0, pos = (self.getX(), self.getY(), self.getZ() - 2.0), blendType = 'easeIn'), Func(self.request, 'Clean'))
self.fallingAnim.start()
def exitFalling(self):
self.stash()
def enterClean(self):
pass
def exitClean(self):
pass
class InventoryGui(DirectObject):
directNotify = DirectNotify().newCategory('InventoryGui')
def __init__(self):
DirectObject.__init__(self)
self.backpack = None
self.threeSlotsPos = [(0, 0, 0.5), (0, 0, 0), (0, 0, -0.5)]
self.fourSlotPos = [(0, 0, 0.45),
(0, 0, 0.15),
(0, 0, -0.15),
(0, 0, -0.45)]
self.availableSlot = 0
self.slots = []
self.activeSlot = None
self.defaultSlots = 3
self.prevSlot = None
self.ammoLabel = None
self.inventoryFrame = None
self.switchSound = True
self.switchSoundSfx = base.loadSfx('phase_3/audio/sfx/GUI_balloon_popup.mp3')
return
def setWeapon(self, slot, playSound = True):
if isinstance(slot, str):
for iSlot in self.slots:
if iSlot.getGag():
if iSlot.getGag().getName() == slot:
slot = iSlot
if self.activeSlot:
self.activeSlot.setOutlineImage('idle')
self.prevSlot = self.activeSlot
if self.backpack.getSupply(slot.getGag().getName()) > 0:
if self.activeSlot != slot:
base.localAvatar.b_equip(GagGlobals.getIDByName(slot.getGag().getName()))
slot.setOutlineImage('selected')
self.activeSlot = slot
elif self.activeSlot == slot and slot.getGag().getState() == GagState.LOADED:
base.localAvatar.b_unEquip()
self.activeSlot = None
self.update()
if self.switchSound and playSound:
SoundInterval(self.switchSoundSfx).start()
else:
return
return
def createGui(self):
self.deleteGui()
phase = 'phase_3.5/maps/'
posGroup = self.threeSlotsPos
self.inventoryFrame = DirectFrame(parent=base.a2dRightCenter, pos=(-0.2, 0, 0))
if self.defaultSlots == 4:
posGroup = self.fourSlotPos
for slot in range(len(posGroup) + 1):
if slot == 3:
posGroup = self.fourSlotPos
slotIdle = loader.loadTexture(phase + 'slot_%s_idle.png' % str(slot + 1))
slotObj = Slot(slot + 1, posGroup[slot], self.inventoryFrame)
slotOutline = OnscreenImage(image=slotIdle, color=(1, 1, 1, 0.5), parent=slotObj)
slotOutline.setTransparency(TransparencyAttrib.MAlpha)
slotObj.setOutline(slotOutline)
self.slots.append(slotObj)
if slot == 3:
slotObj.hide()
self.ammoLabel = DirectLabel(text='Ammo: 0', text_fg=(1, 1, 1, 1), relief=None, text_shadow=(0, 0, 0, 1), text_scale=0.08, pos=(0.2, 0, 0.35), parent=base.a2dBottomLeft)
self.ammoLabel.hide()
self.enableWeaponSwitch()
self.resetScroll()
self.update()
return
def deleteGui(self):
self.disableWeaponSwitch()
for slot in self.slots:
self.slots.remove(slot)
slot.destroy()
if self.ammoLabel:
self.ammoLabel.destroy()
self.ammoLabel = None
if self.inventoryFrame:
self.inventoryFrame.destroy()
self.inventoryFrame = None
return
def resetScroll(self):
nextGag = 0
prevGag = -1
curGag = -1
if self.prevSlot:
prevGag = self.slots.index(self.prevSlot)
if self.activeSlot:
curGag = self.slots.index(self.activeSlot)
if curGag == len(self.slots) - 1:
nextGag = 0
prevGag = curGag - 1
elif curGag == 0:
nextGag = 1
prevGag = len(self.slots) - 1
elif curGag == -1:
prevGag = len(self.slots) - 1
else:
nextGag = curGag + 1
prevGag = curGag - 1
self.accept('wheel_down', self.setWeapon, extraArgs=[self.slots[prevGag]])
self.accept('wheel_up', self.setWeapon, extraArgs=[self.slots[nextGag]])
def update(self):
if not self.backpack:
return
else:
for element in [self.ammoLabel, self.inventoryFrame]:
if not element:
return
for slot in self.slots:
gag = slot.getGag()
if not gag:
continue
supply = self.backpack.getSupply(gag.getName())
index = self.slots.index(slot)
if not gag and len(self.backpack.getGags()) - 1 >= index:
gag = self.backpack.getGagByIndex(index)
slot.setGag(gag)
if self.backpack.getSupply(gag.getName()) > 0:
slot.setOutlineImage('idle')
else:
slot.setOutlineImage('no_ammo')
elif slot == self.activeSlot:
if supply > 0:
slot.setOutlineImage('selected')
self.ammoLabel['text_fg'] = (1, 1, 1, 1)
else:
slot.setOutlineImage('no_ammo')
self.ammoLabel['text_fg'] = (0.9, 0, 0, 1)
self.activeSlot = None
self.ammoLabel.show()
self.ammoLabel['text'] = 'Ammo: %s' % self.backpack.getSupply(slot.getGag().getName())
elif self.backpack.getSupply(slot.getGag().getName()) > 0:
slot.setOutlineImage('idle')
else:
slot.setOutlineImage('no_ammo')
if self.activeSlot == None:
self.ammoLabel.hide()
self.ammoLabel['text'] = 'Ammo: 0'
self.resetScroll()
return
def setBackpack(self, backpack):
self.backpack = backpack
def updateLoadout(self):
if self.backpack:
loadout = self.backpack.getLoadout()
if len(loadout) <= 3:
self.reseatSlots()
elif len(loadout) == 4:
self.reseatSlots(slots=4)
for i in range(len(self.slots)):
slot = self.slots[i]
if i < len(loadout):
slot.setGag(loadout[i])
else:
slot.setGag(None)
self.update()
return
def reseatSlots(self, slots = 3):
for slot in range(len(self.slots) - 1):
if slots == 4:
self.slots[slot].setPos(self.fourSlotPos[slot])
else:
self.slots[slot].setPos(self.threeSlotsPos[slot])
def enableWeaponSwitch(self):
for index in range(len(self.slots)):
self.accept(str(index + 1), self.setWeapon, extraArgs=[self.slots[index]])
def disableWeaponSwitch(self):
for key in ['1',
'2',
'3',
'4',
'wheel_down',
'wheel_up']:
self.ignore(key)
def getSlots(self):
return self.slots
class DistributedPieTurretManager(DistributedObject):
notify = directNotify.newCategory("DistributedPieTurretManager")
def __init__(self, cr):
DistributedObject.__init__(self, cr)
self.myTurret = None
self.guiFrame = None
self.guiLabel = None
self.guiBar = None
self.guiBg = None
self.turretGag = None
return
def announceGenerate(self):
DistributedObject.announceGenerate(self)
base.taskMgr.add(self.__pollMyBattle, "__pollMyBattle")
def disable(self):
base.taskMgr.remove("DPTM.pollTurret")
base.taskMgr.remove("__pollMyBattle")
if hasattr(self, "makeTurretBtn"):
self.makeTurretBtn.destroy()
del self.makeTurretBtn
self.destroyGui()
self.myTurret = None
if base.localAvatar.getMyBattle():
base.localAvatar.getMyBattle().setTurretManager(None)
DistributedObject.disable(self)
return
def __pollTurret(self, turretId, task):
turret = self.cr.doId2do.get(turretId)
if turret != None:
self.myTurret = turret
self.turretGag = None
self.makeGui()
return Task.done
else:
return Task.cont
def setGag(self, upgradeId):
self.turretGag = upgradeId
def d_requestPlace(self, posHpr):
self.sendUpdate("requestPlace", [posHpr])
def turretPlaced(self, turretId):
turret = self.cr.doId2do.get(turretId)
turret.b_setGag(self.turretGag)
self.turretGag = None
base.taskMgr.add(self.__pollTurret, "DPTM.pollTurret", extraArgs=[turretId], appendTask=True)
return
def yourTurretIsDead(self):
base.taskMgr.remove("DPTM.pollTurret")
self.destroyGui()
self.myTurret = None
if base.localAvatar.getPUInventory()[0] > 0:
self.createTurretButton()
return
def makeGui(self):
self.destroyGui()
self.guiFrame = DirectFrame(parent=base.a2dBottomRight, pos=(-0.55, 0, 0.15))
self.guiBg = OnscreenImage(image="phase_4/maps/turret_gui_bg.png", scale=(0.15, 0, 0.075), parent=self.guiFrame)
self.guiBg.setTransparency(True)
self.guiLabel = DirectLabel(
text="Turret",
text_fg=(1, 0, 0, 1),
relief=None,
text_scale=0.05,
text_font=loader.loadFont("phase_3/models/fonts/ImpressBT.ttf"),
pos=(0, 0, 0.025),
parent=self.guiFrame,
)
self.guiBar = DirectWaitBar(
range=self.myTurret.getMaxHealth(),
value=self.myTurret.getHealth(),
scale=0.125,
parent=self.guiFrame,
pos=(0, 0, -0.01),
)
return
def createTurretButton(self):
self.makeTurretBtn = DirectButton(
relief=None,
geom=CIGlobals.getDefaultBtnGeom(),
text="Turret",
text_scale=0.055,
command=self.handleMakeTurretBtn,
pos=(-0.47, 0, 0.1),
geom_scale=(0.5, 1.0, 1.0),
text_pos=(0, -0.01),
parent=base.a2dBottomRight,
)
return
def handleMakeTurretBtn(self):
self.makeTurretBtn.destroy()
del self.makeTurretBtn
x, y, z = base.localAvatar.getPos()
h, p, r = base.localAvatar.getHpr()
self.d_requestPlace([x, y, z, h, p, r])
base.localAvatar.sendUpdate("usedPU", [0])
def __pollMyBattle(self, task):
if base.localAvatar.getMyBattle():
base.localAvatar.getMyBattle().setTurretManager(self)
if base.localAvatar.getPUInventory()[0] > 0:
self.createTurretButton()
return Task.done
return Task.cont
def destroyGui(self):
if self.guiBar:
self.guiBar.destroy()
self.guiBar = None
if self.guiLabel:
self.guiLabel.destroy()
self.guiLabel = None
if self.guiBg:
self.guiBg.destroy()
self.guiBg = None
if self.guiFrame:
self.guiFrame.destroy()
self.guiFrame = None
return
def updateTurretGui(self):
if self.guiBar:
self.guiBar.update(self.myTurret.getHealth())
class DistributedDeliveryGame(DistributedMinigame):
notify = directNotify.newCategory("DistributedDeliveryGame")
def __init__(self, cr):
DistributedMinigame.__init__(self, cr)
self.fsm.addState(
State.State("announceGameOver", self.enterAnnounceGameOver, self.exitAnnounceGameOver, ["gameOver"])
)
self.fsm.getStateNamed("play").addTransition("announceGameOver")
self.world = None
self.gagShop = None
self.sky = None
self.skyUtil = SkyUtil()
base.localAvatar.hasBarrel = False
self.truckBarrelIsFrom = None
self.soundPickUpBarrel = None
self.soundDropOff = None
self.barrelsByAvId = {}
self.bsLabel = None
self.brLabel = None
self.bdLabel = None
self.gagShopCollNP = None
self.barrelsRemaining = 0
self.barrelsStolen = 0
self.barrelsDelivered = 0
return
def allBarrelsGone(self):
self.fsm.request("announceGameOver")
def enterAnnounceGameOver(self):
whistleSfx = base.loadSfx("phase_4/audio/sfx/AA_sound_whistle.mp3")
whistleSfx.play()
del whistleSfx
self.gameOverLbl = DirectLabel(
text="GAME\nOVER!", relief=None, scale=0.35, text_font=CIGlobals.getMickeyFont(), text_fg=(1, 0, 0, 1)
)
return
def exitAnnounceGameOver(self):
self.gameOverLbl.destroy()
del self.gameOverLbl
def setBarrelsRemaining(self, num):
self.barrelsRemaining = num
self.__updateLabels()
def getBarrelsRemaining(self):
return self.barrelsRemaining
def setBarrelsStolen(self, num):
self.barrelsStolen = num
self.__updateLabels()
def getBarrelsStolen(self):
return self.barrelsStolen
def setBarrelsDelivered(self, num):
self.barrelsDelivered = num
self.__updateLabels()
def getBarrelsDelivered(self):
return self.barrelsDelivered
def giveBarrelToSuit(self, suitId):
suit = self.cr.doId2do.get(suitId)
if suit:
barrel = loader.loadModel("phase_4/models/cogHQ/gagTank.bam")
barrel.reparentTo(suit.find("**/joint_Rhold"))
barrel.setP(180)
barrel.setScale(0.2)
barrel.find("**/gagTankColl").removeNode()
self.barrelsByAvId[suitId] = barrel
def giveBarrelToPlayer(self, avId, truckId):
if avId == self.localAvId:
if not base.localAvatar.hasBarrel:
base.localAvatar.hasBarrel = True
base.playSfx(self.soundPickUpBarrel)
self.truckBarrelIsFrom = truckId
else:
return
av = self.cr.doId2do.get(avId)
if av:
av.setForcedTorsoAnim("catchneutral")
barrel = loader.loadModel("phase_4/models/cogHQ/gagTank.bam")
barrel.reparentTo(av.find("**/def_joint_right_hold"))
barrel.setP(90)
barrel.setZ(0.25)
barrel.setScale(0.2)
barrel.find("**/gagTankColl").removeNode()
self.barrelsByAvId[avId] = barrel
def dropOffBarrel(self, avId):
if avId == self.localAvId:
if base.localAvatar.hasBarrel:
base.localAvatar.hasBarrel = False
base.playSfx(self.soundDropOff)
else:
return
av = self.cr.doId2do.get(avId)
if av:
av.clearForcedTorsoAnim()
barrel = self.barrelsByAvId.get(avId)
if barrel != None or not barrel.isEmpty():
barrel.removeNode()
del self.barrelsByAvId[avId]
return
def load(self):
spawn = random.choice(DGG.SpawnPoints)
base.localAvatar.setPos(spawn)
base.localAvatar.setHpr(0, 0, 0)
self.soundPickUpBarrel = base.loadSfx("phase_6/audio/sfx/SZ_MM_gliss.mp3")
self.soundDropOff = base.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_bell_for_trolley.mp3")
self.setMinigameMusic("phase_4/audio/bgm/MG_Delivery.mp3")
self.setDescription(
"A new supply of Gags were just shipped to Toontown! "
+ "Run over to a truck with Gag barrels to take a barrel out. Then, carry it over to the Gag Shop. "
+ "Try to unload and deliver as many barrels as you can to the Gag Shop. "
+ "Watch out for the Cogs - they might try to snatch a barrel!"
)
self.setWinnerPrize(100)
self.setLoserPrize(0)
self.gagShop = loader.loadModel("phase_4/models/modules/gagShop_TT.bam")
self.gagShop.reparentTo(base.render)
self.gagShop.setY(-70)
sphere = CollisionSphere(0, 0, 0, 3)
sphere.setTangible(0)
node = CollisionNode("MGDeliveryGagShop")
node.addSolid(sphere)
self.gagShopCollNP = self.gagShop.attachNewNode(node)
self.world = loader.loadModel("phase_4/models/minigames/delivery_area.egg")
self.world.setY(-5)
self.world.reparentTo(base.render)
self.sky = loader.loadModel("phase_3.5/models/props/TT_sky.bam")
self.sky.reparentTo(base.camera)
ce = CompassEffect.make(NodePath(), CompassEffect.PRot | CompassEffect.PZ)
self.sky.node().setEffect(ce)
self.sky.setZ(-20)
self.skyUtil.startSky(self.sky)
base.camera.setPos(20, 50, 30)
base.camera.lookAt(20, 0, 7.5)
DistributedMinigame.load(self)
def enterStart(self):
DistributedMinigame.enterStart(self)
beepSound = base.loadSfx("phase_4/audio/sfx/MG_delivery_truck_beep.mp3")
base.playSfx(beepSound)
def enterPlay(self):
DistributedMinigame.enterPlay(self)
base.localAvatar.attachCamera()
base.localAvatar.startSmartCamera()
base.localAvatar.enableAvatarControls()
self.brLabel = OnscreenText(
text="",
parent=base.a2dTopRight,
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1),
pos=(-0.1, -0.1, 0),
align=TextNode.ARight,
)
self.bdLabel = OnscreenText(
text="",
parent=base.a2dTopLeft,
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1),
pos=(0.1, -0.1, 0),
align=TextNode.ALeft,
)
self.bsLabel = OnscreenText(
text="",
parent=base.a2dTopLeft,
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1),
pos=(0.1, -0.2, 0),
align=TextNode.ALeft,
)
self.accept("enterMGDeliveryGagShop", self.__maybeDropOffBarrel)
def __maybeDropOffBarrel(self, entry):
if base.localAvatar.hasBarrel and self.truckBarrelIsFrom != None:
self.sendUpdate("requestDropOffBarrel", [self.truckBarrelIsFrom])
self.truckBarrelIsFrom = None
return
def __updateLabels(self):
if self.brLabel:
self.brLabel.setText("Barrels Remaining: {0}".format(self.getBarrelsRemaining()))
if self.bdLabel:
self.bdLabel.setText("Barrels Delivered: {0}".format(self.getBarrelsDelivered()))
if self.bsLabel:
self.bsLabel.setText("Barrels Stolen: {0}".format(self.getBarrelsStolen()))
def exitPlay(self):
self.ignore("enterMGDeliveryGagShop")
base.localAvatar.disableAvatarControls()
base.localAvatar.stopSmartCamera()
base.localAvatar.detachCamera()
self.brLabel.destroy()
self.brLabel = None
self.bsLabel.destroy()
self.bsLabel = None
self.bdLabel.destroy()
self.bdLabel = None
DistributedMinigame.exitPlay(self)
return
def announceGenerate(self):
DistributedMinigame.announceGenerate(self)
self.load()
def disable(self):
if self.world:
self.world.removeNode()
self.world = None
if self.gagShop:
self.gagShop.removeNode()
self.gagShop = None
if self.sky:
self.sky.removeNode()
self.sky = None
if self.gagShopCollNP:
self.gagShopCollNP.removeNode()
self.gagShopCollNP = None
self.skyUtil = None
self.soundPickUpBarrel = None
self.soundDropOff = None
self.truckBarrelIsFrom = None
del base.localAvatar.hasBarrel
self.barrelsByAvId = None
DistributedMinigame.disable(self)
return
class CalendarGuiDay(DirectFrame):
notify = directNotify.newCategory('CalendarGuiDay')
ScrollListTextSize = 0.03
LargeTextSize = 0.0232
def __init__(self, parent, myDate, startDate, dayClickCallback = None, onlyFutureDaysClickable = False):
self.origParent = parent
self.startDate = startDate
self.myDate = myDate
self.dayClickCallback = dayClickCallback
self.onlyFutureDaysClickable = onlyFutureDaysClickable
DirectFrame.__init__(self, parent=parent)
self.timedEvents = []
self.partiesInvitedToToday = []
self.hostedPartiesToday = []
self.yearlyHolidaysToday = []
self.showMarkers = config.GetBool('show-calendar-markers', 0)
self.filter = ToontownGlobals.CalendarFilterShowAll
self.load()
self.createGuiObjects()
self.update()
def createDummyLocators(self):
self.dayButtonLocator = self.attachNewNode('dayButtonLocator')
self.dayButtonLocator.setX(0.1)
self.dayButtonLocator.setZ(-0.05)
self.numberLocator = self.attachNewNode('numberLocator')
self.numberLocator.setX(0.09)
self.scrollLocator = self.attachNewNode('scrollLocator')
self.selectedLocator = self.attachNewNode('selectedLocator')
self.selectedLocator.setX(0.11)
self.selectedLocator.setZ(-0.06)
def load(self):
dayAsset = loader.loadModel('phase_4/models/parties/tt_m_gui_sbk_calendar_box')
dayAsset.reparentTo(self)
self.dayButtonLocator = self.find('**/loc_origin')
self.numberLocator = self.find('**/loc_number')
self.scrollLocator = self.find('**/loc_topLeftList')
self.selectedLocator = self.find('**/loc_origin')
self.todayBox = self.find('**/boxToday')
self.todayBox.hide()
self.selectedFrame = self.find('**/boxHover')
self.selectedFrame.hide()
self.defaultBox = self.find('**/boxBlank')
self.scrollBottomRightLocator = self.find('**/loc_bottomRightList')
self.scrollDownLocator = self.find('**/loc_scrollDown')
self.attachMarker(self.scrollDownLocator)
self.scrollUpLocator = self.find('**/loc_scrollUp')
self.attachMarker(self.scrollUpLocator)
def attachMarker(self, parent, scale = 0.005, color = (1, 0, 0)):
if self.showMarkers:
marker = loader.loadModel('phase_3/models/misc/sphere')
marker.reparentTo(parent)
marker.setScale(scale)
marker.setColor(*color)
def createGuiObjects(self):
self.dayButton = DirectButton(parent=self.dayButtonLocator, image=self.selectedFrame, relief=None, command=self.__clickedOnDay, pressEffect=1, rolloverSound=None, clickSound=None)
self.numberWidget = DirectLabel(parent=self.numberLocator, relief=None, text=str(self.myDate.day), text_scale=0.04, text_align=TextNode.ACenter, text_font=ToontownGlobals.getInterfaceFont(), text_fg=Vec4(110 / 255.0, 126 / 255.0, 255 / 255.0, 1))
self.attachMarker(self.numberLocator)
self.listXorigin = 0
self.listFrameSizeX = self.scrollBottomRightLocator.getX() - self.scrollLocator.getX()
self.scrollHeight = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ()
self.listZorigin = self.scrollBottomRightLocator.getZ()
self.listFrameSizeZ = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ()
self.arrowButtonXScale = 1
self.arrowButtonZScale = 1
self.itemFrameXorigin = 0
self.itemFrameZorigin = 0
self.buttonXstart = self.itemFrameXorigin + 0.21
self.gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui')
buttonOffSet = -0.01
incButtonPos = (0.0, 0, 0)
decButtonPos = (0.0, 0, 0)
itemFrameMinZ = self.listZorigin
itemFrameMaxZ = self.listZorigin + self.listFrameSizeZ
arrowUp = self.find('**/downScroll_up')
arrowDown = self.find('**/downScroll_down')
arrowHover = self.find('**/downScroll_hover')
self.scrollList = DirectScrolledList(parent=self.scrollLocator, relief=None, pos=(0, 0, 0), incButton_image=(arrowUp,
arrowDown,
arrowHover,
arrowUp), incButton_relief=None, incButton_scale=(self.arrowButtonXScale, 1, self.arrowButtonZScale), incButton_pos=incButtonPos, incButton_image3_color=Vec4(1, 1, 1, 0.2), decButton_image=(arrowUp,
arrowDown,
arrowHover,
arrowUp), decButton_relief=None, decButton_scale=(self.arrowButtonXScale, 1, -self.arrowButtonZScale), decButton_pos=decButtonPos, decButton_image3_color=Vec4(1, 1, 1, 0.2), itemFrame_pos=(self.itemFrameXorigin, 0, -0.03), numItemsVisible=4, incButtonCallback=self.scrollButtonPressed, decButtonCallback=self.scrollButtonPressed)
itemFrameParent = self.scrollList.itemFrame.getParent()
self.scrollList.incButton.reparentTo(self.scrollDownLocator)
self.scrollList.decButton.reparentTo(self.scrollUpLocator)
arrowUp.removeNode()
arrowDown.removeNode()
arrowHover.removeNode()
clipper = PlaneNode('clipper')
clipper.setPlane(Plane(Vec3(-1, 0, 0), Point3(0.23, 0, 0)))
clipNP = self.scrollList.component('itemFrame').attachNewNode(clipper)
self.scrollList.component('itemFrame').setClipPlane(clipNP)
def scrollButtonPressed(self):
self.__clickedOnDay()
def adjustForMonth(self):
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.onlyFutureDaysClickable:
if self.myDate.year < curServerDate.year or self.myDate.year == curServerDate.year and self.myDate.month < curServerDate.month or self.myDate.year == curServerDate.year and self.myDate.month == curServerDate.month and self.myDate.day < curServerDate.day:
self.numberWidget.setColorScale(0.5, 0.5, 0.5, 0.5)
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.numberWidget.setColorScale(1, 1, 1, 1)
if self.myDate.month != self.startDate.month:
self.setColorScale(0.75, 0.75, 0.75, 1.0)
if self.dayClickCallback is not None:
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.setColorScale(1, 1, 1, 1)
if self.myDate.date() == curServerDate.date():
self.defaultBox.hide()
self.todayBox.show()
else:
self.defaultBox.show()
self.todayBox.hide()
def destroy(self):
if self.dayClickCallback is not None:
self.numberWidget.destroy()
self.dayClickCallback = None
self.notify.debug('desroying %s' % self.myDate)
try:
for item in self.scrollList['items']:
if hasattr(item, 'description') and item.description and hasattr(item.description, 'destroy'):
self.notify.debug('desroying description of item %s' % item)
item.unbind(DGG.ENTER)
item.unbind(DGG.EXIT)
item.description.destroy()
except e:
self.notify.debug('pass %s' % self.myDate)
self.scrollList.removeAndDestroyAllItems()
self.scrollList.destroy()
self.dayButton.destroy()
DirectFrame.destroy(self)
def addWeeklyHolidays(self):
if not self.filter == ToontownGlobals.CalendarFilterShowAll and not self.filter == ToontownGlobals.CalendarFilterShowOnlyHolidays:
return
if base.cr.newsManager:
holidays = base.cr.newsManager.getHolidaysForWeekday(self.myDate.weekday())
holidayName = ''
holidayDesc = ''
for holidayId in holidays:
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
self.scrollList.refresh()
if config.GetBool('calendar-test-items', 0):
if self.myDate.date() + datetime.timedelta(days=-1) == base.cr.toontownTimeManager.getCurServerDateTime().date():
testItems = ('1:00 AM Party', '2:00 AM CEO', '11:15 AM Party', '5:30 PM CJ', '11:00 PM Party', 'Really Really Long String')
for text in testItems:
newItem = DirectLabel(relief=None, text=text, text_scale=self.ScrollListTextSize, text_align=TextNode.ALeft)
self.scrollList.addItem(newItem)
if self.myDate.date() + datetime.timedelta(days=-2) == base.cr.toontownTimeManager.getCurServerDateTime().date():
testItems = ('1:00 AM Party', '3:00 AM CFO', '11:00 AM Party')
textSize = self.ScrollListTextSize
for text in testItems:
newItem = DirectLabel(relief=None, text=text, text_scale=textSize, text_align=TextNode.ALeft)
self.scrollList.addItem(newItem)
def updateArrowButtons(self):
numItems = 0
try:
numItems = len(self.scrollList['items'])
except e:
numItems = 0
if numItems <= self.scrollList.numItemsVisible:
self.scrollList.incButton.hide()
self.scrollList.decButton.hide()
else:
self.scrollList.incButton.show()
self.scrollList.decButton.show()
def collectTimedEvents(self):
self.timedEvents = []
if self.filter == ToontownGlobals.CalendarFilterShowAll or self.filter == ToontownGlobals.CalendarFilterShowOnlyParties:
for party in localAvatar.partiesInvitedTo:
if party.startTime.date() == self.myDate.date():
self.partiesInvitedToToday.append(party)
self.timedEvents.append((party.startTime.time(), party))
for party in localAvatar.hostedParties:
if party.startTime.date() == self.myDate.date():
self.hostedPartiesToday.append(party)
self.timedEvents.append((party.startTime.time(), party))
if base.cr.newsManager and (self.filter == ToontownGlobals.CalendarFilterShowAll or self.filter == ToontownGlobals.CalendarFilterShowOnlyHolidays):
# December 14th - Winter
if self.myDate.month == 12 and self.myDate.day == 14:
holidayName = 'Winter Holiday'
holidayDesc = 'Celebrate the Winter Holiday with Toontastic decorations,Cattlelog items and more!'
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
if self.myDate.weekday() == 4 or self.myDate.weekday() == 5:
holidayName = 'Fish Bingo!'
holidayDesc = 'Celebrate the weekend with bingo!'
# Janurary 4th - end of Winter
if self.myDate.month == 1 and self.myDate.day == 4:
holidayName = 'Winter Holiday End'
holidayDesc = 'The end of the Winter Holiday!'
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# December 30th - New year's fireworks
if self.myDate.month == 12 and self.myDate.day == 30:
holidayName = "New Year's Fireworks"
holidayDesc = "Let us light the skys with Toontastic fireworks!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# December 31st - New year's fireworks
if self.myDate.month == 12 and self.myDate.day == 31:
holidayName = "New Year's Fireworks"
holidayDesc = "Let us light the skys with Toontastic fireworks!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# October 21st - Halloween
if self.myDate.month == 10 and self.myDate.day == 21:
holidayName = "Halloween Holiday"
holidayDesc = "Celebrate Halloween as spooky trees and streetlights transform Toontown!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# November 1st - end of halloween
if self.myDate.month == 11 and self.myDate.day == 1:
holidayName = " End of Halloween Holiday"
holidayDesc = "The end of the Halloween Holiday!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# March 14th - Ides of March
if self.myDate.month == 3 and self.myDate.day == 14:
holidayName = "Ides of March Invasion"
holidayDesc = "Beware the Ides of March! Stop the Backstabber Cogs from invading Toontown!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# March 15th - Ides of March
if self.myDate.month == 3 and self.myDate.day == 15:
holidayName = "Ides of March Invasion"
holidayDesc = "Beware the Ides of March! Stop the Backstabber Cogs from invading Toontown!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# July 29th - XP week
if self.myDate.month == 7 and self.myDate.day == 29:
holidayName = "Triple XP Week"
holidayDesc = "Celebrate Toontown with extra XP on ALL wacky gags!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# August 5th - end of XP week
if self.myDate.month == 8 and self.myDate.day == 5:
holidayName = "End of Triple XP Week"
holidayDesc = "The end of the triple XP on gags"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
if self.myDate.month == 6 and self.myDate.day == 29:
holidayName = "Summer Fireworks"
holidayDesc = "Celebrate Summer with a fireworks show every hour in each playground!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# March 29th - April Toons' Week
if self.myDate.month == 3 and self.myDate.day == 29:
holidayName = "April Toons' Week"
holidayDesc = "Celebrate April Toons' Week - a holiday built by Toons for Toons!!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# April 11th - April Toons end
if self.myDate.month == 4 and self.myDate.day == 11:
holidayName = "April Toons End"
holidayDesc = "Here lies then end of all the April Toons' Sillyness!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
if self.myDate.month == 7 and self.myDate.day == 15:
holidayName = "End of Summer Fireworks"
holidayDesc = "Here lies the end of the Toontastic Summer Fireworks!"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
# 15th of April
if self.myDate.month == 4 and self.myDate.day == 15:
holidayName = "Tax Day Invasion"
holidayDesc = "Number Crunchers are invading us. Apperntly we owe taxes! What are taxes?"
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 15 and not self.myDate.month == 4:
# holidayName = "V2.0 Mover & Shakers"
# holidayDesc = "V2.0 Mover & Shakers Cogs are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 31 and self.myDate.month == 1:
# holidayName = "Skelecog Legal Eagle"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 31 and self.myDate.month == 3:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 31 and self.myDate.month == 5:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 31 and self.myDate.month == 7:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 31 and self.myDate.month == 8:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 31 and self.myDate.month == 10 :
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 31 and self.myDate.month == 12:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 30 and self.myDate.month == 4:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 30 and self.myDate.month == 6:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 30 and self.myDate.month == 9:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 30 and self.myDate.month == 11:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
#
# if self.myDate.day == 29 and self.myDate.month == 2:
# holidayName = "Skelecog Legal Eagles"
# holidayDesc = "Skelecog Legal Eagles are invading Toontown in masses! Stop them!"
# self.addTitleAndDescToScrollList(holidayName, holidayDesc)
oncelyHolidays = base.cr.newsManager.getOncelyHolidaysForDate(self.myDate)
for holiday in oncelyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.year and holidayStart[1] == self.myDate.month and holidayStart[2] == self.myDate.day:
myTime = datetime.time(holidayStart[3], holidayStart[4])
elif holidayEnd[0] == self.myDate.year and holidayEnd[1] == self.myDate.month and holidayEnd[2] == self.myDate.day:
myTime = datetime.time(holidayEnd[3], holidayEnd[4])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
multipleStartHolidays = base.cr.newsManager.getMultipleStartHolidaysForDate(self.myDate)
for holiday in multipleStartHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.year and holidayStart[1] == self.myDate.month and holidayStart[2] == self.myDate.day:
myTime = datetime.time(holidayStart[3], holidayStart[4])
elif holidayEnd[0] == self.myDate.year and holidayEnd[1] == self.myDate.month and holidayEnd[2] == self.myDate.day:
myTime = datetime.time(holidayEnd[3], holidayEnd[4])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
relativelyHolidays = base.cr.newsManager.getRelativelyHolidaysForDate(self.myDate)
for holiday in relativelyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.month and holidayStart[1] == self.myDate.day:
myTime = datetime.time(holidayStart[2], holidayStart[3])
elif holidayEnd[0] == self.myDate.month and holidayEnd[1] == self.myDate.day:
myTime = datetime.time(holidayEnd[2], holidayEnd[3])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
def timedEventCompare(te1, te2):
if te1[0] < te2[0]:
return -1
elif te1[0] == te2[0]:
return 0
else:
return 1
self.timedEvents.sort(cmp=timedEventCompare)
for timedEvent in self.timedEvents:
if isinstance(timedEvent[1], PartyInfo):
self.addPartyToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][0] == NewsManager.YearlyHolidayType:
self.addYearlyHolidayToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][0] == NewsManager.OncelyHolidayType:
self.addOncelyHolidayToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][0] == NewsManager.OncelyMultipleStartHolidayType:
self.addOncelyMultipleStartHolidayToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][0] == NewsManager.RelativelyHolidayType:
self.addRelativelyHolidayToScrollList(timedEvent[1])
def addYearlyHolidayToScrollList(self, holiday):
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ''
startTime = datetime.time(holidayStart[2], holidayStart[3])
endTime = datetime.time(holidayEnd[2], holidayEnd[3])
startDate = datetime.date(self.myDate.year, holidayStart[0], holidayStart[1])
endDate = datetime.date(self.myDate.year, holidayEnd[0], holidayEnd[1])
if endDate < startDate:
endDate = datetime.date(endDate.year + 1, endDate.month, endDate.day)
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = TTLocalizer.UnknownHoliday % holidayId
if holidayStart[0] == holidayEnd[0] and holidayStart[1] == holidayEnd[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + myStrftime(endTime)
elif self.myDate.month == holidayStart[0] and self.myDate.day == holidayStart[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + endDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.month == holidayEnd[0] and self.myDate.day == holidayEnd[1]:
holidayText = myStrftime(endTime)
holidayText += ' ' + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += '. ' + TTLocalizer.CalendarStartedOn + startDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addOncelyHolidayToScrollList(self, holiday):
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ''
startTime = datetime.time(holidayStart[3], holidayStart[4])
endTime = datetime.time(holidayEnd[3], holidayEnd[4])
startDate = datetime.date(holidayStart[0], holidayStart[1], holidayStart[2])
endDate = datetime.date(holidayStart[0], holidayEnd[1], holidayEnd[2])
if endDate < startDate:
endDate = datetime.date(endDate.year + 1, endDate.month, endDate.day)
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = ''
if holidayStart[1] == holidayEnd[1] and holidayStart[2] == holidayEnd[2]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + myStrftime(endTime)
elif self.myDate.year == holidayStart[0] and self.myDate.month == holidayStart[1] and self.myDate.day == holidayStart[2]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + endDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.year == holidayEnd[0] and self.myDate.month == holidayEnd[1] and self.myDate.day == holidayEnd[2]:
holidayText = myStrftime(endTime)
holidayText += ' ' + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += '. ' + TTLocalizer.CalendarStartedOn + startDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addOncelyMultipleStartHolidayToScrollList(self, holiday):
self.addOncelyHolidayToScrollList(holiday)
def addRelativelyHolidayToScrollList(self, holiday):
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ''
startTime = datetime.time(holidayStart[2], holidayStart[3])
endTime = datetime.time(holidayEnd[2], holidayEnd[3])
startDate = datetime.date(self.myDate.year, holidayStart[0], holidayStart[1])
endDate = datetime.date(self.myDate.year, holidayEnd[0], holidayEnd[1])
if endDate < startDate:
endDate.year += 1
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = ''
if holidayStart[0] == holidayEnd[0] and holidayStart[1] == holidayEnd[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + myStrftime(endTime)
elif self.myDate.month == holidayStart[0] and self.myDate.day == holidayStart[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + endDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.month == holidayEnd[0] and self.myDate.day == holidayEnd[1]:
holidayText = myStrftime(endTime)
holidayText += ' ' + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += '. ' + TTLocalizer.CalendarStartedOn + startDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addTitleAndDescToScrollList(self, title, desc):
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(relief=None, text=title, text_scale=textSize, text_align=TextNode.ALeft, rolloverSound=None, clickSound=None, pressEffect=0, command=self.__clickedOnScrollItem)
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = scrollItemHeight * descTextSize / textSize
descUnderItemZAdjust = max(0.0534, descUnderItemZAdjust)
descUnderItemZAdjust = -descUnderItemZAdjust
descZAdjust = descUnderItemZAdjust
newItem.description = DirectLabel(parent=newItem, pos=(0.115, 0, descZAdjust), text='', text_wordwrap=15, pad=(0.02, 0.02), text_scale=descTextSize, text_align=TextNode.ACenter, textMayChange=0)
newItem.description.checkedHeight = False
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(DGG.ENTER, self.enteredTextItem, extraArgs=[newItem, desc, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
self.scrollList.addItem(newItem)
def exitedTextItem(self, newItem, mousepos):
newItem.description.hide()
def enteredTextItem(self, newItem, descText, descUnderItemZAdjust, mousePos):
if not newItem.description.checkedHeight:
newItem.description.checkedHeight = True
newItem.description['text'] = descText
bounds = newItem.description.getBounds()
descHeight = newItem.description.getHeight()
scrollItemHeight = newItem.getHeight()
descOverItemZAdjust = descHeight - scrollItemHeight / 2.0
descZPos = self.getPos(aspect2d)[2] + descUnderItemZAdjust - descHeight
if descZPos < -1.0:
newItem.description.setZ(descOverItemZAdjust)
descWidth = newItem.description.getWidth()
brightFrame = loader.loadModel('phase_4/models/parties/tt_m_gui_sbk_calendar_popUp_bg')
newItem.description['geom'] = brightFrame
newItem.description['geom_scale'] = (descWidth, 1, descHeight)
descGeomZ = (bounds[2] - bounds[3]) / 2.0
descGeomZ += bounds[3]
newItem.description['geom_pos'] = (0, 0, descGeomZ)
newItem.description.show()
def addPartyToScrollList(self, party):
textSize = self.ScrollListTextSize
descTextSize = 0.05
partyTitle = myStrftime(party.startTime)
partyTitle = partyTitle + ' ' + TTLocalizer.EventsPageCalendarTabParty
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(relief=None, text=partyTitle, text_scale=textSize, text_align=TextNode.ALeft, rolloverSound=None, clickSound=None, pressEffect=0, command=self.__clickedOnScrollItem)
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = scrollItemHeight * descTextSize / textSize
descUnderItemZAdjust = max(0.0534, descUnderItemZAdjust)
descUnderItemZAdjust = -descUnderItemZAdjust
descZAdjust = descUnderItemZAdjust
self.scrollList.addItem(newItem)
newItem.description = MiniInviteVisual(newItem, party)
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(DGG.ENTER, self.enteredTextItem, extraArgs=[newItem, newItem.description, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
def __clickedOnScrollItem(self):
self.__clickedOnDay()
def __clickedOnDay(self):
acceptClick = True
if self.onlyFutureDaysClickable:
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.myDate.date() < curServerDate.date():
acceptClick = False
if not acceptClick:
return
if self.dayClickCallback:
self.dayClickCallback(self)
self.notify.debug('we got clicked on %s' % self.myDate.date())
messenger.send('clickedOnDay', [self.myDate.date()])
def updateSelected(self, selected):
multiplier = 1.1
if selected:
self.selectedFrame.show()
self.setScale(multiplier)
self.setPos(-0.01, 0, 0.01)
grandParent = self.origParent.getParent()
self.origParent.reparentTo(grandParent)
else:
self.selectedFrame.hide()
self.setScale(1.0)
self.setPos(0, 0, 0)
def changeDate(self, startDate, myDate):
self.startDate = startDate
self.myDate = myDate
self.scrollList.removeAndDestroyAllItems()
self.update()
def update(self):
self.numberWidget['text'] = str(self.myDate.day)
self.adjustForMonth()
self.addWeeklyHolidays()
self.collectTimedEvents()
self.updateArrowButtons()
def changeFilter(self, filter):
oldFilter = self.filter
self.filter = filter
if self.filter != oldFilter:
self.scrollList.removeAndDestroyAllItems()
self.update()
class JellybeanRewardGui(DirectFrame):
notify = directNotify.newCategory('JellybeanRewardGui')
PreCountdownDelay = 1.0
CountDownRate = 0.20000000000000001
JarLabelTextColor = (0.94999999999999996, 0.94999999999999996, 0.0, 1.0)
JarLabelMaxedTextColor = (1.0, 0.0, 0.0, 1.0)
def __init__(self, doneEvent):
self.doneEvent = doneEvent
DirectFrame.__init__(self)
self.reparentTo(aspect2d)
self.setPos(0.0, 0.0, 0.16)
self.stash()
publicPartyGui = loader.loadModel(
'phase_4/models/parties/publicPartyGUI')
self.frame = DirectFrame(
parent=self,
geom=publicPartyGui.find('**/activities_background'),
geom_pos=(-0.80000000000000004, 0.0, 0.20000000000000001),
geom_scale=2.0,
relief=None)
self.earnedLabel = DirectLabel(
parent=self,
relief=None,
text=str(0),
text_align=TextNode.ACenter,
text_pos=(0.0, -0.070000000000000007),
text_scale=0.20000000000000001,
text_fg=(0.94999999999999996, 0.94999999999999996, 0.0, 1.0),
text_font=ToontownGlobals.getSignFont(),
textMayChange=True,
image=DirectGuiGlobals.getDefaultDialogGeom(),
image_scale=(0.33000000000000002, 1.0, 0.33000000000000002),
pos=(-0.29999999999999999, 0.0, 0.20000000000000001),
scale=0.90000000000000002)
purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui')
jarImage = purchaseModels.find('**/Jar')
self.jarLabel = DirectLabel(
parent=self,
relief=None,
text=str(0),
text_align=TextNode.ACenter,
text_pos=(0.0, -0.070000000000000007),
text_scale=0.20000000000000001,
text_fg=JellybeanRewardGui.JarLabelTextColor,
text_font=ToontownGlobals.getSignFont(),
textMayChange=True,
image=jarImage,
scale=0.69999999999999996,
pos=(0.29999999999999999, 0.0, 0.17000000000000001))
purchaseModels.removeNode()
del purchaseModels
jarImage.removeNode()
del jarImage
self.messageLabel = DirectLabel(parent=self,
relief=None,
text='',
text_align=TextNode.ALeft,
text_wordwrap=16.0,
text_scale=0.070000000000000007,
pos=(-0.52000000000000002, 0.0,
-0.10000000000000001),
textMayChange=True)
self.doubledJellybeanLabel = DirectLabel(
parent=self,
relief=None,
text=TTLocalizer.PartyRewardDoubledJellybean,
text_align=TextNode.ACenter,
text_wordwrap=12.0,
text_scale=0.089999999999999997,
text_fg=(1.0, 0.125, 0.125, 1.0),
pos=(0.0, 0.0, -0.46500000000000002),
textMayChange=False)
self.doubledJellybeanLabel.hide()
self.closeButton = DirectButton(
parent=self,
relief=None,
text=TTLocalizer.PartyJellybeanRewardOK,
text_align=TextNode.ACenter,
text_scale=0.065000000000000002,
text_pos=(0.0, -0.625),
geom=(publicPartyGui.find('**/startButton_up'),
publicPartyGui.find('**/startButton_down'),
publicPartyGui.find('**/startButton_rollover'),
publicPartyGui.find('**/startButton_inactive')),
geom_pos=(-0.39000000000000001, 0.0, 0.125),
command=self._close)
publicPartyGui.removeNode()
del publicPartyGui
self.countSound = base.loadSfx(
'phase_13/audio/sfx/tick_counter_short.mp3')
self.overMaxSound = base.loadSfx(
'phase_13/audio/sfx/tick_counter_overflow.mp3')
def showReward(self, earnedAmount, jarAmount, message):
JellybeanRewardGui.notify.debug(
'showReward( earnedAmount=%d, jarAmount=%d, ...)' %
(earnedAmount, jarAmount))
self.earnedCount = earnedAmount
self.earnedLabel['text'] = str(self.earnedCount)
self.jarCount = jarAmount
self.jarMax = base.localAvatar.getMaxMoney()
self.jarLabel['text'] = str(self.jarCount)
self.jarLabel['text_fg'] = JellybeanRewardGui.JarLabelTextColor
self.messageLabel['text'] = message
if base.cr.newsManager.isHolidayRunning(
ToontownGlobals.JELLYBEAN_DAY
) and base.cr.newsManager.isHolidayRunning(
ToontownGlobals.JELLYBEAN_PARTIES_HOLIDAY
) or base.cr.newsManager.isHolidayRunning(
ToontownGlobals.JELLYBEAN_PARTIES_HOLIDAY_MONTH):
self.doubledJellybeanLabel.show()
else:
self.doubledJellybeanLabel.hide()
self.unstash()
taskMgr.doMethodLater(JellybeanRewardGui.PreCountdownDelay,
self.transferOneJellybean,
'JellybeanRewardGuiTransferOneJellybean',
extraArgs=[])
def transferOneJellybean(self):
if self.earnedCount == 0:
return None
self.earnedCount -= 1
self.earnedLabel['text'] = str(self.earnedCount)
self.jarCount += 1
if self.jarCount <= self.jarMax:
self.jarLabel['text'] = str(self.jarCount)
elif self.jarCount > self.jarMax:
self.jarLabel[
'text_fg'] = JellybeanRewardGui.JarLabelMaxedTextColor
if self.jarCount <= self.jarMax:
base.playSfx(self.countSound)
else:
base.playSfx(self.overMaxSound)
taskMgr.doMethodLater(JellybeanRewardGui.CountDownRate,
self.transferOneJellybean,
'JellybeanRewardGuiTransferOneJellybean',
extraArgs=[])
def _close(self):
taskMgr.remove('JellybeanRewardGuiTransferOneJellybean')
self.stash()
messenger.send(self.doneEvent)
def destroy(self):
taskMgr.remove('JellybeanRewardGuiTransferOneJellybean')
del self.countSound
del self.overMaxSound
self.frame.destroy()
self.earnedLabel.destroy()
self.jarLabel.destroy()
self.messageLabel.destroy()
self.closeButton.destroy()
DirectFrame.destroy(self)
class DistributedBanquetTable(DistributedObject.DistributedObject, FSM.FSM, BanquetTableBase.BanquetTableBase):
notify = DirectNotifyGlobal.directNotify.newCategory("DistributedBanquetTable")
rotationsPerSeatIndex = [90, 90, 0, 0, -90, -90, 180, 180]
pitcherMinH = -360
pitcherMaxH = 360
rotateSpeed = 30
waterPowerSpeed = base.config.GetDouble("water-power-speed", 15)
waterPowerExponent = base.config.GetDouble("water-power-exponent", 0.75)
useNewAnimations = True
TugOfWarControls = False
OnlyUpArrow = True
if OnlyUpArrow:
BASELINE_KEY_RATE = 3
else:
BASELINE_KEY_RATE = 6
UPDATE_KEY_PRESS_RATE_TASK = "BanquetTableUpdateKeyPressRateTask"
YELLOW_POWER_THRESHOLD = 0.75
RED_POWER_THRESHOLD = 0.96999999999999997
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
FSM.FSM.__init__(self, "DistributedBanquetTable")
self.boss = None
self.index = -1
self.diners = {}
self.dinerStatus = {}
self.serviceLocs = {}
self.chairLocators = {}
self.sitLocators = {}
self.activeIntervals = {}
self.dinerStatusIndicators = {}
self.preparedForPhaseFour = False
self.avId = 0
self.toon = None
self.pitcherSmoother = SmoothMover()
self.pitcherSmoother.setSmoothMode(SmoothMover.SMOn)
self.smoothStarted = 0
self._DistributedBanquetTable__broadcastPeriod = 0.20000000000000001
self.changeSeq = 0
self.lastChangeSeq = 0
self.pitcherAdviceLabel = None
self.fireLength = 250
self.fireTrack = None
self.hitObject = None
self.setupPowerBar()
self.aimStart = None
self.toonPitcherPosition = Point3(0, -2, 0)
self.allowLocalRequestControl = True
self.fadeTrack = None
self.grabTrack = None
self.gotHitByBoss = False
self.keyTTL = []
self.keyRate = 0
self.buttons = [0, 1]
self.lastPowerFired = 0
self.moveSound = None
self.releaseTrack = None
def disable(self):
DistributedObject.DistributedObject.disable(self)
taskMgr.remove(self.triggerName)
taskMgr.remove(self.smoothName)
taskMgr.remove(self.watchControlsName)
taskMgr.remove(self.pitcherAdviceName)
taskMgr.remove(self.posHprBroadcastName)
taskMgr.remove(self.waterPowerTaskName)
if self.releaseTrack:
self.releaseTrack.finish()
self.releaseTrack = None
if self.fireTrack:
self.fireTrack.finish()
self.fireTrack = None
self.cleanupIntervals()
def delete(self):
DistributedObject.DistributedObject.delete(self)
self.boss = None
self.ignoreAll()
for indicator in self.dinerStatusIndicators.values():
indicator.delete()
self.dinerStatusIndicators = {}
for diner in self.diners.values():
diner.delete()
self.diners = {}
self.powerBar.destroy()
self.powerBar = None
self.pitcherMoveSfx.stop()
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
self.loadAssets()
self.smoothName = self.uniqueName("pitcherSmooth")
self.pitcherAdviceName = self.uniqueName("pitcherAdvice")
self.posHprBroadcastName = self.uniqueName("pitcherBroadcast")
self.waterPowerTaskName = self.uniqueName("updateWaterPower")
self.triggerName = self.uniqueName("trigger")
self.watchControlsName = self.uniqueName("watchControls")
def setBossCogId(self, bossCogId):
self.bossCogId = bossCogId
self.boss = base.cr.doId2do[bossCogId]
self.boss.setTable(self, self.index)
def setIndex(self, index):
self.index = index
def setState(self, state, avId, extraInfo):
self.gotHitByBoss = extraInfo
if state == "F":
self.demand("Off")
elif state == "N":
self.demand("On")
elif state == "I":
self.demand("Inactive")
elif state == "R":
self.demand("Free")
elif state == "C":
self.demand("Controlled", avId)
elif state == "L":
self.demand("Flat", avId)
else:
self.notify.error("Invalid state from AI: %s" % state)
def setNumDiners(self, numDiners):
self.numDiners = numDiners
def setDinerInfo(self, hungryDurations, eatingDurations, dinerLevels):
self.dinerInfo = {}
for i in xrange(len(hungryDurations)):
hungryDur = hungryDurations[i]
eatingDur = eatingDurations[i]
dinerLevel = dinerLevels[i]
self.dinerInfo[i] = (hungryDur, eatingDur, dinerLevel)
def loadAssets(self):
self.tableGroup = loader.loadModel("phase_12/models/bossbotHQ/BanquetTableChairs")
tableLocator = self.boss.geom.find("**/TableLocator_%d" % (self.index + 1))
if tableLocator.isEmpty():
self.tableGroup.reparentTo(render)
self.tableGroup.setPos(0, 75, 0)
else:
self.tableGroup.reparentTo(tableLocator)
self.tableGeom = self.tableGroup.find("**/Geometry")
self.setupDiners()
self.setupChairCols()
self.squirtSfx = loader.loadSfx("phase_4/audio/sfx/AA_squirt_seltzer_miss.mp3")
self.hitBossSfx = loader.loadSfx("phase_5/audio/sfx/SA_watercooler_spray_only.mp3")
self.hitBossSoundInterval = SoundInterval(self.hitBossSfx, node=self.boss, volume=1.0)
self.serveFoodSfx = loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_bell_for_trolley.mp3")
self.pitcherMoveSfx = base.loadSfx("phase_4/audio/sfx/MG_cannon_adjust.mp3")
def setupDiners(self):
for i in xrange(self.numDiners):
newDiner = self.createDiner(i)
self.diners[i] = newDiner
self.dinerStatus[i] = self.HUNGRY
def createDiner(self, i):
diner = Suit.Suit()
diner.dna = SuitDNA.SuitDNA()
level = self.dinerInfo[i][2]
level -= 4
diner.dna.newSuitRandom(level=level, dept="c")
diner.setDNA(diner.dna)
if self.useNewAnimations:
diner.loop("sit", fromFrame=i)
else:
diner.pose("landing", 0)
locator = self.tableGroup.find("**/chair_%d" % (i + 1))
locatorScale = locator.getNetTransform().getScale()[0]
correctHeadingNp = locator.attachNewNode("correctHeading")
self.chairLocators[i] = correctHeadingNp
heading = self.rotationsPerSeatIndex[i]
correctHeadingNp.setH(heading)
sitLocator = correctHeadingNp.attachNewNode("sitLocator")
base.sitLocator = sitLocator
pos = correctHeadingNp.getPos(render)
if SuitDNA.getSuitBodyType(diner.dna.name) == "c":
sitLocator.setPos(0.5, 3.6499999999999999, -3.75)
else:
sitLocator.setZ(-2.3999999999999999)
sitLocator.setY(2.5)
sitLocator.setX(0.5)
self.sitLocators[i] = sitLocator
diner.setScale(1.0 / locatorScale)
diner.reparentTo(sitLocator)
newLoc = NodePath("serviceLoc-%d-%d" % (self.index, i))
newLoc.reparentTo(correctHeadingNp)
newLoc.setPos(0, 3.0, 1)
self.serviceLocs[i] = newLoc
base.serviceLoc = newLoc
head = diner.find("**/joint_head")
newIndicator = DinerStatusIndicator.DinerStatusIndicator(parent=head, pos=Point3(0, 0, 3.5), scale=5.0)
newIndicator.wrtReparentTo(diner)
self.dinerStatusIndicators[i] = newIndicator
return diner
def setupChairCols(self):
for i in xrange(self.numDiners):
chairCol = self.tableGroup.find("**/collision_chair_%d" % (i + 1))
colName = "ChairCol-%d-%d" % (self.index, i)
chairCol.setTag("chairIndex", str(i))
chairCol.setName(colName)
chairCol.setCollideMask(ToontownGlobals.WallBitmask)
self.accept("enter" + colName, self.touchedChair)
def touchedChair(self, colEntry):
chairIndex = int(colEntry.getIntoNodePath().getTag("chairIndex"))
if chairIndex in self.dinerStatus:
status = self.dinerStatus[chairIndex]
if status in (self.HUNGRY, self.ANGRY):
self.boss.localToonTouchedChair(self.index, chairIndex)
def serveFood(self, food, chairIndex):
self.removeFoodModel(chairIndex)
serviceLoc = self.serviceLocs.get(chairIndex)
if not food or food.isEmpty():
foodModel = loader.loadModel("phase_12/models/bossbotHQ/canoffood")
foodModel.setScale(ToontownGlobals.BossbotFoodModelScale)
foodModel.reparentTo(serviceLoc)
else:
food.wrtReparentTo(serviceLoc)
tray = food.find("**/tray")
if not tray.isEmpty():
tray.hide()
ivalDuration = 1.5
foodMoveIval = Parallel(
SoundInterval(self.serveFoodSfx, node=food),
ProjectileInterval(
food, duration=ivalDuration, startPos=food.getPos(serviceLoc), endPos=serviceLoc.getPos(serviceLoc)
),
LerpHprInterval(food, ivalDuration, Point3(0, -360, 0)),
)
intervalName = "serveFood-%d-%d" % (self.index, chairIndex)
foodMoveIval.start()
self.activeIntervals[intervalName] = foodMoveIval
def setDinerStatus(self, chairIndex, status):
if chairIndex in self.dinerStatus:
oldStatus = self.dinerStatus[chairIndex]
self.dinerStatus[chairIndex] = status
if oldStatus != status:
if status == self.EATING:
self.changeDinerToEating(chairIndex)
elif status == self.HUNGRY:
self.changeDinerToHungry(chairIndex)
elif status == self.ANGRY:
self.changeDinerToAngry(chairIndex)
elif status == self.DEAD:
self.changeDinerToDead(chairIndex)
elif status == self.HIDDEN:
self.changeDinerToHidden(chairIndex)
def removeFoodModel(self, chairIndex):
serviceLoc = self.serviceLocs.get(chairIndex)
if serviceLoc:
for i in xrange(serviceLoc.getNumChildren()):
serviceLoc.getChild(0).removeNode()
def changeDinerToEating(self, chairIndex):
indicator = self.dinerStatusIndicators.get(chairIndex)
eatingDuration = self.dinerInfo[chairIndex][1]
if indicator:
indicator.request("Eating", eatingDuration)
diner = self.diners[chairIndex]
intervalName = "eating-%d-%d" % (self.index, chairIndex)
eatInTime = 32.0 / 24.0
eatOutTime = 21.0 / 24.0
eatLoopTime = 19 / 24.0
rightHand = diner.getRightHand()
waitTime = 5
loopDuration = eatingDuration - eatInTime - eatOutTime - waitTime
serviceLoc = self.serviceLocs[chairIndex]
def foodAttach(self=self, diner=diner):
foodModel = self.serviceLocs[chairIndex].getChild(0)
(foodModel.reparentTo(diner.getRightHand()),)
(foodModel.setHpr(Point3(0, -94, 0)),)
(foodModel.setPos(Point3(-0.14999999999999999, -0.69999999999999996, -0.40000000000000002)),)
scaleAdj = 1
if SuitDNA.getSuitBodyType(diner.dna.name) == "c":
scaleAdj = 0.59999999999999998
(foodModel.setPos(Point3(0.10000000000000001, -0.25, -0.31)),)
else:
scaleAdj = 0.80000000000000004
(foodModel.setPos(Point3(-0.25, -0.84999999999999998, -0.34000000000000002)),)
oldScale = foodModel.getScale()
newScale = oldScale * scaleAdj
foodModel.setScale(newScale)
def foodDetach(self=self, diner=diner):
foodModel = diner.getRightHand().getChild(0)
(foodModel.reparentTo(serviceLoc),)
(foodModel.setPosHpr(0, 0, 0, 0, 0, 0),)
scaleAdj = 1
if SuitDNA.getSuitBodyType(diner.dna.name) == "c":
scaleAdj = 0.59999999999999998
else:
scakeAdj = 0.80000000000000004
oldScale = foodModel.getScale()
newScale = oldScale / scaleAdj
foodModel.setScale(newScale)
eatIval = Sequence(
ActorInterval(diner, "sit", duration=waitTime),
ActorInterval(diner, "sit-eat-in", startFrame=0, endFrame=6),
Func(foodAttach),
ActorInterval(diner, "sit-eat-in", startFrame=6, endFrame=32),
ActorInterval(diner, "sit-eat-loop", duration=loopDuration, loop=1),
ActorInterval(diner, "sit-eat-out", startFrame=0, endFrame=12),
Func(foodDetach),
ActorInterval(diner, "sit-eat-out", startFrame=12, endFrame=21),
)
eatIval.start()
self.activeIntervals[intervalName] = eatIval
def changeDinerToHungry(self, chairIndex):
intervalName = "eating-%d-%d" % (self.index, chairIndex)
if intervalName in self.activeIntervals:
self.activeIntervals[intervalName].finish()
self.removeFoodModel(chairIndex)
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request("Hungry", self.dinerInfo[chairIndex][0])
diner = self.diners[chairIndex]
if random.choice([0, 1]):
diner.loop("sit-hungry-left")
else:
diner.loop("sit-hungry-right")
def changeDinerToAngry(self, chairIndex):
self.removeFoodModel(chairIndex)
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request("Angry")
diner = self.diners[chairIndex]
diner.loop("sit-angry")
def changeDinerToDead(self, chairIndex):
def removeDeathSuit(suit, deathSuit):
if not deathSuit.isEmpty():
deathSuit.detachNode()
suit.cleanupLoseActor()
self.removeFoodModel(chairIndex)
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request("Dead")
diner = self.diners[chairIndex]
deathSuit = diner
locator = self.tableGroup.find("**/chair_%d" % (chairIndex + 1))
deathSuit = diner.getLoseActor()
ival = Sequence(
Func(self.notify.debug, "before actorinterval sit-lose"),
ActorInterval(diner, "sit-lose"),
Func(self.notify.debug, "before deathSuit.setHpr"),
Func(deathSuit.setHpr, diner.getHpr()),
Func(self.notify.debug, "before diner.hide"),
Func(diner.hide),
Func(self.notify.debug, "before deathSuit.reparentTo"),
Func(deathSuit.reparentTo, self.chairLocators[chairIndex]),
Func(self.notify.debug, "befor ActorInterval lose"),
ActorInterval(deathSuit, "lose", duration=MovieUtil.SUIT_LOSE_DURATION),
Func(self.notify.debug, "before remove deathsuit"),
Func(removeDeathSuit, diner, deathSuit, name="remove-death-suit-%d-%d" % (chairIndex, self.index)),
Func(self.notify.debug, "diner.stash"),
Func(diner.stash),
)
spinningSound = base.loadSfx("phase_3.5/audio/sfx/Cog_Death.mp3")
deathSound = base.loadSfx("phase_3.5/audio/sfx/ENC_cogfall_apart.mp3")
deathSoundTrack = Sequence(
Wait(0.80000000000000004),
SoundInterval(spinningSound, duration=1.2, startTime=1.5, volume=0.20000000000000001, node=deathSuit),
SoundInterval(
spinningSound, duration=3.0, startTime=0.59999999999999998, volume=0.80000000000000004, node=deathSuit
),
SoundInterval(deathSound, volume=0.32000000000000001, node=deathSuit),
)
intervalName = "dinerDie-%d-%d" % (self.index, chairIndex)
deathIval = Parallel(ival, deathSoundTrack)
deathIval.start()
self.activeIntervals[intervalName] = deathIval
def changeDinerToHidden(self, chairIndex):
self.removeFoodModel(chairIndex)
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request("Inactive")
diner = self.diners[chairIndex]
diner.hide()
def setAllDinersToSitNeutral(self):
startFrame = 0
for diner in self.diners.values():
if not diner.isHidden():
diner.loop("sit", fromFrame=startFrame)
startFrame += 1
continue
def cleanupIntervals(self):
for interval in self.activeIntervals.values():
interval.finish()
self.activeIntervals = {}
def clearInterval(self, name, finish=1):
if self.activeIntervals.has_key(name):
ival = self.activeIntervals[name]
if finish:
ival.finish()
else:
ival.pause()
if self.activeIntervals.has_key(name):
del self.activeIntervals[name]
else:
self.notify.debug("interval: %s already cleared" % name)
def finishInterval(self, name):
if self.activeIntervals.has_key(name):
interval = self.activeIntervals[name]
interval.finish()
def getNotDeadInfo(self):
notDeadList = []
for i in xrange(self.numDiners):
if self.dinerStatus[i] != self.DEAD:
notDeadList.append((self.index, i, 12))
continue
return notDeadList
def enterOn(self):
pass
def exitOn(self):
pass
def enterInactive(self):
for chairIndex in xrange(self.numDiners):
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request("Inactive")
self.removeFoodModel(chairIndex)
def exitInactive(self):
pass
def enterFree(self):
self.resetPowerBar()
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.prepareForPhaseFour()
if self.avId == localAvatar.doId:
self.tableGroup.setAlphaScale(0.29999999999999999)
self.tableGroup.setTransparency(1)
taskMgr.doMethodLater(5, self._DistributedBanquetTable__allowDetect, self.triggerName)
self.fadeTrack = Sequence(
Func(self.tableGroup.setTransparency, 1),
self.tableGroup.colorScaleInterval(0.20000000000000001, VBase4(1, 1, 1, 0.29999999999999999)),
)
self.fadeTrack.start()
self.allowLocalRequestControl = False
else:
self.allowLocalRequestControl = True
self.avId = 0
def exitFree(self):
pass
def touchedTable(self, colEntry):
tableIndex = int(colEntry.getIntoNodePath().getTag("tableIndex"))
if self.state == "Free" and self.avId == 0 and self.allowLocalRequestControl:
self.d_requestControl()
def prepareForPhaseFour(self):
if not self.preparedForPhaseFour:
for i in xrange(8):
chair = self.tableGroup.find("**/chair_%d" % (i + 1))
if not chair.isEmpty():
chair.hide()
colChairs = self.tableGroup.findAllMatches("**/ChairCol*")
for i in xrange(colChairs.getNumPaths()):
col = colChairs.getPath(i)
col.stash()
colChairs = self.tableGroup.findAllMatches("**/collision_chair*")
for i in xrange(colChairs.getNumPaths()):
col = colChairs.getPath(i)
col.stash()
tableCol = self.tableGroup.find("**/collision_table")
colName = "TableCol-%d" % self.index
tableCol.setTag("tableIndex", str(self.index))
tableCol.setName(colName)
tableCol.setCollideMask(ToontownGlobals.WallBitmask | ToontownGlobals.BanquetTableBitmask)
self.accept("enter" + colName, self.touchedTable)
self.preparedForPhaseFour = True
self.waterPitcherModel = loader.loadModel("phase_12/models/bossbotHQ/tt_m_ara_bhq_seltzerBottle")
lampNode = self.tableGroup.find("**/lamp_med_5")
pos = lampNode.getPos(self.tableGroup)
lampNode.hide()
bottleLocator = self.tableGroup.find("**/bottle_locator")
pos = bottleLocator.getPos(self.tableGroup)
self.waterPitcherNode = self.tableGroup.attachNewNode("pitcherNode")
self.waterPitcherNode.setPos(pos)
self.waterPitcherModel.reparentTo(self.waterPitcherNode)
self.waterPitcherModel.ls()
self.nozzle = self.waterPitcherModel.find("**/nozzle_tip")
self.handLocator = self.waterPitcherModel.find("**/hand_locator")
self.handPos = self.handLocator.getPos()
def d_requestControl(self):
self.sendUpdate("requestControl")
def d_requestFree(self, gotHitByBoss):
self.sendUpdate("requestFree", [gotHitByBoss])
def enterControlled(self, avId):
self.prepareForPhaseFour()
self.avId = avId
toon = base.cr.doId2do.get(avId)
if not toon:
return None
self.toon = toon
self.grabTrack = self.makeToonGrabInterval(toon)
self.notify.debug("grabTrack=%s" % self.grabTrack)
self.pitcherCamPos = Point3(0, -50, 40)
self.pitcherCamHpr = Point3(0, -21, 0)
if avId == localAvatar.doId:
self.boss.toMovieMode()
self._DistributedBanquetTable__enableControlInterface()
self.startPosHprBroadcast()
self.grabTrack = Sequence(
self.grabTrack,
Func(camera.wrtReparentTo, localAvatar),
LerpPosHprInterval(camera, 1, self.pitcherCamPos, self.pitcherCamHpr),
Func(self.boss.toCraneMode),
)
if self.TugOfWarControls:
self._DistributedBanquetTable__spawnUpdateKeyPressRateTask()
self.accept("exitCrane", self.gotBossZapped)
else:
self.startSmooth()
toon.stopSmooth()
self.grabTrack.start()
def exitControlled(self):
self.ignore("exitCrane")
if self.grabTrack:
self.grabTrack.finish()
self.grabTrack = None
nextState = self.getCurrentOrNextState()
self.notify.debug("nextState=%s" % nextState)
if nextState == "Flat":
place = base.cr.playGame.getPlace()
self.notify.debug("%s" % place.fsm)
if self.avId == localAvatar.doId:
self._DistributedBanquetTable__disableControlInterface()
elif self.toon and not self.toon.isDisabled():
self.toon.loop("neutral")
self.toon.startSmooth()
self.releaseTrack = self.makeToonReleaseInterval(self.toon)
self.stopPosHprBroadcast()
self.stopSmooth()
if self.avId == localAvatar.doId:
localAvatar.wrtReparentTo(render)
self._DistributedBanquetTable__disableControlInterface()
camera.reparentTo(base.localAvatar)
camera.setPos(base.localAvatar.cameraPositions[0][0])
camera.setHpr(0, 0, 0)
self.goToFinalBattle()
self.safeBossToFinalBattleMode()
else:
toon = base.cr.doId2do.get(self.avId)
if toon:
toon.wrtReparentTo(render)
self.releaseTrack.start()
def safeBossToFinalBattleMode(self):
if self.boss:
self.boss.toFinalBattleMode()
def goToFinalBattle(self):
if self.cr:
place = self.cr.playGame.getPlace()
if place and hasattr(place, "fsm"):
if place.fsm.getCurrentState().getName() == "crane":
place.setState("finalBattle")
def makeToonGrabInterval(self, toon):
toon.pose("leverNeutral", 0)
toon.update()
rightHandPos = toon.rightHand.getPos(toon)
self.toonPitcherPosition = Point3(self.handPos[0] - rightHandPos[0], self.handPos[1] - rightHandPos[1], 0)
destZScale = rightHandPos[2] / self.handPos[2]
grabIval = Sequence(
Func(toon.wrtReparentTo, self.waterPitcherNode),
Func(toon.loop, "neutral"),
Parallel(
ActorInterval(toon, "jump"),
Sequence(
Wait(0.42999999999999999),
Parallel(
ProjectileInterval(
toon,
duration=0.90000000000000002,
startPos=toon.getPos(self.waterPitcherNode),
endPos=self.toonPitcherPosition,
),
LerpHprInterval(toon, 0.90000000000000002, Point3(0, 0, 0)),
LerpScaleInterval(self.waterPitcherModel, 0.90000000000000002, Point3(1, 1, destZScale)),
),
),
),
Func(toon.setPos, self.toonPitcherPosition),
Func(toon.loop, "leverNeutral"),
)
return grabIval
def makeToonReleaseInterval(self, toon):
temp1 = self.waterPitcherNode.attachNewNode("temp1")
temp1.setPos(self.toonPitcherPosition)
temp2 = self.waterPitcherNode.attachNewNode("temp2")
temp2.setPos(0, -10, -self.waterPitcherNode.getZ())
startPos = temp1.getPos(render)
endPos = temp2.getPos(render)
temp1.removeNode()
temp2.removeNode()
def getSlideToPos(toon=toon):
return render.getRelativePoint(toon, Point3(0, -10, 0))
if self.gotHitByBoss:
self.notify.debug("creating zap interval instead")
grabIval = Sequence(
Func(toon.loop, "neutral"),
Func(toon.wrtReparentTo, render),
Parallel(ActorInterval(toon, "slip-backward"), toon.posInterval(0.5, getSlideToPos, fluid=1)),
)
else:
grabIval = Sequence(
Func(toon.loop, "neutral"),
Func(toon.wrtReparentTo, render),
Parallel(
ActorInterval(toon, "jump"),
Sequence(
Wait(0.42999999999999999),
ProjectileInterval(toon, duration=0.90000000000000002, startPos=startPos, endPos=endPos),
),
),
)
return grabIval
def b_clearSmoothing(self):
self.d_clearSmoothing()
self.clearSmoothing()
def d_clearSmoothing(self):
self.sendUpdate("clearSmoothing", [0])
def clearSmoothing(self, bogus=None):
self.pitcherSmoother.clearPositions(1)
def doSmoothTask(self, task):
self.pitcherSmoother.computeAndApplySmoothHpr(self.waterPitcherNode)
return Task.cont
def startSmooth(self):
if not self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.reloadPosition()
taskMgr.add(self.doSmoothTask, taskName)
self.smoothStarted = 1
def stopSmooth(self):
if self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.forceToTruePosition()
self.smoothStarted = 0
def _DistributedBanquetTable__enableControlInterface(self):
gui = loader.loadModel("phase_3.5/models/gui/avatar_panel_gui")
self.closeButton = DirectButton(
image=(
gui.find("**/CloseBtn_UP"),
gui.find("**/CloseBtn_DN"),
gui.find("**/CloseBtn_Rllvr"),
gui.find("**/CloseBtn_UP"),
),
relief=None,
scale=2,
text=TTLocalizer.BossbotPitcherLeave,
text_scale=0.040000000000000001,
text_pos=(0, -0.070000000000000007),
text_fg=VBase4(1, 1, 1, 1),
pos=(1.05, 0, -0.81999999999999995),
command=self._DistributedBanquetTable__exitPitcher,
)
self.accept("escape", self._DistributedBanquetTable__exitPitcher)
self.accept("control", self._DistributedBanquetTable__controlPressed)
self.accept("control-up", self._DistributedBanquetTable__controlReleased)
self.accept("InputState-forward", self._DistributedBanquetTable__upArrow)
self.accept("InputState-reverse", self._DistributedBanquetTable__downArrow)
self.accept("InputState-turnLeft", self._DistributedBanquetTable__leftArrow)
self.accept("InputState-turnRight", self._DistributedBanquetTable__rightArrow)
self.accept("arrow_up", self._DistributedBanquetTable__upArrowKeyPressed)
self.accept("arrow_down", self._DistributedBanquetTable__downArrowKeyPressed)
taskMgr.add(self._DistributedBanquetTable__watchControls, self.watchControlsName)
taskMgr.doMethodLater(5, self._DistributedBanquetTable__displayPitcherAdvice, self.pitcherAdviceName)
self.arrowVert = 0
self.arrowHorz = 0
self.powerBar.show()
def _DistributedBanquetTable__disableControlInterface(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = None
self._DistributedBanquetTable__cleanupPitcherAdvice()
self.ignore("escape")
self.ignore("control")
self.ignore("control-up")
self.ignore("InputState-forward")
self.ignore("InputState-reverse")
self.ignore("InputState-turnLeft")
self.ignore("InputState-turnRight")
self.ignore("arrow_up")
self.ignore("arrow_down")
self.arrowVert = 0
self.arrowHorz = 0
taskMgr.remove(self.watchControlsName)
taskMgr.remove(self.waterPowerTaskName)
self.resetPowerBar()
self.aimStart = None
self.powerBar.hide()
if self.TugOfWarControls:
self._DistributedBanquetTable__killUpdateKeyPressRateTask()
self.keyTTL = []
self._DistributedBanquetTable__setMoveSound(None)
def _DistributedBanquetTable__displayPitcherAdvice(self, task):
if self.pitcherAdviceLabel == None:
self.pitcherAdviceLabel = DirectLabel(
text=TTLocalizer.BossbotPitcherAdvice,
text_fg=VBase4(1, 1, 1, 1),
text_align=TextNode.ACenter,
relief=None,
pos=(0, 0, 0.68999999999999995),
scale=0.10000000000000001,
)
def _DistributedBanquetTable__cleanupPitcherAdvice(self):
if self.pitcherAdviceLabel:
self.pitcherAdviceLabel.destroy()
self.pitcherAdviceLabel = None
taskMgr.remove(self.pitcherAdviceName)
def showExiting(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = DirectLabel(
relief=None,
text=TTLocalizer.BossbotPitcherLeaving,
pos=(1.05, 0, -0.88),
text_pos=(0, 0),
text_scale=0.059999999999999998,
text_fg=VBase4(1, 1, 1, 1),
)
self._DistributedBanquetTable__cleanupPitcherAdvice()
def _DistributedBanquetTable__exitPitcher(self):
self.showExiting()
self.d_requestFree(False)
def _DistributedBanquetTable__controlPressed(self):
self._DistributedBanquetTable__cleanupPitcherAdvice()
if self.TugOfWarControls:
if self.power:
self.aimStart = 1
self._DistributedBanquetTable__endFireWater()
elif self.state == "Controlled":
self._DistributedBanquetTable__beginFireWater()
def _DistributedBanquetTable__controlReleased(self):
if self.TugOfWarControls:
pass
1
if self.state == "Controlled":
self._DistributedBanquetTable__endFireWater()
def _DistributedBanquetTable__upArrow(self, pressed):
self._DistributedBanquetTable__incrementChangeSeq()
self._DistributedBanquetTable__cleanupPitcherAdvice()
if pressed:
self.arrowVert = 1
elif self.arrowVert > 0:
self.arrowVert = 0
def _DistributedBanquetTable__downArrow(self, pressed):
self._DistributedBanquetTable__incrementChangeSeq()
self._DistributedBanquetTable__cleanupPitcherAdvice()
if pressed:
self.arrowVert = -1
elif self.arrowVert < 0:
self.arrowVert = 0
def _DistributedBanquetTable__rightArrow(self, pressed):
self._DistributedBanquetTable__incrementChangeSeq()
self._DistributedBanquetTable__cleanupPitcherAdvice()
if pressed:
self.arrowHorz = 1
elif self.arrowHorz > 0:
self.arrowHorz = 0
def _DistributedBanquetTable__leftArrow(self, pressed):
self._DistributedBanquetTable__incrementChangeSeq()
self._DistributedBanquetTable__cleanupPitcherAdvice()
if pressed:
self.arrowHorz = -1
elif self.arrowHorz < 0:
self.arrowHorz = 0
def _DistributedBanquetTable__incrementChangeSeq(self):
self.changeSeq = self.changeSeq + 1 & 255
def stopPosHprBroadcast(self):
taskName = self.posHprBroadcastName
taskMgr.remove(taskName)
def startPosHprBroadcast(self):
taskName = self.posHprBroadcastName
self.b_clearSmoothing()
self.d_sendPitcherPos()
taskMgr.remove(taskName)
taskMgr.doMethodLater(
self._DistributedBanquetTable__broadcastPeriod, self._DistributedBanquetTable__posHprBroadcast, taskName
)
def _DistributedBanquetTable__posHprBroadcast(self, task):
self.d_sendPitcherPos()
taskName = self.posHprBroadcastName
taskMgr.doMethodLater(
self._DistributedBanquetTable__broadcastPeriod, self._DistributedBanquetTable__posHprBroadcast, taskName
)
return Task.done
def d_sendPitcherPos(self):
timestamp = globalClockDelta.getFrameNetworkTime()
self.sendUpdate("setPitcherPos", [self.changeSeq, self.waterPitcherNode.getH(), timestamp])
def setPitcherPos(self, changeSeq, h, timestamp):
self.changeSeq = changeSeq
if self.smoothStarted:
now = globalClock.getFrameTime()
local = globalClockDelta.networkToLocalTime(timestamp, now)
self.pitcherSmoother.setH(h)
self.pitcherSmoother.setTimestamp(local)
self.pitcherSmoother.markPosition()
else:
self.waterPitcherNode.setH(h)
def _DistributedBanquetTable__watchControls(self, task):
if self.arrowHorz:
self._DistributedBanquetTable__movePitcher(self.arrowHorz)
else:
self._DistributedBanquetTable__setMoveSound(None)
return Task.cont
def _DistributedBanquetTable__movePitcher(self, xd):
dt = globalClock.getDt()
h = self.waterPitcherNode.getH() - xd * self.rotateSpeed * dt
h %= 360
self.notify.debug(
"rotSpeed=%.2f curH=%.2f xd =%.2f, dt = %.2f, h=%.2f"
% (self.rotateSpeed, self.waterPitcherNode.getH(), xd, dt, h)
)
limitH = h
self.waterPitcherNode.setH(limitH)
if xd:
self._DistributedBanquetTable__setMoveSound(self.pitcherMoveSfx)
def reloadPosition(self):
self.pitcherSmoother.clearPositions(0)
self.pitcherSmoother.setHpr(self.waterPitcherNode.getHpr())
self.pitcherSmoother.setPhonyTimestamp()
def forceToTruePosition(self):
if self.pitcherSmoother.getLatestPosition():
self.pitcherSmoother.applySmoothHpr(self.waterPitcherNode)
self.pitcherSmoother.clearPositions(1)
def getSprayTrack(
self, color, origin, target, dScaleUp, dHold, dScaleDown, horizScale=1.0, vertScale=1.0, parent=render
):
track = Sequence()
SPRAY_LEN = 1.5
sprayProp = MovieUtil.globalPropPool.getProp("spray")
sprayScale = hidden.attachNewNode("spray-parent")
sprayRot = hidden.attachNewNode("spray-rotate")
spray = sprayRot
spray.setColor(color)
if color[3] < 1.0:
spray.setTransparency(1)
def showSpray(sprayScale, sprayRot, sprayProp, origin, target, parent):
if callable(origin):
origin = origin()
if callable(target):
target = target()
sprayRot.reparentTo(parent)
sprayRot.clearMat()
sprayScale.reparentTo(sprayRot)
sprayScale.clearMat()
sprayProp.reparentTo(sprayScale)
sprayProp.clearMat()
sprayRot.setPos(origin)
sprayRot.lookAt(Point3(target))
track.append(Func(showSpray, sprayScale, sprayRot, sprayProp, origin, target, parent))
def calcTargetScale(target=target, origin=origin, horizScale=horizScale, vertScale=vertScale):
if callable(target):
target = target()
if callable(origin):
origin = origin()
distance = Vec3(target - origin).length()
yScale = distance / SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale, yScale * vertScale)
return targetScale
track.append(LerpScaleInterval(sprayScale, dScaleUp, calcTargetScale, startScale=Point3(0.01, 0.01, 0.01)))
track.append(Func(self.checkHitObject))
track.append(Wait(dHold))
def prepareToShrinkSpray(spray, sprayProp, origin, target):
if callable(target):
target = target()
if callable(origin):
origin = origin()
sprayProp.setPos(Point3(0.0, -SPRAY_LEN, 0.0))
spray.setPos(target)
track.append(Func(prepareToShrinkSpray, spray, sprayProp, origin, target))
track.append(LerpScaleInterval(sprayScale, dScaleDown, Point3(0.01, 0.01, 0.01)))
def hideSpray(spray, sprayScale, sprayRot, sprayProp, propPool):
sprayProp.detachNode()
MovieUtil.removeProp(sprayProp)
sprayRot.removeNode()
sprayScale.removeNode()
track.append(Func(hideSpray, spray, sprayScale, sprayRot, sprayProp, MovieUtil.globalPropPool))
return track
def checkHitObject(self):
if not self.hitObject:
return None
if self.avId != base.localAvatar.doId:
return None
tag = self.hitObject.getNetTag("pieCode")
pieCode = int(tag)
if pieCode == ToontownGlobals.PieCodeBossCog:
self.hitBossSoundInterval.start()
self.sendUpdate("waterHitBoss", [self.index])
if self.TugOfWarControls:
damage = 1
if self.lastPowerFired < self.YELLOW_POWER_THRESHOLD:
damage = 1
elif self.lastPowerFired < self.RED_POWER_THRESHOLD:
damage = 2
else:
damage = 3
self.boss.d_hitBoss(damage)
else:
damage = 1
if self.lastPowerFired < self.YELLOW_POWER_THRESHOLD:
damage = 1
elif self.lastPowerFired < self.RED_POWER_THRESHOLD:
damage = 2
else:
damage = 3
self.boss.d_hitBoss(damage)
def waterHitBoss(self, tableIndex):
if self.index == tableIndex:
self.hitBossSoundInterval.start()
def setupPowerBar(self):
self.powerBar = DirectWaitBar(
pos=(0.0, 0, -0.93999999999999995),
relief=DGG.SUNKEN,
frameSize=(-2.0, 2.0, -0.20000000000000001, 0.20000000000000001),
borderWidth=(0.02, 0.02),
scale=0.25,
range=1,
sortOrder=50,
frameColor=(0.5, 0.5, 0.5, 0.5),
barColor=(0.75, 0.75, 1.0, 0.80000000000000004),
text="",
text_scale=0.26000000000000001,
text_fg=(1, 1, 1, 1),
text_align=TextNode.ACenter,
text_pos=(0, -0.050000000000000003),
)
self.power = 0
self.powerBar["value"] = self.power
self.powerBar.hide()
def resetPowerBar(self):
self.power = 0
self.powerBar["value"] = self.power
self.powerBar["text"] = ""
self.keyTTL = []
def _DistributedBanquetTable__beginFireWater(self):
if self.fireTrack and self.fireTrack.isPlaying():
return None
if self.aimStart != None:
return None
if not self.state == "Controlled":
return None
if not self.avId == localAvatar.doId:
return None
time = globalClock.getFrameTime()
self.aimStart = time
messenger.send("wakeup")
taskMgr.add(self._DistributedBanquetTable__updateWaterPower, self.waterPowerTaskName)
def _DistributedBanquetTable__endFireWater(self):
if self.aimStart == None:
return None
if not self.state == "Controlled":
return None
if not self.avId == localAvatar.doId:
return None
taskMgr.remove(self.waterPowerTaskName)
messenger.send("wakeup")
self.aimStart = None
origin = self.nozzle.getPos(render)
target = self.boss.getPos(render)
angle = deg2Rad(self.waterPitcherNode.getH() + 90)
x = math.cos(angle)
y = math.sin(angle)
fireVector = Point3(x, y, 0)
if self.power < 0.001:
self.power = 0.001
self.lastPowerFired = self.power
fireVector *= self.fireLength * self.power
target = origin + fireVector
segment = CollisionSegment(origin[0], origin[1], origin[2], target[0], target[1], target[2])
fromObject = render.attachNewNode(CollisionNode("pitcherColNode"))
fromObject.node().addSolid(segment)
fromObject.node().setFromCollideMask(
ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask
)
fromObject.node().setIntoCollideMask(BitMask32.allOff())
queue = CollisionHandlerQueue()
base.cTrav.addCollider(fromObject, queue)
base.cTrav.traverse(render)
queue.sortEntries()
self.hitObject = None
if queue.getNumEntries():
entry = queue.getEntry(0)
target = entry.getSurfacePoint(render)
self.hitObject = entry.getIntoNodePath()
base.cTrav.removeCollider(fromObject)
fromObject.removeNode()
self.d_firingWater(origin, target)
self.fireWater(origin, target)
self.resetPowerBar()
def _DistributedBanquetTable__updateWaterPower(self, task):
if not self.powerBar:
print "### no power bar!!!"
return task.done
newPower = self._DistributedBanquetTable__getWaterPower(globalClock.getFrameTime())
self.power = newPower
self.powerBar["value"] = newPower
if self.power < self.YELLOW_POWER_THRESHOLD:
self.powerBar["barColor"] = VBase4(0.75, 0.75, 1.0, 0.80000000000000004)
elif self.power < self.RED_POWER_THRESHOLD:
self.powerBar["barColor"] = VBase4(1.0, 1.0, 0.0, 0.80000000000000004)
else:
self.powerBar["barColor"] = VBase4(1.0, 0.0, 0.0, 0.80000000000000004)
return task.cont
def _DistributedBanquetTable__getWaterPower(self, time):
elapsed = max(time - self.aimStart, 0.0)
t = elapsed / self.waterPowerSpeed
exponent = self.waterPowerExponent
if t > 1:
t = t % 1
power = 1 - math.pow(1 - t, exponent)
if power > 1.0:
power = 1.0
return power
def d_firingWater(self, origin, target):
self.sendUpdate("firingWater", [origin[0], origin[1], origin[2], target[0], target[1], target[2]])
def firingWater(self, startX, startY, startZ, endX, endY, endZ):
origin = Point3(startX, startY, startZ)
target = Point3(endX, endY, endZ)
self.fireWater(origin, target)
def fireWater(self, origin, target):
color = VBase4(0.75, 0.75, 1, 0.80000000000000004)
dScaleUp = 0.10000000000000001
dHold = 0.29999999999999999
dScaleDown = 0.10000000000000001
horizScale = 0.10000000000000001
vertScale = 0.10000000000000001
sprayTrack = self.getSprayTrack(color, origin, target, dScaleUp, dHold, dScaleDown, horizScale, vertScale)
duration = self.squirtSfx.length()
if sprayTrack.getDuration() < duration:
duration = sprayTrack.getDuration()
soundTrack = SoundInterval(self.squirtSfx, node=self.waterPitcherModel, duration=duration)
self.fireTrack = Parallel(sprayTrack, soundTrack)
self.fireTrack.start()
def getPos(self, wrt=render):
return self.tableGroup.getPos(wrt)
def getLocator(self):
return self.tableGroup
def enterFlat(self, avId):
self.prepareForPhaseFour()
self.resetPowerBar()
self.notify.debug("enterFlat %d" % self.index)
if self.avId:
toon = base.cr.doId2do.get(self.avId)
if toon:
toon.wrtReparentTo(render)
toon.setZ(0)
self.tableGroup.setScale(1, 1, 0.01)
if self.avId and self.avId == localAvatar.doId:
localAvatar.b_squish(ToontownGlobals.BossCogDamageLevels[ToontownGlobals.BossCogMoveAttack])
def exitFlat(self):
self.tableGroup.setScale(1.0)
if self.avId:
toon = base.cr.doId2do.get(self.avId)
if toon:
if toon == localAvatar:
self.boss.toCraneMode()
toon.b_setAnimState("neutral")
toon.setAnimState("neutral")
toon.loop("leverNeutral")
def _DistributedBanquetTable__allowDetect(self, task):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = Sequence(
self.tableGroup.colorScaleInterval(0.20000000000000001, VBase4(1, 1, 1, 1)),
Func(self.tableGroup.clearColorScale),
Func(self.tableGroup.clearTransparency),
)
self.fadeTrack.start()
self.allowLocalRequestControl = True
def gotBossZapped(self):
self.showExiting()
self.d_requestFree(True)
def _DistributedBanquetTable__upArrowKeyPressed(self):
if self.TugOfWarControls:
self._DistributedBanquetTable__pressHandler(0)
def _DistributedBanquetTable__downArrowKeyPressed(self):
if self.TugOfWarControls:
self._DistributedBanquetTable__pressHandler(1)
def _DistributedBanquetTable__pressHandler(self, index):
if index == self.buttons[0]:
self.keyTTL.insert(0, 1.0)
if not self.OnlyUpArrow:
self.buttons.reverse()
def _DistributedBanquetTable__spawnUpdateKeyPressRateTask(self):
taskMgr.remove(self.taskName(self.UPDATE_KEY_PRESS_RATE_TASK))
taskMgr.doMethodLater(
0.10000000000000001,
self._DistributedBanquetTable__updateKeyPressRateTask,
self.taskName(self.UPDATE_KEY_PRESS_RATE_TASK),
)
def _DistributedBanquetTable__killUpdateKeyPressRateTask(self):
taskMgr.remove(self.taskName(self.UPDATE_KEY_PRESS_RATE_TASK))
def _DistributedBanquetTable__updateKeyPressRateTask(self, task):
if self.state not in "Controlled":
return Task.done
for i in range(len(self.keyTTL)):
self.keyTTL[i] -= 0.10000000000000001
for i in range(len(self.keyTTL)):
if self.keyTTL[i] <= 0:
a = self.keyTTL[0:i]
del self.keyTTL
self.keyTTL = a
break
continue
self.keyRate = len(self.keyTTL)
keyRateDiff = self.keyRate - self.BASELINE_KEY_RATE
diffPower = keyRateDiff / 300.0
if self.power < 1 and diffPower > 0:
diffPower = diffPower * math.pow(1 - self.power, 1.25)
newPower = self.power + diffPower
if newPower > 1:
newPower = 1
elif newPower < 0:
newPower = 0
self.notify.debug("diffPower=%.2f keyRate = %d, newPower=%.2f" % (diffPower, self.keyRate, newPower))
self.power = newPower
self.powerBar["value"] = newPower
if self.power < self.YELLOW_POWER_THRESHOLD:
self.powerBar["barColor"] = VBase4(0.75, 0.75, 1.0, 0.80000000000000004)
elif self.power < self.RED_POWER_THRESHOLD:
self.powerBar["barColor"] = VBase4(1.0, 1.0, 0.0, 0.80000000000000004)
else:
self.powerBar["barColor"] = VBase4(1.0, 0.0, 0.0, 0.80000000000000004)
self._DistributedBanquetTable__spawnUpdateKeyPressRateTask()
return Task.done
def _DistributedBanquetTable__setMoveSound(self, sfx):
if sfx != self.moveSound:
if self.moveSound:
self.moveSound.stop()
self.moveSound = sfx
if self.moveSound:
base.playSfx(self.moveSound, looping=1, volume=0.5)
class RepairBarnacle(DirectFrame, FSM.FSM):
__module__ = __name__
barnacleFallSounds = None
def __init__(self, name, barnacleGeom):
self.config = RepairGlobals.Careening
DirectFrame.__init__(self, parent=None, relief=None)
self.barnacleGeom = barnacleGeom
FSM.FSM.__init__(self, 'Barnacle_%sFSM' % name)
self._initAudio()
self._initVars()
self._initGUI()
return
def _initVars(self):
self.heat = 0.0
self.hp = 100
self.maxHP = 100
self.currentShake = None
self.fallingAnim = None
return
def _initAudio(self):
if not self.barnacleFallSounds:
RepairBarnacle.barnacleFallSounds = (
loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE1),
loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE2),
loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE3),
loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE4),
loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_CAREEN_COMPLETE5))
def _initGUI(self):
self.barnacleGeom.reparentTo(self)
self.barnacleGeom.setScale(0.6)
self.barnacleGeom.setR(random.random() * 360)
if self.config.showBarnacleHP:
self.hpLabel = DirectLabel(text='',
scale=(0.025, 0.025, 0.025),
pos=(0.0, 0.0, -0.01),
textMayChange=1,
parent=self)
def destroy(self):
if self.currentShake is not None:
self.currentShake.clearToInitial()
self.currentShake = None
del self.currentShake
if self.fallingAnim is not None:
self.fallingAnim.clearToInitial()
self.fallingAnim = None
del self.fallingAnim
self.cleanup()
if self.config.showBarnacleHP:
self.hpLabel.destroy()
del self.hpLabel
DirectFrame.destroy(self)
self.barnacleGeom.removeNode()
del self.barnacleGeom
return
def setMaxHP(self, newMaxHP, globalMaxHP):
self.maxHP = newMaxHP
self.globalMaxHP = globalMaxHP
def setHP(self, newHP):
self.hp = newHP
if self.config.showBarnacleHP:
self.hpLabel['text'] = '%i' % self.hp
self.hpLabel.setText()
if self.hp <= 0.0:
self.hp = 0.0
self.request('Falling')
self.setScale(self.hp * MAX_SCALE_ADD / self.globalMaxHP + MIN_SCALE)
def reduceHP(self, pushDir, powerScale):
amount = pushDir.length()
pushDir.normalize()
self.heat = min(1.0, self.heat + amount)
amount *= 50
if amount > MAX_SCRUB_AMT:
amount = MAX_SCRUB_AMT
amount *= powerScale
newHP = self.hp - amount
self.setHP(newHP)
if self.currentShake is None:
self.currentShake = Sequence(
LerpPosInterval(
self,
duration=0.03,
pos=(self.getX() - pushDir[0] * (0.01 + amount / 1000.0),
self.getY(),
self.getZ() - pushDir[1] * (0.01 + amount / 1000.0)),
blendType='easeIn'),
LerpPosInterval(self,
duration=0.06,
pos=(self.getX(), self.getY(), self.getZ()),
blendType='easeOut'),
LerpPosInterval(
self,
duration=0.04,
pos=(self.getX() + pushDir[0] * (0.0075 + amount / 2000.0),
self.getY(),
self.getZ() + pushDir[1] * (0.005 + amount / 2000.0)),
blendType='easeIn'),
LerpPosInterval(self,
duration=0.08,
pos=(self.getX(), self.getY(), self.getZ()),
blendType='easeOut'),
Func(self.clearCurrentShake))
self.currentShake.start()
return
def checkCollision(self, mousePosition):
sld = Point3(mousePosition.getX(), 0.0,
mousePosition.getY()) - self.getPos(render2d)
return self.getCurrentOrNextState() == 'Idle' and sld.length(
) < self.config.barnacleRadius * self.getScale().getX()
def clearCurrentShake(self):
self.currentShake = None
return
def enterIdle(self):
visibleIndex = random.uniform(0,
self.barnacleGeom.getNumChildren() - 1)
for i in range(self.barnacleGeom.getNumChildren() - 1):
self.barnacleGeom.getChild(i).unstash()
newHP = self.maxHP
self.heat = 0.0
self.setHP(newHP)
self.unstash()
def exitIdle(self):
pass
def enterFalling(self):
if self.currentShake is not None:
self.currentShake.finish()
sound = random.choice(self.barnacleFallSounds)
sound.play()
self.fallingAnim = Sequence(
LerpPosInterval(self,
duration=2.0,
pos=(self.getX(), self.getY(), self.getZ() - 2.0),
blendType='easeIn'), Func(self.request, 'Clean'))
self.fallingAnim.start()
return
def exitFalling(self):
self.stash()
def enterClean(self):
pass
def exitClean(self):
pass
class DistributedGolfSpot(DistributedObject.DistributedObject, FSM.FSM):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedGolfSpot')
positions = ((-45, 100, GolfGlobals.GOLF_BALL_RADIUS),
(-15, 100, GolfGlobals.GOLF_BALL_RADIUS),
(15, 100, GolfGlobals.GOLF_BALL_RADIUS),
(45, 100, GolfGlobals.GOLF_BALL_RADIUS))
toonGolfOffsetPos = Point3(-2, 0, -GolfGlobals.GOLF_BALL_RADIUS)
toonGolfOffsetHpr = Point3(-90, 0, 0)
rotateSpeed = 20
golfPowerSpeed = base.config.GetDouble('golf-power-speed', 3)
golfPowerExponent = base.config.GetDouble('golf-power-exponent', 0.75)
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
FSM.FSM.__init__(self, 'DistributedGolfSpot')
self.boss = None
self.index = None
self.avId = 0
self.toon = None
self.golfSpotSmoother = SmoothMover()
self.golfSpotSmoother.setSmoothMode(SmoothMover.SMOn)
self.smoothStarted = 0
self.__broadcastPeriod = 0.2
if self.index > len(self.positions):
self.notify.error('Invalid index %d' % index)
self.fadeTrack = None
self.setupPowerBar()
self.aimStart = None
self.golfSpotAdviceLabel = None
self.changeSeq = 0
self.lastChangeSeq = 0
self.controlKeyAllowed = False
self.flyBallTracks = {}
self.splatTracks = {}
self.__flyBallBubble = None
self.flyBallHandler = None
self.__flyBallSequenceNum = 0
self.swingInterval = None
self.lastHitSequenceNum = -1
self.goingToReward = False
self.gotHitByBoss = False
self.releaseTrack = None
self.grabTrack = None
self.restoreScaleTrack = None
return
def setBossCogId(self, bossCogId):
self.bossCogId = bossCogId
self.boss = base.cr.doId2do[bossCogId]
self.boss.setGolfSpot(self, self.index)
def setIndex(self, index):
self.index = index
def disable(self):
DistributedObject.DistributedObject.disable(self)
self.ignoreAll()
def delete(self):
DistributedObject.DistributedObject.delete(self)
self.ignoreAll()
self.boss = None
return
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
self.triggerName = self.uniqueName('trigger')
self.triggerEvent = 'enter%s' % self.triggerName
self.smoothName = self.uniqueName('golfSpotSmooth')
self.golfSpotAdviceName = self.uniqueName('golfSpotAdvice')
self.posHprBroadcastName = self.uniqueName('golfSpotBroadcast')
self.ballPowerTaskName = self.uniqueName('updateGolfPower')
self.adjustClubTaskName = self.uniqueName('adjustClub')
self.loadAssets()
self.accept('flyBallHit-%d' % self.index, self.__flyBallHit)
def loadAssets(self):
self.root = render.attachNewNode('golfSpot-%d' % self.index)
self.root.setPos(*self.positions[self.index])
self.ballModel = loader.loadModel('phase_6/models/golf/golf_ball')
self.ballColor = VBase4(1, 1, 1, 1)
if self.index < len(GolfGlobals.PlayerColors):
self.ballColor = VBase4(*GolfGlobals.PlayerColors[self.index])
self.ballModel.setColorScale(self.ballColor)
self.ballModel.reparentTo(self.root)
self.club = loader.loadModel('phase_6/models/golf/putter')
self.clubLookatSpot = self.root.attachNewNode('clubLookat')
self.clubLookatSpot.setY(-(GolfGlobals.GOLF_BALL_RADIUS + 0.1))
cs = CollisionSphere(0, 0, 0, 1)
cs.setTangible(0)
cn = CollisionNode(self.triggerName)
cn.addSolid(cs)
cn.setIntoCollideMask(ToontownGlobals.WallBitmask)
self.trigger = self.root.attachNewNode(cn)
self.trigger.stash()
self.hitBallSfx = loader.loadSfx('phase_6/audio/sfx/Golf_Hit_Ball.ogg')
def cleanup(self):
if self.swingInterval:
self.swingInterval.finish()
self.swingInterval = None
if self.releaseTrack:
self.releaseTrack.finish()
self.releaseTrack = None
flyTracks = self.flyBallTracks.values()
for track in flyTracks:
track.finish()
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
if self.restoreScaleTrack:
self.restoreScaleTrack.finish()
self.restoreScaleTrack = None
self.root.removeNode()
self.ballModel.removeNode()
self.club.removeNode()
if self.powerBar:
self.powerBar.destroy()
self.powerBar = None
taskMgr.remove(self.triggerName)
self.boss = None
return
def setState(self, state, avId, extraInfo):
if not self.isDisabled():
self.gotHitByBoss = extraInfo
if state == 'C':
self.demand('Controlled', avId)
elif state == 'F':
self.demand('Free')
elif state == 'O':
self.demand('Off')
else:
self.notify.error('Invalid state from AI: %s' % state)
def enterOff(self):
pass
def exitOff(self):
pass
def enterFree(self):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.restoreScaleTrack = Sequence(Wait(6),
self.getRestoreScaleInterval(),
name='restoreScaleTrack')
self.restoreScaleTrack.start()
if self.avId == localAvatar.doId:
if not self.isDisabled():
self.ballModel.setAlphaScale(0.3)
self.ballModel.setTransparency(1)
taskMgr.doMethodLater(5, self.__allowDetect, self.triggerName)
self.fadeTrack = Sequence(Func(self.ballModel.setTransparency,
1),
self.ballModel.colorScaleInterval(
0.2, VBase4(1, 1, 1, 0.3)),
name='fadeTrack-enterFree')
self.fadeTrack.start()
else:
self.trigger.unstash()
self.accept(self.triggerEvent, self.__hitTrigger)
self.avId = 0
return
def exitFree(self):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.restoreScaleTrack.finish()
self.restoreScaleTrack = None
taskMgr.remove(self.triggerName)
self.ballModel.clearTransparency()
self.trigger.stash()
self.ignore(self.triggerEvent)
return
def enterControlled(self, avId):
self.avId = avId
toon = base.cr.doId2do.get(avId)
if not toon:
return
self.enableControlKey()
self.toon = toon
self.grabTrack = self.makeToonGrabInterval(toon)
if avId == localAvatar.doId:
self.boss.toCraneMode()
camera.reparentTo(self.root)
camera.setPosHpr(0, -10, 3, 0, 0, 0)
localAvatar.setPos(self.root, self.toonGolfOffsetPos)
localAvatar.setHpr(self.root, self.toonGolfOffsetHpr)
localAvatar.sendCurrentPosition()
self.__enableControlInterface()
self.startPosHprBroadcast()
self.accept('exitCrane', self.gotBossZapped)
self.grabTrack.start()
def exitControlled(self):
self.grabTrack.finish()
del self.grabTrack
if self.swingInterval:
self.swingInterval.finish()
self.swingInterval = None
if not self.ballModel.isEmpty():
if self.ballModel.isHidden():
self.notify.debug('ball is hidden scale =%s' %
self.ballModel.getScale())
else:
self.notify.debug('ball is showing scale=%s' %
self.ballModel.getScale())
if self.toon and not self.toon.isDisabled():
self.toon.startSmooth()
self.releaseTrack = self.makeToonReleaseInterval(self.toon)
self.stopPosHprBroadcast()
self.stopSmooth()
if self.avId == localAvatar.doId:
self.__disableControlInterface()
if not self.goingToReward:
camera.reparentTo(base.localAvatar)
camera.setPos(base.localAvatar.cameraPositions[0][0])
camera.setHpr(0, 0, 0)
self.stopAdjustClubTask()
self.releaseTrack.start()
self.enableControlKey()
return
def __allowDetect(self, task):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = Sequence(self.ballModel.colorScaleInterval(
0.2, self.ballColor),
Func(self.ballModel.clearTransparency),
name='fadeTrack-allowDetect')
self.fadeTrack.start()
self.trigger.unstash()
self.accept(self.triggerEvent, self.__hitTrigger)
def __hitTrigger(self, event):
self.d_requestControl()
def getRestoreScaleInterval(self):
return Sequence()
def d_requestControl(self):
self.sendUpdate('requestControl')
def d_requestFree(self, gotHitByBoss):
self.sendUpdate('requestFree', [gotHitByBoss])
def makeToonGrabInterval(self, toon):
origPos = toon.getPos(self.root)
origHpr = toon.getHpr(self.root)
a = self.accomodateToon(toon)
newPos = toon.getPos()
newHpr = toon.getHpr()
origHpr.setX(PythonUtil.fitSrcAngle2Dest(origHpr[0], newHpr[0]))
self.notify.debug('toon.setPosHpr %s %s' % (origPos, origHpr))
toon.setPosHpr(origPos, origHpr)
walkTime = 0.2
reach = Sequence()
if reach.getDuration() < walkTime:
reach = Sequence(
ActorInterval(toon,
'walk',
loop=1,
duration=walkTime - reach.getDuration()), reach)
i = Sequence(
Parallel(toon.posInterval(walkTime, newPos, origPos),
toon.hprInterval(walkTime, newHpr, origHpr), reach),
Func(toon.stopLookAround))
if toon == base.localAvatar:
i.append(Func(self.switchToAnimState, 'GolfPuttLoop'))
i.append(Func(self.startAdjustClubTask))
i = Parallel(i, a)
return i
def accomodateToon(self, toon):
toon.wrtReparentTo(self.root)
toon.setPos(self.toonGolfOffsetPos)
toon.setHpr(self.toonGolfOffsetHpr)
return Sequence()
def switchToAnimState(self, animStateName, forced=False):
curAnimState = base.localAvatar.animFSM.getCurrentState()
curAnimStateName = ''
if curAnimState:
curAnimStateName = curAnimState.getName()
if curAnimStateName != animStateName or forced:
base.localAvatar.b_setAnimState(animStateName)
def __enableControlInterface(self):
gui = loader.loadModel('phase_3.5/models/gui/avatar_panel_gui')
self.closeButton = DirectButton(image=(gui.find('**/CloseBtn_UP'),
gui.find('**/CloseBtn_DN'),
gui.find('**/CloseBtn_Rllvr'),
gui.find('**/CloseBtn_UP')),
relief=None,
scale=2,
text=TTLocalizer.BossbotGolfSpotLeave,
text_scale=0.04,
text_pos=(0, -0.07),
text_fg=VBase4(1, 1, 1, 1),
pos=(1.05, 0, -0.82),
command=self.__exitGolfSpot)
self.accept('escape', self.__exitGolfSpot)
self.accept('control', self.__controlPressed)
self.accept('control-up', self.__controlReleased)
self.accept('InputState-forward', self.__upArrow)
self.accept('InputState-reverse', self.__downArrow)
self.accept('InputState-turnLeft', self.__leftArrow)
self.accept('InputState-turnRight', self.__rightArrow)
taskMgr.add(self.__watchControls, 'watchGolfSpotControls')
taskMgr.doMethodLater(5, self.__displayGolfSpotAdvice,
self.golfSpotAdviceName)
self.arrowVert = 0
self.arrowHorz = 0
if self.powerBar:
self.powerBar.show()
return
def __disableControlInterface(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = None
self.__cleanupGolfSpotAdvice()
self.ignore('escape')
self.ignore('control')
self.ignore('control-up')
self.ignore('InputState-forward')
self.ignore('InputState-reverse')
self.ignore('InputState-turnLeft')
self.ignore('InputState-turnRight')
self.arrowVert = 0
self.arrowHorz = 0
taskMgr.remove('watchGolfSpotControls')
if self.powerBar:
self.powerBar.hide()
else:
self.notify.debug('self.powerBar is none')
return
def setupPowerBar(self):
self.powerBar = DirectWaitBar(pos=(0.0, 0, -0.94),
relief=DGG.SUNKEN,
frameSize=(-2.0, 2.0, -0.2, 0.2),
borderWidth=(0.02, 0.02),
scale=0.25,
range=100,
sortOrder=50,
frameColor=(0.5, 0.5, 0.5, 0.5),
barColor=(1.0, 0.0, 0.0, 1.0),
text='',
text_scale=0.26,
text_fg=(1, 1, 1, 1),
text_align=TextNode.ACenter,
text_pos=(0, -0.05))
self.power = 0
self.powerBar['value'] = self.power
self.powerBar.hide()
def resetPowerBar(self):
self.power = 0
self.powerBar['value'] = self.power
self.powerBar['text'] = ''
def __displayGolfSpotAdvice(self, task):
if self.golfSpotAdviceLabel == None:
self.golfSpotAdviceLabel = DirectLabel(
text=TTLocalizer.BossbotGolfSpotAdvice,
text_fg=VBase4(1, 1, 1, 1),
text_align=TextNode.ACenter,
relief=None,
pos=(0, 0, 0.69),
scale=0.1)
return
def __cleanupGolfSpotAdvice(self):
if self.golfSpotAdviceLabel:
self.golfSpotAdviceLabel.destroy()
self.golfSpotAdviceLabel = None
taskMgr.remove(self.golfSpotAdviceName)
return
def showExiting(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = DirectLabel(
relief=None,
text=TTLocalizer.BossbotGolfSpotLeaving,
pos=(1.05, 0, -0.88),
text_pos=(0, 0),
text_scale=0.06,
text_fg=VBase4(1, 1, 1, 1))
self.__cleanupGolfSpotAdvice()
return
def __exitGolfSpot(self):
self.d_requestFree(False)
def __controlPressed(self):
if self.controlKeyAllowed:
self.__beginFireBall()
def __controlReleased(self):
if self.controlKeyAllowed:
self.__endFireBall()
def __upArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowVert = 1
elif self.arrowVert > 0:
self.arrowVert = 0
def __downArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowVert = -1
elif self.arrowVert < 0:
self.arrowVert = 0
def __rightArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowHorz = 1
self.switchToAnimState('GolfRotateLeft')
elif self.arrowHorz > 0:
self.arrowHorz = 0
self.switchToAnimState('GolfPuttLoop')
def __leftArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowHorz = -1
self.switchToAnimState('GolfRotateRight')
elif self.arrowHorz < 0:
self.arrowHorz = 0
self.switchToAnimState('GolfPuttLoop')
def __watchControls(self, task):
if self.arrowHorz:
self.__moveGolfSpot(self.arrowHorz)
return Task.cont
def __moveGolfSpot(self, xd):
dt = globalClock.getDt()
h = self.root.getH() - xd * self.rotateSpeed * dt
h %= 360
limitH = h
self.root.setH(limitH)
def __incrementChangeSeq(self):
self.changeSeq = self.changeSeq + 1 & 255
def __beginFireBall(self):
if self.aimStart != None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
time = globalClock.getFrameTime()
self.aimStart = time
messenger.send('wakeup')
taskMgr.add(self.__updateBallPower, self.ballPowerTaskName)
return
def __endFireBall(self):
if self.aimStart == None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
taskMgr.remove(self.ballPowerTaskName)
self.disableControlKey()
messenger.send('wakeup')
self.aimStart = None
power = self.power
angle = self.root.getH()
self.notify.debug('incrementing self.__flyBallSequenceNum')
self.__flyBallSequenceNum = (self.__flyBallSequenceNum + 1) % 255
self.sendSwingInfo(power, angle, self.__flyBallSequenceNum)
self.setSwingInfo(power, angle, self.__flyBallSequenceNum)
self.resetPowerBar()
return
def __updateBallPower(self, task):
if not self.powerBar:
print '### no power bar!!!'
return task.done
newPower = self.__getBallPower(globalClock.getFrameTime())
self.power = newPower
self.powerBar['value'] = newPower
return task.cont
def __getBallPower(self, time):
elapsed = max(time - self.aimStart, 0.0)
t = elapsed / self.golfPowerSpeed
t = math.pow(t, self.golfPowerExponent)
power = int(t * 100) % 200
if power > 100:
power = 200 - power
return power
def stopPosHprBroadcast(self):
taskName = self.posHprBroadcastName
taskMgr.remove(taskName)
def startPosHprBroadcast(self):
taskName = self.posHprBroadcastName
self.b_clearSmoothing()
self.d_sendGolfSpotPos()
taskMgr.remove(taskName)
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast,
taskName)
def __posHprBroadcast(self, task):
self.d_sendGolfSpotPos()
taskName = self.posHprBroadcastName
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast,
taskName)
return Task.done
def d_sendGolfSpotPos(self):
timestamp = globalClockDelta.getFrameNetworkTime()
self.sendUpdate(
'setGolfSpotPos',
[self.changeSeq, self.root.getH(), timestamp])
def setGolfSpotPos(self, changeSeq, h, timestamp):
self.changeSeq = changeSeq
if self.smoothStarted:
now = globalClock.getFrameTime()
local = globalClockDelta.networkToLocalTime(timestamp, now)
self.golfSpotSmoother.setH(h)
self.golfSpotSmoother.setTimestamp(local)
self.golfSpotSmoother.markPosition()
else:
self.root.setH(h)
def b_clearSmoothing(self):
self.d_clearSmoothing()
self.clearSmoothing()
def d_clearSmoothing(self):
self.sendUpdate('clearSmoothing', [0])
def clearSmoothing(self, bogus=None):
self.golfSpotSmoother.clearPositions(1)
def doSmoothTask(self, task):
self.golfSpotSmoother.computeAndApplySmoothHpr(self.root)
return Task.cont
def startSmooth(self):
if not self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.reloadPosition()
taskMgr.add(self.doSmoothTask, taskName)
self.smoothStarted = 1
def stopSmooth(self):
if self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.forceToTruePosition()
self.smoothStarted = 0
def makeToonReleaseInterval(self, toon):
def getSlideToPos(toon=toon):
return render.getRelativePoint(toon, Point3(0, -5, 0))
if self.gotHitByBoss:
grabIval = Sequence(Func(self.detachClub),
name='makeToonReleaseInterval-gotHitByBoss')
if not toon.isEmpty():
toonIval = Sequence(Func(toon.wrtReparentTo, render),
Parallel(
ActorInterval(toon, 'slip-backward'),
toon.posInterval(0.5,
getSlideToPos,
fluid=1)),
name='makeToonReleaseInterval-toonIval')
grabIval.append(toonIval)
else:
grabIval = Sequence(Func(self.detachClub))
if not toon.isEmpty():
toonIval = Sequence(
Parallel(
ActorInterval(toon,
'walk',
duration=1.0,
playRate=-1.0),
LerpPosInterval(toon,
duration=1.0,
pos=Point3(-10, 0, 0))),
Func(toon.wrtReparentTo, render))
grabIval.append(toonIval)
if localAvatar.doId == toon.doId:
if not self.goingToReward and toon.hp > 0:
grabIval.append(Func(self.goToFinalBattle))
grabIval.append(
Func(self.notify.debug, 'goingToFinalBattlemode'))
grabIval.append(Func(self.safeBossToFinalBattleMode))
return grabIval
def safeBossToFinalBattleMode(self):
if self.boss:
self.boss.toFinalBattleMode()
def goToFinalBattle(self):
if self.cr:
place = self.cr.playGame.getPlace()
if place and hasattr(place, 'fsm'):
curState = place.fsm.getCurrentState().getName()
if place.fsm.getCurrentState().getName() == 'crane':
place.setState('finalBattle')
else:
self.notify.debug('NOT going to final battle, state=%s' %
curState)
def attachClub(self, avId, pointToBall=False):
club = self.club
if club:
av = base.cr.doId2do.get(avId)
if av:
av.useLOD(1000)
lHand = av.getLeftHands()[0]
club.setPos(0, 0, 0)
club.reparentTo(lHand)
netScale = club.getNetTransform().getScale()[1]
counterActToonScale = lHand.find('**/counteractToonScale')
if counterActToonScale.isEmpty():
counterActToonScale = lHand.attachNewNode(
'counteractToonScale')
counterActToonScale.setScale(1 / netScale)
self.notify.debug('creating counterActToonScale for %s' %
av.getName())
club.reparentTo(counterActToonScale)
club.setX(-0.25 * netScale)
if pointToBall:
club.lookAt(self.clubLookatSpot)
def detachClub(self):
if not self.club.isEmpty():
self.club.reparentTo(self.root)
self.club.setZ(-20)
self.club.setScale(1)
def adjustClub(self):
club = self.club
if club:
distance = club.getDistance(self.clubLookatSpot)
scaleFactor = distance / 2.058
club.setScale(1, scaleFactor, 1)
def startAdjustClubTask(self):
taskMgr.add(self.adjustClubTask, self.adjustClubTaskName)
def stopAdjustClubTask(self):
taskMgr.remove(self.adjustClubTaskName)
def adjustClubTask(self, task):
self.attachClub(self.avId, True)
self.adjustClub()
return task.cont
def enableControlKey(self):
self.controlKeyAllowed = True
def disableControlKey(self):
self.controlKeyAllowed = False
def sendSwingInfo(self, power, angle, sequenceNum):
self.sendUpdate('setSwingInfo', [power, angle, sequenceNum])
def startBallPlayback(self, power, angle, sequenceNum):
flyBall = self.ballModel.copyTo(NodePath())
flyBall.setScale(1.0)
flyBallBubble = self.getFlyBallBubble().instanceTo(NodePath())
flyBallBubble.reparentTo(flyBall)
flyBall.setTag('pieSequence', str(sequenceNum))
flyBall.setTag('throwerId', str(self.avId))
t = power / 100.0
t = 1.0 - t
dist = 300 - 200 * t
time = 1.5 + 0.5 * t
proj = ProjectileInterval(None,
startPos=Point3(0, 0, 0),
endPos=Point3(0, dist, 0),
duration=time)
relVel = proj.startVel
def getVelocity(root=self.root, relVel=relVel):
return render.getRelativeVector(root, relVel)
fly = Sequence(
Func(flyBall.reparentTo, render),
Func(flyBall.setPosHpr, self.root, 0, 0, 0, 0, 0, 0),
Func(base.cTrav.addCollider, flyBallBubble, self.flyBallHandler),
ProjectileInterval(flyBall, startVel=getVelocity, duration=3),
Func(flyBall.detachNode),
Func(base.cTrav.removeCollider, flyBallBubble),
Func(self.notify.debug, 'removed collider'),
Func(self.flyBallFinishedFlying, sequenceNum))
flyWithSound = Parallel(fly,
SoundInterval(self.hitBallSfx, node=self.root),
name='flyWithSound')
self.notify.debug('starting flyball track')
flyWithSound.start()
self.flyBallTracks[sequenceNum] = flyWithSound
return
def setSwingInfo(self, power, angle, sequenceNum):
av = base.cr.doId2do.get(self.avId)
self.swingInterval = Sequence()
if av:
self.stopAdjustClubTask()
self.swingInterval = Sequence(
ActorInterval(av,
'swing-putt',
startFrame=0,
endFrame=GolfGlobals.BALL_CONTACT_FRAME),
Func(self.startBallPlayback, power, angle, sequenceNum),
Func(self.ballModel.hide),
ActorInterval(av,
'swing-putt',
startFrame=GolfGlobals.BALL_CONTACT_FRAME,
endFrame=24), Func(self.ballModel.setScale, 0.1),
Func(self.ballModel.show),
LerpScaleInterval(self.ballModel, 1.0, Point3(1, 1, 1)),
Func(self.enableControlKey))
if av == localAvatar:
self.swingInterval.append(
Func(self.switchToAnimState, 'GolfPuttLoop', True))
self.swingInterval.start()
def getFlyBallBubble(self):
if self.__flyBallBubble == None:
bubble = CollisionSphere(0, 0, 0, GolfGlobals.GOLF_BALL_RADIUS)
node = CollisionNode('flyBallBubble')
node.addSolid(bubble)
node.setFromCollideMask(ToontownGlobals.PieBitmask
| ToontownGlobals.CameraBitmask
| ToontownGlobals.FloorBitmask)
node.setIntoCollideMask(BitMask32.allOff())
self.__flyBallBubble = NodePath(node)
self.flyBallHandler = CollisionHandlerEvent()
self.flyBallHandler.addInPattern('flyBallHit-%d' % self.index)
return self.__flyBallBubble
def __flyBallHit(self, entry):
print entry
def flyBallFinishedFlying(self, sequence):
if self.flyBallTracks.has_key(sequence):
del self.flyBallTracks[sequence]
def __finishFlyBallTrack(self, sequence):
if self.flyBallTracks.has_key(sequence):
flyBallTrack = self.flyBallTracks[sequence]
del self.flyBallTracks[sequence]
flyBallTrack.finish()
def flyBallFinishedSplatting(self, sequence):
if self.splatTracks.has_key(sequence):
del self.splatTracks[sequence]
def __flyBallHit(self, entry):
if not entry.hasSurfacePoint() or not entry.hasInto():
return
if not entry.getInto().isTangible():
return
sequence = int(entry.getFromNodePath().getNetTag('pieSequence'))
self.__finishFlyBallTrack(sequence)
if self.splatTracks.has_key(sequence):
splatTrack = self.splatTracks[sequence]
del self.splatTracks[sequence]
splatTrack.finish()
flyBallCode = 0
flyBallCodeStr = entry.getIntoNodePath().getNetTag('pieCode')
if flyBallCodeStr:
flyBallCode = int(flyBallCodeStr)
pos = entry.getSurfacePoint(render)
timestamp32 = globalClockDelta.getFrameNetworkTime(bits=32)
throwerId = int(entry.getFromNodePath().getNetTag('throwerId'))
splat = self.getFlyBallSplatInterval(pos[0], pos[1], pos[2],
flyBallCode, throwerId)
splat = Sequence(splat, Func(self.flyBallFinishedSplatting, sequence))
self.splatTracks[sequence] = splat
splat.start()
self.notify.debug(
'doId=%d into=%s flyBallCode=%d, throwerId=%d' %
(self.doId, entry.getIntoNodePath(), flyBallCode, throwerId))
if flyBallCode == ToontownGlobals.PieCodeBossCog and self.avId == localAvatar.doId and self.lastHitSequenceNum != self.__flyBallSequenceNum:
self.lastHitSequenceNum = self.__flyBallSequenceNum
self.boss.d_ballHitBoss(10)
elif flyBallCode == ToontownGlobals.PieCodeToon and self.avId == localAvatar.doId and self.lastHitSequenceNum != self.__flyBallSequenceNum:
self.lastHitSequenceNum = self.__flyBallSequenceNum
avatarDoId = entry.getIntoNodePath().getNetTag('avatarDoId')
if avatarDoId == '':
self.notify.warning('Toon %s has no avatarDoId tag.' %
repr(entry.getIntoNodePath()))
return
doId = int(avatarDoId)
if doId != localAvatar.doId:
pass
def getFlyBallSplatInterval(self, x, y, z, flyBallCode, throwerId):
from toontown.toonbase import ToontownBattleGlobals
from toontown.battle import BattleProps
splatName = 'dust'
splat = BattleProps.globalPropPool.getProp(splatName)
splat.setBillboardPointWorld(2)
color = ToontownGlobals.PieCodeColors.get(flyBallCode)
if color:
splat.setColor(*color)
if flyBallCode == ToontownGlobals.PieCodeBossCog:
self.notify.debug('changing color to %s' % self.ballColor)
splat.setColor(self.ballColor)
sound = loader.loadSfx('phase_11/audio/sfx/LB_evidence_miss.ogg')
vol = 1.0
if flyBallCode == ToontownGlobals.PieCodeBossCog:
sound = loader.loadSfx('phase_4/audio/sfx/Golf_Hit_Barrier_1.ogg')
soundIval = SoundInterval(sound, node=splat, volume=vol)
if flyBallCode == ToontownGlobals.PieCodeBossCog and localAvatar.doId == throwerId:
vol = 1.0
soundIval = SoundInterval(sound, node=localAvatar, volume=vol)
ival = Parallel(
Func(splat.reparentTo, render), Func(splat.setPos, x, y, z),
soundIval,
Sequence(ActorInterval(splat, splatName), Func(splat.detachNode)))
return ival
def setGoingToReward(self):
self.goingToReward = True
def gotBossZapped(self):
self.showExiting()
self.d_requestFree(True)
class DistributedGolfSpot(DistributedObject.DistributedObject, FSM.FSM):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedGolfSpot')
positions = ((-45, 100, GolfGlobals.GOLF_BALL_RADIUS),
(-15, 100, GolfGlobals.GOLF_BALL_RADIUS),
(15, 100, GolfGlobals.GOLF_BALL_RADIUS),
(45, 100, GolfGlobals.GOLF_BALL_RADIUS))
toonGolfOffsetPos = Point3(-2, 0, -GolfGlobals.GOLF_BALL_RADIUS)
toonGolfOffsetHpr = Point3(-90, 0, 0)
rotateSpeed = 20
golfPowerSpeed = base.config.GetDouble('golf-power-speed', 3)
golfPowerExponent = base.config.GetDouble('golf-power-exponent', 0.75)
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
FSM.FSM.__init__(self, 'DistributedGolfSpot')
self.boss = None
self.index = None
self.avId = 0
self.toon = None
self.golfSpotSmoother = SmoothMover()
self.golfSpotSmoother.setSmoothMode(SmoothMover.SMOn)
self.smoothStarted = 0
self.__broadcastPeriod = 0.2
if self.index > len(self.positions):
self.notify.error('Invalid index %d' % index)
self.fadeTrack = None
self.setupPowerBar()
self.aimStart = None
self.golfSpotAdviceLabel = None
self.changeSeq = 0
self.lastChangeSeq = 0
self.controlKeyAllowed = False
self.flyBallTracks = {}
self.splatTracks = {}
self.__flyBallBubble = None
self.flyBallHandler = None
self.__flyBallSequenceNum = 0
self.swingInterval = None
self.lastHitSequenceNum = -1
self.goingToReward = False
self.gotHitByBoss = False
self.releaseTrack = None
self.grabTrack = None
self.restoreScaleTrack = None
return
def setBossCogId(self, bossCogId):
self.bossCogId = bossCogId
self.boss = base.cr.doId2do[bossCogId]
self.boss.setGolfSpot(self, self.index)
def setIndex(self, index):
self.index = index
def disable(self):
DistributedObject.DistributedObject.disable(self)
self.ignoreAll()
def delete(self):
DistributedObject.DistributedObject.delete(self)
self.ignoreAll()
self.boss = None
return
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
self.triggerName = self.uniqueName('trigger')
self.triggerEvent = 'enter%s' % self.triggerName
self.smoothName = self.uniqueName('golfSpotSmooth')
self.golfSpotAdviceName = self.uniqueName('golfSpotAdvice')
self.posHprBroadcastName = self.uniqueName('golfSpotBroadcast')
self.ballPowerTaskName = self.uniqueName('updateGolfPower')
self.adjustClubTaskName = self.uniqueName('adjustClub')
self.loadAssets()
self.accept('flyBallHit-%d' % self.index, self.__flyBallHit)
def loadAssets(self):
self.root = render.attachNewNode('golfSpot-%d' % self.index)
self.root.setPos(*self.positions[self.index])
self.ballModel = loader.loadModel('phase_6/models/golf/golf_ball')
self.ballColor = VBase4(1, 1, 1, 1)
if self.index < len(GolfGlobals.PlayerColors):
self.ballColor = VBase4(*GolfGlobals.PlayerColors[self.index])
self.ballModel.setColorScale(self.ballColor)
self.ballModel.reparentTo(self.root)
self.club = loader.loadModel('phase_6/models/golf/putter')
self.clubLookatSpot = self.root.attachNewNode('clubLookat')
self.clubLookatSpot.setY(-(GolfGlobals.GOLF_BALL_RADIUS + 0.1))
cs = CollisionSphere(0, 0, 0, 1)
cs.setTangible(0)
cn = CollisionNode(self.triggerName)
cn.addSolid(cs)
cn.setIntoCollideMask(ToontownGlobals.WallBitmask)
self.trigger = self.root.attachNewNode(cn)
self.trigger.stash()
self.hitBallSfx = loader.loadSfx('phase_6/audio/sfx/Golf_Hit_Ball.ogg')
def cleanup(self):
if self.swingInterval:
self.swingInterval.finish()
self.swingInterval = None
if self.releaseTrack:
self.releaseTrack.finish()
self.releaseTrack = None
flyTracks = self.flyBallTracks.values()
for track in flyTracks:
track.finish()
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
if self.restoreScaleTrack:
self.restoreScaleTrack.finish()
self.restoreScaleTrack = None
self.root.removeNode()
self.ballModel.removeNode()
self.club.removeNode()
if self.powerBar:
self.powerBar.destroy()
self.powerBar = None
taskMgr.remove(self.triggerName)
self.boss = None
return
def setState(self, state, avId, extraInfo):
if not self.isDisabled():
self.gotHitByBoss = extraInfo
if state == 'C':
self.demand('Controlled', avId)
elif state == 'F':
self.demand('Free')
elif state == 'O':
self.demand('Off')
else:
self.notify.error('Invalid state from AI: %s' % state)
def enterOff(self):
pass
def exitOff(self):
pass
def enterFree(self):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.restoreScaleTrack = Sequence(Wait(6), self.getRestoreScaleInterval(), name='restoreScaleTrack')
self.restoreScaleTrack.start()
if self.avId == localAvatar.doId:
if not self.isDisabled():
self.ballModel.setAlphaScale(0.3)
self.ballModel.setTransparency(1)
taskMgr.doMethodLater(5, self.__allowDetect, self.triggerName)
self.fadeTrack = Sequence(Func(self.ballModel.setTransparency, 1), self.ballModel.colorScaleInterval(0.2, VBase4(1, 1, 1, 0.3)), name='fadeTrack-enterFree')
self.fadeTrack.start()
else:
self.trigger.unstash()
self.accept(self.triggerEvent, self.__hitTrigger)
self.avId = 0
return
def exitFree(self):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.restoreScaleTrack.finish()
self.restoreScaleTrack = None
taskMgr.remove(self.triggerName)
self.ballModel.clearTransparency()
self.trigger.stash()
self.ignore(self.triggerEvent)
return
def enterControlled(self, avId):
self.avId = avId
toon = base.cr.doId2do.get(avId)
if not toon:
return
self.enableControlKey()
self.toon = toon
self.grabTrack = self.makeToonGrabInterval(toon)
if avId == localAvatar.doId:
self.boss.toCraneMode()
camera.reparentTo(self.root)
camera.setPosHpr(0, -10, 3, 0, 0, 0)
localAvatar.setPos(self.root, self.toonGolfOffsetPos)
localAvatar.setHpr(self.root, self.toonGolfOffsetHpr)
localAvatar.sendCurrentPosition()
self.__enableControlInterface()
self.startPosHprBroadcast()
self.accept('exitCrane', self.gotBossZapped)
self.grabTrack.start()
def exitControlled(self):
self.grabTrack.finish()
del self.grabTrack
if self.swingInterval:
self.swingInterval.finish()
self.swingInterval = None
if not self.ballModel.isEmpty():
if self.ballModel.isHidden():
self.notify.debug('ball is hidden scale =%s' % self.ballModel.getScale())
else:
self.notify.debug('ball is showing scale=%s' % self.ballModel.getScale())
if self.toon and not self.toon.isDisabled():
self.toon.startSmooth()
self.releaseTrack = self.makeToonReleaseInterval(self.toon)
self.stopPosHprBroadcast()
self.stopSmooth()
if self.avId == localAvatar.doId:
self.__disableControlInterface()
if not self.goingToReward:
camera.reparentTo(base.localAvatar)
camera.setPos(base.localAvatar.cameraPositions[0][0])
camera.setHpr(0, 0, 0)
self.stopAdjustClubTask()
self.releaseTrack.start()
self.enableControlKey()
return
def __allowDetect(self, task):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = Sequence(self.ballModel.colorScaleInterval(0.2, self.ballColor), Func(self.ballModel.clearTransparency), name='fadeTrack-allowDetect')
self.fadeTrack.start()
self.trigger.unstash()
self.accept(self.triggerEvent, self.__hitTrigger)
def __hitTrigger(self, event):
self.d_requestControl()
def getRestoreScaleInterval(self):
return Sequence()
def d_requestControl(self):
self.sendUpdate('requestControl')
def d_requestFree(self, gotHitByBoss):
self.sendUpdate('requestFree', [gotHitByBoss])
def makeToonGrabInterval(self, toon):
origPos = toon.getPos(self.root)
origHpr = toon.getHpr(self.root)
a = self.accomodateToon(toon)
newPos = toon.getPos()
newHpr = toon.getHpr()
origHpr.setX(PythonUtil.fitSrcAngle2Dest(origHpr[0], newHpr[0]))
self.notify.debug('toon.setPosHpr %s %s' % (origPos, origHpr))
toon.setPosHpr(origPos, origHpr)
walkTime = 0.2
reach = Sequence()
if reach.getDuration() < walkTime:
reach = Sequence(ActorInterval(toon, 'walk', loop=1, duration=walkTime - reach.getDuration()), reach)
i = Sequence(Parallel(toon.posInterval(walkTime, newPos, origPos), toon.hprInterval(walkTime, newHpr, origHpr), reach), Func(toon.stopLookAround))
if toon == base.localAvatar:
i.append(Func(self.switchToAnimState, 'GolfPuttLoop'))
i.append(Func(self.startAdjustClubTask))
i = Parallel(i, a)
return i
def accomodateToon(self, toon):
toon.wrtReparentTo(self.root)
toon.setPos(self.toonGolfOffsetPos)
toon.setHpr(self.toonGolfOffsetHpr)
return Sequence()
def switchToAnimState(self, animStateName, forced = False):
curAnimState = base.localAvatar.animFSM.getCurrentState()
curAnimStateName = ''
if curAnimState:
curAnimStateName = curAnimState.getName()
if curAnimStateName != animStateName or forced:
base.localAvatar.b_setAnimState(animStateName)
def __enableControlInterface(self):
gui = loader.loadModel('phase_3.5/models/gui/avatar_panel_gui')
self.closeButton = DirectButton(image=(gui.find('**/CloseBtn_UP'),
gui.find('**/CloseBtn_DN'),
gui.find('**/CloseBtn_Rllvr'),
gui.find('**/CloseBtn_UP')), relief=None, scale=2, text=TTLocalizer.BossbotGolfSpotLeave, text_scale=0.04, text_pos=(0, -0.07), text_fg=VBase4(1, 1, 1, 1), pos=(1.05, 0, -0.82), command=self.__exitGolfSpot)
self.accept('escape', self.__exitGolfSpot)
self.accept('control', self.__controlPressed)
self.accept('control-up', self.__controlReleased)
self.accept('InputState-forward', self.__upArrow)
self.accept('InputState-reverse', self.__downArrow)
self.accept('InputState-turnLeft', self.__leftArrow)
self.accept('InputState-turnRight', self.__rightArrow)
taskMgr.add(self.__watchControls, 'watchGolfSpotControls')
taskMgr.doMethodLater(5, self.__displayGolfSpotAdvice, self.golfSpotAdviceName)
self.arrowVert = 0
self.arrowHorz = 0
if self.powerBar:
self.powerBar.show()
return
def __disableControlInterface(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = None
self.__cleanupGolfSpotAdvice()
self.ignore('escape')
self.ignore('control')
self.ignore('control-up')
self.ignore('InputState-forward')
self.ignore('InputState-reverse')
self.ignore('InputState-turnLeft')
self.ignore('InputState-turnRight')
self.arrowVert = 0
self.arrowHorz = 0
taskMgr.remove('watchGolfSpotControls')
if self.powerBar:
self.powerBar.hide()
else:
self.notify.debug('self.powerBar is none')
return
def setupPowerBar(self):
self.powerBar = DirectWaitBar(pos=(0.0, 0, -0.94), relief=DGG.SUNKEN, frameSize=(-2.0,
2.0,
-0.2,
0.2), borderWidth=(0.02, 0.02), scale=0.25, range=100, sortOrder=50, frameColor=(0.5, 0.5, 0.5, 0.5), barColor=(1.0, 0.0, 0.0, 1.0), text='', text_scale=0.26, text_fg=(1, 1, 1, 1), text_align=TextNode.ACenter, text_pos=(0, -0.05))
self.power = 0
self.powerBar['value'] = self.power
self.powerBar.hide()
def resetPowerBar(self):
self.power = 0
self.powerBar['value'] = self.power
self.powerBar['text'] = ''
def __displayGolfSpotAdvice(self, task):
if self.golfSpotAdviceLabel == None:
self.golfSpotAdviceLabel = DirectLabel(text=TTLocalizer.BossbotGolfSpotAdvice, text_fg=VBase4(1, 1, 1, 1), text_align=TextNode.ACenter, relief=None, pos=(0, 0, 0.69), scale=0.1)
return
def __cleanupGolfSpotAdvice(self):
if self.golfSpotAdviceLabel:
self.golfSpotAdviceLabel.destroy()
self.golfSpotAdviceLabel = None
taskMgr.remove(self.golfSpotAdviceName)
return
def showExiting(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = DirectLabel(relief=None, text=TTLocalizer.BossbotGolfSpotLeaving, pos=(1.05, 0, -0.88), text_pos=(0, 0), text_scale=0.06, text_fg=VBase4(1, 1, 1, 1))
self.__cleanupGolfSpotAdvice()
return
def __exitGolfSpot(self):
self.d_requestFree(False)
def __controlPressed(self):
if self.controlKeyAllowed:
self.__beginFireBall()
def __controlReleased(self):
if self.controlKeyAllowed:
self.__endFireBall()
def __upArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowVert = 1
elif self.arrowVert > 0:
self.arrowVert = 0
def __downArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowVert = -1
elif self.arrowVert < 0:
self.arrowVert = 0
def __rightArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowHorz = 1
self.switchToAnimState('GolfRotateLeft')
elif self.arrowHorz > 0:
self.arrowHorz = 0
self.switchToAnimState('GolfPuttLoop')
def __leftArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowHorz = -1
self.switchToAnimState('GolfRotateRight')
elif self.arrowHorz < 0:
self.arrowHorz = 0
self.switchToAnimState('GolfPuttLoop')
def __watchControls(self, task):
if self.arrowHorz:
self.__moveGolfSpot(self.arrowHorz)
return Task.cont
def __moveGolfSpot(self, xd):
dt = globalClock.getDt()
h = self.root.getH() - xd * self.rotateSpeed * dt
h %= 360
limitH = h
self.root.setH(limitH)
def __incrementChangeSeq(self):
self.changeSeq = self.changeSeq + 1 & 255
def __beginFireBall(self):
if self.aimStart != None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
time = globalClock.getFrameTime()
self.aimStart = time
messenger.send('wakeup')
taskMgr.add(self.__updateBallPower, self.ballPowerTaskName)
return
def __endFireBall(self):
if self.aimStart == None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
taskMgr.remove(self.ballPowerTaskName)
self.disableControlKey()
messenger.send('wakeup')
self.aimStart = None
power = self.power
angle = self.root.getH()
self.notify.debug('incrementing self.__flyBallSequenceNum')
self.__flyBallSequenceNum = (self.__flyBallSequenceNum + 1) % 255
self.sendSwingInfo(power, angle, self.__flyBallSequenceNum)
self.setSwingInfo(power, angle, self.__flyBallSequenceNum)
self.resetPowerBar()
return
def __updateBallPower(self, task):
if not self.powerBar:
print '### no power bar!!!'
return task.done
newPower = self.__getBallPower(globalClock.getFrameTime())
self.power = newPower
self.powerBar['value'] = newPower
return task.cont
def __getBallPower(self, time):
elapsed = max(time - self.aimStart, 0.0)
t = elapsed / self.golfPowerSpeed
t = math.pow(t, self.golfPowerExponent)
power = int(t * 100) % 200
if power > 100:
power = 200 - power
return power
def stopPosHprBroadcast(self):
taskName = self.posHprBroadcastName
taskMgr.remove(taskName)
def startPosHprBroadcast(self):
taskName = self.posHprBroadcastName
self.b_clearSmoothing()
self.d_sendGolfSpotPos()
taskMgr.remove(taskName)
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast, taskName)
def __posHprBroadcast(self, task):
self.d_sendGolfSpotPos()
taskName = self.posHprBroadcastName
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast, taskName)
return Task.done
def d_sendGolfSpotPos(self):
timestamp = globalClockDelta.getFrameNetworkTime()
self.sendUpdate('setGolfSpotPos', [self.changeSeq, self.root.getH(), timestamp])
def setGolfSpotPos(self, changeSeq, h, timestamp):
self.changeSeq = changeSeq
if self.smoothStarted:
now = globalClock.getFrameTime()
local = globalClockDelta.networkToLocalTime(timestamp, now)
self.golfSpotSmoother.setH(h)
self.golfSpotSmoother.setTimestamp(local)
self.golfSpotSmoother.markPosition()
else:
self.root.setH(h)
def b_clearSmoothing(self):
self.d_clearSmoothing()
self.clearSmoothing()
def d_clearSmoothing(self):
self.sendUpdate('clearSmoothing', [0])
def clearSmoothing(self, bogus = None):
self.golfSpotSmoother.clearPositions(1)
def doSmoothTask(self, task):
self.golfSpotSmoother.computeAndApplySmoothHpr(self.root)
return Task.cont
def startSmooth(self):
if not self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.reloadPosition()
taskMgr.add(self.doSmoothTask, taskName)
self.smoothStarted = 1
def stopSmooth(self):
if self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.forceToTruePosition()
self.smoothStarted = 0
def makeToonReleaseInterval(self, toon):
def getSlideToPos(toon = toon):
return render.getRelativePoint(toon, Point3(0, -5, 0))
if self.gotHitByBoss:
grabIval = Sequence(Func(self.detachClub), name='makeToonReleaseInterval-gotHitByBoss')
if not toon.isEmpty():
toonIval = Sequence(Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'slip-backward'), toon.posInterval(0.5, getSlideToPos, fluid=1)), name='makeToonReleaseInterval-toonIval')
grabIval.append(toonIval)
else:
grabIval = Sequence(Func(self.detachClub))
if not toon.isEmpty():
toonIval = Sequence(Parallel(ActorInterval(toon, 'walk', duration=1.0, playRate=-1.0), LerpPosInterval(toon, duration=1.0, pos=Point3(-10, 0, 0))), Func(toon.wrtReparentTo, render))
grabIval.append(toonIval)
if localAvatar.doId == toon.doId:
if not self.goingToReward and toon.hp > 0:
grabIval.append(Func(self.goToFinalBattle))
grabIval.append(Func(self.notify.debug, 'goingToFinalBattlemode'))
grabIval.append(Func(self.safeBossToFinalBattleMode))
return grabIval
def safeBossToFinalBattleMode(self):
if self.boss:
self.boss.toFinalBattleMode()
def goToFinalBattle(self):
if self.cr:
place = self.cr.playGame.getPlace()
if place and hasattr(place, 'fsm'):
curState = place.fsm.getCurrentState().getName()
if place.fsm.getCurrentState().getName() == 'crane':
place.setState('finalBattle')
else:
self.notify.debug('NOT going to final battle, state=%s' % curState)
def attachClub(self, avId, pointToBall = False):
club = self.club
if club:
av = base.cr.doId2do.get(avId)
if av:
av.useLOD(1000)
lHand = av.getLeftHands()[0]
club.setPos(0, 0, 0)
club.reparentTo(lHand)
netScale = club.getNetTransform().getScale()[1]
counterActToonScale = lHand.find('**/counteractToonScale')
if counterActToonScale.isEmpty():
counterActToonScale = lHand.attachNewNode('counteractToonScale')
counterActToonScale.setScale(1 / netScale)
self.notify.debug('creating counterActToonScale for %s' % av.getName())
club.reparentTo(counterActToonScale)
club.setX(-0.25 * netScale)
if pointToBall:
club.lookAt(self.clubLookatSpot)
def detachClub(self):
if not self.club.isEmpty():
self.club.reparentTo(self.root)
self.club.setZ(-20)
self.club.setScale(1)
def adjustClub(self):
club = self.club
if club:
distance = club.getDistance(self.clubLookatSpot)
scaleFactor = distance / 2.058
club.setScale(1, scaleFactor, 1)
def startAdjustClubTask(self):
taskMgr.add(self.adjustClubTask, self.adjustClubTaskName)
def stopAdjustClubTask(self):
taskMgr.remove(self.adjustClubTaskName)
def adjustClubTask(self, task):
self.attachClub(self.avId, True)
self.adjustClub()
return task.cont
def enableControlKey(self):
self.controlKeyAllowed = True
def disableControlKey(self):
self.controlKeyAllowed = False
def sendSwingInfo(self, power, angle, sequenceNum):
self.sendUpdate('setSwingInfo', [power, angle, sequenceNum])
def startBallPlayback(self, power, angle, sequenceNum):
flyBall = self.ballModel.copyTo(NodePath())
flyBall.setScale(1.0)
flyBallBubble = self.getFlyBallBubble().instanceTo(NodePath())
flyBallBubble.reparentTo(flyBall)
flyBall.setTag('pieSequence', str(sequenceNum))
flyBall.setTag('throwerId', str(self.avId))
t = power / 100.0
t = 1.0 - t
dist = 300 - 200 * t
time = 1.5 + 0.5 * t
proj = ProjectileInterval(None, startPos=Point3(0, 0, 0), endPos=Point3(0, dist, 0), duration=time)
relVel = proj.startVel
def getVelocity(root = self.root, relVel = relVel):
return render.getRelativeVector(root, relVel)
fly = Sequence(Func(flyBall.reparentTo, render), Func(flyBall.setPosHpr, self.root, 0, 0, 0, 0, 0, 0), Func(base.cTrav.addCollider, flyBallBubble, self.flyBallHandler), ProjectileInterval(flyBall, startVel=getVelocity, duration=3), Func(flyBall.detachNode), Func(base.cTrav.removeCollider, flyBallBubble), Func(self.notify.debug, 'removed collider'), Func(self.flyBallFinishedFlying, sequenceNum))
flyWithSound = Parallel(fly, SoundInterval(self.hitBallSfx, node=self.root), name='flyWithSound')
self.notify.debug('starting flyball track')
flyWithSound.start()
self.flyBallTracks[sequenceNum] = flyWithSound
return
def setSwingInfo(self, power, angle, sequenceNum):
av = base.cr.doId2do.get(self.avId)
self.swingInterval = Sequence()
if av:
self.stopAdjustClubTask()
self.swingInterval = Sequence(ActorInterval(av, 'swing-putt', startFrame=0, endFrame=GolfGlobals.BALL_CONTACT_FRAME), Func(self.startBallPlayback, power, angle, sequenceNum), Func(self.ballModel.hide), ActorInterval(av, 'swing-putt', startFrame=GolfGlobals.BALL_CONTACT_FRAME, endFrame=24), Func(self.ballModel.setScale, 0.1), Func(self.ballModel.show), LerpScaleInterval(self.ballModel, 1.0, Point3(1, 1, 1)), Func(self.enableControlKey))
if av == localAvatar:
self.swingInterval.append(Func(self.switchToAnimState, 'GolfPuttLoop', True))
self.swingInterval.start()
def getFlyBallBubble(self):
if self.__flyBallBubble == None:
bubble = CollisionSphere(0, 0, 0, GolfGlobals.GOLF_BALL_RADIUS)
node = CollisionNode('flyBallBubble')
node.addSolid(bubble)
node.setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask)
node.setIntoCollideMask(BitMask32.allOff())
self.__flyBallBubble = NodePath(node)
self.flyBallHandler = CollisionHandlerEvent()
self.flyBallHandler.addInPattern('flyBallHit-%d' % self.index)
return self.__flyBallBubble
def __flyBallHit(self, entry):
print entry
def flyBallFinishedFlying(self, sequence):
if self.flyBallTracks.has_key(sequence):
del self.flyBallTracks[sequence]
def __finishFlyBallTrack(self, sequence):
if self.flyBallTracks.has_key(sequence):
flyBallTrack = self.flyBallTracks[sequence]
del self.flyBallTracks[sequence]
flyBallTrack.finish()
def flyBallFinishedSplatting(self, sequence):
if self.splatTracks.has_key(sequence):
del self.splatTracks[sequence]
def __flyBallHit(self, entry):
if not entry.hasSurfacePoint() or not entry.hasInto():
return
if not entry.getInto().isTangible():
return
sequence = int(entry.getFromNodePath().getNetTag('pieSequence'))
self.__finishFlyBallTrack(sequence)
if self.splatTracks.has_key(sequence):
splatTrack = self.splatTracks[sequence]
del self.splatTracks[sequence]
splatTrack.finish()
flyBallCode = 0
flyBallCodeStr = entry.getIntoNodePath().getNetTag('pieCode')
if flyBallCodeStr:
flyBallCode = int(flyBallCodeStr)
pos = entry.getSurfacePoint(render)
timestamp32 = globalClockDelta.getFrameNetworkTime(bits=32)
throwerId = int(entry.getFromNodePath().getNetTag('throwerId'))
splat = self.getFlyBallSplatInterval(pos[0], pos[1], pos[2], flyBallCode, throwerId)
splat = Sequence(splat, Func(self.flyBallFinishedSplatting, sequence))
self.splatTracks[sequence] = splat
splat.start()
self.notify.debug('doId=%d into=%s flyBallCode=%d, throwerId=%d' % (self.doId,
entry.getIntoNodePath(),
flyBallCode,
throwerId))
if flyBallCode == ToontownGlobals.PieCodeBossCog and self.avId == localAvatar.doId and self.lastHitSequenceNum != self.__flyBallSequenceNum:
self.lastHitSequenceNum = self.__flyBallSequenceNum
self.boss.d_ballHitBoss(1)
elif flyBallCode == ToontownGlobals.PieCodeToon and self.avId == localAvatar.doId and self.lastHitSequenceNum != self.__flyBallSequenceNum:
self.lastHitSequenceNum = self.__flyBallSequenceNum
avatarDoId = entry.getIntoNodePath().getNetTag('avatarDoId')
if avatarDoId == '':
self.notify.warning('Toon %s has no avatarDoId tag.' % repr(entry.getIntoNodePath()))
return
doId = int(avatarDoId)
if doId != localAvatar.doId:
pass
def getFlyBallSplatInterval(self, x, y, z, flyBallCode, throwerId):
from toontown.toonbase import ToontownBattleGlobals
from toontown.battle import BattleProps
splatName = 'dust'
splat = BattleProps.globalPropPool.getProp(splatName)
splat.setBillboardPointWorld(2)
color = ToontownGlobals.PieCodeColors.get(flyBallCode)
if color:
splat.setColor(*color)
if flyBallCode == ToontownGlobals.PieCodeBossCog:
self.notify.debug('changing color to %s' % self.ballColor)
splat.setColor(self.ballColor)
sound = loader.loadSfx('phase_11/audio/sfx/LB_evidence_miss.ogg')
vol = 1.0
if flyBallCode == ToontownGlobals.PieCodeBossCog:
sound = loader.loadSfx('phase_4/audio/sfx/Golf_Hit_Barrier_1.ogg')
soundIval = SoundInterval(sound, node=splat, volume=vol)
if flyBallCode == ToontownGlobals.PieCodeBossCog and localAvatar.doId == throwerId:
vol = 1.0
soundIval = SoundInterval(sound, node=localAvatar, volume=vol)
ival = Parallel(Func(splat.reparentTo, render), Func(splat.setPos, x, y, z), soundIval, Sequence(ActorInterval(splat, splatName), Func(splat.detachNode)))
return ival
def setGoingToReward(self):
self.goingToReward = True
def gotBossZapped(self):
self.showExiting()
self.d_requestFree(True)
class DistributedCogThiefGame(DistributedMinigame):
notify = directNotify.newCategory('DistributedCogThiefGame')
ToonSpeed = CTGG.ToonSpeed
StageHalfWidth = 200.0
StageHalfHeight = 100.0
BarrelScale = 0.3
TOON_Z = 0
UPDATE_SUITS_TASK = 'CogThiefGameUpdateSuitsTask'
REWARD_COUNTDOWN_TASK = 'cogThiefGameRewardCountdown'
ControlKeyLimitTime = 1.0
def __init__(self, cr):
DistributedMinigame.__init__(self, cr)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedCogThiefGame', [
State.State('off', self.enterOff, self.exitOff, ['play']),
State.State('play', self.enterPlay, self.exitPlay, ['cleanup']),
State.State('cleanup', self.enterCleanup, self.exitCleanup, [])
], 'off', 'cleanup')
self.addChildGameFSM(self.gameFSM)
toon = base.localAvatar
camera.reparentTo(toon)
camera.setPos(0, -15, 5)
camera.setHpr(0, -5, 0)
self.barrels = []
self.cogInfo = {}
self.lastTimeControlPressed = 0
self.stolenBarrels = []
self.useOrthoWalk = config.GetBool('cog-thief-ortho', 0)
self.resultIval = None
self.gameIsEnding = False
self.__textGen = TextNode('cogThiefGame')
self.__textGen.setFont(ToontownGlobals.getSignFont())
self.__textGen.setAlign(TextNode.ACenter)
return
def getTitle(self):
return TTLocalizer.CogThiefGameTitle
def getInstructions(self):
return TTLocalizer.CogThiefGameInstructions
def getMaxDuration(self):
return 0
def load(self):
self.notify.debug('load')
DistributedMinigame.load(self)
self.music = base.loader.loadMusic('phase_4/audio/bgm/MG_CogThief.ogg')
self.initCogInfo()
for barrelIndex in range(CTGG.NumBarrels):
barrel = loader.loadModel(
'phase_4/models/minigames/cogthief_game_gagTank')
barrel.setPos(CTGG.BarrelStartingPositions[barrelIndex])
barrel.setScale(self.BarrelScale)
barrel.reparentTo(render)
barrel.setTag('barrelIndex', str(barrelIndex))
collSphere = CollisionSphere(0, 0, 0, 4)
collSphere.setTangible(0)
name = 'BarrelSphere-%d' % barrelIndex
collSphereName = self.uniqueName(name)
collNode = CollisionNode(collSphereName)
collNode.setFromCollideMask(CTGG.BarrelBitmask)
collNode.addSolid(collSphere)
colNp = barrel.attachNewNode(collNode)
handler = CollisionHandlerEvent()
handler.setInPattern('barrelHit-%fn')
base.cTrav.addCollider(colNp, handler)
self.accept('barrelHit-' + collSphereName, self.handleEnterBarrel)
nodeToHide = '**/gagMoneyTen'
if barrelIndex % 2:
nodeToHide = '**/gagMoneyFive'
iconToHide = barrel.find(nodeToHide)
if not iconToHide.isEmpty():
iconToHide.hide()
self.barrels.append(barrel)
self.gameBoard = loader.loadModel(
'phase_8/models/minigames/tag_arena_DG')
self.sky = loader.loadModel('phase_3.5/models/props/TT_sky')
self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0)
self.gameBoard.setScale(1.0)
self.sky.setPosHpr(0, 0, -47, 0, 0, 0)
self.sky.setScale(1.0)
self.toonSDs = {}
avId = self.localAvId
toonSD = CogThiefGameToonSD.CogThiefGameToonSD(avId, self)
self.toonSDs[avId] = toonSD
toonSD.load()
self.loadCogs()
self.toonHitTracks = {}
self.toonPieTracks = {}
self.sndOof = base.loader.loadSfx(
'phase_4/audio/sfx/MG_cannon_hit_dirt.ogg')
self.sndRewardTick = base.loader.loadSfx(
'phase_3.5/audio/sfx/tick_counter.ogg')
self.sndPerfect = base.loader.loadSfx(
'phase_4/audio/sfx/ring_perfect.ogg')
self.timer = ToontownTimer.ToontownTimer()
self.timer.posInTopRightCorner()
self.timer.hide()
purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui')
self.jarImage = purchaseModels.find('**/Jar')
self.jarImage.reparentTo(hidden)
self.rewardPanel = DirectLabel(parent=hidden,
relief=None,
pos=(-0.173, -1.2, -0.55),
scale=0.65,
text='',
text_scale=0.2,
text_fg=(0.95, 0.95, 0, 1),
text_pos=(0, -0.13),
text_font=ToontownGlobals.getSignFont(),
image=self.jarImage)
self.rewardPanelTitle = DirectLabel(parent=self.rewardPanel,
relief=None,
pos=(0, 0, 0.06),
scale=0.08,
text=TTLocalizer.CannonGameReward,
text_fg=(0.95, 0.95, 0, 1),
text_shadow=(0, 0, 0, 1))
return
def unload(self):
self.notify.debug('unload')
DistributedMinigame.unload(self)
del self.music
self.removeChildGameFSM(self.gameFSM)
del self.gameFSM
self.gameBoard.removeNode()
self.sky.removeNode()
del self.gameBoard
for barrel in self.barrels:
barrel.removeNode()
del self.barrels
for avId in self.toonSDs.keys():
toonSD = self.toonSDs[avId]
toonSD.unload()
del self.toonSDs
self.timer.destroy()
del self.timer
self.rewardPanel.destroy()
del self.rewardPanel
self.jarImage.removeNode()
del self.jarImage
del self.sndRewardTick
def onstage(self):
self.notify.debug('onstage')
DistributedMinigame.onstage(self)
self.gameBoard.reparentTo(render)
self.sky.reparentTo(render)
lt = base.localAvatar
lt.reparentTo(render)
self.__placeToon(self.localAvId)
lt.setSpeed(0, 0)
toonSD = self.toonSDs[self.localAvId]
toonSD.enter()
toonSD.fsm.request('normal')
self.stopGameWalk()
for cogIndex in xrange(self.getNumCogs()):
suit = self.cogInfo[cogIndex]['suit'].suit
pos = self.cogInfo[cogIndex]['pos']
suit.reparentTo(self.gameBoard)
suit.setPos(pos)
for avId in self.avIdList:
self.toonHitTracks[avId] = Wait(0.1)
self.toonRNGs = []
for i in xrange(self.numPlayers):
self.toonRNGs.append(RandomNumGen.RandomNumGen(self.randomNumGen))
self.sndTable = {
'hitBySuit': [None] * self.numPlayers,
'falling': [None] * self.numPlayers
}
for i in xrange(self.numPlayers):
self.sndTable['hitBySuit'][i] = base.loader.loadSfx(
'phase_4/audio/sfx/MG_Tag_C.ogg')
self.sndTable['falling'][i] = base.loader.loadSfx(
'phase_4/audio/sfx/MG_cannon_whizz.ogg')
base.playMusic(self.music, looping=1, volume=0.8)
return
def offstage(self):
self.notify.debug('offstage')
self.gameBoard.hide()
self.music.stop()
for barrel in self.barrels:
barrel.hide()
for avId in self.toonSDs.keys():
self.toonSDs[avId].exit()
for avId in self.avIdList:
av = self.getAvatar(avId)
if av:
av.resetLOD()
self.timer.reparentTo(hidden)
self.rewardPanel.reparentTo(hidden)
DistributedMinigame.offstage(self)
def handleDisabledAvatar(self, avId):
self.notify.debug('handleDisabledAvatar')
self.notify.debug('avatar ' + str(avId) + ' disabled')
self.toonSDs[avId].exit(unexpectedExit=True)
del self.toonSDs[avId]
DistributedMinigame.handleDisabledAvatar(self, avId)
def setGameReady(self):
if not self.hasLocalToon:
return
self.notify.debug('setGameReady')
if DistributedMinigame.setGameReady(self):
return
for avId in self.remoteAvIdList:
toon = self.getAvatar(avId)
if toon:
toon.reparentTo(render)
self.__placeToon(avId)
toon.useLOD(1000)
toonSD = CogThiefGameToonSD.CogThiefGameToonSD(avId, self)
self.toonSDs[avId] = toonSD
toonSD.load()
toonSD.enter()
toonSD.fsm.request('normal')
toon.startSmooth()
def setGameStart(self, timestamp):
if not self.hasLocalToon:
return
self.notify.debug('setGameStart')
DistributedMinigame.setGameStart(self, timestamp)
if not config.GetBool('cog-thief-endless', 0):
self.timer.show()
self.timer.countdown(CTGG.GameTime, self.__gameTimerExpired)
self.clockStopTime = None
self.rewardPanel.reparentTo(base.a2dTopRight)
self.scoreMult = MinigameGlobals.getScoreMult(self.cr.playGame.hood.id)
self.__startRewardCountdown()
self.gameFSM.request('play')
return
def enterOff(self):
self.notify.debug('enterOff')
def exitOff(self):
pass
def enterPlay(self):
self.notify.debug('enterPlay')
self.startGameWalk()
self.spawnUpdateSuitsTask()
self.accept('delete', self.controlKeyPressed)
self.accept('insert', self.controlKeyPressed)
self.accept('alt', self.controlKeyPressed)
self.pieHandler = CollisionHandlerEvent()
self.pieHandler.setInPattern('pieHit-%fn')
def exitPlay(self):
self.ignore('control')
if self.resultIval and self.resultIval.isPlaying():
self.resultIval.finish()
self.resultIval = None
return
def enterCleanup(self):
self.__killRewardCountdown()
if hasattr(self, 'jarIval'):
self.jarIval.finish()
del self.jarIval
for key in self.toonHitTracks:
ival = self.toonHitTracks[key]
if ival.isPlaying():
ival.finish()
self.toonHitTracks = {}
for key in self.toonPieTracks:
ival = self.toonPieTracks[key]
if ival.isPlaying():
ival.finish()
self.toonPieTracks = {}
for key in self.cogInfo:
cogThief = self.cogInfo[key]['suit']
cogThief.cleanup()
self.removeUpdateSuitsTask()
self.notify.debug('enterCleanup')
def exitCleanup(self):
pass
def __placeToon(self, avId):
toon = self.getAvatar(avId)
if toon:
index = self.avIdList.index(avId)
toon.setPos(CTGG.ToonStartingPositions[index])
toon.setHpr(CTGG.ToonStartingRotations[index])
def moveCameraToTop(self):
camera.reparentTo(render)
p = self.cameraTopView
camera.setPosHpr(p[0], p[1], p[2], p[3], p[4], p[5])
camera.setZ(camera.getZ() +
config.GetFloat('cog-thief-z-camera-adjust', 0.0))
def destroyGameWalk(self):
self.notify.debug('destroyOrthoWalk')
if self.useOrthoWalk:
self.gameWalk.destroy()
del self.gameWalk
else:
self.notify.debug('TODO destroyGameWalk')
def initGameWalk(self):
self.notify.debug('startOrthoWalk')
if self.useOrthoWalk:
def doCollisions(oldPos, newPos, self=self):
x = bound(newPos[0], CTGG.StageHalfWidth, -CTGG.StageHalfWidth)
y = bound(newPos[1], CTGG.StageHalfHeight,
-CTGG.StageHalfHeight)
newPos.setX(x)
newPos.setY(y)
return newPos
orthoDrive = OrthoDrive(self.ToonSpeed,
customCollisionCallback=doCollisions,
instantTurn=True)
self.gameWalk = OrthoWalk(orthoDrive,
broadcast=not self.isSinglePlayer())
else:
self.gameWalk = CogThiefWalk.CogThiefWalk('walkDone')
forwardSpeed = self.ToonSpeed / 2.0
base.mouseInterfaceNode.setForwardSpeed(forwardSpeed)
multiplier = forwardSpeed / ToontownGlobals.ToonForwardSpeed
base.mouseInterfaceNode.setRotateSpeed(
ToontownGlobals.ToonRotateSpeed * 4)
def initCogInfo(self):
for cogIndex in xrange(self.getNumCogs()):
self.cogInfo[cogIndex] = {
'pos': Point3(CTGG.CogStartingPositions[cogIndex]),
'goal': CTGG.NoGoal,
'goalId': CTGG.InvalidGoalId,
'suit': None
}
return
def loadCogs(self):
suitTypes = ['ds', 'ac', 'bc', 'ms']
for suitIndex in xrange(self.getNumCogs()):
st = base.cr.newsManager.getInvadingSuit()
if not st:
st = self.randomNumGen.choice(suitTypes)
suit = CogThief.CogThief(suitIndex, st, self, self.getCogSpeed())
self.cogInfo[suitIndex]['suit'] = suit
def handleEnterSphere(self, colEntry):
if self.gameIsEnding:
return
intoName = colEntry.getIntoNodePath().getName()
fromName = colEntry.getFromNodePath().getName()
debugInto = intoName.split('/')
debugFrom = fromName.split('/')
self.notify.debug(
'handleEnterSphere gametime=%s %s into %s' %
(self.getCurrentGameTime(), debugFrom[(-1)], debugInto[(-1)]))
intoName = colEntry.getIntoNodePath().getName()
if 'CogThiefSphere' in intoName:
parts = intoName.split('-')
suitNum = int(parts[1])
self.localToonHitBySuit(suitNum)
def localToonHitBySuit(self, suitNum):
self.notify.debug('localToonHitBySuit %d' % suitNum)
timestamp = globalClockDelta.localToNetworkTime(
globalClock.getFrameTime(), bits=32)
pos = self.cogInfo[suitNum]['suit'].suit.getPos()
self.sendUpdate(
'hitBySuit',
[self.localAvId, timestamp, suitNum, pos[0], pos[1], pos[2]])
self.showToonHitBySuit(self.localAvId, timestamp)
self.makeSuitRespondToToonHit(timestamp, suitNum)
def hitBySuit(self, avId, timestamp, suitNum, x, y, z):
if not self.hasLocalToon:
return
if self.gameFSM.getCurrentState().getName() not in ('play', ):
self.notify.warning('ignoring msg: av %s hit by suit' % avId)
return
if self.gameIsEnding:
return
self.notify.debug('avatar ' + ` avId ` + ' hit by a suit')
if avId != self.localAvId:
self.showToonHitBySuit(avId, timestamp)
self.makeSuitRespondToToonHit(timestamp, suitNum)
def showToonHitBySuit(self, avId, timestamp):
toon = self.getAvatar(avId)
if toon == None:
return
rng = self.toonRNGs[self.avIdList.index(avId)]
curPos = toon.getPos(render)
oldTrack = self.toonHitTracks[avId]
if oldTrack.isPlaying():
oldTrack.finish()
toon.setPos(curPos)
toon.setZ(self.TOON_Z)
parentNode = render.attachNewNode('mazeFlyToonParent-' + ` avId `)
parentNode.setPos(toon.getPos())
toon.reparentTo(parentNode)
toon.setPos(0, 0, 0)
startPos = parentNode.getPos()
dropShadow = toon.dropShadow.copyTo(parentNode)
dropShadow.setScale(toon.dropShadow.getScale(render))
trajectory = Trajectory.Trajectory(0,
Point3(0, 0, 0),
Point3(0, 0, 50),
gravMult=1.0)
oldFlyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
trajectory = Trajectory.Trajectory(0,
Point3(0, 0, 0),
Point3(0, 0, 40),
gravMult=1.0)
flyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
avIndex = self.avIdList.index(avId)
endPos = CTGG.ToonStartingPositions[avIndex]
def flyFunc(t,
trajectory,
startPos=startPos,
endPos=endPos,
dur=flyDur,
moveNode=parentNode,
flyNode=toon):
u = t / dur
moveNode.setX(startPos[0] + u * (endPos[0] - startPos[0]))
moveNode.setY(startPos[1] + u * (endPos[1] - startPos[1]))
flyNode.setPos(trajectory.getPos(t))
flyTrack = Sequence(LerpFunctionInterval(flyFunc,
fromData=0.0,
toData=flyDur,
duration=flyDur,
extraArgs=[trajectory]),
name=toon.uniqueName('hitBySuit-fly'))
geomNode = toon.getGeomNode()
startHpr = geomNode.getHpr()
destHpr = Point3(startHpr)
hRot = rng.randrange(1, 8)
if rng.choice([0, 1]):
hRot = -hRot
destHpr.setX(destHpr[0] + hRot * 360)
spinHTrack = Sequence(LerpHprInterval(geomNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(geomNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinH'))
parent = geomNode.getParent()
rotNode = parent.attachNewNode('rotNode')
geomNode.reparentTo(rotNode)
rotNode.setZ(toon.getHeight() / 2.0)
oldGeomNodeZ = geomNode.getZ()
geomNode.setZ(-toon.getHeight() / 2.0)
startHpr = rotNode.getHpr()
destHpr = Point3(startHpr)
pRot = rng.randrange(1, 3)
if rng.choice([0, 1]):
pRot = -pRot
destHpr.setY(destHpr[1] + pRot * 360)
spinPTrack = Sequence(LerpHprInterval(rotNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(rotNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinP'))
i = self.avIdList.index(avId)
soundTrack = Sequence(Func(base.playSfx,
self.sndTable['hitBySuit'][i]),
Wait(flyDur * (2.0 / 3.0)),
SoundInterval(self.sndTable['falling'][i],
duration=flyDur * (1.0 / 3.0)),
name=toon.uniqueName('hitBySuit-soundTrack'))
def preFunc(self=self, avId=avId, toon=toon, dropShadow=dropShadow):
forwardSpeed = toon.forwardSpeed
rotateSpeed = toon.rotateSpeed
if avId == self.localAvId:
self.stopGameWalk()
else:
toon.stopSmooth()
if forwardSpeed or rotateSpeed:
toon.setSpeed(forwardSpeed, rotateSpeed)
toon.dropShadow.hide()
def postFunc(self=self,
avId=avId,
oldGeomNodeZ=oldGeomNodeZ,
dropShadow=dropShadow,
parentNode=parentNode):
if avId == self.localAvId:
base.localAvatar.setPos(endPos)
if hasattr(self, 'gameWalk'):
toon = base.localAvatar
toon.setSpeed(0, 0)
self.startGameWalk()
dropShadow.removeNode()
del dropShadow
toon = self.getAvatar(avId)
if toon:
toon.dropShadow.show()
geomNode = toon.getGeomNode()
rotNode = geomNode.getParent()
baseNode = rotNode.getParent()
geomNode.reparentTo(baseNode)
rotNode.removeNode()
del rotNode
geomNode.setZ(oldGeomNodeZ)
if toon:
toon.reparentTo(render)
toon.setPos(endPos)
parentNode.removeNode()
del parentNode
if avId != self.localAvId:
if toon:
toon.startSmooth()
preFunc()
slipBack = Parallel(
Sequence(ActorInterval(toon, 'slip-backward', endFrame=24),
ActorInterval(toon, 'slip-backward', startFrame=24)))
if toon.doId == self.localAvId:
slipBack.append(SoundInterval(self.sndOof))
hitTrack = Sequence(Parallel(flyTrack, spinHTrack, spinPTrack,
soundTrack),
slipBack,
Func(postFunc),
name=toon.uniqueName('hitBySuit'))
self.notify.debug('hitTrack duration = %s' % hitTrack.getDuration())
self.toonHitTracks[avId] = hitTrack
hitTrack.start(globalClockDelta.localElapsedTime(timestamp))
return
def updateSuitGoal(self, timestamp, inResponseToClientStamp, suitNum,
goalType, goalId, x, y, z):
if not self.hasLocalToon:
return
self.notify.debug(
'updateSuitGoal gameTime=%s timeStamp=%s cog=%s goal=%s goalId=%s (%.1f, %.1f,%.1f)'
% (self.getCurrentGameTime(), timestamp, suitNum,
CTGG.GoalStr[goalType], goalId, x, y, z))
cog = self.cogInfo[suitNum]
cog['goal'] = goalType
cog['goalId'] = goalId
newPos = Point3(x, y, z)
cog['pos'] = newPos
suit = cog['suit']
suit.updateGoal(timestamp, inResponseToClientStamp, goalType, goalId,
newPos)
def spawnUpdateSuitsTask(self):
self.notify.debug('spawnUpdateSuitsTask')
for cogIndex in self.cogInfo:
suit = self.cogInfo[cogIndex]['suit']
suit.gameStart(self.gameStartTime)
taskMgr.remove(self.UPDATE_SUITS_TASK)
taskMgr.add(self.updateSuitsTask, self.UPDATE_SUITS_TASK)
def removeUpdateSuitsTask(self):
taskMgr.remove(self.UPDATE_SUITS_TASK)
def updateSuitsTask(self, task):
if self.gameIsEnding:
return task.done
for cogIndex in self.cogInfo:
suit = self.cogInfo[cogIndex]['suit']
suit.think()
return task.cont
def makeSuitRespondToToonHit(self, timestamp, suitNum):
cog = self.cogInfo[suitNum]['suit']
cog.respondToToonHit(timestamp)
def handleEnterBarrel(self, colEntry):
if self.gameIsEnding:
return
intoName = colEntry.getIntoNodePath().getName()
fromName = colEntry.getFromNodePath().getName()
debugInto = intoName.split('/')
debugFrom = fromName.split('/')
self.notify.debug(
'handleEnterBarrel gameTime=%s %s into %s' %
(self.getCurrentGameTime(), debugFrom[(-1)], debugInto[(-1)]))
if 'CogThiefSphere' in intoName:
parts = intoName.split('-')
cogIndex = int(parts[1])
barrelName = colEntry.getFromNodePath().getName()
barrelParts = barrelName.split('-')
barrelIndex = int(barrelParts[1])
cog = self.cogInfo[cogIndex]['suit']
if cog.barrel == CTGG.NoBarrelCarried and barrelIndex not in self.stolenBarrels:
timestamp = globalClockDelta.localToNetworkTime(
globalClock.getFrameTime(), bits=32)
if cog.suit:
cogPos = cog.suit.getPos()
collisionPos = colEntry.getContactPos(render)
if (cogPos - collisionPos).length() > 4:
import pdb
pdb.set_trace()
self.sendUpdate('cogHitBarrel', [
timestamp, cogIndex, barrelIndex, cogPos[0], cogPos[1],
cogPos[2]
])
def makeCogCarryBarrel(self, timestamp, inResponseToClientStamp, cogIndex,
barrelIndex, x, y, z):
if not self.hasLocalToon:
return
if self.gameIsEnding:
return
self.notify.debug(
'makeCogCarryBarrel gameTime=%s timeStamp=%s cog=%s barrel=%s (%.1f, %.1f,%.1f)'
% (self.getCurrentGameTime(), timestamp, cogIndex, barrelIndex, x,
y, z))
barrel = self.barrels[barrelIndex]
self.notify.debug('barrelPos= %s' % barrel.getPos())
cog = self.cogInfo[cogIndex]['suit']
cogPos = Point3(x, y, z)
cog.makeCogCarryBarrel(timestamp, inResponseToClientStamp, barrel,
barrelIndex, cogPos)
def makeCogDropBarrel(self, timestamp, inResponseToClientStamp, cogIndex,
barrelIndex, x, y, z):
if not self.hasLocalToon:
return
self.notify.debug(
'makeCogDropBarrel gameTime=%s timeStamp=%s cog=%s barrel=%s (%.1f, %.1f,%.1f)'
% (self.getCurrentGameTime(), timestamp, cogIndex, barrelIndex, x,
y, z))
barrel = self.barrels[barrelIndex]
self.notify.debug('barrelPos= %s' % barrel.getPos())
cog = self.cogInfo[cogIndex]['suit']
cogPos = Point3(x, y, z)
cog.makeCogDropBarrel(timestamp, inResponseToClientStamp, barrel,
barrelIndex, cogPos)
def controlKeyPressed(self):
if self.isToonPlayingHitTrack(self.localAvId):
return
if self.gameIsEnding:
return
if self.getCurrentGameTime(
) - self.lastTimeControlPressed > self.ControlKeyLimitTime:
self.lastTimeControlPressed = self.getCurrentGameTime()
self.notify.debug('controlKeyPressed')
toonSD = self.toonSDs[self.localAvId]
curState = toonSD.fsm.getCurrentState().getName()
toon = self.getAvatar(self.localAvId)
timestamp = globalClockDelta.localToNetworkTime(
globalClock.getFrameTime(), bits=32)
pos = toon.getPos()
heading = toon.getH()
self.sendUpdate(
'throwingPie',
[self.localAvId, timestamp, heading, pos[0], pos[1], pos[2]])
self.showToonThrowingPie(self.localAvId, timestamp, heading, pos)
def throwingPie(self, avId, timestamp, heading, x, y, z):
if not self.hasLocalToon:
return
if self.gameFSM.getCurrentState().getName() not in ('play', ):
self.notify.warning('ignoring msg: av %s hit by suit' % avId)
return
self.notify.debug('avatar ' + ` avId ` + ' throwing pie')
if avId != self.localAvId:
pos = Point3(x, y, z)
self.showToonThrowingPie(avId, timestamp, heading, pos)
def showToonThrowingPie(self, avId, timestamp, heading, pos):
toon = self.getAvatar(avId)
if toon:
tossTrack, pieTrack, flyPie = self.getTossPieInterval(
toon, pos[0], pos[1], pos[2], heading, 0, 0, 0)
def removePieFromTraverser(flyPie=flyPie):
if base.cTrav:
if flyPie:
base.cTrav.removeCollider(flyPie)
if avId == self.localAvId:
flyPie.setTag('throwerId', str(avId))
collSphere = CollisionSphere(0, 0, 0, 0.5)
collSphere.setTangible(0)
name = 'PieSphere-%d' % avId
collSphereName = self.uniqueName(name)
collNode = CollisionNode(collSphereName)
collNode.setFromCollideMask(ToontownGlobals.PieBitmask)
collNode.addSolid(collSphere)
colNp = flyPie.attachNewNode(collNode)
colNp.show()
base.cTrav.addCollider(colNp, self.pieHandler)
self.accept('pieHit-' + collSphereName, self.handlePieHitting)
def matchRunningAnim(toon=toon):
toon.playingAnim = None
toon.setSpeed(toon.forwardSpeed, toon.rotateSpeed)
return
newTossTrack = Sequence(tossTrack, Func(matchRunningAnim))
pieTrack = Parallel(newTossTrack, pieTrack)
elapsedTime = globalClockDelta.localElapsedTime(timestamp)
if elapsedTime < 16.0 / 24.0:
elapsedTime = 16.0 / 24.0
pieTrack.start(elapsedTime)
self.toonPieTracks[avId] = pieTrack
def getTossPieInterval(self,
toon,
x,
y,
z,
h,
p,
r,
power,
beginFlyIval=Sequence()):
from toontown.toonbase import ToontownBattleGlobals
from toontown.battle import BattleProps
pie = toon.getPieModel()
pie.setScale(0.9)
flyPie = pie.copyTo(NodePath('a'))
pieName = ToontownBattleGlobals.pieNames[toon.pieType]
pieType = BattleProps.globalPropPool.getPropType(pieName)
animPie = Sequence()
if pieType == 'actor':
animPie = ActorInterval(pie, pieName, startFrame=48)
sound = loader.loadSfx('phase_3.5/audio/sfx/AA_pie_throw_only.ogg')
t = power / 100.0
dist = 100 - 70 * t
time = 1 + 0.5 * t
proj = ProjectileInterval(None,
startPos=Point3(0, 0, 0),
endPos=Point3(0, dist, 0),
duration=time)
relVel = proj.startVel
def getVelocity(toon=toon, relVel=relVel):
return render.getRelativeVector(toon, relVel) * 0.6
toss = Track(
(0,
Sequence(
Func(toon.setPosHpr, x, y, z, h, p, r),
Func(pie.reparentTo, toon.rightHand),
Func(pie.setPosHpr, 0, 0, 0, 0, 0, 0),
Parallel(
ActorInterval(
toon, 'throw', startFrame=48, partName='torso'),
animPie), Func(toon.loop, 'neutral'))),
(16.0 / 24.0, Func(pie.detachNode)))
fly = Track(
(14.0 / 24.0, SoundInterval(sound, node=toon)),
(16.0 / 24.0,
Sequence(
Func(flyPie.reparentTo, render),
Func(flyPie.setPosHpr, toon, 0.52, 0.97, 2.24, 0, -45, 0),
beginFlyIval,
ProjectileInterval(flyPie, startVel=getVelocity, duration=6),
Func(flyPie.detachNode))))
return (toss, fly, flyPie)
def handlePieHitting(self, colEntry):
if self.gameIsEnding:
return
into = colEntry.getIntoNodePath()
intoName = into.getName()
if 'CogThiefPieSphere' in intoName:
timestamp = globalClockDelta.localToNetworkTime(
globalClock.getFrameTime(), bits=32)
parts = intoName.split('-')
suitNum = int(parts[1])
pos = self.cogInfo[suitNum]['suit'].suit.getPos()
if pos in CTGG.CogStartingPositions:
self.notify.debug('Cog %d hit at starting pos %s, ignoring' %
(suitNum, pos))
else:
self.sendUpdate('pieHitSuit', [
self.localAvId, timestamp, suitNum, pos[0], pos[1], pos[2]
])
self.makeSuitRespondToPieHit(timestamp, suitNum)
def pieHitSuit(self, avId, timestamp, suitNum, x, y, z):
if not self.hasLocalToon:
return
if self.gameFSM.getCurrentState().getName() not in ('play', ):
self.notify.warning('ignoring msg: av %s hit by suit' % avId)
return
if self.gameIsEnding:
return
self.notify.debug('avatar ' + ` avId ` + ' hit by a suit')
if avId != self.localAvId:
self.makeSuitRespondToPieHit(timestamp, suitNum)
def makeSuitRespondToPieHit(self, timestamp, suitNum):
cog = self.cogInfo[suitNum]['suit']
cog.respondToPieHit(timestamp)
def sendCogAtReturnPos(self, cogIndex, barrelIndex):
timestamp = globalClockDelta.localToNetworkTime(
globalClock.getFrameTime(), bits=32)
self.sendUpdate('cogAtReturnPos', [timestamp, cogIndex, barrelIndex])
def markBarrelStolen(self, timestamp, inResponseToClientStamp,
barrelIndex):
if not self.hasLocalToon:
return
if barrelIndex not in self.stolenBarrels:
self.stolenBarrels.append(barrelIndex)
barrel = self.barrels[barrelIndex]
barrel.hide()
if config.GetBool('cog-thief-check-barrels', 1):
if not config.GetBool('cog-thief-endless', 0):
if len(self.stolenBarrels) == len(self.barrels):
localStamp = globalClockDelta.networkToLocalTime(timestamp,
bits=32)
gameTime = self.local2GameTime(localStamp)
self.clockStopTime = gameTime
self.notify.debug('clockStopTime = %s' % gameTime)
score = int(self.scoreMult * CTGG.calcScore(gameTime) +
0.5)
self.rewardPanel['text'] = str(score)
self.showResults()
def __gameTimerExpired(self):
self.notify.debug('game timer expired')
self.showResults()
def __startRewardCountdown(self):
taskMgr.remove(self.REWARD_COUNTDOWN_TASK)
taskMgr.add(self.__updateRewardCountdown, self.REWARD_COUNTDOWN_TASK)
def __killRewardCountdown(self):
taskMgr.remove(self.REWARD_COUNTDOWN_TASK)
def __updateRewardCountdown(self, task):
curTime = self.getCurrentGameTime()
if self.clockStopTime is not None:
if self.clockStopTime < curTime:
self.notify.debug('self.clockStopTime < curTime %s %s' %
(self.clockStopTime, curTime))
self.__killRewardCountdown()
curTime = self.clockStopTime
if curTime > CTGG.GameTime:
curTime = CTGG.GameTime
score = int(self.scoreMult * CTGG.calcScore(curTime) + 0.5)
if not hasattr(task, 'curScore'):
task.curScore = score
result = Task.cont
if hasattr(self, 'rewardPanel'):
self.rewardPanel['text'] = str(score)
if task.curScore != score:
if hasattr(self, 'jarIval'):
self.jarIval.finish()
s = self.rewardPanel.getScale()
self.jarIval = Parallel(Sequence(
self.rewardPanel.scaleInterval(0.15,
s * 3.0 / 4.0,
blendType='easeOut'),
self.rewardPanel.scaleInterval(0.15, s,
blendType='easeIn')),
SoundInterval(self.sndRewardTick),
name='cogThiefGameRewardJarThrob')
self.jarIval.start()
task.curScore = score
else:
result = Task.done
return result
def startGameWalk(self):
if self.useOrthoWalk:
self.gameWalk.start()
else:
self.gameWalk.enter()
self.gameWalk.fsm.request('walking')
def stopGameWalk(self):
if self.useOrthoWalk:
self.gameWalk.stop()
else:
self.gameWalk.exit()
def getCogThief(self, cogIndex):
return self.cogInfo[cogIndex]['suit']
def isToonPlayingHitTrack(self, avId):
if avId in self.toonHitTracks:
track = self.toonHitTracks[avId]
if track.isPlaying():
return True
return False
def getNumCogs(self):
result = config.GetInt('cog-thief-num-cogs', 0)
if not result:
safezone = self.getSafezoneId()
result = CTGG.calculateCogs(self.numPlayers, safezone)
return result
def getCogSpeed(self):
result = 6.0
safezone = self.getSafezoneId()
result = CTGG.calculateCogSpeed(self.numPlayers, safezone)
return result
def showResults(self):
if not self.gameIsEnding:
self.gameIsEnding = True
for barrel in self.barrels:
barrel.wrtReparentTo(render)
for key in self.cogInfo:
thief = self.cogInfo[key]['suit']
thief.suit.setPos(100, 0, 0)
thief.suit.hide()
self.__killRewardCountdown()
self.stopGameWalk()
numBarrelsSaved = len(self.barrels) - len(self.stolenBarrels)
resultStr = ''
if numBarrelsSaved == len(self.barrels):
resultStr = TTLocalizer.CogThiefPerfect
else:
if numBarrelsSaved > 1:
resultStr = TTLocalizer.CogThiefBarrelsSaved % {
'num': numBarrelsSaved
}
else:
if numBarrelsSaved == 1:
resultStr = TTLocalizer.CogThiefBarrelSaved % {
'num': numBarrelsSaved
}
else:
resultStr = TTLocalizer.CogThiefNoBarrelsSaved
perfectTextSubnode = hidden.attachNewNode(
self.__genText(resultStr))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
def safeGameOver(self=self):
if not self.frameworkFSM.isInternalStateInFlux():
self.gameOver()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(
LerpScaleInterval(perfectText,
duration=0.5,
scale=0.3,
startScale=0.0),
LerpFunctionInterval(fadeFunc,
fromData=0.0,
toData=1.0,
duration=0.5)), Wait(2.0),
Parallel(
LerpScaleInterval(perfectText, duration=0.5, scale=1.0),
LerpFunctionInterval(fadeFunc,
fromData=1.0,
toData=0.0,
duration=0.5,
blendType='easeIn')),
Func(destroyText), WaitInterval(0.5), Func(safeGameOver))
if numBarrelsSaved == len(self.barrels):
soundTrack = SoundInterval(self.sndPerfect)
else:
soundTrack = Sequence()
self.resultIval = Parallel(textTrack, soundTrack)
self.resultIval.start()
if config.GetBool('want-blueprint4-ARG', False):
MinigameGlobals.generateDebugARGPhrase()
def __genText(self, text):
self.__textGen.setText(text)
return self.__textGen.generate()
def getIntroTrack(self):
base.camera.setPosHpr(0, -13.66, 13.59, 0, -51.6, 0)
result = Sequence(
Wait(2),
LerpPosHprInterval(base.camera,
13,
Point3(self.cameraTopView[0],
self.cameraTopView[1],
self.cameraTopView[2]),
Point3(self.cameraTopView[3],
self.cameraTopView[4],
self.cameraTopView[5]),
blendType='easeIn'))
return result
class GroupTrackerGroup(DirectButton):
def __init__(self, parent, leaderId, leaderName, shardName, category,
memberIds, memberNames, **kw):
self.leaderId = leaderId
self.leaderName = leaderName
self.shardName = shardName
self.category = category
self.memberIds = memberIds
self.memberNames = memberNames
self.playerCount = None
if parent is None:
parent = aspect2d
text = TTLocalizer.GroupTrackerCategoryToText[self.category]
optiondefs = (('text', text, None), ('text_fg', (0.0, 0.0, 0.0, 1.0),
None), ('text_align',
TextNode.ALeft, None),
('text_pos', (0.0, 0.0, 0.0), None),
('text_scale', 0.05, None), ('relief', None, None))
self.defineoptions(kw, optiondefs)
DirectButton.__init__(self, parent)
self.initialiseoptions(GroupTrackerGroup)
self.playerCount = DirectLabel(parent=self,
pos=(0.6, 0, 0),
relief=None,
text='',
text_align=TextNode.ARight,
text_scale=0.05,
text_fg=(0, 0, 0, 1))
self.updatePlayerCount()
def destroy(self):
if hasattr(self, 'playerCount'):
if self.playerCount:
self.playerCount.destroy()
del self.playerCount
DirectButton.destroy(self)
def updatePlayerCount(self):
maxPlayers = GroupTrackerGlobals.CATEGORY_TO_MAX_PLAYERS[self.category]
self.playerCount['text'] = ( ` len(self.memberIds) ` + '/' +
` maxPlayers `)
def getLeaderId(self):
return self.leaderId
def getLeader(self):
return self.leaderName
def getDistrict(self):
return self.shardName
def getTitle(self):
return TTLocalizer.GroupTrackerCategoryToText[self.category]
def getCurrentPlayers(self):
return len(self.memberIds)
def getCategory(self):
return self.category
def getMaxPlayers(self):
return GroupTrackerGlobals.CATEGORY_TO_MAX_PLAYERS[self.category]
def getMemberNames(self):
return self.memberNames
def getMemberIds(self):
return self.memberIds
class RepairSawingGame(RepairMincroGame):
sawSounds = None
boardComplet = None
boardDestroyed = None
def __init__(self, repairGame):
self.config = RepairGlobals.Sawing
notify = DirectNotifyGlobal.directNotify.newCategory('RepairSawingGame')
RepairMincroGame.__init__(self, repairGame, 'sawing', PLocalizer.Minigame_Repair_Sawing_Start)
def _initVars(self):
RepairMincroGame._initVars(self)
self.boardsPool = { }
self.currentBoard = None
self.currentBoardIndex = 0
self.onDeckBoard = None
self.onDeckBoardIndex = 0
self.totalScore = 0.0
self.hitZone1Penalty = False
self.hitZone2Penalty = False
self.hitBoardPenalty = False
self.moveDiffForSound = 0.0
self.startPositions = (Point3(0.0, 0.0, 0.0),)
self.currentStartIndex = 0
self.lastMousePos = None
self.board_left = None
self.board_right = None
self.cut = None
self.zone1_right = None
self.zone1_left = None
self.zone2_right = None
self.zone2_left = None
self.piece1 = None
self.piece2 = None
self.lastHitIndex = -1
self.sawWaypoints = []
def _initAudio(self):
RepairMincroGame._initAudio(self)
if not self.sawSounds:
RepairSawingGame.sawSounds = (loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT01), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT02), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT03), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT04))
RepairSawingGame.boardComplete = loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_COMPLETE)
RepairSawingGame.boardDestroyed = loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_FAIL)
def _initVisuals(self):
RepairMincroGame._initVisuals(self)
self.setBin('fixed', 36)
self.model = loader.loadModel('models/gui/pir_m_gui_srp_sawing_main')
sawModel = self.model.find('**/saw')
sawModel.setR(193)
sawModel.setPos(0.90000000000000002, 0.0, -0.16500000000000001)
sawModel.setBin('gui-popup', 0)
self.sawButton = RepairSaw(parent = self, clickDownCommand = self.sawAttachedToMouse, clickUpCommand = self.sawRemovedFromMouse, geom = sawModel, text_pos = (0.20000000000000001, -0.29999999999999999), text_fg = (1, 0, 0, 1), scale = (0.29999999999999999, 0.29999999999999999, 0.29999999999999999), relief = None, pressEffect = 0, frameSize = (-0.050000000000000003, 1.05, -0.29999999999999999, 0.050000000000000003), rolloverSound = None, clickSound = None)
self.sawingLine = RepairSawingLine(self, self.config.sawlineLineThickness, self.config.sawlineColor, self.config.sawlineLinespawnDist)
self.progressDescriptionLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Description, text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ARight, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.20000000000000001, 0.0, 0.5), parent = self)
self.progressLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Thresholds[3], text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ALeft, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.17999999999999999, 0.0, 0.5), parent = self)
self.boardDestroyedLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Board_Destroyed, text_fg = (1.0, 0.0, 0.0, 1.0), text_pos = (0.0, 0.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.10000000000000001, 0.10000000000000001, 0.10000000000000001), pos = (0.0, 0.0, 0.10000000000000001), parent = self)
self.boardDestroyedLabel.setBin('fixed', 38)
self.boardDestroyedLabel.stash()
def _initIntervals(self):
RepairMincroGame._initIntervals(self)
self.newBoardSequence = Sequence(name = 'RepairSawingGame.newBoardSequence')
self.splitBoardSequence = Sequence(name = 'RepairSawGame.splitBoardSequence')
self.dropBoardSequence = Sequence(name = 'RepairSawGame.dropBoardSequence')
def getNewBoard(self, boardIndex):
board = self.model.find('**/wood%i' % boardIndex).copyTo(NodePath('board%i' % len(self.boardsPool)))
board.reparentTo(self)
piece1 = board.find('**/piece_1')
piece1.setPythonTag('piece_1', self.piece1)
piece1.setY(self.config.boardYDist)
piece2 = board.find('**/piece_2')
piece2.setPythonTag('piece_2', self.piece2)
piece2.setY(self.config.boardYDist)
pieceCut = board.find('**/piece_cut')
pieceCut.setPythonTag('cut', self.cut)
pieceCut.setColor(self.config.cutColor)
pieceCut.setY(self.config.boardYDist)
board_left = piece1.find('**/board')
board_left.setPythonTag('left', self.board_left)
board_right = piece2.find('**/board')
board_right.setPythonTag('right', self.board_right)
zone1_right = piece2.find('**/zone_1')
zone1_right.setPythonTag('zone1_right', self.zone1_right)
zone1_right.setColor(self.config.zone1Color)
zone1_left = piece1.find('**/zone_1')
zone1_left.setPythonTag('zone1_left', self.zone1_left)
zone1_left.setColor(self.config.zone1Color)
zone2_right = piece2.find('**/zone_2')
zone2_right.setPythonTag('zone2_right', self.zone2_right)
zone2_right.setColor(self.config.zone2Color)
zone2_left = piece1.find('**/zone_2')
zone2_left.setPythonTag('zone2_left', self.zone2_left)
zone2_left.setColor(self.config.zone2Color)
board.stash()
return board
def reset(self):
for key in self.boardsPool.keys():
board = self.boardsPool[key]
board.removeNode()
self.boardsPool.clear()
if self.currentBoard:
self.currentBoard.removeNode()
self.currentBoard = None
if self.onDeckBoard:
self.onDeckBoard.removeNode()
self.onDeckBoard = None
for boardIndex in self.currentDifficultySet:
boardIndex -= 1
if 'copy1_%s' % boardIndex not in self.boardsPool:
board = self.getNewBoard(boardIndex)
self.boardsPool['copy1_%s' % boardIndex] = board
if 'copy2_%s' % boardIndex not in self.boardsPool:
board = self.getNewBoard(boardIndex)
self.boardsPool['copy2_%s' % boardIndex] = board
continue
self.currentBoardIndex = 0
self.currentBoard = None
self.moveNewBoardOnDeck()
self.onDeckBoard.unstash()
self.totalScore = 0
self.startPositions = (Point3(0.0, 0.0, 0.0),)
self.sawButton.stash()
self.sawButton.reparentTo(self)
self.lastHitIndex = -1
self.moveDiffForSound = 0.0
RepairMincroGame.reset(self)
self.repairGame.gui.setTutorial(self.name)
self.repairGame.gui.setTitle(self.name)
def destroy(self):
RepairMincroGame.destroy(self)
taskMgr.remove('SawingGame.updateSawTask')
self.sawButton.destroy()
self.sawButton.removeNode()
del self.sawButton
if self.currentBoard:
self.currentBoard.removeNode()
self.currentBoard = None
if self.onDeckBoard:
self.onDeckBoard.removeNode()
self.onDeckBoard = None
self.sawingLine = None
self.progressDescriptionLabel.destroy()
self.progressDescriptionLabel = None
self.progressLabel.destroy()
self.progressLabel = None
self.boardDestroyedLabel.destroy()
self.boardDestroyedLabel = None
for key in self.boardsPool.keys():
board = self.boardsPool[key]
if not board.isEmpty():
board.removeNode()
continue
self.boardsPool.clear()
self.newBoardSequence.clearToInitial()
del self.newBoardSequence
self.splitBoardSequence.clearToInitial()
del self.splitBoardSequence
self.dropBoardSequence.clearToInitial()
del self.dropBoardSequence
def setDifficulty(self, difficulty):
RepairMincroGame.setDifficulty(self, difficulty)
percent = difficulty / self.repairGame.difficultyMax
difIndex = int(math.floor(percent * (len(self.config.difficultySets) - 1)))
self.currentDifficultySet = self.config.difficultySets[difIndex]
def splitBoard(self):
self.sawingLine.reset()
board = self.currentBoard
boardIndex = self.currentBoardIndex
if self.hitZone2Penalty:
boardSplitAnim = Parallel(LerpPosInterval(self.board_left, duration = self.config.splitBoardAnimTime, pos = Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.board_right, duration = self.config.splitBoardAnimTime, pos = Point3(2.0, 0.0, 0.0)), LerpFunc(self.zone2_left.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.zone2_right.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.zone1_left.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.zone1_right.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.cut.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0))
elif self.hitZone1Penalty:
boardSplitAnim = Parallel(LerpPosInterval(self.board_left, duration = self.config.splitBoardAnimTime, pos = Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.board_right, duration = self.config.splitBoardAnimTime, pos = Point3(2.0, 0.0, 0.0)), LerpPosInterval(self.zone2_left, duration = self.config.splitBoardAnimTime, pos = Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.zone2_right, duration = self.config.splitBoardAnimTime, pos = Point3(2.0, 0.0, 0.0)), LerpFunc(self.zone1_left.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.zone1_right.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.cut.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0))
else:
boardSplitAnim = Parallel(LerpPosInterval(self.piece1, duration = self.config.splitBoardAnimTime, pos = Point3(-2.0, self.config.boardYDist, 0.0)), LerpPosInterval(self.piece2, duration = self.config.splitBoardAnimTime, pos = Point3(2.0, self.config.boardYDist, 0.0)), LerpFunc(self.cut.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0))
self.splitBoardSequence = Sequence(Func(self.updateScore), Func(self.boardComplete.play), boardSplitAnim, Func(board.stash), Func(self.piece1.setPos, self.piece1.getPos()), Func(self.piece2.setPos, self.piece2.getPos()), Func(self.board_right.setPos, self.board_right.getPos()), Func(self.board_left.setPos, self.board_left.getPos()), Func(self.zone2_right.setPos, self.zone2_right.getPos()), Func(self.zone2_left.setPos, self.zone2_left.getPos()), Func(self.zone1_right.setPos, self.zone1_right.getPos()), Func(self.zone1_left.setPos, self.zone1_left.getPos()), Func(self.cut.setSa, 1.0), Func(self.zone1_right.setSa, 1.0), Func(self.zone1_left.setSa, 1.0), Func(self.zone2_right.setSa, 1.0), Func(self.zone2_left.setSa, 1.0), Func(self.board_right.setSa, 1.0), Func(self.board_left.setSa, 1.0), Func(self.loadNewBoard), Func(self.addBoardBackToPool, board, boardIndex), name = 'RepairSawGame.splitBoardSequence')
self.splitBoardSequence.start()
def dropBoard(self):
board = self.currentBoard
boardIndex = self.currentBoardIndex
self.dropBoardSequence = Sequence(Parallel(Sequence(Func(self.boardDestroyedLabel.unstash), Wait(1.5), Func(self.boardDestroyedLabel.stash)), Sequence(Wait(0.5), Func(self.boardDestroyed.play), Func(self.sawingLine.reset), LerpPosInterval(board, duration = self.config.splitBoardAnimTime, pos = Point3(0.0, 0.0, -2.0)), Func(board.stash), Wait(0.5), Func(self.loadNewBoard), Func(self.addBoardBackToPool, board, boardIndex))), name = 'RepairSawGame.dropBoardSequence')
self.dropBoardSequence.start()
def addBoardBackToPool(self, board, boardIndex):
if 'copy1_%s' % boardIndex not in self.boardsPool:
self.boardsPool['copy1_%s' % boardIndex] = board
elif 'copy2_%s' % boardIndex not in self.boardsPool:
self.boardsPool['copy2_%s' % boardIndex] = board
else:
self.notify.error('Two copies of board type %i already in the boardsPool!' % boardIndex)
def updateScoreText(self):
self.progressLabel.unstash()
self.progressDescriptionLabel.unstash()
if self.hitBoardPenalty:
self.progressLabel['text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[0]
self.progressLabel['text_fg'] = Vec4(1.0, 0.0, 0.0, 1.0)
self.progressLabel.setText()
elif self.hitZone2Penalty:
self.progressLabel['text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[1]
self.progressLabel['text_fg'] = Vec4(1.0, 0.5, 0.0, 1.0)
self.progressLabel.setText()
elif self.hitZone1Penalty:
self.progressLabel['text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[2]
self.progressLabel['text_fg'] = Vec4(1.0, 1.0, 0.0, 1.0)
self.progressLabel.setText()
else:
self.progressLabel['text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[3]
self.progressLabel['text_fg'] = Vec4(0.0, 1.0, 0.0, 1.0)
self.progressLabel.setText()
def moveNewBoardOnDeck(self):
boardIndex = random.randint(0, len(self.currentDifficultySet) - 1)
boardType = self.currentDifficultySet[boardIndex]
boardType -= 1
if 'copy1_%s' % boardType in self.boardsPool:
self.onDeckBoard = self.boardsPool['copy1_%s' % boardType]
del self.boardsPool['copy1_%s' % boardType]
elif 'copy2_%s' % boardType in self.boardsPool:
self.onDeckBoard = self.boardsPool['copy2_%s' % boardType]
del self.boardsPool['copy2_%s' % boardType]
else:
self.notify.error('No copies of board type %i in the boardsPool!' % boardType)
self.onDeckBoardIndex = boardType
self.onDeckBoard.setScale(0.25)
self.onDeckBoard.setPos(0.5, -2.0, 0.56000000000000005)
self.onDeckBoard.unstash()
def loadNewBoard(self):
self.progressLabel.stash()
self.progressDescriptionLabel.stash()
if self.totalScore >= self.config.totalPoints:
if self.onDeckBoard:
self.onDeckBoard.stash()
self.progressDescriptionLabel.stash()
taskMgr.remove('SawingGame.updateSawTask')
self.request('Outro')
return None
self.currentBoard = self.onDeckBoard
self.currentBoardIndex = self.onDeckBoardIndex
self.piece1 = self.currentBoard.find('**/piece_1')
self.piece1.setTransparency(1)
self.piece2 = self.currentBoard.find('**/piece_2')
self.piece2.setTransparency(1)
self.cut = self.currentBoard.find('**/piece_cut')
self.cut.setColor(self.config.cutColor)
self.cut.setTransparency(1)
self.board_left = self.piece1.find('**/board')
self.board_left.setTransparency(1)
self.zone1_left = self.piece1.find('**/zone_1')
self.zone1_left.setTransparency(1)
self.zone2_left = self.piece1.find('**/zone_2')
self.zone2_left.setTransparency(1)
self.board_right = self.piece2.find('**/board')
self.board_right.setTransparency(1)
self.zone1_right = self.piece2.find('**/zone_1')
self.zone1_right.setTransparency(1)
self.zone2_right = self.piece2.find('**/zone_2')
self.zone2_right.setTransparency(1)
self.board_left.setCollideMask(SAW_COLLIDE_MASK)
self.board_right.setCollideMask(SAW_COLLIDE_MASK)
self.cut.setCollideMask(SAW_COLLIDE_MASK)
self.zone1_right.setCollideMask(SAW_COLLIDE_MASK)
self.zone1_left.setCollideMask(SAW_COLLIDE_MASK)
self.zone2_right.setCollideMask(SAW_COLLIDE_MASK)
self.zone2_left.setCollideMask(SAW_COLLIDE_MASK)
self.startPositions = (self.currentBoard.find('**/locator_start_0').getPos() + Point3(*self.config.activeBoardPosition), self.currentBoard.find('**/locator_start_1').getPos() + Point3(*self.config.activeBoardPosition))
self.currentStartIndex = 0
for waypoint in self.sawWaypoints:
waypoint.removeNode()
self.sawWaypoints = []
locator = self.currentBoard.find('**/locator_0')
index = 0
while not locator.isEmpty():
self.sawWaypoints.append(SawWaypoint(index, self.currentBoard, locator.getPos()))
locator = self.currentBoard.find('**/locator_%i' % (index + 1))
index += 1
self.sawButton.deactivate()
self.sawButton.setPos(self.startPositions[self.currentStartIndex])
self.hitBoardPenalty = False
self.hitZone1Penalty = False
self.hitZone2Penalty = False
self.lastMousePos = None
self.moveDiffForSound = self.config.playSawingSoundDelta + 0.10000000000000001
self.newBoardSequence = Sequence(Parallel(self.currentBoard.posInterval(self.config.newBoardAnimTime, Point3(*self.config.activeBoardPosition)), self.currentBoard.scaleInterval(self.config.newBoardAnimTime, 1.0)), name = 'RepairSawingGame.newBoardSequence')
if self.state in [
'Game']:
self.newBoardSequence.append(Func(self.sawButton.activate))
self.newBoardSequence.append(Wait(0.5))
self.newBoardSequence.append(Func(self.moveNewBoardOnDeck))
self.newBoardSequence.start()
def updateSawTask(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
relative = Point3(mpos.getX(), 0.0, mpos.getY())
relative = self.getRelativePoint(render2d, relative)
moveDiff = 0.0
if self.lastMousePos != None:
moveDiff = (relative - self.lastMousePos).length()
pickedObjects = self.repairGame.mousePicker.getCollisions(self.currentBoard, useIntoNodePaths = True)
self.updateWaypoints()
if len(pickedObjects) > 0:
self.moveDiffForSound += moveDiff
if self.moveDiffForSound > self.config.playSawingSoundDelta:
sawSoundPlaying = False
for sound in self.sawSounds:
if sound.status() == 2:
sawSoundPlaying = True
break
continue
if sawSoundPlaying == False:
sound = random.choice(self.sawSounds)
sound.play()
self.moveDiffForSound = 0.0
if self.board_right in pickedObjects or self.board_left in pickedObjects:
for waypoint in self.sawWaypoints:
waypoint.hit = False
self.hitBoardPenalty = True
self.dropBoard()
self.sawButton.deactivate()
elif self.cut in pickedObjects:
self.updateWaypoints()
elif self.zone1_right in pickedObjects or self.zone1_left in pickedObjects:
self.updateWaypoints()
if self.hitZone1Penalty == False:
self.hitZone1Penalty = True
elif self.zone2_right in pickedObjects or self.zone2_left in pickedObjects:
self.updateWaypoints()
if self.hitZone2Penalty == False:
self.hitZone2Penalty = True
self.updateScoreText()
else:
boardComplete = True
for waypoint in self.sawWaypoints:
if not waypoint.hit:
boardComplete = False
break
continue
if boardComplete:
self.splitBoard()
self.sawButton.deactivate()
self.lastMousePos = self.sawButton.getPos()
return Task.cont
def updateScore(self):
if not self.hitBoardPenalty:
currBoardScore = self.config.pointsPerBoard
if not self.hitZone1Penalty:
pass
currBoardScore -= self.config.pointsLostForZone1 * self.hitZone2Penalty
currBoardScore -= self.config.pointsLostForZone2 * self.hitZone2Penalty
rating = 4 - 1 * self.hitZone2Penalty - 3 * self.hitZone1Penalty
self.totalScore += currBoardScore
self.totalScore = min(self.totalScore, self.config.totalPoints)
percent = int((self.totalScore / self.config.totalPoints) * 100.0)
self.repairGame.d_reportMincroGameProgress(percent, rating)
def resetWaypoints(self):
for waypoint in self.sawWaypoints:
waypoint.hit = False
def updateWaypoints(self):
waypointList = self.getHitWaypoints()
for waypointIndex in waypointList:
self.lastHitIndex = waypointIndex
self.sawWaypoints[waypointIndex].hit = True
if waypointIndex == 0 and not (self.sawWaypoints[-1].hit):
self.currentStartIndex = 0
continue
if waypointIndex == len(self.sawWaypoints) - 1 and not (self.sawWaypoints[0].hit):
self.currentStartIndex = 1
continue
def getHitWaypoints(self):
waypointsHit = []
testDelta = self.config.testWaypointDelta
for i in range(len(self.sawWaypoints)):
waypointPos = self.sawWaypoints[i].getPos(self)
closestDistance = 9999
if self.lastMousePos != None:
currMousePos = self.sawButton.getPos()
lastMousePos = self.lastMousePos
totalLength = (currMousePos - lastMousePos).length()
testLength = testDelta
while testLength < totalLength:
testPos = (currMousePos - lastMousePos) * (testLength / totalLength) + lastMousePos
self.updateSawLine(testPos)
testDistance = (testPos - waypointPos).length()
closestDistance = min(testDistance, closestDistance)
testLength += testDelta
self.updateSawLine(self.sawButton.getPos())
testDistance = (self.sawButton.getPos() - waypointPos).length()
closestDistance = min(testDistance, closestDistance)
if closestDistance < self.config.waypointRange[self.currentBoardIndex]:
waypointsHit.append(i)
continue
return waypointsHit
def updateSawLine(self, pos):
if pos.getX() < -0.63300000000000001 or pos.getX() > 0.63300000000000001:
self.sawingLine.reset()
return None
if pos.getZ() < -0.183 or pos.getZ() > 0.375:
self.sawingLine.reset()
return None
self.sawingLine.update(pos)
def getClosestPosition(self, positions):
closestIndex = -1
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
relative = Point3(mpos.getX(), 0.0, mpos.getY())
relative = self.getRelativePoint(base.a2dBackground, relative)
bestDistance = 99999.0
for i in range(len(positions)):
dX = relative.getX() - positions[i].getX()
dZ = relative.getZ() - positions[i].getZ()
newDistance = dX * dX + dZ * dZ
if newDistance < bestDistance:
bestDistance = newDistance
closestIndex = i
continue
return closestIndex
def sawAttachedToMouse(self):
self.lastHitIndex = -1
if not taskMgr.hasTaskNamed('SawingGame.updateSawTask'):
taskMgr.add(self.updateSawTask, 'SawingGame.updateSawTask', priority = 2)
def sawRemovedFromMouse(self):
if not self.sawButton.isStashed():
self.sawButton.setPos(self.startPositions[self.currentStartIndex])
self.lastHitIndex = -1
self.resetWaypoints()
self.lastMousePos = None
self.progressLabel.stash()
self.progressDescriptionLabel.stash()
self.sawingLine.reset()
self.hitBoardPenalty = False
self.hitZone1Penalty = False
self.hitZone2Penalty = False
taskMgr.remove('SawingGame.updateSawTask')
def enterIntro(self):
RepairMincroGame.enterIntro(self)
self.loadNewBoard()
def enterGame(self):
RepairMincroGame.enterGame(self)
self.repairGame.mousePicker.setCollisionMask(SAW_COLLIDE_MASK)
self.sawButton.activate()
def exitGame(self):
RepairMincroGame.exitGame(self)
self.sawButton.deactivate()
self.repairGame.mousePicker.clearCollisionMask()
taskMgr.remove('SawingGame.updateSawTask')
self.splitBoardSequence.clearToInitial()
self.dropBoardSequence.clearToInitial()
localAvatar.guiMgr._showCursor()
def enterOutro(self):
RepairMincroGame.enterOutro(self)
self.repairGame.d_reportMincroGameScore(150)
class GroupTrackerGroup(DirectButton):
def __init__(self, parent, leaderId, leaderName, shardName, category, memberIds, memberNames, **kw):
self.leaderId = leaderId
self.leaderName = leaderName
self.shardName = shardName
self.category = category
self.memberIds = memberIds
self.memberNames = memberNames
self.playerCount = None
if parent is None:
parent = aspect2d
text = TTLocalizer.GroupTrackerCategoryToText[self.category]
optiondefs = (
('text', text, None),
('text_fg', (0.0, 0.0, 0.0, 1.0), None),
('text_align', TextNode.ALeft, None),
('text_pos', (0.0, 0.0, 0.0), None),
('text_scale', 0.05, None),
('relief', None, None)
)
self.defineoptions(kw, optiondefs)
DirectButton.__init__(self, parent)
self.initialiseoptions(GroupTrackerGroup)
self.playerCount = DirectLabel(parent=self, pos=(0.6, 0, 0), relief=None, text='', text_align=TextNode.ARight, text_scale=0.05, text_fg=(0, 0, 0, 1))
self.updatePlayerCount()
def destroy(self):
if hasattr(self, 'playerCount'):
if self.playerCount:
self.playerCount.destroy()
del self.playerCount
DirectButton.destroy(self)
def updatePlayerCount(self):
maxPlayers = GroupTrackerGlobals.CATEGORY_TO_MAX_PLAYERS[self.category]
self.playerCount['text'] = (`len(self.memberIds)` + '/' + `maxPlayers`)
def getLeaderId(self):
return self.leaderId
def getLeader(self):
return self.leaderName
def getDistrict(self):
return self.shardName
def getTitle(self):
return TTLocalizer.GroupTrackerCategoryToText[self.category]
def getCurrentPlayers(self):
return len(self.memberIds)
def getCategory(self):
return self.category
def getMaxPlayers(self):
return GroupTrackerGlobals.CATEGORY_TO_MAX_PLAYERS[self.category]
def getMemberNames(self):
return self.memberNames
def getMemberIds(self):
return self.memberIds
class QuestPoster(DirectFrame):
notify = directNotify.newCategory('QuestPoster')
# We need to declare and initialize these variables here
# because some methods use them as default arguments.
auxIcon = None
# Requires one parameter, quest, this must be a Quest instance.
# The next argument, parent, is where to reparent the DirectFrame to.
# The next arguments are simply additional options when setting up the DirectFrame.
def __init__(self, quest, parent=aspect2d, **kw):
# The quest this poster is representing.
self.quest = quest
self.accessibleObjectives = quest.accessibleObjectives if quest else []
self.viewObjective = quest.accessibleObjectives.seek(
) if quest else None
isObjComplete = False if not quest else (
self.accessibleObjectives.isComplete() or quest.isComplete())
# Let's define our options for the DirectFrame.
bookModel = loader.loadModel(
'phase_3.5/models/gui/stickerbook_gui.bam')
optiondefs = (('relief', None,
None), ('image', bookModel.find('**/questCard'),
None), ('image_scale', (0.8, 1.0, 0.58), None),
('image_color', (1.0, 1.0, 1.0,
1.0) if not isObjComplete else Vec4(
*QuestGlobals.LIGHT_GREEN),
None), ('state', DGG.NORMAL, None))
self.defineoptions(kw, optiondefs)
# Finally, initialize the DirectFrame.
DirectFrame.__init__(self, parent, relief=None)
self.initialiseoptions(QuestPoster)
# Let's declare and initialize our barebone GUI element variables.
questTitle = '' if not self.quest else self.quest.name
self.titleLabel = DirectLabel(parent=self,
relief=None,
text=questTitle,
text_font=CIGlobals.getMinnieFont(),
text_fg=QuestGlobals.TEXT_COLOR,
text_scale=0.05,
text_align=TextNode.ACenter,
text_wordwrap=25.0,
textMayChange=1,
pos=(0, 0, 0.23))
##########################################################################
# THE FOLLOWING ELEMENTS BELOW ARE GROUPED TOGETHER #
##########################################################################
# The background frame where the objective image is displayed.
# This is the colored background frame.
circleGui = loader.loadModel(
'phase_4/models/gui/CircleIconBackgroundGui.bam')
self.auxFrame = DirectFrame(
parent=self,
relief=None,
image=circleGui.find('**/circle_display_interior'),
image_scale=0.18,
text='',
text_pos=(0, -0.11),
text_fg=QuestGlobals.TEXT_COLOR,
text_scale=QuestGlobals.QPtextScale,
text_align=TextNode.ACenter,
text_wordwrap=11.0,
pos=QuestGlobals.DEFAULT_LEFT_PICTURE_POS)
if self.quest and len(
self.quest.accessibleObjectives) > 1 and not isObjComplete:
# We can only use arrows when we have more than one objective available.
arrowGui = loader.loadModel('phase_4/models/gui/QuestArrowGui.bam')
self.prevObjArrow = DirectButton(
parent=self.auxFrame,
relief=None,
geom=((arrowGui.find('**/quest_arrow_enabled'),
arrowGui.find('**/quest_arrow_click'),
arrowGui.find('**/quest_arrow_mouseover'),
arrowGui.find('**/quest_arrow_disabled'))),
scale=0.08,
command=self.switchObjective,
extraArgs=[0],
hpr=(180, 0, 0),
pos=QuestGlobals.DEFAULT_LEFT_ARROW_POS)
self.nextObjArrow = DirectButton(
parent=self.auxFrame,
relief=None,
geom=((arrowGui.find('**/quest_arrow_enabled'),
arrowGui.find('**/quest_arrow_click'),
arrowGui.find('**/quest_arrow_mouseover'),
arrowGui.find('**/quest_arrow_disabled'))),
scale=0.08,
command=self.switchObjective,
pos=QuestGlobals.DEFAULT_RIGHT_ARROW_POS)
# The icon that goes on top of the aux frame.
self.auxIcon = DirectFrame(parent=self.auxFrame,
relief=None,
text=' ',
text_font=CIGlobals.getSuitFont(),
text_pos=(0, -0.03),
text_fg=QuestGlobals.TEXT_COLOR,
text_scale=0.13,
text_align=TextNode.ACenter,
text_wordwrap=13.0,
textMayChange=1)
self.auxIcon.setColorOff(-1)
self.auxOutline = DirectLabel(
parent=self.auxFrame,
relief=None,
image=circleGui.find('**/circle_display_outline'),
image_scale=0.18)
# The aux text saying: DEFEAT, RECOVER, etc.
self.auxText = DirectLabel(parent=self,
relief=None,
text=QuestGlobals.RECOVER,
text_font=CIGlobals.getToonFont(),
text_scale=QuestGlobals.QPauxText,
text_fg=QuestGlobals.TEXT_COLOR,
text_align=TextNode.ACenter,
textMayChange=1,
pos=QuestGlobals.DEFAULT_AUX_POS)
self.auxText.hide()
##########################################################################
# Information displayed about the objective.
self.objectiveInfo = DirectLabel(
parent=self,
relief=None,
text='',
text_font=CIGlobals.getToonFont(),
text_fg=QuestGlobals.TEXT_COLOR,
text_scale=0.04,
text_align=TextNode.ACenter,
text_wordwrap=QuestGlobals.QPtextWordwrap,
textMayChange=1,
pos=(QuestGlobals.DEFAULT_INFO_POS))
self.objectiveInfo.hide()
# Information displayed showing the location.
self.locationInfo = DirectLabel(
parent=self,
relief=None,
text='N/A',
text_font=CIGlobals.getToonFont(),
text_fg=QuestGlobals.TEXT_COLOR,
text_scale=QuestGlobals.QPtextScale,
text_align=TextNode.ACenter,
text_wordwrap=QuestGlobals.QPtextWordwrap,
textMayChange=1,
pos=(0, 0, -0.115))
self.locationInfo.hide()
# The progress bar showing the objective's progress
self.progressBar = DirectWaitBar(parent=self,
relief=DGG.SUNKEN,
frameSize=(-0.95, 0.95, -0.1, 0.12),
borderWidth=(0.025, 0.025),
scale=0.2,
frameColor=(0.945, 0.875, 0.706, 1.0),
barColor=(0.5, 0.7, 0.5, 1),
text='0/0',
text_font=CIGlobals.getToonFont(),
text_scale=0.19,
text_fg=(0.05, 0.14, 0.4, 1),
text_align=TextNode.ACenter,
text_pos=(0, -0.05),
pos=(0, 0, -0.2425))
self.progressBar.hide()
# The wood panel at the bottom where rewards are displayed.
rewardFrameGeom = loader.loadModel(
'phase_4/models/gui/gag_shop_purchase_gui.bam')
self.rewardFrame = DirectFrame(
parent=self,
relief=None,
geom=rewardFrameGeom.find('**/Goofys_Sign'),
geom_scale=(0.62, 0, 0.4),
pos=(-0.015, 0, -0.25))
# Let's setup our reward frames.
reward = None
if self.quest and len(self.quest.rewards) > 0:
reward = self.quest.rewards[0]
self.lReward = QuestRewardFrame(self, reward)
# The text displayed on the right side of the frame with additional information, if necessary.
self.sideInfo = DirectLabel(parent=self,
relief=None,
text=QuestGlobals.JUST_FOR_FUN,
text_fg=(0.0, 0.439, 1.0, 1.0),
text_shadow=(0, 0, 0, 1),
pos=(-0.2825, 0, 0.2),
scale=0.03)
self.sideInfo.setR(-30)
# This side information is usually not needed, let's hide it.
self.sideInfo.hide()
# Remove the nodes of the loaded models we no longer need.
circleGui.removeNode()
bookModel.removeNode()
rewardFrameGeom.removeNode()
# We are only removing this node if we generated arrows.
if hasattr(self, 'arrowGui'):
arrowGui.removeNode()
# Let's hide this until it is needed.
self.hide()
return
def switchObjective(self, forward=1):
if forward:
self.accessibleObjectives.nextObjective()
else:
self.accessibleObjectives.lastObjective()
self.viewObjective = self.accessibleObjectives.seek()
self.setup()
def setup(self):
if self.quest:
objective = self.viewObjective
complete = self.accessibleObjectives.isComplete()
# Let's reset our positioning of elements.
self.auxFrame.setPos(QuestGlobals.DEFAULT_LEFT_PICTURE_POS)
self.auxText.setPos(QuestGlobals.DEFAULT_AUX_POS)
self.objectiveInfo.setPos(QuestGlobals.DEFAULT_INFO_POS)
# Let's reset our icon.
self.auxIcon.setScale(1, 1, 1)
self.auxIcon.setPos(0, 0, 0)
self.auxIcon.setHpr(0, 0, 0)
self.objectiveInfo.show()
self.auxFrame.show()
# Let's setup the quest progress bar
progress = objective.progress if hasattr(objective,
'progress') else None
if objective.goal > 1:
self.progressBar['range'] = objective.goal
self.progressBar['value'] = progress & pow(2, 16) - 1
if objective.HasProgress and objective.goal > 1 and not complete:
self.progressBar.show()
self.auxText.show()
# Let's handle the objectives.
if not complete:
if objective.__class__ == CogObjective:
self.handleCogObjective()
elif objective.__class__ == CogBuildingObjective:
self.handleCogBuildingObjective()
elif objective.__class__ == MinigameObjective:
self.handleMinigameObjective()
elif objective.__class__ == VisitNPCObjective:
self.handleNPCObjective()
else:
bgColor = QuestGlobals.RED
if objective.type in DefeatObjectives:
bgColor = QuestGlobals.BLUE
self.handleNPCObjective(auxText=QuestGlobals.RETURN + ' to',
frameColor=bgColor)
self.lReward.setup()
newLineInObjInfo = '\n' in self.objectiveInfo['text']
isShopLoc = QuestGlobals.isShopLocation(
objective.area) if not complete else True
if complete:
locationText = QuestGlobals.getLocationText(None, objective)
else:
locationText = QuestGlobals.getLocationText(objective.area)
self.locationInfo['text'] = locationText
self.locationInfo['text_pos'] = (0.0, (0.025 if isShopLoc else (
-0.025 if newLineInObjInfo else 0.0)))
self.locationInfo.show()
else:
# We want to be able to show empty quest posters.
self.titleLabel.hide()
self.auxFrame.hide()
self.auxIcon.hide()
self.titleLabel.initialiseoptions(DirectLabel)
self.auxIcon.initialiseoptions(DirectFrame)
self.auxText.initialiseoptions(DirectLabel)
self.objectiveInfo.initialiseoptions(DirectLabel)
self.locationInfo.initialiseoptions(DirectLabel)
self.rewardFrame.initialiseoptions(DirectFrame)
self.sideInfo.initialiseoptions(DirectLabel)
self.lReward.initialiseoptions(DirectFrame)
# Handle arrow stuff if necessary.
if hasattr(self, 'prevObjArrow'):
index = self.accessibleObjectives.seeker
self.prevObjArrow['state'] = DGG.NORMAL
self.nextObjArrow['state'] = DGG.NORMAL
self.prevObjArrow.setPos(QuestGlobals.DEFAULT_LEFT_ARROW_POS)
self.nextObjArrow.setPos(QuestGlobals.DEFAULT_RIGHT_ARROW_POS)
if index == 0:
self.prevObjArrow['state'] = DGG.DISABLED
elif index == len(self.accessibleObjectives) - 1:
self.nextObjArrow['state'] = DGG.DISABLED
self.prevObjArrow.initialiseoptions(DirectButton)
self.nextObjArrow.initialiseoptions(DirectButton)
# Changes geometry and scale of an icon.
def handleSimpleIcon(self, geom, scale, icon):
icon['geom'] = geom
icon['geom_scale'] = scale
def handleComplexIcon(self,
geom,
icon,
scale=QuestGlobals.IMAGE_SCALE_SMALL):
geom.setDepthWrite(1)
geom.setDepthTest(1)
self.fitGeometry(geom, fFlip=1)
self.handleSimpleIcon(geom, scale, icon)
# We have to rotate the head and set the scale of the icon.
if CIGlobals.Suit in geom.getName():
cogName = geom.getPythonTag('Settings')
data = QuestGlobals.Suit2PosterZNDScale.get(cogName)
zOffset = data[0]
headScale = data[1]
icon.setScale(headScale)
icon.setZ(icon.getZ() + zOffset)
icon.setH(180)
else:
icon.setZ(icon.getZ() - 0.01)
def handleCogObjective(self,
iconElement=auxIcon,
auxText=QuestGlobals.DEFEAT,
frameColor=QuestGlobals.BLUE):
objective = self.viewObjective
infoText = objective.getTaskInfo()
if objective.__class__ == RecoverItemObjective:
infoText = CIGlobals.makePlural(objective.cog)
if not iconElement:
iconElement = self.auxIcon
# Let's make sure we have a current objective that is
# an instance of the CogObjective class and this poster isn't destroyed.
if not objective or not hasattr(self, 'titleLabel') or not isinstance(
objective, CogObjective):
return
if objective.dept:
icons = loader.loadModel('phase_3/models/gui/cog_icons.bam')
deptIcon = None
if objective.dept == Dept.BOSS:
deptIcon = icons.find('**/CorpIcon')
else:
deptIcon = icons.find('**/%sIcon' %
objective.dept.getTie().title())
# Correct the medallion color.
deptIcon.setColor(SuitGlobals.medallionColors[objective.dept])
# Setup the icon and remove the icons node.
self.handleSimpleIcon(deptIcon, 0.13, iconElement)
icons.removeNode()
elif objective.cog == QuestGlobals.Any:
# We aren't fighting a Cog in particular.
cogIcon = QuestGlobals.getCogIcon()
self.handleSimpleIcon(cogIcon, 0.13, iconElement)
# We're fighting a Cog in particular.
if not objective.cog == QuestGlobals.Any:
cogHeadInstance = SuitBank.getSuitByName(objective.cog).getHead()
cogHead = cogHeadInstance.generate()
cogHead.setName('%sHead' % CIGlobals.Suit)
cogHead.setPythonTag('Settings', cogHeadInstance.head)
cogHead.setScale(2)
cogHead.setLightOff()
self.handleComplexIcon(cogHead, iconElement)
# HACK FIX: Corrects the buggy Flunky glasses.
glasses = cogHead.find('**/glasses')
if glasses and not glasses.isEmpty():
glasses.setScale(1)
glasses.reparentTo(cogHead)
if not iconElement is self.auxIcon:
if hasattr(self, 'goalInfo'):
# We're working with the second frame, on the right.
# Let's update the information pertaining to this side.
self.goalInfo['text'] = infoText
self.goalInfo.setPos(QuestGlobals.RECOVER_INFO2_POS)
self.auxText.setPos(QuestGlobals.RECOVER_AUX_POS)
else:
raise AttributeError(
'Attempted to setup DoubleFrame information for poster using default style.'
)
else:
self.objectiveInfo['text'] = infoText
# Let's set the progress bar text
pgBarText = '%d of %d %s' % (objective.progress, objective.goal,
CIGlobals.makePastTense(auxText))
self.progressBar['text'] = pgBarText
self.auxText['text'] = auxText
# Let's set the color of the poster.
frame = self.auxFrame if iconElement is self.auxIcon else self.goalFrame
frame['image_color'] = Vec4(*frameColor)
def handleCogBuildingObjective(self,
iconElement=auxIcon,
auxText=QuestGlobals.DEFEAT,
frameColor=QuestGlobals.BLUE):
objective = self.viewObjective
infoText = objective.getTaskInfo()
if not iconElement:
iconElement = self.auxIcon
# Let's make sure we have a current objective that is
# an instance of the CogBuildingObjective class and this poster isn't destroyed.
if not objective or not hasattr(self, 'titleLabel') or not isinstance(
objective, CogBuildingObjective):
return
# If we aren't looking for any specific department of building.
if objective.dept == QuestGlobals.Any:
# Let's just use the good ol' generic building icon.
self.handleSimpleIcon(QuestGlobals.getCogBuildingIcon(),
QuestGlobals.SIMPLE_IMAGE_SCALE, iconElement)
else:
# Ah geez, we're looking for a specific department.
# Bossbot tie names are messed up, so we need this if statement.
dept = objective.dept.getTie(
) if not objective.dept == Dept.BOSS else 'corp'
bldgMdl = loader.loadModel(
'phase_4/models/modules/suit_landmark_%s.bam' % dept)
# Next, we need to load the building elevator.
elevator = loader.loadModel('phase_4/models/modules/elevator.bam')
elevator.reparentTo(bldgMdl.find('**/*_door_origin'))
self.handleComplexIcon(bldgMdl, iconElement)
# Let's set the progress bar text
pgBarText = '%d of %d %s' % (objective.progress, objective.goal,
CIGlobals.makePastTense(auxText))
self.progressBar['text'] = pgBarText
self.objectiveInfo['text'] = infoText
self.auxText['text'] = auxText
self.auxFrame['image_color'] = Vec4(*frameColor)
def handleMinigameObjective(self,
iconElement=auxIcon,
auxText=QuestGlobals.PLAY,
frameColor=QuestGlobals.RED):
objective = self.viewObjective
infoText = objective.getTaskInfo()
if not iconElement:
iconElement = self.auxIcon
# Let's make sure we have a current objective that is
# an instance of the MinigameObjective class and this poster isn't destroyed.
if not objective or not hasattr(self, 'titleLabel') or not isinstance(
objective, MinigameObjective):
return
# Let's set the icon to the minigame icon.
self.handleSimpleIcon(QuestGlobals.getTrolleyIcon(),
QuestGlobals.SIMPLE_IMAGE_SCALE, iconElement)
# Let's set the progress bar text
pgBarText = '%d of %d %s' % (objective.progress, objective.goal,
CIGlobals.makePastTense(auxText))
self.progressBar['text'] = pgBarText
self.objectiveInfo['text'] = infoText
self.auxText['text'] = auxText
self.auxFrame['image_color'] = Vec4(*frameColor)
def handleNPCObjective(self,
iconElement=auxIcon,
auxText=QuestGlobals.VISIT,
frameColor=QuestGlobals.BROWN):
objective = self.viewObjective
npcId = 0
if self.accessibleObjectives.isComplete() and not hasattr(
objective, 'npcId'):
npcId = objective.assigner
elif hasattr(objective, 'npcId'):
npcId = objective.npcId
if npcId == 0:
infoText = 'A %s' % NPCGlobals.lHQOfficerF
else:
infoText = NPCGlobals.NPCToonNames[npcId]
if not iconElement:
iconElement = self.auxIcon
# Let's generate the head.
if not npcId == 0:
dna = ToonDNA()
dna.setDNAStrand(NPCGlobals.NPCToonDict.get(npcId)[2])
head = ToonGlobals.generateGuiHead(dna)
self.handleComplexIcon(head,
iconElement,
scale=QuestGlobals.IMAGE_SCALE_SMALL - 0.01)
else:
self.handleSimpleIcon(QuestGlobals.getHQIcon(),
QuestGlobals.SIMPLE_IMAGE_SCALE, iconElement)
self.auxText['text'] = auxText
if not iconElement is self.auxIcon:
if hasattr(self, 'goalInfo'):
# We're working with the second frame, on the right.
# Let's update the information pertaining to this side.
self.goalInfo['text'] = infoText
self.goalInfo.setPos(QuestGlobals.RECOVER_INFO2_POS)
self.auxText.setPos(QuestGlobals.RECOVER_AUX_POS)
self.goalFrame['image_color'] = frameColor
else:
raise AttributeError(
'Attempted to setup DoubleFrame information for poster using default style.'
)
else:
self.objectiveInfo['text'] = infoText
self.auxFrame['image_color'] = frameColor
def fitGeometry(self, geom, fFlip=0, dimension=0.8):
p1 = Point3()
p2 = Point3()
geom.calcTightBounds(p1, p2)
if fFlip:
t = p1[0]
p1.setX(-p2[0])
p2.setX(-t)
d = p2 - p1
biggest = max(d[0], d[2])
s = dimension / biggest
mid = (p1 + d / 2.0) * s
geomXform = hidden.attachNewNode('geomXform')
for child in geom.getChildren():
child.reparentTo(geomXform)
geomXform.setPosHprScale(-mid[0], -mid[1] + 1, -mid[2], 180, 0, 0, s,
s, s)
geomXform.reparentTo(geom)
def destroy(self):
if hasattr(self, 'titleLabel'):
self.titleLabel.destroy()
self.auxFrame.destroy()
self.auxIcon.destroy()
self.auxOutline.destroy()
self.auxText.destroy()
self.objectiveInfo.destroy()
self.locationInfo.destroy()
self.progressBar.destroy()
self.rewardFrame.destroy()
self.sideInfo.destroy()
self.lReward.destroy()
# We need to cleanup our arrows if they were created.
if hasattr(self, 'prevObjArrow'):
self.prevObjArrow.destroy()
self.nextObjArrow.destroy()
del self.prevObjArrow
del self.nextObjArrow
del self.titleLabel
del self.auxFrame
del self.auxIcon
del self.auxOutline
del self.auxText
del self.objectiveInfo
del self.locationInfo
del self.progressBar
del self.rewardFrame
del self.sideInfo
del self.lReward
del self.accessibleObjectives
del self.viewObjective
DirectFrame.destroy(self)
self.notify.debug('Destroyed all elements.')
class JellybeanRewardGui(DirectFrame):
notify = directNotify.newCategory('JellybeanRewardGui')
PreCountdownDelay = 1.0
CountDownRate = 0.2
JarLabelTextColor = (0.95, 0.95, 0.0, 1.0)
JarLabelMaxedTextColor = (1.0, 0.0, 0.0, 1.0)
def __init__(self, doneEvent):
self.doneEvent = doneEvent
DirectFrame.__init__(self)
self.reparentTo(aspect2d)
self.setPos(0.0, 0.0, 0.16)
self.stash()
publicPartyGui = loader.loadModel('phase_4/models/parties/publicPartyGUI')
self.frame = DirectFrame(parent=self, geom=publicPartyGui.find('**/activities_background'), geom_pos=(-0.8, 0.0, 0.2), geom_scale=2.0, relief=None)
self.earnedLabel = DirectLabel(parent=self, relief=None, text=str(0), text_align=TextNode.ACenter, text_pos=(0.0, -0.07), text_scale=0.2, text_fg=(0.95, 0.95, 0.0, 1.0), text_font=ToontownGlobals.getSignFont(), textMayChange=True, image=DirectGuiGlobals.getDefaultDialogGeom(), image_scale=(0.33, 1.0, 0.33), pos=(-0.3, 0.0, 0.2), scale=0.9)
purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui')
jarImage = purchaseModels.find('**/Jar')
self.jarLabel = DirectLabel(parent=self, relief=None, text=str(0), text_align=TextNode.ACenter, text_pos=(0.0, -0.07), text_scale=0.2, text_fg=JellybeanRewardGui.JarLabelTextColor, text_font=ToontownGlobals.getSignFont(), textMayChange=True, image=jarImage, scale=0.7, pos=(0.3, 0.0, 0.17))
purchaseModels.removeNode()
del purchaseModels
jarImage.removeNode()
del jarImage
self.messageLabel = DirectLabel(parent=self, relief=None, text='', text_align=TextNode.ALeft, text_wordwrap=16.0, text_scale=0.07, pos=(-0.52, 0.0, -0.1), textMayChange=True)
self.doubledJellybeanLabel = DirectLabel(parent=self, relief=None, text=TTLocalizer.PartyRewardDoubledJellybean, text_align=TextNode.ACenter, text_wordwrap=12.0, text_scale=0.09, text_fg=(1.0, 0.125, 0.125, 1.0), pos=(0.0, 0.0, -0.465), textMayChange=False)
self.doubledJellybeanLabel.hide()
self.closeButton = DirectButton(parent=self, relief=None, text=TTLocalizer.PartyJellybeanRewardOK, text_align=TextNode.ACenter, text_scale=0.065, text_pos=(0.0, -0.625), geom=(publicPartyGui.find('**/startButton_up'),
publicPartyGui.find('**/startButton_down'),
publicPartyGui.find('**/startButton_rollover'),
publicPartyGui.find('**/startButton_inactive')), geom_pos=(-0.39, 0.0, 0.125), command=self._close)
publicPartyGui.removeNode()
del publicPartyGui
self.countSound = base.loadSfx('phase_13/audio/sfx/tick_counter_short.mp3')
self.overMaxSound = base.loadSfx('phase_13/audio/sfx/tick_counter_overflow.mp3')
return
def showReward(self, earnedAmount, jarAmount, message):
JellybeanRewardGui.notify.debug('showReward( earnedAmount=%d, jarAmount=%d, ...)' % (earnedAmount, jarAmount))
self.earnedCount = earnedAmount
self.earnedLabel['text'] = str(self.earnedCount)
self.jarCount = jarAmount
self.jarMax = base.localAvatar.getMaxMoney()
self.jarLabel['text'] = str(self.jarCount)
self.jarLabel['text_fg'] = JellybeanRewardGui.JarLabelTextColor
self.messageLabel['text'] = message
if base.cr.newsManager.isHolidayRunning(ToontownGlobals.JELLYBEAN_DAY) or base.cr.newsManager.isHolidayRunning(ToontownGlobals.JELLYBEAN_PARTIES_HOLIDAY) or base.cr.newsManager.isHolidayRunning(ToontownGlobals.JELLYBEAN_PARTIES_HOLIDAY_MONTH):
self.doubledJellybeanLabel.show()
else:
self.doubledJellybeanLabel.hide()
self.unstash()
taskMgr.doMethodLater(JellybeanRewardGui.PreCountdownDelay, self.transferOneJellybean, 'JellybeanRewardGuiTransferOneJellybean', extraArgs=[])
def transferOneJellybean(self):
if self.earnedCount == 0:
return
self.earnedCount -= 1
self.earnedLabel['text'] = str(self.earnedCount)
self.jarCount += 1
if self.jarCount <= self.jarMax:
self.jarLabel['text'] = str(self.jarCount)
elif self.jarCount > self.jarMax:
self.jarLabel['text_fg'] = JellybeanRewardGui.JarLabelMaxedTextColor
if self.jarCount <= self.jarMax:
base.playSfx(self.countSound)
else:
base.playSfx(self.overMaxSound)
taskMgr.doMethodLater(JellybeanRewardGui.CountDownRate, self.transferOneJellybean, 'JellybeanRewardGuiTransferOneJellybean', extraArgs=[])
def _close(self):
taskMgr.remove('JellybeanRewardGuiTransferOneJellybean')
self.stash()
messenger.send(self.doneEvent)
def destroy(self):
taskMgr.remove('JellybeanRewardGuiTransferOneJellybean')
del self.countSound
del self.overMaxSound
self.frame.destroy()
self.earnedLabel.destroy()
self.jarLabel.destroy()
self.messageLabel.destroy()
self.closeButton.destroy()
DirectFrame.destroy(self)
class RepairMincroGame(DirectFrame, FSM.FSM):
readySound = None
goSound = None
completeSound = None
def __init__(self, repairGame, name, startText):
DirectFrame.__init__(self, parent = repairGame.gui, relief = None)
FSM.FSM.__init__(self, '%sFSM' % name)
self.defaultTransitions = {
'Idle': [
'Intro',
'Final'],
'Intro': [
'Game',
'Idle',
'Final'],
'Game': [
'Outro',
'Idle',
'Final'],
'Outro': [
'Idle',
'Final'],
'Final': [] }
self.name = name
self.repairGame = repairGame
self.startText = startText
self._initVars()
self._initAudio()
self._initVisuals()
self._initIntervals()
self.request('Idle')
def _initVars(self):
self.complete = False
self.difficulty = 0
def _initAudio(self):
if not self.readySound:
RepairMincroGame.readySound = loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_GENERAL_READY)
RepairMincroGame.goSound = loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_GENERAL_GO)
RepairMincroGame.completeSound = loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_GENERAL_GAMECOMPLETE)
def _initVisuals(self):
self.countDownLabel = DirectLabel(text = self.startText, text_fg = (1.0, 1.0, 1.0, 1.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), scale = (0.16, 0.16, 0.16), pos = (0.0, 0.0, 0.14999999999999999), parent = self, relief = None, textMayChange = 1)
self.countDownLabel.setBin('fixed', 37)
self.winLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Win, text_fg = (1.0, 1.0, 1.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.16, 0.16, 0.16), pos = RepairGlobals.Common.youWinPos[self.name], relief = None, parent = self)
self.winLabel.setBin('fixed', 37)
self.winLabel.stash()
self.scoreLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Win, text_fg = (1.0, 1.0, 1.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.10000000000000001, 0.10000000000000001, 0.10000000000000001), pos = RepairGlobals.Common.scorePos[self.name], relief = None, parent = self)
self.scoreLabel.setBin('fixed', 37)
self.scoreLabel.stash()
self.postWinLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pick_New_Game, text_fg = (1.0, 1.0, 1.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.14000000000000001, 0.14000000000000001, 0.14000000000000001), pos = RepairGlobals.Common.youWinPos[self.name], relief = None, textMayChange = 1, parent = self.repairGame.gui)
self.postWinLabel.setBin('fixed', 37)
self.postWinLabel.stash()
def _initIntervals(self):
normalPos = Vec3(0.0, 0.0, 0.14999999999999999)
belowScreenPos = Vec3(normalPos.getX(), normalPos.getY(), normalPos.getZ() - 0.25)
aboveScreenPos = Vec3(normalPos.getX(), normalPos.getY(), normalPos.getZ() + 0.25)
self.introSequence = Sequence(Func(self.setCountDown, PLocalizer.Minigame_Repair_Countdown_Ready), Parallel(LerpFunc(self.countDownLabel.setPos, fromData = belowScreenPos, toData = normalPos, duration = 0.25), LerpFunc(self.countDownLabel.setAlphaScale, fromData = 0.0, toData = 1.0, duration = 0.25)), Func(self.readySound.play), Wait(0.5), Parallel(LerpFunc(self.countDownLabel.setPos, fromData = normalPos, toData = aboveScreenPos, duration = 0.25), LerpFunc(self.countDownLabel.setAlphaScale, fromData = 1.0, toData = 0.0, duration = 0.25)), Func(self.setCountDown, self.startText), Parallel(LerpFunc(self.countDownLabel.setPos, fromData = belowScreenPos, toData = normalPos, duration = 0.25), LerpFunc(self.countDownLabel.setAlphaScale, fromData = 0.0, toData = 1.0, duration = 0.25)), Func(self.goSound.play), Wait(0.5), Parallel(LerpFunc(self.countDownLabel.setPos, fromData = normalPos, toData = aboveScreenPos, duration = 0.25), LerpFunc(self.countDownLabel.setAlphaScale, fromData = 1.0, toData = 0.0, duration = 0.25)), Func(self.request, 'Game'), name = 'RepairMincroGame.introSequence')
normalPos = Vec3(RepairGlobals.Common.youWinPos[self.name])
normalScorePos = Vec3(RepairGlobals.Common.scorePos[self.name])
belowScreenPos = Vec3(normalPos.getX(), normalPos.getY(), normalPos.getZ() - 0.25)
aboveScreenPos = Vec3(normalPos.getX(), normalPos.getY(), normalPos.getZ() + 0.25)
belowScreenScorePos = Vec3(normalScorePos.getX(), normalScorePos.getY(), normalScorePos.getZ() - 0.25)
aboveScreenScorePos = Vec3(normalScorePos.getX(), normalScorePos.getY(), normalScorePos.getZ() + 0.25)
self.outroSequence = Sequence(Func(self.winLabel.setAlphaScale, 0), Func(self.scoreLabel.setAlphaScale, 0), Func(self.postWinLabel.setAlphaScale, 0), Func(self.winLabel.setPos, belowScreenPos), Func(self.scoreLabel.setPos, belowScreenScorePos), Func(self.postWinLabel.setPos, belowScreenPos), Func(self.setScoreLabelText), Func(self.winLabel.unstash), Func(self.scoreLabel.unstash), Func(self.postWinLabel.unstash), Parallel(LerpFunc(self.scoreLabel.setPos, fromData = belowScreenScorePos, toData = normalScorePos, duration = 0.25), LerpFunc(self.scoreLabel.setAlphaScale, fromData = 0.0, toData = 1.0, duration = 0.25), LerpFunc(self.winLabel.setPos, fromData = belowScreenPos, toData = normalPos, duration = 0.25), LerpFunc(self.winLabel.setAlphaScale, fromData = 0.0, toData = 1.0, duration = 0.25)), Func(self.completeSound.play), Wait(1.0), Parallel(LerpFunc(self.winLabel.setPos, fromData = normalPos, toData = aboveScreenPos, duration = 0.25), LerpFunc(self.winLabel.setAlphaScale, fromData = 1.0, toData = 0.0, duration = 0.25), LerpFunc(self.scoreLabel.setPos, fromData = normalScorePos, toData = aboveScreenScorePos, duration = 0.25), LerpFunc(self.scoreLabel.setAlphaScale, fromData = 1.0, toData = 0.0, duration = 0.25)), Func(self.winLabel.stash), Func(self.scoreLabel.stash), Func(self.stashPostWinLabelIfCycleComplete), Wait(0.25), Parallel(LerpFunc(self.postWinLabel.setPos, fromData = belowScreenPos, toData = normalPos, duration = 0.25), LerpFunc(self.postWinLabel.setAlphaScale, fromData = 0.0, toData = 1.0, duration = 0.25)), name = 'outroSequence')
self.cleanupSequence = Sequence(Parallel(LerpFunc(self.postWinLabel.setPos, fromData = normalPos, toData = aboveScreenPos, duration = 0.5), LerpFunc(self.postWinLabel.setAlphaScale, fromData = 1.0, toData = 0.0, duration = 0.5), LerpFunc(self.scoreLabel.setAlphaScale, fromData = 1.0, toData = 0.0, duration = 0.5)), Func(self.scoreLabel.stash), Func(self.postWinLabel.stash), name = 'cleanupSequence')
def updatePostWinLabel(self):
if self.repairGame.isThereAnOpenGame():
self.postWinLabel['text'] = PLocalizer.Minigame_Repair_Pick_New_Game
else:
self.postWinLabel['text'] = PLocalizer.Minigame_Repair_Waiting_For_Players
self.postWinLabel.setText()
def setScoreLabelText(self):
labelSet = False
for i in [
0,
1,
2]:
if not labelSet:
percent = self.difficulty / self.repairGame.difficultyMax
dif = RepairGlobals.Common.speedThresholds[self.name][i][1] - RepairGlobals.Common.speedThresholds[self.name][i][0]
goalTime = RepairGlobals.Common.speedThresholds[self.name][i][0] + dif * percent
if self.repairGame.repairClock.gameTime < goalTime:
labelSet = True
self.scoreLabel['text'] = PLocalizer.Minigame_Repair_Speed_Thresholds[i]
self.repairGame.repairClock.gameTime < goalTime
if not labelSet:
self.scoreLabel['text'] = PLocalizer.Minigame_Repair_Speed_Thresholds[3]
def stashPostWinLabelIfCycleComplete(self):
if self.repairGame.isCycleComplete():
self.postWinLabel.stash()
def setDifficulty(self, difficulty):
self.difficulty = difficulty
def setCountDown(self, text):
self.countDownLabel['text'] = text
self.countDownLabel.setText()
self.countDownLabel.setAlphaScale(0.0)
def destroy(self):
DirectFrame.destroy(self)
self.countDownLabel.destroy()
del self.countDownLabel
self.winLabel.destroy()
del self.winLabel
self.introSequence.clearToInitial()
del self.introSequence
self.outroSequence.clearToInitial()
del self.outroSequence
self.cleanupSequence.clearToInitial()
del self.cleanupSequence
del self.repairGame
self.cleanup()
def reset(self):
self.complete = False
self.repairGame.repairClock.stop()
def enterIdle(self):
self.stash()
def exitIdle(self):
pass
def enterIntro(self):
self.unstash()
self.countDownLabel.unstash()
self.introSequence.start()
self.reset()
self.countDownLabel.reparentTo(self)
def exitIntro(self):
self.countDownLabel.stash()
self.introSequence.clearToInitial()
def enterGame(self):
self.repairGame.repairClock.restart()
def exitGame(self):
self.repairGame.repairClock.pause()
def enterOutro(self):
self.outroSequence.start()
self.complete = True
def exitOutro(self):
self.outroSequence.finish()
self.cleanupSequence.start()
self.reset()
self.repairGame.gui.clearTutorial()
self.repairGame.gui.clearTitle()
def enterFinal(self):
pass
class CalendarGuiDay(DirectFrame):
"""A class to represent the gui for one day in the month.
Do not put references to the shtiker page or book, so this
class may be extended later."""
notify = directNotify.newCategory("CalendarGuiDay")
ScrollListTextSize = 0.03
def __init__(self,
parent,
myDate,
startDate,
dayClickCallback=None,
onlyFutureDaysClickable=False):
"""Construct ourself."""
self.origParent = parent
self.startDate = startDate
self.myDate = myDate
self.dayClickCallback = dayClickCallback
# If true, only allow clicks on days in the future
self.onlyFutureDaysClickable = onlyFutureDaysClickable
DirectFrame.__init__(self, parent=parent)
self.timedEvents = []
self.partiesInvitedToToday = []
self.hostedPartiesToday = []
self.yearlyHolidaysToday = [] # either ending or starting today
self.showMarkers = base.config.GetBool('show-calendar-markers', 0)
self.filter = ToontownGlobals.CalendarFilterShowAll
self.load()
# self.createDummyLocators()
self.createGuiObjects()
self.update()
def createDummyLocators(self):
"""Put some programming locators until we get the real art assets."""
self.dayButtonLocator = self.attachNewNode('dayButtonLocator')
self.dayButtonLocator.setX(0.1)
self.dayButtonLocator.setZ(-0.05)
self.numberLocator = self.attachNewNode('numberLocator')
self.numberLocator.setX(0.09)
self.scrollLocator = self.attachNewNode('scrollLocator')
self.selectedLocator = self.attachNewNode('selectedLocator')
self.selectedLocator.setX(0.11)
self.selectedLocator.setZ(-0.06)
def load(self):
"""Load the assets, and make sure locators are there."""
dayAsset = loader.loadModel(
'phase_4/models/parties/tt_m_gui_sbk_calendar_box')
dayAsset.reparentTo(self)
self.dayButtonLocator = self.find('**/loc_origin')
self.numberLocator = self.find('**/loc_number')
self.scrollLocator = self.find('**/loc_topLeftList')
self.selectedLocator = self.find('**/loc_origin')
self.todayBox = self.find('**/boxToday')
self.todayBox.hide()
self.selectedFrame = self.find('**/boxHover')
self.selectedFrame.hide()
self.defaultBox = self.find('**/boxBlank')
self.scrollBottomRightLocator = self.find('**/loc_bottomRightList')
self.scrollDownLocator = self.find('**/loc_scrollDown')
self.attachMarker(self.scrollDownLocator)
self.scrollUpLocator = self.find('**/loc_scrollUp')
self.attachMarker(self.scrollUpLocator)
def attachMarker(self, parent, scale=0.005, color=(1, 0, 0)):
"""Attach a marker to the parent to aid in visual debugging."""
if self.showMarkers:
marker = loader.loadModel("phase_3/models/misc/sphere")
marker.reparentTo(parent)
marker.setScale(scale)
marker.setColor(*color)
def createGuiObjects(self):
"""Create the other gui objects in the month, assumes we have proper locators."""
# we create an invisible button so the day can be clicked on
self.dayButton = DirectButton(
parent=self.dayButtonLocator,
image=self.selectedFrame,
relief=None,
command=self.__clickedOnDay,
# next three settings are for debug
pressEffect=1,
rolloverSound=None,
clickSound=None)
self.numberWidget = DirectLabel(
parent=self.numberLocator,
relief=None,
text=str(self.myDate.day),
text_scale=0.04,
text_align=TextNode.ACenter,
text_font=ToontownGlobals.getInterfaceFont(),
text_fg=Vec4(110 / 255.0, 126 / 255.0, 255 / 255.0, 1),
)
self.attachMarker(self.numberLocator)
self.listXorigin = 0
self.listFrameSizeX = self.scrollBottomRightLocator.getX(
) - self.scrollLocator.getX()
self.scrollHeight = self.scrollLocator.getZ(
) - self.scrollBottomRightLocator.getZ()
self.listZorigin = self.scrollBottomRightLocator.getZ()
self.listFrameSizeZ = self.scrollLocator.getZ(
) - self.scrollBottomRightLocator.getZ()
self.arrowButtonXScale = 1
self.arrowButtonZScale = 1
self.itemFrameXorigin = 0
self.itemFrameZorigin = 0
self.buttonXstart = self.itemFrameXorigin + 0.21
self.gui = loader.loadModel("phase_3.5/models/gui/friendslist_gui")
buttonOffSet = -0.01
# these settings put the arrow buttons on the top
incButtonPos = (0.0, 0, 0)
decButtonPos = (0.0, 0, 0)
# these settings put the arrow buttons on the right side
# incButtonPos = (self.buttonXstart,0,self.listZorigin - buttonOffSet)
# decButtonPos = (self.buttonXstart, 0, self.listZorigin + self.listFrameSizeZ + buttonOffSet)
itemFrameMinZ = self.listZorigin
itemFrameMaxZ = self.listZorigin + self.listFrameSizeZ
arrowUp = self.find("**/downScroll_up")
arrowDown = self.find("**/downScroll_down")
arrowHover = self.find("**/downScroll_hover")
self.scrollList = DirectScrolledList(
parent=self.scrollLocator,
relief=None,
pos=(0, 0, 0),
# inc and dec are DirectButtons
# incButton is on the bottom of page, decButton is on the top!
incButton_image=(
arrowUp,
arrowDown,
arrowHover,
arrowUp,
),
incButton_relief=None,
incButton_scale=(self.arrowButtonXScale, 1,
self.arrowButtonZScale),
incButton_pos=incButtonPos,
# Make the disabled button fade out
incButton_image3_color=Vec4(1, 1, 1, 0.2),
decButton_image=(
arrowUp,
arrowDown,
arrowHover,
arrowUp,
),
decButton_relief=None,
decButton_scale=(self.arrowButtonXScale, 1,
-self.arrowButtonZScale),
decButton_pos=decButtonPos,
# Make the disabled button fade out
decButton_image3_color=Vec4(1, 1, 1, 0.2),
# itemFrame is a DirectFrame, shift it down a bit to match top left scroll
itemFrame_pos=(self.itemFrameXorigin, 0, -0.03),
# each item is a button with text on it
numItemsVisible=4,
# so we select the day when we click on a scroll button
incButtonCallback=self.scrollButtonPressed,
decButtonCallback=self.scrollButtonPressed,
)
# make sure the arrow buttons appear over item frame
itemFrameParent = self.scrollList.itemFrame.getParent()
self.scrollList.incButton.reparentTo(self.scrollDownLocator)
self.scrollList.decButton.reparentTo(self.scrollUpLocator)
arrowUp.removeNode()
arrowDown.removeNode()
arrowHover.removeNode()
# Set up a clipping plane to truncate names that would extend
# off the right end of the scrolled list.
clipper = PlaneNode('clipper')
clipper.setPlane(Plane(Vec3(-1, 0, 0), Point3(0.23, 0, 0)))
clipNP = self.scrollList.component('itemFrame').attachNewNode(clipper)
self.scrollList.component('itemFrame').setClipPlane(clipNP)
def scrollButtonPressed(self):
"""Select the current day when the scroll button is pressed."""
self.__clickedOnDay()
def adjustForMonth(self):
"""Darken us if we are not in the same month as startDate."""
# make us glow if are equal to the serverDate
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.onlyFutureDaysClickable:
if self.myDate.year < curServerDate.year or \
( self.myDate.year == curServerDate.year and self.myDate.month < curServerDate.month ) or \
( self.myDate.year == curServerDate.year and self.myDate.month == curServerDate.month and self.myDate.day < curServerDate.day ):
self.numberWidget.setColorScale(0.5, 0.5, 0.5, 0.5)
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.numberWidget.setColorScale(1, 1, 1, 1)
if self.myDate.month != self.startDate.month:
self.setColorScale(0.75, 0.75, 0.75, 1.0)
if self.dayClickCallback is not None:
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.setColorScale(1, 1, 1, 1)
if self.myDate.date() == curServerDate.date():
self.defaultBox.hide()
self.todayBox.show()
else:
self.defaultBox.show()
self.todayBox.hide()
def destroy(self):
if self.dayClickCallback is not None:
self.numberWidget.destroy()
self.dayClickCallback = None
self.notify.debug('desroying %s' % self.myDate)
try:
for item in self.scrollList['items']:
if hasattr(item,
"description") and item.description and hasattr(
item.description, 'destroy'):
self.notify.debug('desroying description of item %s' %
item)
item.unbind(DGG.ENTER)
item.unbind(DGG.EXIT)
item.description.destroy()
except e:
self.notify.debug('pass %s' % self.myDate)
# an empty scroll list will come to this point
pass
self.scrollList.removeAndDestroyAllItems()
self.scrollList.destroy()
self.dayButton.destroy()
DirectFrame.destroy(self)
def addWeeklyHolidays(self):
"""Add weekly holidays to our scroll list."""
if not (self.filter == ToontownGlobals.CalendarFilterShowAll or \
self.filter == ToontownGlobals.CalendarFilterShowOnlyHolidays):
return
if base.cr.newsManager:
holidays = base.cr.newsManager.getHolidaysForWeekday(
self.myDate.weekday())
holidayName = ""
holidayDesc = ""
for holidayId in holidays:
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[
holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[
holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
self.scrollList.refresh()
if base.config.GetBool('calendar-test-items', 0):
# add test items just so we see scroll list arrows
if self.myDate.date() + datetime.timedelta(
days=-1
) == base.cr.toontownTimeManager.getCurServerDateTime().date():
testItems = ("1:00 AM Party", "2:00 AM CEO", "11:15 AM Party",
"5:30 PM CJ", "11:00 PM Party",
"Really Really Long String")
for text in testItems:
newItem = DirectLabel(
relief=None,
text=text,
text_scale=self.ScrollListTextSize,
text_align=TextNode.ALeft,
)
self.scrollList.addItem(newItem)
if self.myDate.date() + datetime.timedelta(
days=-2
) == base.cr.toontownTimeManager.getCurServerDateTime().date():
testItems = (
"1:00 AM Party",
"3:00 AM CFO",
"11:00 AM Party",
)
textSize = self.ScrollListTextSize
for text in testItems:
newItem = DirectLabel(
relief=None,
text=text,
text_scale=textSize,
text_align=TextNode.ALeft,
)
self.scrollList.addItem(newItem)
def updateArrowButtons(self):
"""If we don't have anything in out scroll list, hide the arrow buttons."""
numItems = 0
try:
numItems = len(self.scrollList['items'])
except e:
numItems = 0
if numItems <= self.scrollList.numItemsVisible:
self.scrollList.incButton.hide()
self.scrollList.decButton.hide()
else:
self.scrollList.incButton.show()
self.scrollList.decButton.show()
def collectTimedEvents(self):
"""Sort by time the events in my day."""
# possible events would be yearly holidays,
# oncely holidays and relatively holidays
# parties
# and in the future planned boss battle raids
self.timedEvents = []
if (self.filter == ToontownGlobals.CalendarFilterShowAll or \
self.filter == ToontownGlobals.CalendarFilterShowOnlyParties):
for party in localAvatar.partiesInvitedTo:
#if self.myDate.month == 9 and self.myDate.day == 1:
# import pdb; pdb.set_trace()
if party.startTime.date() == self.myDate.date():
self.partiesInvitedToToday.append(party)
self.timedEvents.append((party.startTime.time(), party))
for party in localAvatar.hostedParties:
if party.startTime.date() == self.myDate.date():
self.hostedPartiesToday.append(party)
self.timedEvents.append((party.startTime.time(), party))
if base.cr.newsManager and (self.filter == ToontownGlobals.CalendarFilterShowAll or \
self.filter == ToontownGlobals.CalendarFilterShowOnlyHolidays):
yearlyHolidays = base.cr.newsManager.getYearlyHolidaysForDate(
self.myDate)
for holiday in yearlyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.month and \
holidayStart[1] == self.myDate.day:
myTime = datetime.time(holidayStart[2], holidayStart[3])
elif holidayEnd[0] == self.myDate.month and \
holidayEnd[1] == self.myDate.day:
myTime = datetime.time(holidayEnd[2], holidayEnd[3])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
oncelyHolidays = base.cr.newsManager.getOncelyHolidaysForDate(
self.myDate)
for holiday in oncelyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.year and \
holidayStart[1] == self.myDate.month and \
holidayStart[2] == self.myDate.day:
myTime = datetime.time(holidayStart[3], holidayStart[4])
elif holidayEnd[0] == self.myDate.year and \
holidayEnd[1] == self.myDate.month and \
holidayEnd[2] == self.myDate.day:
myTime = datetime.time(holidayEnd[3], holidayEnd[4])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
multipleStartHolidays = base.cr.newsManager.getMultipleStartHolidaysForDate(
self.myDate)
for holiday in multipleStartHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.year and \
holidayStart[1] == self.myDate.month and \
holidayStart[2] == self.myDate.day:
myTime = datetime.time(holidayStart[3], holidayStart[4])
elif holidayEnd[0] == self.myDate.year and \
holidayEnd[1] == self.myDate.month and \
holidayEnd[2] == self.myDate.day:
myTime = datetime.time(holidayEnd[3], holidayEnd[4])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
relativelyHolidays = base.cr.newsManager.getRelativelyHolidaysForDate(
self.myDate)
for holiday in relativelyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.month and \
holidayStart[1] == self.myDate.day:
myTime = datetime.time(holidayStart[2], holidayStart[3])
elif holidayEnd[0] == self.myDate.month and \
holidayEnd[1] == self.myDate.day:
myTime = datetime.time(holidayEnd[2], holidayEnd[3])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
# sort timedEvents
def timedEventCompare(te1, te2):
if te1[0] < te2[0]:
return -1
elif te1[0] == te2[0]:
return 0
else:
return 1
self.timedEvents.sort(cmp=timedEventCompare)
# now add them to the scroll list
for timedEvent in self.timedEvents:
if isinstance(timedEvent[1], PartyInfo):
self.addPartyToScrollList(timedEvent[1])
elif isinstance(
timedEvent[1], tuple
) and timedEvent[1][0] == NewsManager.YearlyHolidayType:
self.addYearlyHolidayToScrollList(timedEvent[1])
elif isinstance(
timedEvent[1], tuple
) and timedEvent[1][0] == NewsManager.OncelyHolidayType:
self.addOncelyHolidayToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][
0] == NewsManager.OncelyMultipleStartHolidayType:
self.addOncelyMultipleStartHolidayToScrollList(timedEvent[1])
elif isinstance(
timedEvent[1], tuple
) and timedEvent[1][0] == NewsManager.RelativelyHolidayType:
self.addRelativelyHolidayToScrollList(timedEvent[1])
def addYearlyHolidayToScrollList(self, holiday):
"""Add a yearly holiday to the scroll list. Could be start date or end date"""
# first figure out if it ends on the same day
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ""
startTime = datetime.time(holidayStart[2], holidayStart[3])
endTime = datetime.time(holidayEnd[2], holidayEnd[3])
startDate = datetime.date(self.myDate.year, holidayStart[0],
holidayStart[1])
endDate = datetime.date(self.myDate.year, holidayEnd[0], holidayEnd[1])
if endDate < startDate:
endDate = datetime.date(endDate.year + 1, endDate.month,
endDate.day)
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = TTLocalizer.UnknownHoliday % holidayId
if holidayStart[0] == holidayEnd[0] and \
holidayStart[1] == holidayEnd[1]:
# end of holiday is on the same day
holidayText = myStrftime(startTime)
holidayText += " " + holidayName
holidayDesc += " " + TTLocalizer.CalendarEndsAt + myStrftime(
endTime)
elif self.myDate.month == holidayStart[0] and \
self.myDate.day == holidayStart[1]:
holidayText = myStrftime(startTime)
holidayText += " " + holidayName
holidayDesc = holidayName + ". " + holidayDesc
holidayDesc += " " + TTLocalizer.CalendarEndsAt + endDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.month == holidayEnd[0] and \
self.myDate.day == holidayEnd[1]:
holidayText = myStrftime(endTime)
holidayText += " " + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += ". " + TTLocalizer.CalendarStartedOn + startDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addOncelyHolidayToScrollList(self, holiday):
"""Add a oncely holiday to the scroll list. Could be start date or end date"""
# first figure out if it ends on the same day
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ""
startTime = datetime.time(holidayStart[3], holidayStart[4])
endTime = datetime.time(holidayEnd[3], holidayEnd[4])
startDate = datetime.date(holidayStart[0], holidayStart[1],
holidayStart[2])
endDate = datetime.date(holidayStart[0], holidayEnd[1], holidayEnd[2])
if endDate < startDate:
endDate = datetime.date(endDate.year + 1, endDate.month,
endDate.day)
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = ""
if holidayStart[1] == holidayEnd[1] and \
holidayStart[2] == holidayEnd[2]:
# end of holiday is on the same day
holidayText = myStrftime(startTime)
holidayText += " " + holidayName
holidayDesc = holidayName + ". " + holidayDesc
holidayDesc += " " + TTLocalizer.CalendarEndsAt + myStrftime(
endTime)
elif self.myDate.year == holidayStart[0] and \
self.myDate.month == holidayStart[1] and \
self.myDate.day == holidayStart[2]:
holidayText = myStrftime(startTime)
holidayText += " " + holidayName
holidayDesc = holidayName + ". " + holidayDesc
holidayDesc += " " + TTLocalizer.CalendarEndsAt + endDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.year == holidayEnd[0] and \
self.myDate.month == holidayEnd[1] and \
self.myDate.day == holidayEnd[2]:
holidayText = myStrftime(endTime)
holidayText += " " + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += ". " + TTLocalizer.CalendarStartedOn + startDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addOncelyMultipleStartHolidayToScrollList(self, holiday):
"""Add a multiple start holiday to the scroll list. Could be start date or end date"""
# I can't think of anything different we'd do from addOncely, so just call that
self.addOncelyHolidayToScrollList(holiday)
def addRelativelyHolidayToScrollList(self, holiday):
"""Add a relatively holiday to the scroll list. Could be start date or end date"""
# first figure out if it ends on the same day
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ""
startTime = datetime.time(holidayStart[2], holidayStart[3])
endTime = datetime.time(holidayEnd[2], holidayEnd[3])
startDate = datetime.date(self.myDate.year, holidayStart[0],
holidayStart[1])
endDate = datetime.date(self.myDate.year, holidayEnd[0], holidayEnd[1])
if endDate < startDate:
endDate.year += 1
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = ""
if holidayStart[0] == holidayEnd[0] and \
holidayStart[1] == holidayEnd[1]:
# end of holiday is on the same day
holidayText = myStrftime(startTime)
holidayText += " " + holidayName
holidayDesc += " " + TTLocalizer.CalendarEndsAt + myStrftime(
endTime)
elif self.myDate.month == holidayStart[0] and \
self.myDate.day == holidayStart[1]:
holidayText = myStrftime(startTime)
holidayText += " " + holidayName
holidayDesc = holidayName + ". " + holidayDesc
holidayDesc += " " + TTLocalizer.CalendarEndsAt + endDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.month == holidayEnd[0] and \
self.myDate.day == holidayEnd[1]:
holidayText = myStrftime(endTime)
holidayText += " " + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += ". " + TTLocalizer.CalendarStartedOn + startDate.strftime(
TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addTitleAndDescToScrollList(self, title, desc):
"""Add a text title and popup description to the scrollList."""
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(
relief=None,
text=title,
text_scale=textSize,
text_align=TextNode.ALeft,
rolloverSound=None,
clickSound=None,
pressEffect=0,
command=self.__clickedOnScrollItem,
)
# lower tool tip a little
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = (scrollItemHeight * descTextSize / textSize)
descUnderItemZAdjust = max(
0.0534, descUnderItemZAdjust) # ensure minimum height
descUnderItemZAdjust = -descUnderItemZAdjust
# self.notify.debug('scrollItemHeight of %s = %f' % (title, scrollItemHeight))
descZAdjust = descUnderItemZAdjust
# self.notify.debug('descUnderItemZAdjust of %s = %f' % (title, descUnderItemZAdjust))
newItem.description = DirectLabel(
parent=newItem,
pos=(0.115, 0, descZAdjust),
text='',
text_wordwrap=15,
pad=(0.02, 0.02),
text_scale=descTextSize,
text_align=TextNode.ACenter,
textMayChange=0,
)
# if we set text here, it really slows down changing the month
# do it when we first enter the scroll item instead
newItem.description.checkedHeight = False
# # workaround to stop getting clipped by plane node
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(DGG.ENTER,
self.enteredTextItem,
extraArgs=[newItem, desc, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
self.scrollList.addItem(newItem)
def exitedTextItem(self, newItem, mousepos):
newItem.description.hide()
def enteredTextItem(self, newItem, descText, descUnderItemZAdjust,
mousePos):
# compute if we go over edge, then adjust if needed
if not newItem.description.checkedHeight:
newItem.description.checkedHeight = True
newItem.description['text'] = descText
bounds = newItem.description.getBounds()
descHeight = newItem.description.getHeight()
# lets see if we go down too far
scrollItemHeight = newItem.getHeight()
descOverItemZAdjust = descHeight - (scrollItemHeight / 2.0)
descZPos = self.getPos(
aspect2d)[2] + descUnderItemZAdjust - descHeight
if descZPos < -1.0:
newItem.description.setZ(descOverItemZAdjust)
descWidth = newItem.description.getWidth()
brightFrame = loader.loadModel(
'phase_4/models/parties/tt_m_gui_sbk_calendar_popUp_bg')
newItem.description['geom'] = brightFrame
newItem.description['geom_scale'] = (descWidth, 1, descHeight)
descGeomZ = (bounds[2] - bounds[3]) / 2.0
descGeomZ += bounds[3]
# self.notify.debug('descGeomZ=%s' % descGeomZ)
newItem.description['geom_pos'] = (0, 0, descGeomZ)
# self.notify.debug('descWidth=%s descHeight=%s' % (descWidth, descHeight))
newItem.description.show()
def addPartyToScrollList(self, party):
"""Add a party to the scroll list."""
textSize = self.ScrollListTextSize
descTextSize = 0.05
partyTitle = myStrftime(party.startTime)
partyTitle = partyTitle + " " + TTLocalizer.EventsPageCalendarTabParty
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(
relief=None,
text=partyTitle,
text_scale=textSize,
text_align=TextNode.ALeft,
rolloverSound=None,
clickSound=None,
pressEffect=0,
command=self.__clickedOnScrollItem,
)
# lower tool tip a little
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = (scrollItemHeight * descTextSize / textSize)
descUnderItemZAdjust = max(
0.0534, descUnderItemZAdjust) # ensure minimum height
descUnderItemZAdjust = -descUnderItemZAdjust
# self.notify.debug('scrollItemHeight of %s = %f' % (title, scrollItemHeight))
descZAdjust = descUnderItemZAdjust
# self.notify.debug('descUnderItemZAdjust of %s = %f' % (title, descUnderItemZAdjust))
self.scrollList.addItem(newItem)
newItem.description = MiniInviteVisual(newItem, party)
# # workaround to stop getting clipped by plane node
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(
DGG.ENTER,
self.enteredTextItem,
extraArgs=[newItem, newItem.description, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
def __clickedOnScrollItem(self):
"""Handle the user clicking on a scroll item."""
self.__clickedOnDay()
def __clickedOnDay(self):
"""Handle user clicking on us a day square."""
acceptClick = True
if self.onlyFutureDaysClickable:
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.myDate.date() < curServerDate.date():
acceptClick = False
if not acceptClick:
return
if self.dayClickCallback:
self.dayClickCallback(self)
self.notify.debug('we got clicked on %s' % self.myDate.date())
# tell the calendarGuiMonth
messenger.send('clickedOnDay', [self.myDate.date()])
def updateSelected(self, selected):
# note set multiplier to 1.0 if we don't want to pop selected days
multiplier = 1.1
if selected:
self.selectedFrame.show()
self.setScale(multiplier)
self.setPos(-0.01, 0, 0.01)
grandParent = self.origParent.getParent()
self.origParent.reparentTo(grandParent)
else:
self.selectedFrame.hide()
self.setScale(1.0)
self.setPos(0, 0, 0)
def changeDate(self, startDate, myDate):
"""Change the date that we are displaying."""
self.startDate = startDate
self.myDate = myDate
self.scrollList.removeAndDestroyAllItems()
self.update()
def update(self):
"""Fill in the day with the proper contents."""
self.numberWidget['text'] = str(self.myDate.day)
self.adjustForMonth()
self.addWeeklyHolidays()
self.collectTimedEvents()
self.updateArrowButtons()
def changeFilter(self, filter):
"""Change our fliter, update scroll items if needed."""
oldFilter = self.filter
self.filter = filter
if self.filter != oldFilter:
self.scrollList.removeAndDestroyAllItems()
self.update()
class GroupTrackerPage(ShtikerPage.ShtikerPage):
notify = directNotify.newCategory('GroupTrackerPage')
def __init__(self):
ShtikerPage.ShtikerPage.__init__(self)
self.groupWidgets = []
self.playerWidgets = []
self.images = [] # image nodes: Possible images to apply on groups
self.scrollList = None # DirectScrolledList: Holds the GroupTrackerGroup widgets
self.scrollTitle = None # DirectLabel: Title of the list that holds the groups
self.playerList = None # DirectScrolledList: Holds players when showing a specific group details
self.playerListTitle = None # DirectLabel: Title of the playerList
self.groupInfoTitle = None # DirectLabel: holds the group detail title to show on the right
self.groupInfoDistrict = None # DirectLabel: shows group detail district on the right
self.statusMessage = None # DirectLabel: Shows important messages like Loading... or "No boarding groups available"
self.groupIcon = None # DirectButton: Icon to associate with the group ex. sellbot icon or cashbot icon depending on group info
self.wantGroupToggle = None # DirectButton: Allows the toon to toggle his listing
def load(self):
self.listXorigin = -0.02
self.listFrameSizeX = 0.67
self.listZorigin = -0.96
self.listFrameSizeZ = 1.04
self.arrowButtonScale = 1.3
self.itemFrameXorigin = -0.237
self.itemFrameZorigin = 0.365
self.buttonXstart = self.itemFrameXorigin + 0.293
self.gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui')
guiButton = loader.loadModel('phase_3/models/gui/quit_button')
self.scrollList = DirectScrolledList(
parent=self,
relief=None,
pos=(-0.5, 0, 0),
incButton_image=(self.gui.find('**/FndsLst_ScrollUp'),
self.gui.find('**/FndsLst_ScrollDN'),
self.gui.find('**/FndsLst_ScrollUp_Rllvr'),
self.gui.find('**/FndsLst_ScrollUp')),
incButton_relief=None,
incButton_scale=(self.arrowButtonScale, self.arrowButtonScale,
-self.arrowButtonScale),
incButton_pos=(self.buttonXstart, 0,
self.itemFrameZorigin - 0.999),
incButton_image3_color=Vec4(1, 1, 1, 0.2),
decButton_image=(self.gui.find('**/FndsLst_ScrollUp'),
self.gui.find('**/FndsLst_ScrollDN'),
self.gui.find('**/FndsLst_ScrollUp_Rllvr'),
self.gui.find('**/FndsLst_ScrollUp')),
decButton_relief=None,
decButton_scale=(self.arrowButtonScale, self.arrowButtonScale,
self.arrowButtonScale),
decButton_pos=(self.buttonXstart, 0,
self.itemFrameZorigin + 0.227),
decButton_image3_color=Vec4(1, 1, 1, 0.2),
itemFrame_pos=(self.itemFrameXorigin, 0, self.itemFrameZorigin),
itemFrame_scale=1.0,
itemFrame_relief=DGG.SUNKEN,
itemFrame_frameSize=(self.listXorigin,
self.listXorigin + self.listFrameSizeX,
self.listZorigin,
self.listZorigin + self.listFrameSizeZ),
itemFrame_frameColor=(0.85, 0.95, 1, 1),
itemFrame_borderWidth=(0.01, 0.01),
numItemsVisible=15,
forceHeight=0.065,
items=self.groupWidgets)
self.scrollTitle = DirectFrame(parent=self.scrollList,
text=TTLocalizer.GroupTrackerListTitle,
text_scale=0.06,
text_align=TextNode.ACenter,
relief=None,
pos=(self.buttonXstart, 0,
self.itemFrameZorigin + 0.127))
self.playerList = DirectScrolledList(
parent=self,
relief=None,
pos=(0.45, 0, 0.1),
incButton_image=(self.gui.find('**/FndsLst_ScrollUp'),
self.gui.find('**/FndsLst_ScrollDN'),
self.gui.find('**/FndsLst_ScrollUp_Rllvr'),
self.gui.find('**/FndsLst_ScrollUp')),
incButton_relief=None,
incButton_scale=(1.0, 1.0, -1.0),
incButton_pos=(0, 0, -0.28),
incButton_image3_color=Vec4(1, 1, 1, 0.05),
decButton_image=(self.gui.find('**/FndsLst_ScrollUp'),
self.gui.find('**/FndsLst_ScrollDN'),
self.gui.find('**/FndsLst_ScrollUp_Rllvr'),
self.gui.find('**/FndsLst_ScrollUp')),
decButton_relief=None,
decButton_scale=(1.0, 1.0, 1.0),
decButton_pos=(0.0, 0, 0.04),
decButton_image3_color=Vec4(1, 1, 1, 0.25),
itemFrame_pos=(0, 0, -0.05),
itemFrame_scale=1.0,
itemFrame_relief=DGG.SUNKEN,
itemFrame_frameSize=(
-0.3,
0.3, #x
-0.2,
0.06), #z
itemFrame_frameColor=(0.85, 0.95, 1, 1),
itemFrame_borderWidth=(0.01, 0.01),
numItemsVisible=4,
forceHeight=0.05,
items=self.playerWidgets)
self.playerListTitle = DirectFrame(parent=self.playerList,
text='',
text_scale=0.05,
text_align=TextNode.ACenter,
relief=None,
pos=(0, 0, 0.08))
self.groupInfoTitle = DirectLabel(parent=self,
text='',
text_scale=0.080,
text_align=TextNode.ACenter,
text_wordwrap=15,
relief=None,
pos=(0.45, 0, 0.5))
self.groupInfoDistrict = DirectLabel(parent=self,
text='',
text_scale=0.050,
text_align=TextNode.ACenter,
text_wordwrap=15,
relief=None,
pos=(0.45, 0, 0.4))
self.statusMessage = DirectLabel(parent=self,
text='',
text_scale=0.060,
text_align=TextNode.ACenter,
text_wordwrap=5,
relief=None,
pos=(0.45, 0, 0.1))
# Group Image:
self.groupIcon = DirectButton(parent=self,
relief=None,
state=DGG.DISABLED,
image=None,
image_scale=(0.35, 1, 0.35),
image_color=Vec4(1.0, 1.0, 1.0, 0.75),
pos=(0.45, 10, -0.45),
command=self.doNothing)
# Group Toggle:
self.wantGroupToggle = DirectButton(
parent=self,
relief=None,
image=(guiButton.find('**/QuitBtn_UP'),
guiButton.find('**/QuitBtn_DN'),
guiButton.find('**/QuitBtn_RLVR')),
image_scale=(0.7, 1, 1),
text='',
text_scale=0.052,
text_pos=(0, -0.02),
pos=(0.2, 0, -0.65),
command=self.toggleWantGroup)
self.updateWantGroupButton()
# Loading possible group icons
suitIcons = loader.loadModel('phase_3/models/gui/cog_icons')
bossbotIcon = suitIcons.find('**/CorpIcon')
bossbotIcon.setColor(SUIT_ICON_COLORS[0])
self.images.append(bossbotIcon)
lawbotIcon = suitIcons.find('**/LegalIcon')
lawbotIcon.setColor(SUIT_ICON_COLORS[1])
self.images.append(lawbotIcon)
cashbotIcon = suitIcons.find('**/MoneyIcon')
cashbotIcon.setColor(SUIT_ICON_COLORS[2])
self.images.append(cashbotIcon)
sellbotIcon = suitIcons.find('**/SalesIcon')
sellbotIcon.setColor(SUIT_ICON_COLORS[3])
self.images.append(sellbotIcon)
# Clean up
self.clearGroupInfo()
self.statusMessage.hide()
suitIcons.removeNode()
self.gui.removeNode()
guiButton.removeNode()
self.accept('GroupTrackerResponse', self.updatePage)
def unload(self):
self.scrollList.destroy()
self.groupInfoDistrict.destroy()
self.playerList.destroy()
self.groupInfoTitle.destroy()
self.groupIcon.destroy()
self.wantGroupToggle.destroy()
for widget in self.playerWidgets:
widget.destroy()
for widget in self.groupWidgets:
widget.destroy()
self.playerWidgets = []
del self.scrollList
del self.groupInfoDistrict
del self.playerList
del self.groupInfoTitle
del self.groupIcon
del self.wantGroupToggle
ShtikerPage.ShtikerPage.unload(self)
def enter(self):
ShtikerPage.ShtikerPage.enter(self)
self.setGroups([]) # CLEAR IT ALL
self.setPlayers() # CLEAR IT ALL
if (self.scrollList['items'] == []):
self.statusMessage['text'] = TTLocalizer.GroupTrackerLoading
self.statusMessage.show()
base.cr.globalGroupTracker.requestGroups()
taskMgr.doMethodLater(3, self.displayNoGroupsTaskHandler,
self.uniqueName('timeout'))
def displayNoGroups(self):
self.statusMessage['text'] = TTLocalizer.GroupTrackerEmpty
self.statusMessage.show()
self.clearGroupInfo()
def displayNoGroupsTaskHandler(self, task):
self.displayNoGroups()
return task.done
def updatePage(self):
taskMgr.remove(self.uniqueName('timeout'))
groups = base.cr.globalGroupTracker.getGroupInfo()
self.setGroups(groups)
def exit(self):
self.clearGroupInfo()
ShtikerPage.ShtikerPage.exit(self)
base.cr.globalGroupTracker.doneRequesting()
def updateGroupInfoEventHandle(self, groupWidget, mouseEvent):
self.updateGroupInfo(groupWidget)
def updateGroupInfo(self, groupWidget):
''' Updates the Right Page of the Group Tracker Page with new Info '''
self.statusMessage.hide()
# Update the Player List
self.setPlayers(groupWidget)
self.playerList.show()
# Update the Player List Title
self.playerListTitle['text'] = ('Players ' +
str(groupWidget.getCurrentPlayers()) +
'/' +
str(groupWidget.getMaxPlayers()) + ':')
self.playerListTitle.show()
# Update the District
self.groupInfoDistrict[
'text'] = TTLocalizer.BoardingGroupDistrictInformation % {
'district': groupWidget.getDistrict()
}
self.groupInfoDistrict.show()
# Update the Title
self.groupInfoTitle['text'] = groupWidget.getTitle()
self.groupInfoTitle.show()
# Update the Image
self.groupIcon['image'] = self.images[
GroupTrackerGlobals.CATEGORY_TO_IMAGE_ID[
groupWidget.getCategory()]]
self.groupIcon['image_scale'] = (0.35, 1, 0.35)
self.groupIcon.show()
def clearGroupInfo(self):
self.playerList.hide()
self.playerListTitle.hide()
self.groupInfoDistrict.hide()
self.groupInfoTitle.hide()
self.groupIcon.hide()
def setPlayers(self, groupWidget=None):
''' Calls updatePlayerList '''
# Clear the Widgets that were held in the listings
for playerWidget in self.playerWidgets:
playerWidget.destroy()
self.playerWidgets = []
# Make a player widget for each player
# TODO: Edit this stuff when avIds come from players
if groupWidget:
leaderId = groupWidget.getLeaderId()
playerNames = groupWidget.getMemberNames()
playerIds = groupWidget.getMemberIds()
for playerName in playerNames:
playerId = playerIds[playerNames.index(playerName)]
isLeader = playerId == leaderId
self.playerWidgets.append(
GroupTrackerPlayer(parent=self,
avId=playerId,
name=playerName,
isLeader=isLeader))
self.updatePlayerList()
def reconsiderGroupInfo(self, groupWidget):
''' If someone is viewing this info and it was updated, we also want to update the info being viewed '''
if self.playerWidgets is None or self.playerList['items'] == []:
return # No Info is being viewed at the moment since you cant have an empty group
# We have to update if this group's leader is the leader in the playerlist being viewed right now
leaderId = groupWidget.getLeaderId()
# Check all the players in the playerList being viewed for the same leader
for playerWidget in self.playerWidgets:
if playerWidget.getLeader():
if leaderId == playerWidget.getId():
self.updateGroupInfo(groupWidget)
return False
return True
def setGroups(self, groups):
''' Calls updateGroupList '''
# Clear our Group Widgets
for group in self.groupWidgets:
group.destroy()
self.groupWidgets = []
wantReconsiderInfo = True
# Create a new group widget for each group
for group in groups:
if not group[GroupTrackerGlobals.SHOW] or len(
group[GroupTrackerGlobals.MEMBER_IDS]) == 0:
continue # We are using this to see if this group is dead or if someone doesnt want it up
leaderId = 0
for i, g in base.cr.globalGroupTracker.leader2Group.items():
if g == group:
leaderId = i
if not leaderId:
continue
leaderName = group[GroupTrackerGlobals.LEADER_NAME]
shardName = group[GroupTrackerGlobals.SHARD_NAME]
category = group[GroupTrackerGlobals.CATEGORY]
memberIds = group[GroupTrackerGlobals.MEMBER_IDS]
memberNames = group[GroupTrackerGlobals.MEMBER_NAMES]
groupWidget = GroupTrackerGroup(parent=self,
leaderId=leaderId,
leaderName=leaderName,
shardName=shardName,
category=category,
memberIds=memberIds,
memberNames=memberNames)
groupWidget.bind(DGG.WITHIN,
self.updateGroupInfoEventHandle,
extraArgs=[groupWidget])
self.groupWidgets.append(groupWidget)
if wantReconsiderInfo:
wantReconsiderInfo = self.reconsiderGroupInfo(groupWidget)
# Edge case where a group that was removed, info might remain on the screen if it didn't exist any more
if wantReconsiderInfo:
self.clearGroupInfo()
# There are no groups, hide the information
if len(self.groupWidgets) == 0:
self.displayNoGroups()
self.updateGroupList()
def updateGroupList(self):
self.statusMessage.hide()
if self.scrollList is None:
return
# Clear the Group Listing
for item in self.scrollList['items']:
if item:
self.scrollList.removeItem(item, refresh=True)
self.scrollList['items'] = []
# Re-populate the Group Listing
for groupWidget in self.groupWidgets:
self.scrollList.addItem(groupWidget, refresh=True)
if len(self.groupWidgets) == 0:
self.displayNoGroups()
def updatePlayerList(self):
if self.playerList is None:
return
# Clear the Player Listing
for item in self.playerList['items']:
if item:
self.playerList.removeItem(item)
self.playerList['items'] = []
# Re-Populate the List
for playerWidget in self.playerWidgets:
self.playerList.addItem(playerWidget)
def toggleWantGroup(self):
if settings.get('grouptracker', False):
settings['grouptracker'] = False
base.cr.globalGroupTracker.showMe(False)
else:
settings['grouptracker'] = True
base.cr.globalGroupTracker.showMe(True)
base.localAvatar.wantGroupTracker()
base.localAvatar.wantGroupTracker(
) # Updates the ai toon so the boarding group AI could know what he wants
self.updateWantGroupButton()
def updateWantGroupButton(self):
if settings.get('grouptracker', False):
self.wantGroupToggle['text'] = 'Hide Me'
else:
self.wantGroupToggle['text'] = 'Show Me'
def doNothing(self):
pass
class CIProgressScreen:
def __init__(self):
self.bgm = loader.loadModel('phase_3/models/gui/progress-background.bam')
self.bgm.find('**/logo').stash()
self.bg = self.bgm.find('**/bg')
self.logo = loader.loadTexture('phase_3/maps/CogInvasion_Logo.png')
self.logoImg = OnscreenImage(image=self.logo, scale=(0.5, 0, 0.3), pos=(0, 0, 0), parent=hidden)
self.logoImg.setTransparency(True)
self.bg_img = OnscreenImage(image=self.bg, parent=hidden)
self.bg_img.setSx(1.35)
self.bg_img.hide()
self.progress_bar = DirectWaitBar(value=0, pos=(0, 0, -0.85), parent=hidden, text_pos=(0, 0, 0.2))
self.progress_bar.setSx(1.064)
self.progress_bar.setSz(0.38)
self.loading_lbl = DirectLabel(text='', relief=None, scale=0.08, pos=(-1.0725, 0, -0.79), text_align=TextNode.ALeft, sortOrder=100, text_fg=(0.343, 0.343, 0.343, 1.0), text_font=CIGlobals.getMinnieFont(), parent=hidden, text_shadow=(0, 0, 0, 1))
return
def begin(self, hood, range, wantGui):
render.hide()
self.renderFrames()
base.setBackgroundColor(0, 0, 0)
if hood == 'localAvatarEnterGame':
self.loading_lbl['text'] = 'Entering...'
elif hood == 'init':
self.loading_lbl['text'] = 'Loading...'
else:
self.loading_lbl['text'] = 'Heading to %s...' % hood
self.progress_bar['barColor'] = (0.343, 0.343, 0.343, 1.0)
self.progress_bar['range'] = range
self.bgm.reparentTo(aspect2d)
self.bg.reparentTo(render2d)
self.bg_img.reparentTo(hidden)
self.loading_lbl.reparentTo(aspect2d)
self.logoImg.reparentTo(aspect2d)
self.progress_bar.reparentTo(aspect2d)
self.__count = 0
self.__expectedCount = range
self.progress_bar.update(self.__count)
def renderFramesTask(self, task):
self.renderFrames()
return task.cont
def end(self):
base.setBackgroundColor(CIGlobals.DefaultBackgroundColor)
taskMgr.remove('renderFrames')
render.show()
self.progress_bar.finish()
self.bg_img.reparentTo(hidden)
self.logoImg.reparentTo(hidden)
self.bg.reparentTo(hidden)
self.bgm.reparentTo(hidden)
self.loading_lbl.reparentTo(hidden)
self.progress_bar.reparentTo(hidden)
self.renderFrames()
def destroy(self):
self.bg.removeNode()
del self.bg
self.bgm.removeNode()
del self.bgm
self.bg_img.destroy()
self.loading_lbl.destroy()
self.progress_bar.destroy()
self.bgm.destroy()
del self.bg_img
del self.loading_lbl
del self.progress_bar
del self.bgm
def renderFrames(self):
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
def tick(self):
self.__count += 1
self.progress_bar.update(self.__count)
class DistributedRaceGame(DistributedMinigame.DistributedMinigame):
def __init__(self, cr):
try:
self.DistributedRaceGame_initialized
return
except:
self.DistributedRaceGame_initialized = 1
DistributedMinigame.DistributedMinigame.__init__(self, cr)
self.movement = RaceGameMovement.RaceGameMovement(base.localAvatar)
self.skyUtil = SkyUtil()
self.raceFSM = ClassicFSM('DistributedRaceGame', [
State('race', self.enterRace, self.exitRace),
State('raceTransition', self.enterRaceTransition,
self.exitRaceTransition),
State('off', self.enterRaceOff, self.exitRaceOff)
], 'off', 'off')
self.raceFSM.enterInitialState()
self.cr = cr
self.track = None
self.sky = None
self.countSfx = base.loadSfx("phase_5/audio/sfx/firehydrant_popup.ogg")
self.goSfx = base.loadSfx("phase_4/audio/sfx/AA_sound_whistle.ogg")
self.game = CIGlobals.RaceGame
self.trackPath = "phase_4/models/minigames/sprint_track.egg"
self.skyPath = "phase_3.5/models/props/TT_sky.bam"
self.lanePos = [(-22.00, -205.00, 0.00), (-11.66, -205.00, 0.00),
(0.00, -205.00, 0.00), (-33.66, -205.00, 0.00)]
self.initialCamPos = {
"pos": (41.10, -145.00, 25.88),
"hpr": (135.00, 345.96, 0.0)
}
self.raceCamPos = (-24.52, -37.22, 25.00)
self.lane = 0
return
def load(self):
self.deleteWorld()
self.track = loader.loadModel(self.trackPath)
self.track.reparentTo(render)
self.sky = loader.loadModel(self.skyPath)
self.sky.reparentTo(self.track)
self.skyUtil.startSky(self.sky)
self.setMinigameMusic("phase_4/audio/bgm/MG_toontag.ogg")
self.setDescription("Tap the left and right arrow keys repeatedly, in turns, as fast as " + \
"you can to win the race! Every time your power bar hits the top, the boost bar starts" + \
" to fill. When the boost bar is full, press CTRL to boost for a few seconds.")
self.setWinnerPrize(100)
self.setLoserPrize(5)
self.d_requestToonLane()
camera.reparentTo(render)
camera.setPos(self.initialCamPos["pos"])
camera.setHpr(self.initialCamPos["hpr"])
DistributedMinigame.DistributedMinigame.load(self)
def enterPlay(self):
DistributedMinigame.DistributedMinigame.enterPlay(self)
self.raceFSM.request('raceTransition')
def exitPlay(self):
DistributedMinigame.DistributedMinigame.exitPlay(self)
self.raceFSM.request('off')
def enterRace(self):
self.startMovement()
def exitRace(self):
self.stopMovement()
def enterRaceOff(self):
pass
def exitRaceOff(self):
pass
def enterRaceTransition(self):
self.raceTrans = Sequence(Wait(0.5), Func(self.moveCameraToToon),
Wait(4.5), Func(self.moveCameraToTop),
Wait(4.5), Func(self.startCountdown))
self.raceTrans.start()
def exitRaceTransition(self):
self.raceTrans.pause()
del self.raceTrans
def startMovement(self):
self.movement.createGui()
self.movement.fsm.request('run')
def enterGameOver(self, winner=0, winnerDoId=0, allPrize=0):
self.raceFSM.request('off')
DistributedMinigame.DistributedMinigame.enterGameOver(
self, winner, winnerDoId, allPrize)
def stopMovement(self):
self.movement.cleanup()
self.movement.deleteGui()
def startCountdown(self):
""" Start the countdown to the start of the race. """
self.countdownLbl = DirectLabel(text="",
text_scale=0.3,
text_font=CIGlobals.getMickeyFont(),
text_fg=(1, 1, 0, 1),
pos=(0, 0, 0.5))
Sequence(Func(self.setCountdownText, "3"), Wait(1.0),
Func(self.setCountdownText, "2"), Wait(1.0),
Func(self.setCountdownText, "1"), Wait(1.0),
Func(self.setCountdownText, "GO!"), Wait(1.5),
Func(self.deleteCountdownLabel)).start()
def setCountdownText(self, number):
self.countdownLbl['text'] = number
if number == "GO!":
self.countdownLbl['text_fg'] = (0, 1, 0, 1)
self.goSfx.play()
self.raceFSM.request('race')
else:
self.countSfx.play()
def deleteCountdownLabel(self):
self.countdownLbl.destroy()
del self.countdownLbl
def moveCameraToToon(self):
camPInt = LerpPosInterval(camera,
duration=3.0,
pos=self.localAv.getPos(render) + (0, 15, 3),
startPos=(camera.getPos(render)),
blendType="easeInOut")
camQInt = camera.quatInterval(3.0,
hpr=Vec3(180, 0, 0),
blendType="easeInOut")
camPInt.start()
camQInt.start()
def moveCameraToTop(self):
camera.setPos(camera.getPos(self.localAv))
camera.reparentTo(self.localAv)
oldPos = camera.getPos()
camera.setPos(self.raceCamPos)
oldHpr = camera.getHpr()
camera.lookAt(self.localAv.getPart('head'))
newHpr = camera.getHpr()
camera.setHpr(oldHpr)
camera.setPos(oldPos)
camPInt = LerpPosInterval(camera,
duration=3.0,
pos=self.raceCamPos,
startPos=oldPos,
blendType="easeInOut")
camQInt = camera.quatInterval(3.0, hpr=newHpr, blendType="easeInOut")
camPInt.start()
camQInt.start()
def deleteWorld(self):
if self.track:
self.track.removeNode()
self.track = None
if self.sky:
self.skyUtil.stopSky()
self.sky.removeNode()
self.sky = None
def setToonLane(self, lane):
self.lane = lane
base.localAvatar.setPos(self.lanePos[lane])
base.localAvatar.setHpr(0, 0, 0)
def getToonLane(self):
return self.lane
def d_requestToonLane(self):
self.sendUpdate('requestToonLane', [])
def announceGenerate(self):
DistributedMinigame.DistributedMinigame.announceGenerate(self)
self.load()
def disable(self):
DistributedMinigame.DistributedMinigame.disable(self)
self.deleteWorld()
self.raceFSM.requestFinalState()
del self.raceFSM
self.countSfx = None
self.goSfx = None
class InventoryGui(DirectObject):
directNotify = DirectNotify().newCategory('InventoryGui')
HiddenPos = (0.2, 0, 0)
VisiblePos = (-0.1725, 0, 0)
SwitchTime = 0.3
AutoShowTime = 1.5
DELETED = False
def __init__(self):
DirectObject.__init__(self)
self.backpack = base.localAvatar.backpack
if not self.backpack:
return
self.backpack.loadoutGUI = self
self.oneSlotPos = [(0, 0, 0)]
self.twoSlotsPos = [(0, 0, 0.3), (0, 0, -0.2)]
self.threeSlotsPos = [(0, 0, 0.5), (0, 0, 0), (0, 0, -0.5)]
self.fourSlotPos = [(0, 0, 0.5), (0, 0, 0.15), (0, 0, -0.2),
(0, 0, -0.55)]
self.availableSlot = 0
self.slots = []
self.activeSlot = None
self.defaultSlots = 3
self.prevSlot = None
self.ammoLabel = None
self.inventoryFrame = DirectFrame(parent=base.a2dRightCenter,
pos=(-0.1725, 0, 0))
self.visibilityBtn = DirectButton(text='',
relief=None,
text_bg=(1, 1, 1, 0),
parent=base.a2dRightCenter,
pos=(-0.1725, 0, 0),
frameSize=(-0.2, 0.2, -0.725, 0.7),
clickSound=None,
rolloverSound=None)
self.visibilityBtn.bind(DGG.WITHIN, self.__handleVisEnter)
self.visibilityBtn.bind(DGG.WITHOUT, self.__handleVisExit)
self.visibilityBtn.setBin('background', 10)
self.visibilityBtn = None
self.visibilityBtnStatus = 0
self.switchSound = True
self.switchSoundSfx = base.loadSfx(
'phase_3/audio/sfx/GUI_balloon_popup.ogg')
self.visibilityFSM = ClassicFSM('InventoryGui-VisibilityFSM', [
State('off', self.enterOff, self.exitOff),
State('hidden', self.enterHidden, self.exitHidden),
State('hidden2visible', self.enterHidden2Visible,
self.exitHidden2Visible),
State('visible', self.enterVisible, self.exitVisible),
State('visible2hidden', self.enterVisible2Hidden,
self.exitVisible2Hidden)
], 'off', 'off')
self.visibilityFSM.enterInitialState()
self.visibilityFSM.request('hidden')
return
def enterOff(self):
pass
def exitOff(self):
pass
def enterHidden(self):
self.inventoryFrame.setPos(InventoryGui.HiddenPos)
self.inventoryFrame.hide()
def exitHidden(self):
pass
def enterVisible(self, autoShow=False):
self.inventoryFrame.setPos(InventoryGui.VisiblePos)
self.inventoryFrame.show()
if self.visibilityBtnStatus == 0:
if autoShow is False:
self.visibilityFSM.request('visible2hidden')
def exitVisible(self):
pass
def enterHidden2Visible(self, autoShow=False):
self.inventoryFrame.show()
self.moveIval = LerpPosInterval(self.inventoryFrame,
duration=InventoryGui.SwitchTime,
pos=InventoryGui.VisiblePos,
startPos=InventoryGui.HiddenPos)
self.moveIval.setDoneEvent('hidden2visible')
self.acceptOnce('hidden2visible', self.visibilityFSM.request,
['visible', [autoShow]])
self.moveIval.start()
def exitHidden2Visible(self):
self.ignore('hidden2visible')
self.moveIval.finish()
del self.moveIval
def enterVisible2Hidden(self):
self.moveIval = LerpPosInterval(self.inventoryFrame,
duration=InventoryGui.SwitchTime,
pos=InventoryGui.HiddenPos,
startPos=InventoryGui.VisiblePos)
self.moveIval.setDoneEvent('visible2hidden')
self.acceptOnce('visible2hidden', self.visibilityFSM.request,
['hidden'])
self.moveIval.start()
def exitVisible2Hidden(self):
self.ignore('visible2hidden')
self.moveIval.finish()
del self.moveIval
def click_setWeapon(self, slot, cmd):
self.setWeapon(slot, playSound=False)
def setWeapon(self, slot, playSound=True, showUpIfHidden=False):
if isinstance(slot, str):
for iSlot in self.slots:
if iSlot.getGag():
if iSlot.getGag().getID() == slot:
slot = iSlot
if self.activeSlot and slot != self.activeSlot:
self.activeSlot.setOutlineImage('idle')
self.prevSlot = self.activeSlot
if slot.getGag() and self.backpack.getSupply(slot.getGag().getID(
)) > 0 and not slot.getGag().getState() == GagState.RECHARGING:
if self.activeSlot != slot:
gagId = slot.getGag().getID()
base.localAvatar.needsToSwitchToGag = gagId
if base.localAvatar.gagsTimedOut == False:
base.localAvatar.b_equip(gagId)
base.localAvatar.enableGagKeys()
slot.setOutlineImage('selected')
self.activeSlot = slot
else:
if self.activeSlot == slot and slot.getGag().getState() in [
GagState.LOADED, GagState.RECHARGING
]:
base.localAvatar.needsToSwitchToGag = 'unequip'
if base.localAvatar.gagsTimedOut == False:
base.localAvatar.b_unEquip()
base.localAvatar.enableGagKeys()
self.activeSlot = None
self.update()
if self.switchSound and playSound:
base.playSfx(self.switchSoundSfx)
if showUpIfHidden:
base.taskMgr.remove('showUpIfHidden')
self.__autoVisEnter()
base.taskMgr.doMethodLater(InventoryGui.AutoShowTime,
self.__autoVisExitTask,
'showUpIfHidden')
return
def __autoVisExitTask(self, task):
if self.visibilityBtnStatus == 0:
self.__handleVisExit(None, updateBtnStatus=False)
return task.done
def __autoVisEnter(self):
self.__handleVisEnter(None, True, False)
return
def __handleVisEnter(self, foo, autoShow=False, updateBtnStatus=True):
if updateBtnStatus:
self.visibilityBtnStatus = 1
if self.visibilityFSM.getCurrentState().getName() == 'hidden':
self.visibilityFSM.request('hidden2visible', [autoShow])
else:
if self.visibilityFSM.getCurrentState().getName(
) == 'visible2hidden':
self.visibilityFSM.request('visible')
def __handleVisExit(self, foo, updateBtnStatus=True):
if updateBtnStatus:
self.visibilityBtnStatus = 0
base.taskMgr.remove('showUpIfHidden')
if self.visibilityFSM.getCurrentState().getName() == 'visible':
self.visibilityFSM.request('visible2hidden')
def createGui(self):
self.deleteGui()
posGroup = self.threeSlotsPos
if self.defaultSlots == 4:
posGroup = self.fourSlotPos
for slot in range(len(posGroup) + 1):
if slot == 3:
posGroup = self.fourSlotPos
slotObj = Slot(self, slot + 1, posGroup[slot], self.inventoryFrame)
self.slots.append(slotObj)
if slot == 3:
slotObj.hide()
self.ammoLabel = DirectLabel(text='Ammo: 0',
text_fg=(1, 1, 1, 1),
relief=None,
text_shadow=(0, 0, 0, 1),
text_scale=0.08,
pos=(0.2, 0, 0.35),
parent=base.a2dBottomLeft)
self.ammoLabel.hide()
self.enableWeaponSwitch()
self.resetScroll()
self.update()
return
def deleteGui(self):
self.disableWeaponSwitch()
for slot in self.slots:
slot.destroy()
self.slots = []
if self.ammoLabel:
self.ammoLabel.destroy()
self.ammoLabel = None
self.DELETED = True
return
def resetScroll(self):
nextGag = 0
prevGag = -1
curGag = -1
if self.prevSlot:
prevGag = self.slots.index(self.prevSlot)
if self.activeSlot:
curGag = self.slots.index(self.activeSlot)
if curGag == len(self.slots) - 1:
nextGag = 0
prevGag = curGag - 1
else:
if curGag == 0:
nextGag = 1
prevGag = len(self.slots) - 1
else:
if curGag == -1:
prevGag = len(self.slots) - 1
else:
nextGag = curGag + 1
prevGag = curGag - 1
self.accept('wheel_down',
self.setWeapon,
extraArgs=[self.slots[nextGag], True, True])
self.accept('wheel_up',
self.setWeapon,
extraArgs=[self.slots[prevGag], True, True])
def update(self):
if not self.backpack:
return
for element in [self.ammoLabel, self.inventoryFrame]:
if not element:
return
updateSlots = list(self.slots)
for slot in self.slots:
gag = slot.getGag()
if not gag:
updateSlots.remove(slot)
slot.hide()
continue
supply = self.backpack.getSupply(gag.getID())
index = self.slots.index(slot)
if not gag and len(self.backpack.getGags()) - 1 >= index:
gag = self.backpack.getGagByIndex(index)
slot.setGag(gag)
if self.backpack.getSupply(gag.getID(
)) > 0 and not gag.getState() == GagState.RECHARGING:
slot.setOutlineImage('idle')
else:
slot.setOutlineImage('no_ammo')
elif slot == self.activeSlot:
self.ammoLabel['text_fg'] = (1, 1, 1, 1)
if supply > 0 and not gag.getState() == GagState.RECHARGING:
slot.setOutlineImage('selected')
else:
if supply <= 0:
self.ammoLabel['text_fg'] = (0.9, 0, 0, 1)
slot.setOutlineImage('no_ammo')
self.activeSlot = None
self.ammoLabel.show()
self.ammoLabel['text'] = 'Ammo: %s' % self.backpack.getSupply(
slot.getGag().getID())
elif self.backpack.getSupply(slot.getGag().getID(
)) > 0 and not gag.getState() == GagState.RECHARGING:
slot.setOutlineImage('idle')
else:
slot.setOutlineImage('no_ammo')
numSlots = len(updateSlots)
posGroup = {
1: self.oneSlotPos,
2: self.twoSlotsPos,
3: self.threeSlotsPos,
4: self.fourSlotPos
}.get(numSlots)
for i in xrange(len(updateSlots)):
updateSlots[i].setPos(posGroup[i])
updateSlots[i].show()
if self.activeSlot == None:
self.ammoLabel.hide()
self.ammoLabel['text'] = 'Ammo: 0'
self.resetScroll()
return
def setBackpack(self, backpack):
self.backpack = backpack
def updateLoadout(self):
if self.backpack:
loadout = self.backpack.getLoadout()
if len(loadout) <= 3:
self.reseatSlots()
else:
if len(loadout) == 4:
self.reseatSlots(slots=4)
for i in range(len(self.slots)):
slot = self.slots[i]
if i < len(loadout):
slot.setGag(loadout[i])
else:
slot.setGag(None)
self.update()
return
def reseatSlots(self, slots=3):
for slot in range(len(self.slots) - 1):
if slots == 4:
self.slots[slot].setPos(self.fourSlotPos[slot])
else:
self.slots[slot].setPos(self.threeSlotsPos[slot])
def enableWeaponSwitch(self):
for index in range(len(self.slots)):
self.accept(str(index + 1),
self.setWeapon,
extraArgs=[self.slots[index], True, True])
def disableWeaponSwitch(self):
for key in ['1', '2', '3', '4', 'wheel_down', 'wheel_up']:
self.ignore(key)
def getSlots(self):
return self.slots
def getActiveSlot(self):
return self.activeSlot
def isDeleted(self):
return self.DELETED
class CalendarGuiDay(DirectFrame):
notify = directNotify.newCategory('CalendarGuiDay')
ScrollListTextSize = 0.03
def __init__(self, parent, myDate, startDate, dayClickCallback = None, onlyFutureDaysClickable = False):
self.origParent = parent
self.startDate = startDate
self.myDate = myDate
self.dayClickCallback = dayClickCallback
self.onlyFutureDaysClickable = onlyFutureDaysClickable
DirectFrame.__init__(self, parent=parent)
self.timedEvents = []
self.partiesInvitedToToday = []
self.hostedPartiesToday = []
self.yearlyHolidaysToday = []
self.showMarkers = base.config.GetBool('show-calendar-markers', 0)
self.filter = ToontownGlobals.CalendarFilterShowAll
self.load()
self.createGuiObjects()
self.update()
def createDummyLocators(self):
self.dayButtonLocator = self.attachNewNode('dayButtonLocator')
self.dayButtonLocator.setX(0.1)
self.dayButtonLocator.setZ(-0.05)
self.numberLocator = self.attachNewNode('numberLocator')
self.numberLocator.setX(0.09)
self.scrollLocator = self.attachNewNode('scrollLocator')
self.selectedLocator = self.attachNewNode('selectedLocator')
self.selectedLocator.setX(0.11)
self.selectedLocator.setZ(-0.06)
def load(self):
dayAsset = loader.loadModel('phase_4/models/parties/tt_m_gui_sbk_calendar_box')
dayAsset.reparentTo(self)
self.dayButtonLocator = self.find('**/loc_origin')
self.numberLocator = self.find('**/loc_number')
self.scrollLocator = self.find('**/loc_topLeftList')
self.selectedLocator = self.find('**/loc_origin')
self.todayBox = self.find('**/boxToday')
self.todayBox.hide()
self.selectedFrame = self.find('**/boxHover')
self.selectedFrame.hide()
self.defaultBox = self.find('**/boxBlank')
self.scrollBottomRightLocator = self.find('**/loc_bottomRightList')
self.scrollDownLocator = self.find('**/loc_scrollDown')
self.attachMarker(self.scrollDownLocator)
self.scrollUpLocator = self.find('**/loc_scrollUp')
self.attachMarker(self.scrollUpLocator)
def attachMarker(self, parent, scale = 0.005, color = (1, 0, 0)):
if self.showMarkers:
marker = loader.loadModel('phase_3/models/misc/sphere')
marker.reparentTo(parent)
marker.setScale(scale)
marker.setColor(*color)
def createGuiObjects(self):
self.dayButton = DirectButton(parent=self.dayButtonLocator, image=self.selectedFrame, relief=None, command=self.__clickedOnDay, pressEffect=1, rolloverSound=None, clickSound=None)
self.numberWidget = DirectLabel(parent=self.numberLocator, relief=None, text=str(self.myDate.day), text_scale=0.04, text_align=TextNode.ACenter, text_font=ToontownGlobals.getInterfaceFont(), text_fg=Vec4(110 / 255.0, 126 / 255.0, 255 / 255.0, 1))
self.attachMarker(self.numberLocator)
self.listXorigin = 0
self.listFrameSizeX = self.scrollBottomRightLocator.getX() - self.scrollLocator.getX()
self.scrollHeight = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ()
self.listZorigin = self.scrollBottomRightLocator.getZ()
self.listFrameSizeZ = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ()
self.arrowButtonXScale = 1
self.arrowButtonZScale = 1
self.itemFrameXorigin = 0
self.itemFrameZorigin = 0
self.buttonXstart = self.itemFrameXorigin + 0.21
self.gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui')
buttonOffSet = -0.01
incButtonPos = (0.0, 0, 0)
decButtonPos = (0.0, 0, 0)
itemFrameMinZ = self.listZorigin
itemFrameMaxZ = self.listZorigin + self.listFrameSizeZ
arrowUp = self.find('**/downScroll_up')
arrowDown = self.find('**/downScroll_down')
arrowHover = self.find('**/downScroll_hover')
self.scrollList = DirectScrolledList(parent=self.scrollLocator, relief=None, pos=(0, 0, 0), incButton_image=(arrowUp,
arrowDown,
arrowHover,
arrowUp), incButton_relief=None, incButton_scale=(self.arrowButtonXScale, 1, self.arrowButtonZScale), incButton_pos=incButtonPos, incButton_image3_color=Vec4(1, 1, 1, 0.2), decButton_image=(arrowUp,
arrowDown,
arrowHover,
arrowUp), decButton_relief=None, decButton_scale=(self.arrowButtonXScale, 1, -self.arrowButtonZScale), decButton_pos=decButtonPos, decButton_image3_color=Vec4(1, 1, 1, 0.2), itemFrame_pos=(self.itemFrameXorigin, 0, -0.03), numItemsVisible=4, incButtonCallback=self.scrollButtonPressed, decButtonCallback=self.scrollButtonPressed)
itemFrameParent = self.scrollList.itemFrame.getParent()
self.scrollList.incButton.reparentTo(self.scrollDownLocator)
self.scrollList.decButton.reparentTo(self.scrollUpLocator)
arrowUp.removeNode()
arrowDown.removeNode()
arrowHover.removeNode()
clipper = PlaneNode('clipper')
clipper.setPlane(Plane(Vec3(-1, 0, 0), Point3(0.23, 0, 0)))
clipNP = self.scrollList.component('itemFrame').attachNewNode(clipper)
self.scrollList.component('itemFrame').setClipPlane(clipNP)
return
def scrollButtonPressed(self):
self.__clickedOnDay()
def adjustForMonth(self):
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.onlyFutureDaysClickable:
if self.myDate.year < curServerDate.year or self.myDate.year == curServerDate.year and self.myDate.month < curServerDate.month or self.myDate.year == curServerDate.year and self.myDate.month == curServerDate.month and self.myDate.day < curServerDate.day:
self.numberWidget.setColorScale(0.5, 0.5, 0.5, 0.5)
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.numberWidget.setColorScale(1, 1, 1, 1)
if self.myDate.month != self.startDate.month:
self.setColorScale(0.75, 0.75, 0.75, 1.0)
if self.dayClickCallback is not None:
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.setColorScale(1, 1, 1, 1)
if self.myDate.date() == curServerDate.date():
self.defaultBox.hide()
self.todayBox.show()
else:
self.defaultBox.show()
self.todayBox.hide()
return
def destroy(self):
if self.dayClickCallback is not None:
self.numberWidget.destroy()
self.dayClickCallback = None
self.notify.debug('desroying %s' % self.myDate)
try:
for item in self.scrollList['items']:
if hasattr(item, 'description') and item.description and hasattr(item.description, 'destroy'):
self.notify.debug('desroying description of item %s' % item)
item.unbind(DGG.ENTER)
item.unbind(DGG.EXIT)
item.description.destroy()
except e:
self.notify.debug('pass %s' % self.myDate)
self.scrollList.removeAndDestroyAllItems()
self.scrollList.destroy()
self.dayButton.destroy()
DirectFrame.destroy(self)
return
def addWeeklyHolidays(self):
if not self.filter == ToontownGlobals.CalendarFilterShowAll and not self.filter == ToontownGlobals.CalendarFilterShowOnlyHolidays:
return
if base.cr.newsManager:
holidays = base.cr.newsManager.getHolidaysForWeekday(self.myDate.weekday())
holidayName = ''
holidayDesc = ''
for holidayId in holidays:
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
self.addTitleAndDescToScrollList(holidayName, holidayDesc)
self.scrollList.refresh()
if base.config.GetBool('calendar-test-items', 0):
if self.myDate.date() + datetime.timedelta(days=-1) == base.cr.toontownTimeManager.getCurServerDateTime().date():
testItems = ('1:00 AM Party', '2:00 AM CEO', '11:15 AM Party', '5:30 PM CJ', '11:00 PM Party', 'Really Really Long String')
for text in testItems:
newItem = DirectLabel(relief=None, text=text, text_scale=self.ScrollListTextSize, text_align=TextNode.ALeft)
self.scrollList.addItem(newItem)
if self.myDate.date() + datetime.timedelta(days=-2) == base.cr.toontownTimeManager.getCurServerDateTime().date():
testItems = ('1:00 AM Party', '3:00 AM CFO', '11:00 AM Party')
textSize = self.ScrollListTextSize
for text in testItems:
newItem = DirectLabel(relief=None, text=text, text_scale=textSize, text_align=TextNode.ALeft)
self.scrollList.addItem(newItem)
def updateArrowButtons(self):
numItems = 0
try:
numItems = len(self.scrollList['items'])
except e:
numItems = 0
if numItems <= self.scrollList.numItemsVisible:
self.scrollList.incButton.hide()
self.scrollList.decButton.hide()
else:
self.scrollList.incButton.show()
self.scrollList.decButton.show()
def collectTimedEvents(self):
self.timedEvents = []
if self.filter == ToontownGlobals.CalendarFilterShowAll or self.filter == ToontownGlobals.CalendarFilterShowOnlyParties:
for party in localAvatar.partiesInvitedTo:
if party.startTime.date() == self.myDate.date():
self.partiesInvitedToToday.append(party)
self.timedEvents.append((party.startTime.time(), party))
for party in localAvatar.hostedParties:
if party.startTime.date() == self.myDate.date():
self.hostedPartiesToday.append(party)
self.timedEvents.append((party.startTime.time(), party))
if base.cr.newsManager and (self.filter == ToontownGlobals.CalendarFilterShowAll or self.filter == ToontownGlobals.CalendarFilterShowOnlyHolidays):
yearlyHolidays = base.cr.newsManager.getYearlyHolidaysForDate(self.myDate)
for holiday in yearlyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.month and holidayStart[1] == self.myDate.day:
myTime = datetime.time(holidayStart[2], holidayStart[3])
elif holidayEnd[0] == self.myDate.month and holidayEnd[1] == self.myDate.day:
myTime = datetime.time(holidayEnd[2], holidayEnd[3])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
oncelyHolidays = base.cr.newsManager.getOncelyHolidaysForDate(self.myDate)
for holiday in oncelyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.year and holidayStart[1] == self.myDate.month and holidayStart[2] == self.myDate.day:
myTime = datetime.time(holidayStart[3], holidayStart[4])
elif holidayEnd[0] == self.myDate.year and holidayEnd[1] == self.myDate.month and holidayEnd[2] == self.myDate.day:
myTime = datetime.time(holidayEnd[3], holidayEnd[4])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
multipleStartHolidays = base.cr.newsManager.getMultipleStartHolidaysForDate(self.myDate)
for holiday in multipleStartHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.year and holidayStart[1] == self.myDate.month and holidayStart[2] == self.myDate.day:
myTime = datetime.time(holidayStart[3], holidayStart[4])
elif holidayEnd[0] == self.myDate.year and holidayEnd[1] == self.myDate.month and holidayEnd[2] == self.myDate.day:
myTime = datetime.time(holidayEnd[3], holidayEnd[4])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
relativelyHolidays = base.cr.newsManager.getRelativelyHolidaysForDate(self.myDate)
for holiday in relativelyHolidays:
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
if holidayStart[0] == self.myDate.month and holidayStart[1] == self.myDate.day:
myTime = datetime.time(holidayStart[2], holidayStart[3])
elif holidayEnd[0] == self.myDate.month and holidayEnd[1] == self.myDate.day:
myTime = datetime.time(holidayEnd[2], holidayEnd[3])
else:
self.notify.error('holiday is not today %s' % holiday)
self.timedEvents.append((myTime, holiday))
def timedEventCompare(te1, te2):
if te1[0] < te2[0]:
return -1
elif te1[0] == te2[0]:
return 0
else:
return 1
self.timedEvents.sort(cmp=timedEventCompare)
for timedEvent in self.timedEvents:
if isinstance(timedEvent[1], PartyInfo):
self.addPartyToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][0] == NewsManager.YearlyHolidayType:
self.addYearlyHolidayToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][0] == NewsManager.OncelyHolidayType:
self.addOncelyHolidayToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][0] == NewsManager.OncelyMultipleStartHolidayType:
self.addOncelyMultipleStartHolidayToScrollList(timedEvent[1])
elif isinstance(timedEvent[1], tuple) and timedEvent[1][0] == NewsManager.RelativelyHolidayType:
self.addRelativelyHolidayToScrollList(timedEvent[1])
def addYearlyHolidayToScrollList(self, holiday):
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ''
startTime = datetime.time(holidayStart[2], holidayStart[3])
endTime = datetime.time(holidayEnd[2], holidayEnd[3])
startDate = datetime.date(self.myDate.year, holidayStart[0], holidayStart[1])
endDate = datetime.date(self.myDate.year, holidayEnd[0], holidayEnd[1])
if endDate < startDate:
endDate = datetime.date(endDate.year + 1, endDate.month, endDate.day)
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = TTLocalizer.UnknownHoliday % holidayId
if holidayStart[0] == holidayEnd[0] and holidayStart[1] == holidayEnd[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + myStrftime(endTime)
elif self.myDate.month == holidayStart[0] and self.myDate.day == holidayStart[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + endDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.month == holidayEnd[0] and self.myDate.day == holidayEnd[1]:
holidayText = myStrftime(endTime)
holidayText += ' ' + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += '. ' + TTLocalizer.CalendarStartedOn + startDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addOncelyHolidayToScrollList(self, holiday):
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ''
startTime = datetime.time(holidayStart[3], holidayStart[4])
endTime = datetime.time(holidayEnd[3], holidayEnd[4])
startDate = datetime.date(holidayStart[0], holidayStart[1], holidayStart[2])
endDate = datetime.date(holidayStart[0], holidayEnd[1], holidayEnd[2])
if endDate < startDate:
endDate = datetime.date(endDate.year + 1, endDate.month, endDate.day)
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = ''
if holidayStart[1] == holidayEnd[1] and holidayStart[2] == holidayEnd[2]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + myStrftime(endTime)
elif self.myDate.year == holidayStart[0] and self.myDate.month == holidayStart[1] and self.myDate.day == holidayStart[2]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + endDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.year == holidayEnd[0] and self.myDate.month == holidayEnd[1] and self.myDate.day == holidayEnd[2]:
holidayText = myStrftime(endTime)
holidayText += ' ' + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += '. ' + TTLocalizer.CalendarStartedOn + startDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addOncelyMultipleStartHolidayToScrollList(self, holiday):
self.addOncelyHolidayToScrollList(holiday)
def addRelativelyHolidayToScrollList(self, holiday):
holidayId = holiday[1]
holidayStart = holiday[2]
holidayEnd = holiday[3]
holidayType = holiday[0]
holidayText = ''
startTime = datetime.time(holidayStart[2], holidayStart[3])
endTime = datetime.time(holidayEnd[2], holidayEnd[3])
startDate = datetime.date(self.myDate.year, holidayStart[0], holidayStart[1])
endDate = datetime.date(self.myDate.year, holidayEnd[0], holidayEnd[1])
if endDate < startDate:
endDate.year += 1
if holidayId in TTLocalizer.HolidayNamesInCalendar:
holidayName = TTLocalizer.HolidayNamesInCalendar[holidayId][0]
holidayDesc = TTLocalizer.HolidayNamesInCalendar[holidayId][1]
else:
holidayName = TTLocalizer.UnknownHoliday % holidayId
holidayDesc = ''
if holidayStart[0] == holidayEnd[0] and holidayStart[1] == holidayEnd[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + myStrftime(endTime)
elif self.myDate.month == holidayStart[0] and self.myDate.day == holidayStart[1]:
holidayText = myStrftime(startTime)
holidayText += ' ' + holidayName
holidayDesc = holidayName + '. ' + holidayDesc
holidayDesc += ' ' + TTLocalizer.CalendarEndsAt + endDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(endTime)
elif self.myDate.month == holidayEnd[0] and self.myDate.day == holidayEnd[1]:
holidayText = myStrftime(endTime)
holidayText += ' ' + TTLocalizer.CalendarEndDash + holidayName
holidayDesc = TTLocalizer.CalendarEndOf + holidayName
holidayDesc += '. ' + TTLocalizer.CalendarStartedOn + startDate.strftime(TTLocalizer.HolidayFormat) + myStrftime(startTime)
else:
self.notify.error('unhandled case')
self.addTitleAndDescToScrollList(holidayText, holidayDesc)
def addTitleAndDescToScrollList(self, title, desc):
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(relief=None, text=title, text_scale=textSize, text_align=TextNode.ALeft, rolloverSound=None, clickSound=None, pressEffect=0, command=self.__clickedOnScrollItem)
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = scrollItemHeight * descTextSize / textSize
descUnderItemZAdjust = max(0.0534, descUnderItemZAdjust)
descUnderItemZAdjust = -descUnderItemZAdjust
descZAdjust = descUnderItemZAdjust
newItem.description = DirectLabel(parent=newItem, pos=(0.115, 0, descZAdjust), text='', text_wordwrap=15, pad=(0.02, 0.02), text_scale=descTextSize, text_align=TextNode.ACenter, textMayChange=0)
newItem.description.checkedHeight = False
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(DGG.ENTER, self.enteredTextItem, extraArgs=[newItem, desc, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
self.scrollList.addItem(newItem)
return
def exitedTextItem(self, newItem, mousepos):
newItem.description.hide()
def enteredTextItem(self, newItem, descText, descUnderItemZAdjust, mousePos):
if not newItem.description.checkedHeight:
newItem.description.checkedHeight = True
newItem.description['text'] = descText
bounds = newItem.description.getBounds()
descHeight = newItem.description.getHeight()
scrollItemHeight = newItem.getHeight()
descOverItemZAdjust = descHeight - scrollItemHeight / 2.0
descZPos = self.getPos(aspect2d)[2] + descUnderItemZAdjust - descHeight
if descZPos < -1.0:
newItem.description.setZ(descOverItemZAdjust)
descWidth = newItem.description.getWidth()
brightFrame = loader.loadModel('phase_4/models/parties/tt_m_gui_sbk_calendar_popUp_bg')
newItem.description['geom'] = brightFrame
newItem.description['geom_scale'] = (descWidth, 1, descHeight)
descGeomZ = (bounds[2] - bounds[3]) / 2.0
descGeomZ += bounds[3]
newItem.description['geom_pos'] = (0, 0, descGeomZ)
newItem.description.show()
def addPartyToScrollList(self, party):
textSize = self.ScrollListTextSize
descTextSize = 0.05
partyTitle = myStrftime(party.startTime)
partyTitle = partyTitle + ' ' + TTLocalizer.EventsPageCalendarTabParty
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(relief=None, text=partyTitle, text_scale=textSize, text_align=TextNode.ALeft, rolloverSound=None, clickSound=None, pressEffect=0, command=self.__clickedOnScrollItem)
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = scrollItemHeight * descTextSize / textSize
descUnderItemZAdjust = max(0.0534, descUnderItemZAdjust)
descUnderItemZAdjust = -descUnderItemZAdjust
descZAdjust = descUnderItemZAdjust
self.scrollList.addItem(newItem)
newItem.description = MiniInviteVisual(newItem, party)
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(DGG.ENTER, self.enteredTextItem, extraArgs=[newItem, newItem.description, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
return
def __clickedOnScrollItem(self):
self.__clickedOnDay()
def __clickedOnDay(self):
acceptClick = True
if self.onlyFutureDaysClickable:
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.myDate.date() < curServerDate.date():
acceptClick = False
if not acceptClick:
return
if self.dayClickCallback:
self.dayClickCallback(self)
self.notify.debug('we got clicked on %s' % self.myDate.date())
messenger.send('clickedOnDay', [self.myDate.date()])
def updateSelected(self, selected):
multiplier = 1.1
if selected:
self.selectedFrame.show()
self.setScale(multiplier)
self.setPos(-0.01, 0, 0.01)
grandParent = self.origParent.getParent()
self.origParent.reparentTo(grandParent)
else:
self.selectedFrame.hide()
self.setScale(1.0)
self.setPos(0, 0, 0)
def changeDate(self, startDate, myDate):
self.startDate = startDate
self.myDate = myDate
self.scrollList.removeAndDestroyAllItems()
self.update()
def update(self):
self.numberWidget['text'] = str(self.myDate.day)
self.adjustForMonth()
self.addWeeklyHolidays()
self.collectTimedEvents()
self.updateArrowButtons()
def changeFilter(self, filter):
oldFilter = self.filter
self.filter = filter
if self.filter != oldFilter:
self.scrollList.removeAndDestroyAllItems()
self.update()
class BattleShop(Shop):
notify = directNotify.newCategory("BattleShop")
def __init__(self, distShop, doneEvent):
Shop.__init__(self, distShop, doneEvent)
self.upgradePrices = {
0: 200 # Turret
}
self.maxPU = 1
self.turret_btn = None
self.turret_lbl = None
def enter(self):
Shop.enter(self)
self.starting_turret = base.localAvatar.getPUInventory()[0]
self.turret_btn = DirectButton(relief=None,
geom=CIGlobals.getDefaultBtnGeom(),
text="Turret",
text_scale=0.055,
command=self.purchasePU,
extraArgs=[0])
self.turret_lbl = DirectLabel(relief=None,
scale=0.05,
text="{0}/{1}".format(
base.localAvatar.getPUInventory()[0],
self.maxPU),
pos=(0, 0, -0.1))
def purchasePU(self, index):
if base.localAvatar.getMoney() < self.upgradePrices[index]:
self.handleNoMoney()
return
if base.localAvatar.getPUInventory()[index] < self.maxPU:
base.localAvatar.setMoney(base.localAvatar.getMoney() -
self.upgradePrices[index])
base.localAvatar.getPUInventory()[index] = self.maxPU
self.update()
def update(self):
Shop.update(self)
self.turret_lbl['text'] = "{0}/{1}".format(
base.localAvatar.getPUInventory()[0], self.maxPU)
if base.localAvatar.getPUInventory()[0] >= self.maxPU:
self.turret_btn['state'] = DGG.DISABLED
def confirmPurchase(self):
array = []
array.append(base.localAvatar.getPUInventory()[0])
if base.localAvatar.getPUInventory()[0] > 0:
if not base.localAvatar.getMyBattle().getTurretManager().myTurret:
base.localAvatar.getMyBattle().getTurretManager(
).createTurretButton()
self.distShop.sendUpdate('confirmPurchase',
[array, base.localAvatar.getMoney()])
Shop.confirmPurchase(self)
def cancelPurchase(self):
base.localAvatar.setMoney(self.starting_money)
base.localAvatar.getPUInventory()[0] = self.starting_turret
Shop.cancelPurchase(self)
def exit(self):
Shop.exit(self)
self.turret_btn.destroy()
del self.turret_btn
self.turret_lbl.destroy()
del self.turret_lbl
return
class DistributedCogThiefGame(DistributedMinigame):
notify = directNotify.newCategory('DistributedCogThiefGame')
ToonSpeed = CTGG.ToonSpeed
StageHalfWidth = 200.0
StageHalfHeight = 100.0
BarrelScale = 0.25
TOON_Z = 0
UPDATE_SUITS_TASK = 'CogThiefGameUpdateSuitsTask'
REWARD_COUNTDOWN_TASK = 'cogThiefGameRewardCountdown'
ControlKeyLimitTime = 1.0
def __init__(self, cr):
DistributedMinigame.__init__(self, cr)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedCogThiefGame', [State.State('off', self.enterOff, self.exitOff, ['play']), State.State('play', self.enterPlay, self.exitPlay, ['cleanup']), State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup')
self.addChildGameFSM(self.gameFSM)
self.cameraTopView = (0, 0, 55, 0, -90.0, 0)
self.barrels = []
self.cogInfo = {}
self.lastTimeControlPressed = 0
self.stolenBarrels = []
self.resultIval = None
self.gameIsEnding = False
self.__textGen = TextNode('cogThiefGame')
self.__textGen.setFont(ToontownGlobals.getSignFont())
self.__textGen.setAlign(TextNode.ACenter)
return
def getTitle(self):
return TTLocalizer.CogThiefGameTitle
def getInstructions(self):
return TTLocalizer.CogThiefGameInstructions
def getMaxDuration(self):
return 0
def load(self):
self.notify.debug('load')
DistributedMinigame.load(self)
self.music = base.loadMusic('phase_4/audio/bgm/MG_CogThief.ogg')
self.initCogInfo()
for barrelIndex in range(CTGG.NumBarrels):
barrel = loader.loadModel('phase_4/models/minigames/cogthief_game_gagTank')
barrel.setPos(CTGG.BarrelStartingPositions[barrelIndex])
barrel.setScale(self.BarrelScale)
barrel.reparentTo(render)
barrel.setTag('barrelIndex', str(barrelIndex))
collSphere = CollisionSphere(0, 0, 0, 4)
collSphere.setTangible(0)
name = 'BarrelSphere-%d' % barrelIndex
collSphereName = self.uniqueName(name)
collNode = CollisionNode(collSphereName)
collNode.setFromCollideMask(CTGG.BarrelBitmask)
collNode.addSolid(collSphere)
colNp = barrel.attachNewNode(collNode)
handler = CollisionHandlerEvent()
handler.setInPattern('barrelHit-%fn')
base.cTrav.addCollider(colNp, handler)
self.accept('barrelHit-' + collSphereName, self.handleEnterBarrel)
nodeToHide = '**/gagMoneyTen'
if barrelIndex % 2:
nodeToHide = '**/gagMoneyFive'
iconToHide = barrel.find(nodeToHide)
if not iconToHide.isEmpty():
iconToHide.hide()
self.barrels.append(barrel)
self.gameBoard = loader.loadModel('phase_4/models/minigames/cogthief_game')
self.gameBoard.find('**/floor_TT').hide()
self.gameBoard.find('**/floor_DD').hide()
self.gameBoard.find('**/floor_DG').hide()
self.gameBoard.find('**/floor_MM').hide()
self.gameBoard.find('**/floor_BR').hide()
self.gameBoard.find('**/floor_DL').hide()
zone = self.getSafezoneId()
if zone == ToontownGlobals.ToontownCentral:
self.gameBoard.find('**/floor_TT').show()
elif zone == ToontownGlobals.DonaldsDock:
self.gameBoard.find('**/floor_DD').show()
elif zone == ToontownGlobals.DaisyGardens:
self.gameBoard.find('**/floor_DG').show()
elif zone == ToontownGlobals.MinniesMelodyland:
self.gameBoard.find('**/floor_MM').show()
elif zone == ToontownGlobals.TheBrrrgh:
self.gameBoard.find('**/floor_BR').show()
elif zone == ToontownGlobals.DonaldsDreamland:
self.gameBoard.find('**/floor_DL').show()
else:
self.gameBoard.find('**/floor_TT').show()
self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0)
self.gameBoard.setScale(1.0)
self.toonSDs = {}
avId = self.localAvId
toonSD = CogThiefGameToonSD.CogThiefGameToonSD(avId, self)
self.toonSDs[avId] = toonSD
toonSD.load()
self.loadCogs()
self.toonHitTracks = {}
self.toonPieTracks = {}
self.sndOof = base.loadSfx('phase_4/audio/sfx/MG_cannon_hit_dirt.ogg')
self.sndRewardTick = base.loadSfx('phase_3.5/audio/sfx/tick_counter.ogg')
self.sndPerfect = base.loadSfx('phase_4/audio/sfx/ring_perfect.ogg')
self.timer = ToontownTimer.ToontownTimer()
self.timer.posInTopRightCorner()
self.timer.hide()
purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui')
self.jarImage = purchaseModels.find('**/Jar')
self.jarImage.reparentTo(hidden)
self.rewardPanel = DirectLabel(parent=hidden, relief=None, pos=(1.16, 0.0, 0.45), scale=0.65, text='', text_scale=0.2, text_fg=(0.95, 0.95, 0, 1), text_pos=(0, -0.13), text_font=ToontownGlobals.getSignFont(), image=self.jarImage)
self.rewardPanelTitle = DirectLabel(parent=self.rewardPanel, relief=None, pos=(0, 0, 0.06), scale=0.08, text=TTLocalizer.CannonGameReward, text_fg=(0.95, 0.95, 0, 1), text_shadow=(0, 0, 0, 1))
self.initGameWalk()
return
def unload(self):
self.notify.debug('unload')
DistributedMinigame.unload(self)
del self.music
self.removeChildGameFSM(self.gameFSM)
del self.gameFSM
self.gameBoard.removeNode()
del self.gameBoard
for barrel in self.barrels:
barrel.removeNode()
del self.barrels
for avId in self.toonSDs.keys():
toonSD = self.toonSDs[avId]
toonSD.unload()
del self.toonSDs
self.timer.destroy()
del self.timer
self.rewardPanel.destroy()
del self.rewardPanel
self.jarImage.removeNode()
del self.jarImage
del self.sndRewardTick
def onstage(self):
self.notify.debug('onstage')
DistributedMinigame.onstage(self)
self.gameBoard.reparentTo(render)
lt = base.localAvatar
lt.reparentTo(render)
self.__placeToon(self.localAvId)
lt.setSpeed(0, 0)
self.moveCameraToTop()
toonSD = self.toonSDs[self.localAvId]
toonSD.enter()
toonSD.fsm.request('normal')
self.stopGameWalk()
for cogIndex in xrange(self.getNumCogs()):
suit = self.cogInfo[cogIndex]['suit'].suit
pos = self.cogInfo[cogIndex]['pos']
suit.reparentTo(self.gameBoard)
suit.setPos(pos)
for avId in self.avIdList:
self.toonHitTracks[avId] = Wait(0.1)
self.toonRNGs = []
for i in xrange(self.numPlayers):
self.toonRNGs.append(RandomNumGen.RandomNumGen(self.randomNumGen))
self.sndTable = {'hitBySuit': [None] * self.numPlayers,
'falling': [None] * self.numPlayers}
for i in xrange(self.numPlayers):
self.sndTable['hitBySuit'][i] = base.loadSfx('phase_4/audio/sfx/MG_Tag_C.ogg')
self.sndTable['falling'][i] = base.loadSfx('phase_4/audio/sfx/MG_cannon_whizz.ogg')
base.playMusic(self.music, looping=1, volume=0.8)
self.introTrack = self.getIntroTrack()
self.introTrack.start()
return
def offstage(self):
self.notify.debug('offstage')
self.gameBoard.hide()
self.music.stop()
for barrel in self.barrels:
barrel.hide()
for avId in self.toonSDs.keys():
self.toonSDs[avId].exit()
for avId in self.avIdList:
av = self.getAvatar(avId)
if av:
av.resetLOD()
self.timer.reparentTo(hidden)
self.rewardPanel.reparentTo(hidden)
if self.introTrack.isPlaying():
self.introTrack.finish()
del self.introTrack
DistributedMinigame.offstage(self)
def handleDisabledAvatar(self, avId):
self.notify.debug('handleDisabledAvatar')
self.notify.debug('avatar ' + str(avId) + ' disabled')
self.toonSDs[avId].exit(unexpectedExit=True)
del self.toonSDs[avId]
DistributedMinigame.handleDisabledAvatar(self, avId)
def setGameReady(self):
if not self.hasLocalToon:
return
self.notify.debug('setGameReady')
if DistributedMinigame.setGameReady(self):
return
for avId in self.remoteAvIdList:
toon = self.getAvatar(avId)
if toon:
toon.reparentTo(render)
self.__placeToon(avId)
toon.useLOD(1000)
toonSD = CogThiefGameToonSD.CogThiefGameToonSD(avId, self)
self.toonSDs[avId] = toonSD
toonSD.load()
toonSD.enter()
toonSD.fsm.request('normal')
toon.startSmooth()
def setGameStart(self, timestamp):
if not self.hasLocalToon:
return
self.notify.debug('setGameStart')
DistributedMinigame.setGameStart(self, timestamp)
if not base.config.GetBool('cog-thief-endless', 0):
self.timer.show()
self.timer.countdown(CTGG.GameTime, self.__gameTimerExpired)
self.clockStopTime = None
self.rewardPanel.reparentTo(aspect2d)
self.scoreMult = MinigameGlobals.getScoreMult(self.cr.playGame.hood.id)
self.__startRewardCountdown()
if self.introTrack.isPlaying():
self.introTrack.finish()
self.gameFSM.request('play')
return
def enterOff(self):
self.notify.debug('enterOff')
def exitOff(self):
pass
def enterPlay(self):
self.notify.debug('enterPlay')
self.startGameWalk()
self.spawnUpdateSuitsTask()
self.accept('control', self.controlKeyPressed)
self.pieHandler = CollisionHandlerEvent()
self.pieHandler.setInPattern('pieHit-%fn')
def exitPlay(self):
self.ignore('control')
if self.resultIval and self.resultIval.isPlaying():
self.resultIval.finish()
self.resultIval = None
return
def enterCleanup(self):
self.__killRewardCountdown()
if hasattr(self, 'jarIval'):
self.jarIval.finish()
del self.jarIval
for key in self.toonHitTracks:
ival = self.toonHitTracks[key]
if ival.isPlaying():
ival.finish()
self.toonHitTracks = {}
for key in self.toonPieTracks:
ival = self.toonPieTracks[key]
if ival.isPlaying():
ival.finish()
self.toonPieTracks = {}
for key in self.cogInfo:
cogThief = self.cogInfo[key]['suit']
cogThief.cleanup()
self.removeUpdateSuitsTask()
self.notify.debug('enterCleanup')
def exitCleanup(self):
pass
def __placeToon(self, avId):
toon = self.getAvatar(avId)
if toon:
index = self.avIdList.index(avId)
toon.setPos(CTGG.ToonStartingPositions[index])
toon.setHpr(0, 0, 0)
def moveCameraToTop(self):
camera.reparentTo(render)
p = self.cameraTopView
camera.setPosHpr(p[0], p[1], p[2], p[3], p[4], p[5])
base.camLens.setMinFov(46/(4./3.))
camera.setZ(camera.getZ() + base.config.GetFloat('cog-thief-z-camera-adjust', 0.0))
def destroyGameWalk(self):
self.notify.debug('destroyOrthoWalk')
self.gameWalk.destroy()
del self.gameWalk
def initGameWalk(self):
self.notify.debug('startOrthoWalk')
def doCollisions(oldPos, newPos, self = self):
x = bound(newPos[0], CTGG.StageHalfWidth, -CTGG.StageHalfWidth)
y = bound(newPos[1], CTGG.StageHalfHeight, -CTGG.StageHalfHeight)
newPos.setX(x)
newPos.setY(y)
return newPos
orthoDrive = OrthoDrive(self.ToonSpeed, customCollisionCallback=doCollisions, instantTurn=True)
self.gameWalk = OrthoWalk(orthoDrive, broadcast=not self.isSinglePlayer())
def initCogInfo(self):
for cogIndex in xrange(self.getNumCogs()):
self.cogInfo[cogIndex] = {'pos': Point3(CTGG.CogStartingPositions[cogIndex]),
'goal': CTGG.NoGoal,
'goalId': CTGG.InvalidGoalId,
'suit': None}
return
def loadCogs(self):
suitTypes = ['ds',
'ac',
'bc',
'ms']
for suitIndex in xrange(self.getNumCogs()):
st = self.randomNumGen.choice(suitTypes)
suit = CogThief.CogThief(suitIndex, st, self, self.getCogSpeed())
self.cogInfo[suitIndex]['suit'] = suit
def handleEnterSphere(self, colEntry):
if self.gameIsEnding:
return
intoName = colEntry.getIntoNodePath().getName()
fromName = colEntry.getFromNodePath().getName()
debugInto = intoName.split('/')
debugFrom = fromName.split('/')
self.notify.debug('handleEnterSphere gametime=%s %s into %s' % (self.getCurrentGameTime(), debugFrom[-1], debugInto[-1]))
intoName = colEntry.getIntoNodePath().getName()
if 'CogThiefSphere' in intoName:
parts = intoName.split('-')
suitNum = int(parts[1])
self.localToonHitBySuit(suitNum)
def localToonHitBySuit(self, suitNum):
self.notify.debug('localToonHitBySuit %d' % suitNum)
timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime(), bits=32)
pos = self.cogInfo[suitNum]['suit'].suit.getPos()
self.sendUpdate('hitBySuit', [self.localAvId,
timestamp,
suitNum,
pos[0],
pos[1],
pos[2]])
self.showToonHitBySuit(self.localAvId, timestamp)
self.makeSuitRespondToToonHit(timestamp, suitNum)
def hitBySuit(self, avId, timestamp, suitNum, x, y, z):
if not self.hasLocalToon:
return
if self.gameFSM.getCurrentState().getName() not in ['play']:
self.notify.warning('ignoring msg: av %s hit by suit' % avId)
return
if self.gameIsEnding:
return
self.notify.debug('avatar ' + `avId` + ' hit by a suit')
if avId != self.localAvId:
self.showToonHitBySuit(avId, timestamp)
self.makeSuitRespondToToonHit(timestamp, suitNum)
def showToonHitBySuit(self, avId, timestamp):
toon = self.getAvatar(avId)
if toon == None:
return
rng = self.toonRNGs[self.avIdList.index(avId)]
curPos = toon.getPos(render)
oldTrack = self.toonHitTracks[avId]
if oldTrack.isPlaying():
oldTrack.finish()
toon.setPos(curPos)
toon.setZ(self.TOON_Z)
parentNode = render.attachNewNode('mazeFlyToonParent-' + `avId`)
parentNode.setPos(toon.getPos())
toon.reparentTo(parentNode)
toon.setPos(0, 0, 0)
startPos = parentNode.getPos()
dropShadow = toon.dropShadow.copyTo(parentNode)
dropShadow.setScale(toon.dropShadow.getScale(render))
trajectory = Trajectory.Trajectory(0, Point3(0, 0, 0), Point3(0, 0, 50), gravMult=1.0)
oldFlyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
trajectory = Trajectory.Trajectory(0, Point3(0, 0, 0), Point3(0, 0, 50), gravMult=0.55)
flyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
avIndex = self.avIdList.index(avId)
endPos = CTGG.ToonStartingPositions[avIndex]
def flyFunc(t, trajectory, startPos = startPos, endPos = endPos, dur = flyDur, moveNode = parentNode, flyNode = toon):
u = t / dur
moveNode.setX(startPos[0] + u * (endPos[0] - startPos[0]))
moveNode.setY(startPos[1] + u * (endPos[1] - startPos[1]))
flyNode.setPos(trajectory.getPos(t))
flyTrack = Sequence(LerpFunctionInterval(flyFunc, fromData=0.0, toData=flyDur, duration=flyDur, extraArgs=[trajectory]), name=toon.uniqueName('hitBySuit-fly'))
geomNode = toon.getGeomNode()
startHpr = geomNode.getHpr()
destHpr = Point3(startHpr)
hRot = rng.randrange(1, 8)
if rng.choice([0, 1]):
hRot = -hRot
destHpr.setX(destHpr[0] + hRot * 360)
spinHTrack = Sequence(LerpHprInterval(geomNode, flyDur, destHpr, startHpr=startHpr), Func(geomNode.setHpr, startHpr), name=toon.uniqueName('hitBySuit-spinH'))
parent = geomNode.getParent()
rotNode = parent.attachNewNode('rotNode')
geomNode.reparentTo(rotNode)
rotNode.setZ(toon.getHeight() / 2.0)
oldGeomNodeZ = geomNode.getZ()
geomNode.setZ(-toon.getHeight() / 2.0)
startHpr = rotNode.getHpr()
destHpr = Point3(startHpr)
pRot = rng.randrange(1, 3)
if rng.choice([0, 1]):
pRot = -pRot
destHpr.setY(destHpr[1] + pRot * 360)
spinPTrack = Sequence(LerpHprInterval(rotNode, flyDur, destHpr, startHpr=startHpr), Func(rotNode.setHpr, startHpr), name=toon.uniqueName('hitBySuit-spinP'))
i = self.avIdList.index(avId)
soundTrack = Sequence(Func(base.playSfx, self.sndTable['hitBySuit'][i]), Wait(flyDur * (2.0 / 3.0)), SoundInterval(self.sndTable['falling'][i], duration=flyDur * (1.0 / 3.0)), name=toon.uniqueName('hitBySuit-soundTrack'))
def preFunc(self = self, avId = avId, toon = toon, dropShadow = dropShadow):
forwardSpeed = toon.forwardSpeed
rotateSpeed = toon.rotateSpeed
if avId == self.localAvId:
self.stopGameWalk()
else:
toon.stopSmooth()
if forwardSpeed or rotateSpeed:
toon.setSpeed(forwardSpeed, rotateSpeed)
toon.dropShadow.hide()
def postFunc(self = self, avId = avId, oldGeomNodeZ = oldGeomNodeZ, dropShadow = dropShadow, parentNode = parentNode):
if avId == self.localAvId:
base.localAvatar.setPos(endPos)
if hasattr(self, 'gameWalk'):
toon = base.localAvatar
toon.setSpeed(0, 0)
self.startGameWalk()
dropShadow.removeNode()
del dropShadow
toon = self.getAvatar(avId)
if toon:
toon.dropShadow.show()
geomNode = toon.getGeomNode()
rotNode = geomNode.getParent()
baseNode = rotNode.getParent()
geomNode.reparentTo(baseNode)
rotNode.removeNode()
del rotNode
geomNode.setZ(oldGeomNodeZ)
if toon:
toon.reparentTo(render)
toon.setPos(endPos)
parentNode.removeNode()
del parentNode
if avId != self.localAvId:
if toon:
toon.startSmooth()
preFunc()
slipBack = Parallel(Sequence(ActorInterval(toon, 'slip-backward', endFrame=24), Wait(CTGG.LyingDownDuration - (flyDur - oldFlyDur)), ActorInterval(toon, 'slip-backward', startFrame=24)))
if toon.doId == self.localAvId:
slipBack.append(SoundInterval(self.sndOof))
hitTrack = Sequence(Parallel(flyTrack, spinHTrack, spinPTrack, soundTrack), slipBack, Func(postFunc), name=toon.uniqueName('hitBySuit'))
self.notify.debug('hitTrack duration = %s' % hitTrack.getDuration())
self.toonHitTracks[avId] = hitTrack
hitTrack.start(globalClockDelta.localElapsedTime(timestamp))
return
def updateSuitGoal(self, timestamp, inResponseToClientStamp, suitNum, goalType, goalId, x, y, z):
if not self.hasLocalToon:
return
self.notify.debug('updateSuitGoal gameTime=%s timeStamp=%s cog=%s goal=%s goalId=%s (%.1f, %.1f,%.1f)' % (self.getCurrentGameTime(),
timestamp,
suitNum,
CTGG.GoalStr[goalType],
goalId,
x,
y,
z))
cog = self.cogInfo[suitNum]
cog['goal'] = goalType
cog['goalId'] = goalId
newPos = Point3(x, y, z)
cog['pos'] = newPos
suit = cog['suit']
suit.updateGoal(timestamp, inResponseToClientStamp, goalType, goalId, newPos)
def spawnUpdateSuitsTask(self):
self.notify.debug('spawnUpdateSuitsTask')
for cogIndex in self.cogInfo:
suit = self.cogInfo[cogIndex]['suit']
suit.gameStart(self.gameStartTime)
taskMgr.remove(self.UPDATE_SUITS_TASK)
taskMgr.add(self.updateSuitsTask, self.UPDATE_SUITS_TASK)
def removeUpdateSuitsTask(self):
taskMgr.remove(self.UPDATE_SUITS_TASK)
def updateSuitsTask(self, task):
if self.gameIsEnding:
return task.done
for cogIndex in self.cogInfo:
suit = self.cogInfo[cogIndex]['suit']
suit.think()
return task.cont
def makeSuitRespondToToonHit(self, timestamp, suitNum):
cog = self.cogInfo[suitNum]['suit']
cog.respondToToonHit(timestamp)
def handleEnterBarrel(self, colEntry):
if self.gameIsEnding:
return
intoName = colEntry.getIntoNodePath().getName()
fromName = colEntry.getFromNodePath().getName()
debugInto = intoName.split('/')
debugFrom = fromName.split('/')
self.notify.debug('handleEnterBarrel gameTime=%s %s into %s' % (self.getCurrentGameTime(), debugFrom[-1], debugInto[-1]))
if 'CogThiefSphere' in intoName:
parts = intoName.split('-')
cogIndex = int(parts[1])
barrelName = colEntry.getFromNodePath().getName()
barrelParts = barrelName.split('-')
barrelIndex = int(barrelParts[1])
cog = self.cogInfo[cogIndex]['suit']
if cog.barrel == CTGG.NoBarrelCarried and barrelIndex not in self.stolenBarrels:
timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime(), bits=32)
if cog.suit:
cogPos = cog.suit.getPos()
collisionPos = colEntry.getContactPos(render)
if (cogPos - collisionPos).length() > 4:
import pdb
pdb.set_trace()
self.sendUpdate('cogHitBarrel', [timestamp,
cogIndex,
barrelIndex,
cogPos[0],
cogPos[1],
cogPos[2]])
def makeCogCarryBarrel(self, timestamp, inResponseToClientStamp, cogIndex, barrelIndex, x, y, z):
if not self.hasLocalToon:
return
if self.gameIsEnding:
return
self.notify.debug('makeCogCarryBarrel gameTime=%s timeStamp=%s cog=%s barrel=%s (%.1f, %.1f,%.1f)' % (self.getCurrentGameTime(),
timestamp,
cogIndex,
barrelIndex,
x,
y,
z))
barrel = self.barrels[barrelIndex]
self.notify.debug('barrelPos= %s' % barrel.getPos())
cog = self.cogInfo[cogIndex]['suit']
cogPos = Point3(x, y, z)
cog.makeCogCarryBarrel(timestamp, inResponseToClientStamp, barrel, barrelIndex, cogPos)
def makeCogDropBarrel(self, timestamp, inResponseToClientStamp, cogIndex, barrelIndex, x, y, z):
if not self.hasLocalToon:
return
self.notify.debug('makeCogDropBarrel gameTime=%s timeStamp=%s cog=%s barrel=%s (%.1f, %.1f,%.1f)' % (self.getCurrentGameTime(),
timestamp,
cogIndex,
barrelIndex,
x,
y,
z))
barrel = self.barrels[barrelIndex]
self.notify.debug('barrelPos= %s' % barrel.getPos())
cog = self.cogInfo[cogIndex]['suit']
cogPos = Point3(x, y, z)
cog.makeCogDropBarrel(timestamp, inResponseToClientStamp, barrel, barrelIndex, cogPos)
def controlKeyPressed(self):
if self.isToonPlayingHitTrack(self.localAvId):
return
if self.gameIsEnding:
return
if self.getCurrentGameTime() - self.lastTimeControlPressed > self.ControlKeyLimitTime:
self.lastTimeControlPressed = self.getCurrentGameTime()
self.notify.debug('controlKeyPressed')
toonSD = self.toonSDs[self.localAvId]
curState = toonSD.fsm.getCurrentState().getName()
toon = self.getAvatar(self.localAvId)
timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime(), bits=32)
pos = toon.getPos()
heading = toon.getH()
self.sendUpdate('throwingPie', [self.localAvId,
timestamp,
heading,
pos[0],
pos[1],
pos[2]])
self.showToonThrowingPie(self.localAvId, timestamp, heading, pos)
def throwingPie(self, avId, timestamp, heading, x, y, z):
if not self.hasLocalToon:
return
if self.gameFSM.getCurrentState().getName() not in ['play']:
self.notify.warning('ignoring msg: av %s hit by suit' % avId)
return
self.notify.debug('avatar ' + `avId` + ' throwing pie')
if avId != self.localAvId:
pos = Point3(x, y, z)
self.showToonThrowingPie(avId, timestamp, heading, pos)
def showToonThrowingPie(self, avId, timestamp, heading, pos):
toon = self.getAvatar(avId)
if toon:
tossTrack, pieTrack, flyPie = self.getTossPieInterval(toon, pos[0], pos[1], pos[2], heading, 0, 0, 0)
def removePieFromTraverser(flyPie = flyPie):
if base.cTrav:
if flyPie:
base.cTrav.removeCollider(flyPie)
if avId == self.localAvId:
flyPie.setTag('throwerId', str(avId))
collSphere = CollisionSphere(0, 0, 0, 0.5)
collSphere.setTangible(0)
name = 'PieSphere-%d' % avId
collSphereName = self.uniqueName(name)
collNode = CollisionNode(collSphereName)
collNode.setFromCollideMask(ToontownGlobals.PieBitmask)
collNode.addSolid(collSphere)
colNp = flyPie.attachNewNode(collNode)
colNp.show()
base.cTrav.addCollider(colNp, self.pieHandler)
self.accept('pieHit-' + collSphereName, self.handlePieHitting)
def matchRunningAnim(toon = toon):
toon.playingAnim = None
toon.setSpeed(toon.forwardSpeed, toon.rotateSpeed)
return
newTossTrack = Sequence(tossTrack, Func(matchRunningAnim))
pieTrack = Parallel(newTossTrack, pieTrack)
elapsedTime = globalClockDelta.localElapsedTime(timestamp)
if elapsedTime < 16.0 / 24.0:
elapsedTime = 16.0 / 24.0
pieTrack.start(elapsedTime)
self.toonPieTracks[avId] = pieTrack
def getTossPieInterval(self, toon, x, y, z, h, p, r, power, beginFlyIval = Sequence()):
from toontown.toonbase import ToontownBattleGlobals
from toontown.battle import BattleProps
pie = toon.getPieModel()
pie.setScale(0.9)
flyPie = pie.copyTo(NodePath('a'))
pieName = ToontownBattleGlobals.pieNames[toon.pieType]
pieType = BattleProps.globalPropPool.getPropType(pieName)
animPie = Sequence()
if pieType == 'actor':
animPie = ActorInterval(pie, pieName, startFrame=48)
sound = loader.loadSfx('phase_3.5/audio/sfx/AA_pie_throw_only.ogg')
t = power / 100.0
dist = 100 - 70 * t
time = 1 + 0.5 * t
proj = ProjectileInterval(None, startPos=Point3(0, 0, 0), endPos=Point3(0, dist, 0), duration=time)
relVel = proj.startVel
def getVelocity(toon = toon, relVel = relVel):
return render.getRelativeVector(toon, relVel) * 0.6
toss = Track((0, Sequence(Func(toon.setPosHpr, x, y, z, h, p, r), Func(pie.reparentTo, toon.rightHand), Func(pie.setPosHpr, 0, 0, 0, 0, 0, 0), Parallel(ActorInterval(toon, 'throw', startFrame=48, partName='torso'), animPie), Func(toon.loop, 'neutral'))), (16.0 / 24.0, Func(pie.detachNode)))
fly = Track((14.0 / 24.0, SoundInterval(sound, node=toon)), (16.0 / 24.0, Sequence(Func(flyPie.reparentTo, render), Func(flyPie.setPosHpr, toon, 0.52, 0.97, 2.24, 0, -45, 0), beginFlyIval, ProjectileInterval(flyPie, startVel=getVelocity, duration=6), Func(flyPie.detachNode))))
return (toss, fly, flyPie)
def handlePieHitting(self, colEntry):
if self.gameIsEnding:
return
into = colEntry.getIntoNodePath()
intoName = into.getName()
if 'CogThiefPieSphere' in intoName:
timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime(), bits=32)
parts = intoName.split('-')
suitNum = int(parts[1])
pos = self.cogInfo[suitNum]['suit'].suit.getPos()
if pos in CTGG.CogStartingPositions:
self.notify.debug('Cog %d hit at starting pos %s, ignoring' % (suitNum, pos))
else:
self.sendUpdate('pieHitSuit', [self.localAvId,
timestamp,
suitNum,
pos[0],
pos[1],
pos[2]])
self.makeSuitRespondToPieHit(timestamp, suitNum)
def pieHitSuit(self, avId, timestamp, suitNum, x, y, z):
if not self.hasLocalToon:
return
if self.gameFSM.getCurrentState().getName() not in ['play']:
self.notify.warning('ignoring msg: av %s hit by suit' % avId)
return
if self.gameIsEnding:
return
self.notify.debug('avatar ' + `avId` + ' hit by a suit')
if avId != self.localAvId:
self.makeSuitRespondToPieHit(timestamp, suitNum)
def makeSuitRespondToPieHit(self, timestamp, suitNum):
cog = self.cogInfo[suitNum]['suit']
cog.respondToPieHit(timestamp)
def sendCogAtReturnPos(self, cogIndex, barrelIndex):
timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime(), bits=32)
self.sendUpdate('cogAtReturnPos', [timestamp, cogIndex, barrelIndex])
def markBarrelStolen(self, timestamp, inResponseToClientStamp, barrelIndex):
if not self.hasLocalToon:
return
if barrelIndex not in self.stolenBarrels:
self.stolenBarrels.append(barrelIndex)
barrel = self.barrels[barrelIndex]
barrel.hide()
if base.config.GetBool('cog-thief-check-barrels', 1):
if not base.config.GetBool('cog-thief-endless', 0):
if len(self.stolenBarrels) == len(self.barrels):
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32)
gameTime = self.local2GameTime(localStamp)
self.clockStopTime = gameTime
self.notify.debug('clockStopTime = %s' % gameTime)
score = int(self.scoreMult * CTGG.calcScore(gameTime) + 0.5)
self.rewardPanel['text'] = str(score)
self.showResults()
def __gameTimerExpired(self):
self.notify.debug('game timer expired')
self.showResults()
def __startRewardCountdown(self):
taskMgr.remove(self.REWARD_COUNTDOWN_TASK)
taskMgr.add(self.__updateRewardCountdown, self.REWARD_COUNTDOWN_TASK)
def __killRewardCountdown(self):
taskMgr.remove(self.REWARD_COUNTDOWN_TASK)
def __updateRewardCountdown(self, task):
curTime = self.getCurrentGameTime()
if self.clockStopTime is not None:
if self.clockStopTime < curTime:
self.notify.debug('self.clockStopTime < curTime %s %s' % (self.clockStopTime, curTime))
self.__killRewardCountdown()
curTime = self.clockStopTime
if curTime > CTGG.GameTime:
curTime = CTGG.GameTime
score = int(self.scoreMult * CTGG.calcScore(curTime) + 0.5)
if not hasattr(task, 'curScore'):
task.curScore = score
result = Task.cont
if hasattr(self, 'rewardPanel'):
self.rewardPanel['text'] = str(score)
if task.curScore != score:
if hasattr(self, 'jarIval'):
self.jarIval.finish()
s = self.rewardPanel.getScale()
self.jarIval = Parallel(Sequence(self.rewardPanel.scaleInterval(0.15, s * 3.0 / 4.0, blendType='easeOut'), self.rewardPanel.scaleInterval(0.15, s, blendType='easeIn')), SoundInterval(self.sndRewardTick), name='cogThiefGameRewardJarThrob')
self.jarIval.start()
task.curScore = score
else:
result = Task.done
return result
def startGameWalk(self):
self.gameWalk.start()
def stopGameWalk(self):
self.gameWalk.stop()
def getCogThief(self, cogIndex):
return self.cogInfo[cogIndex]['suit']
def isToonPlayingHitTrack(self, avId):
if avId in self.toonHitTracks:
track = self.toonHitTracks[avId]
if track.isPlaying():
return True
return False
def getNumCogs(self):
result = base.config.GetInt('cog-thief-num-cogs', 0)
if not result:
safezone = self.getSafezoneId()
result = CTGG.calculateCogs(self.numPlayers, safezone)
return result
def getCogSpeed(self):
result = 6.0
safezone = self.getSafezoneId()
result = CTGG.calculateCogSpeed(self.numPlayers, safezone)
return result
def showResults(self):
if not self.gameIsEnding:
self.gameIsEnding = True
for barrel in self.barrels:
barrel.wrtReparentTo(render)
for key in self.cogInfo:
thief = self.cogInfo[key]['suit']
thief.suit.setPos(100, 0, 0)
thief.suit.hide()
self.__killRewardCountdown()
self.stopGameWalk()
numBarrelsSaved = len(self.barrels) - len(self.stolenBarrels)
resultStr = ''
if numBarrelsSaved == len(self.barrels):
resultStr = TTLocalizer.CogThiefPerfect
elif numBarrelsSaved > 1:
resultStr = TTLocalizer.CogThiefBarrelsSaved % {'num': numBarrelsSaved}
elif numBarrelsSaved == 1:
resultStr = TTLocalizer.CogThiefBarrelSaved % {'num': numBarrelsSaved}
else:
resultStr = TTLocalizer.CogThiefNoBarrelsSaved
perfectTextSubnode = hidden.attachNewNode(self.__genText(resultStr))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text = perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text = perfectText):
text.removeNode()
def safeGameOver(self = self):
if not self.frameworkFSM.isInternalStateInFlux():
self.gameOver()
textTrack = Sequence(Func(perfectText.reparentTo, aspect2d), Parallel(LerpScaleInterval(perfectText, duration=0.5, scale=0.3, startScale=0.0), LerpFunctionInterval(fadeFunc, fromData=0.0, toData=1.0, duration=0.5)), Wait(2.0), Parallel(LerpScaleInterval(perfectText, duration=0.5, scale=1.0), LerpFunctionInterval(fadeFunc, fromData=1.0, toData=0.0, duration=0.5, blendType='easeIn')), Func(destroyText), WaitInterval(0.5), Func(safeGameOver))
if numBarrelsSaved == len(self.barrels):
soundTrack = SoundInterval(self.sndPerfect)
else:
soundTrack = Sequence()
self.resultIval = Parallel(textTrack, soundTrack)
self.resultIval.start()
def __genText(self, text):
self.__textGen.setText(text)
return self.__textGen.generate()
def getIntroTrack(self):
base.camera.setPosHpr(0, -13.66, 13.59, 0, -51.6, 0)
result = Sequence(Wait(2), LerpPosHprInterval(base.camera, 13, Point3(self.cameraTopView[0], self.cameraTopView[1], self.cameraTopView[2]), Point3(self.cameraTopView[3], self.cameraTopView[4], self.cameraTopView[5]), blendType='easeIn'))
return result
class DistributedMinigame(DistributedObject.DistributedObject, Timer.Timer):
def __init__(self, cr):
try:
self.DistributedMinigame_initialized
return
except:
self.DistributedMinigame_initialized = 1
DistributedObject.DistributedObject.__init__(self, cr)
Timer.Timer.__init__(self)
self.headPanels = HeadPanels()
self.finalScoreUI = FinalScoreGUI()
self.fsm = ClassicFSM('DistributedMinigame', [
State('start', self.enterStart, self.exitStart, ['waitForOthers']),
State('waitForOthers', self.enterWaitForOthers,
self.exitWaitForOthers, ['play']),
State('play', self.enterPlay, self.exitPlay, ['gameOver']),
State('gameOver', self.enterGameOver, self.exitGameOver, ['off']),
State('off', self.enterOff, self.exitOff)
], 'off', 'off')
self.fsm.enterInitialState()
self.cr = cr
self.localAv = base.localAvatar
self.localAvId = self.localAv.doId
self.musicPath = 'phase_4/audio/bgm/trolley_song.mid'
self.winSfx = base.loadSfx('phase_4/audio/sfx/MG_win.ogg')
self.loseSfx = base.loadSfx('phase_4/audio/sfx/MG_lose.ogg')
self.prizeHigh = base.loadSfx('phase_6/audio/sfx/KART_Applause_1.ogg')
self.prizeLow = base.loadSfx('phase_6/audio/sfx/KART_Applause_4.ogg')
self.music = None
self.description = ''
self.descDialog = None
self.winnerPrize = 0
self.loserPrize = 0
self.winnerMsg = 'Winner!\nYou have earned: %s Jellybeans'
self.loserMsg = 'Loser!\nYou have earned: %s Jellybeans'
self.allWinnerMsgs = [
'Nice try!\nYou have earned: %s', 'Good job!\nYou have earned: %s',
'Way to go!\nYou have earned: %s', 'Awesome!\nYou have earned: %s'
]
self.timer = None
self.timeLbl = None
self.alertText = None
self.alertPulse = None
self.popupSound = None
self.gameOverLbl = OnscreenText(text="TIME'S\nUP!",
scale=0.25,
font=CIGlobals.getMickeyFont(),
fg=(1, 0, 0, 1))
self.gameOverLbl.setBin('gui-popup', 60)
self.gameOverLbl.hide()
return
def getTeamDNAColor(self, team):
pass
def showAlert(self, text):
self.stopPulse()
base.playSfx(self.popupSound)
self.alertText.setText(text)
self.alertPulse = getAlertPulse(self.alertText)
self.alertPulse.start()
def stopPulse(self):
if self.alertPulse:
self.alertPulse.finish()
self.alertPulse = None
return
def enterFinalScores(self):
self.finalScoreUI.load()
self.finalScoreUI.showFinalScores()
def exitFinalScores(self):
self.finalScoreUI.hideFinalScores()
self.finalScoreUI.unload()
def finalScores(self, avIdList, scoreList):
self.finalScoreUI.handleFinalScores(avIdList, scoreList)
def generateHeadPanel(self, gender, head, headtype, color, doId, name):
self.headPanels.generate(gender, head, headtype, color, doId, name)
def updateHeadPanelValue(self, doId, direction):
self.headPanels.updateValue(doId, direction)
def setTimerTime(self, time):
self.setTime(time)
def createTimer(self):
Timer.Timer.load(self)
def deleteTimer(self):
Timer.Timer.unload(self)
def setDescription(self, desc):
self.description = desc
def getDescription(self):
return self.description
def enterStart(self):
self.descDialog = GlobalDialog(style=3,
message=self.getDescription(),
doneEvent='gameDescAck')
self.acceptOnce('gameDescAck', self.handleDescAck)
def handleDescAck(self):
self.d_ready()
self.fsm.request('waitForOthers')
def exitStart(self):
self.ignore('gameDescAck')
self.descDialog.cleanup()
del self.descDialog
def enterWaitForOthers(self):
self.waitLbl = DirectLabel(text='Waiting for other players...',
relief=None,
text_fg=(1, 1, 1, 1),
text_scale=0.08,
text_shadow=(0, 0, 0, 1))
return
def exitWaitForOthers(self):
self.waitLbl.destroy()
del self.waitLbl
def setLoserPrize(self, prize):
self.loserPrize = prize
def setWinnerPrize(self, prize):
self.winnerPrize = prize
def getLoserPrize(self):
return self.loserPrize
def getWinnerPrize(self):
return self.winnerPrize
def winner(self):
self.winSfx.play()
self.localAv.b_setAnimState('happy')
Sequence(Wait(3.5), Func(self.displayGameOver, 'winner')).start()
def showPrize(self, amt):
self.winSfx.play()
self.localAv.b_setAnimState('happy')
Sequence(Wait(3.5), Func(self.displayGameOver, 'showPrize',
amt)).start()
def loser(self):
self.loseSfx.play()
self.localAv.b_setAnimState('neutral')
Sequence(Wait(3.5), Func(self.displayGameOver, 'loser')).start()
def displayGameOver(self, scenario, amt=None):
if scenario == 'winner':
msg = self.winnerMsg % self.winnerPrize
self.prizeHigh.play()
else:
if scenario == 'loser':
msg = self.loserMsg % self.loserPrize
self.prizeLow.play()
else:
if scenario == 'showPrize':
msg = random.choice(self.allWinnerMsgs) % amt
self.prizeHigh.play()
self.gameOverDialog = GlobalDialog(message=msg,
style=3,
doneEvent='gameOverAck')
self.acceptOnce('gameOverAck', self.__handleGameOverAck)
self.gameOverDialog.show()
def deleteGameOverDialog(self):
self.ignore('gameOverAck')
if hasattr(self, 'gameOverDialog'):
self.gameOverDialog.cleanup()
del self.gameOverDialog
def __handleGameOverAck(self):
self.fsm.requestFinalState()
Sequence(Func(base.transitions.irisOut, 1.0), Wait(1.2),
Func(self.d_leaving),
Func(self.headBackToMinigameArea)).start()
def headBackToMinigameArea(self):
whereName = ZoneUtil.getWhereName(CIGlobals.MinigameAreaId)
loaderName = ZoneUtil.getLoaderName(CIGlobals.MinigameAreaId)
requestStatus = {
'zoneId': CIGlobals.MinigameAreaId,
'hoodId': CIGlobals.MinigameArea,
'where': whereName,
'how': 'teleportIn',
'avId': base.localAvatar.doId,
'shardId': None,
'loader': loaderName
}
self.cr.playGame.hood.fsm.request('quietZone', [requestStatus])
return
def abort(self):
self.headBackToMinigameArea()
def load(self, showDesc=True):
if showDesc:
self.fsm.request('start')
base.transitions.irisIn()
def d_leaving(self):
self.sendUpdate('leaving', [])
def allPlayersReady(self):
self.fsm.request('play')
def enterPlay(self):
self.playMinigameMusic()
def exitPlay(self):
self.stopMinigameMusic()
def enterOff(self):
pass
def exitOff(self):
pass
def enterGameOver(self, winner, winnerDoId, allPrize):
if winner:
if self.localAvId in winnerDoId:
self.winner()
else:
self.loser()
else:
self.showPrize(allPrize)
def exitGameOver(self):
self.deleteGameOverDialog()
def gameOver(self, winner=0, winnerDoId=[], allPrize=0):
self.fsm.request('gameOver', [winner, winnerDoId, allPrize])
def setMinigameMusic(self, path):
self.musicPath = path
def getMinigameMusic(self):
return self.musicPath
def playMinigameMusic(self):
self.stopMinigameMusic()
self.music = base.loadMusic(self.musicPath)
self.music.setLoop(True)
self.music.setVolume(0.8)
self.music.play()
def stopMinigameMusic(self):
if self.music:
self.music.stop()
self.music = None
return
def d_ready(self):
self.sendUpdate('ready', [])
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
base.minigame = self
self.alertText = getAlertText()
self.popupSound = base.loadSfx(
'phase_3/audio/sfx/GUI_balloon_popup.ogg')
NametagGlobals.setWant2dNametags(False)
def disable(self):
base.localAvatar.getGeomNode().setColorScale(VBase4(1, 1, 1, 1))
if hasattr(self, 'gameOverLbl') and self.gameOverLbl:
self.gameOverLbl.destroy()
self.gameOverLbl = None
NametagGlobals.setWant2dNametags(True)
base.localAvatar.setPosHpr(0, 0, 0, 0, 0, 0)
self.fsm.requestFinalState()
del self.fsm
self.winSfx = None
self.loseSfx = None
self.prizeHigh = None
self.prizeLow = None
self.headPanels.delete()
self.headPanels = None
self.finalScoreUI.unload()
self.finalScoreUI = None
base.minigame = None
DistributedObject.DistributedObject.disable(self)
return
class CharSelection:
notify = directNotify.newCategory('CharSelection')
STAGE_TOON_POS = (66.4, 74.47, -25)
STAGE_TOON_HPR = (227.73, 0, 0)
NO_TOON = 'Empty Slot'
PLAY = 'Play'
CREATE = 'Create'
TITLE = 'Pick A Toon To Play'
def __init__(self, avChooser):
self.avChooser = avChooser
self.choice = None
self.charList = None
self.charNameLabel = None
self.charButtons = []
self.playOrCreateButton = None
self.deleteButton = None
self.quitButton = None
self.world = None
self.sky = None
self.fog = None
self.title = None
self.stageToon = None
self.selectionFSM = ClassicFSM.ClassicFSM('CharSelection', [State.State('off', self.enterOff, self.exitOff), State.State('character', self.enterCharSelected, self.exitCharSelected), State.State('empty', self.enterEmptySelected, self.exitEmptySelected)], 'off', 'off')
self.selectionFSM.enterInitialState()
return
def __setupStageToon(self):
self.stageToon = Toon(base.cr)
self.stageToon.setPos(self.STAGE_TOON_POS)
self.stageToon.setHpr(self.STAGE_TOON_HPR)
def cleanupStageToon(self):
if self.stageToon != None:
self.stageToon.disable()
self.stageToon.delete()
self.stageToon = None
return
def enterOff(self):
pass
def exitOff(self):
pass
def enterCharSelected(self, slot):
self.choice = self.avChooser.getAvChoiceBySlot(slot)
dna = self.choice.dna
name = self.choice.name
self.stageToon.setName(name)
self.stageToon.setDNAStrand(dna)
self.stageToon.nameTag.setColorLocal()
self.stageToon.animFSM.request('neutral')
self.stageToon.reparentTo(base.render)
self.charNameLabel.setText(name)
self.playOrCreateButton['text'] = self.PLAY
self.playOrCreateButton['extraArgs'] = ['play']
self.playOrCreateButton.show()
self.deleteButton.show()
def exitCharSelected(self):
self.stageToon.animFSM.requestFinalState()
self.stageToon.deleteCurrentToon()
self.stageToon.reparentTo(base.hidden)
self.playOrCreateButton.hide()
self.deleteButton.hide()
self.choice = None
return
def enterEmptySelected(self):
self.charNameLabel.setText(self.NO_TOON)
self.playOrCreateButton['text'] = self.CREATE
self.playOrCreateButton['extraArgs'] = ['create']
self.playOrCreateButton.show()
def exitEmptySelected(self):
self.playOrCreateButton.hide()
def __action(self, action):
for btn in self.charButtons:
if btn['state'] == DGG.DISABLED:
self.slot = btn.getPythonTag('slot')
break
func = None
arg = None
if action == 'delete':
func = self.deleteToon
arg = self.choice.avId
elif action == 'play':
func = self.playGame
arg = self.choice.slot
elif action == 'create':
func = self.enterMAT
elif action == 'quit':
func = sys.exit
base.transitions.fadeOut(0.3)
if arg != None:
Sequence(Wait(0.31), Func(func, arg)).start()
else:
Sequence(Wait(0.31), Func(func)).start()
return
def playGame(self, slot):
messenger.send('avChooseDone', [self.avChooser.getAvChoiceBySlot(slot)])
def enterMAT(self):
messenger.send('enterMakeAToon', [self.slot])
def deleteToon(self, avId):
self.avChooser.avChooseFSM.request('waitForToonDelResponse', [avId])
def __handleCharButton(self, slot):
for btn in self.charButtons:
if btn.getPythonTag('slot') == slot:
btn['state'] = DGG.DISABLED
else:
btn['state'] = DGG.NORMAL
if self.avChooser.hasToonInSlot(slot):
self.selectionFSM.request('character', [slot])
else:
self.selectionFSM.request('empty')
def load(self):
base.cr.renderFrame()
base.camLens.setMinFov(CIGlobals.DefaultCameraFov / (4.0 / 3.0))
self.__setupStageToon()
self.world = loader.loadModel('phase_9/models/cogHQ/SellbotHQExterior.bam')
self.world.reparentTo(base.render)
self.world.setPos(0, 227.09, -25.36)
self.sky = loader.loadModel('phase_9/models/cogHQ/cog_sky.bam')
self.sky.setScale(1)
self.sky.reparentTo(base.render)
self.sky.find('**/InnerGroup').removeNode()
self.fog = Fog('charSelectFog')
self.fog.setColor(0.2, 0.2, 0.2)
self.fog.setExpDensity(0.003)
base.render.setFog(self.fog)
self.title = DirectLabel(text=self.TITLE, text_font=CIGlobals.getMickeyFont(), text_fg=(1, 0.9, 0.1, 1), relief=None, text_scale=0.13, pos=(0, 0, 0.82))
self.charNameLabel = OnscreenText(text='', font=CIGlobals.getMickeyFont(), pos=(-0.25, 0.5, 0), fg=(1, 0.9, 0.1, 1.0))
self.charNameLabel.hide()
self.playOrCreateButton = DirectButton(text='', pos=(0.8125, 0, -0.735), command=self.__action, geom=CIGlobals.getDefaultBtnGeom(), text_scale=0.06, relief=None, text_pos=(0, -0.01))
self.playOrCreateButton.hide()
self.deleteButton = DirectButton(text='Delete', pos=(0.8125, 0, -0.835), command=self.__action, extraArgs=['delete'], geom=CIGlobals.getDefaultBtnGeom(), text_scale=0.06, relief=None, text_pos=(0, -0.01))
self.deleteButton.hide()
self.quitButton = DirectButton(text='Quit', pos=(-1.1, 0, -0.925), command=self.__action, extraArgs=['quit'], text_scale=0.06, geom=CIGlobals.getDefaultBtnGeom(), relief=None, text_pos=(0, -0.01))
textRolloverColor = Vec4(1, 1, 0, 1)
textDownColor = Vec4(0.5, 0.9, 1, 1)
textDisabledColor = Vec4(0.4, 0.8, 0.4, 1)
for slot in range(6):
if self.avChooser.hasToonInSlot(slot):
choice = self.avChooser.getAvChoiceBySlot(slot)
text = choice.name
else:
text = self.NO_TOON
btn = DirectButton(relief=None, text=text, text_scale=0.06, text_align=TextNode.ALeft, text1_bg=textDownColor, text2_bg=textRolloverColor, text3_fg=textDisabledColor, textMayChange=0, command=self.__handleCharButton, extraArgs=[slot], text_pos=(0, 0, 0.0))
btn.setPythonTag('slot', slot)
self.charButtons.append(btn)
btn['state'] = DGG.NORMAL
gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui.bam')
listXorigin = -0.02
listFrameSizeX = 0.625
listZorigin = -0.96
listFrameSizeZ = 1.04
arrowButtonScale = 1.3
itemFrameXorigin = -0.237
itemFrameZorigin = 0.365
buttonXstart = itemFrameXorigin + 0.293
self.charList = DirectScrolledList(relief=None, pos=(0.75, 0, 0.08), incButton_image=(gui.find('**/FndsLst_ScrollUp'),
gui.find('**/FndsLst_ScrollDN'),
gui.find('**/FndsLst_ScrollUp_Rllvr'),
gui.find('**/FndsLst_ScrollUp')), incButton_relief=None, incButton_scale=(arrowButtonScale, arrowButtonScale, -arrowButtonScale), incButton_pos=(buttonXstart, 0, itemFrameZorigin - 0.999), incButton_image3_color=Vec4(1, 1, 1, 0.2), decButton_image=(gui.find('**/FndsLst_ScrollUp'),
gui.find('**/FndsLst_ScrollDN'),
gui.find('**/FndsLst_ScrollUp_Rllvr'),
gui.find('**/FndsLst_ScrollUp')), decButton_relief=None, decButton_scale=(arrowButtonScale, arrowButtonScale, arrowButtonScale), decButton_pos=(buttonXstart, 0, itemFrameZorigin + 0.125), decButton_image3_color=Vec4(1, 1, 1, 0.2), itemFrame_pos=(itemFrameXorigin, 0, itemFrameZorigin), itemFrame_scale=1.0, itemFrame_relief=DGG.SUNKEN, itemFrame_frameSize=(listXorigin,
listXorigin + listFrameSizeX,
listZorigin,
listZorigin + listFrameSizeZ), itemFrame_frameColor=(0.85, 0.95, 1, 1), itemFrame_borderWidth=(0.01, 0.01), numItemsVisible=15, forceHeight=0.075, items=self.charButtons)
base.camera.setPos(75.12, 63.22, -23)
base.camera.setHpr(26.57, 9.62, 0)
return
def unload(self):
self.selectionFSM.requestFinalState()
self.cleanupStageToon()
self.choice = None
if self.charButtons:
for btn in self.charButtons:
btn.destroy()
self.charButtons = None
if self.charList:
self.charList.destroy()
self.charList = None
if self.charNameLabel:
self.charNameLabel.destroy()
self.charNameLabel = None
if self.playOrCreateButton:
self.playOrCreateButton.destroy()
self.playOrCreateButton = None
if self.deleteButton:
self.deleteButton.destroy()
self.deleteButton = None
if self.quitButton:
self.quitButton.destroy()
self.quitButton = None
if self.sky:
self.sky.removeNode()
self.sky = None
if self.world:
self.world.removeNode()
self.world = None
if self.title:
self.title.destroy()
self.title = None
base.render.clearFog()
self.fog = None
base.camera.setPos(0, 0, 0)
base.camera.setHpr(0, 0, 0)
base.transitions.noTransitions()
del self.selectionFSM
return
class GloveShopGui:
def __init__(self):
self.index = 0
self.id = time.time()
self.lastGlove = base.localAvatar.style.gloveColor
self.timer = ToontownTimer.ToontownTimer()
self.timer.reparentTo(aspect2d)
self.timer.posInTopRightCorner()
self.timer.countdown(GloveNPCGlobals.TIMER_SECONDS, self.__exit,
[GloveNPCGlobals.TIMER_END])
self.setupButtons()
self.bindButtons()
self.__updateIndex(0)
def setupButtons(self):
gui = loader.loadModel('phase_3/models/gui/tt_m_gui_mat_mainGui')
arrowImage = (gui.find('**/tt_t_gui_mat_shuffleArrowUp'),
gui.find('**/tt_t_gui_mat_shuffleArrowDown'))
buttonImage = (gui.find('**/tt_t_gui_mat_shuffleUp'),
gui.find('**/tt_t_gui_mat_shuffleDown'))
self.title = DirectLabel(aspect2d,
relief=None,
text=TTLocalizer.GloveGuiTitle,
text_fg=(0, 1, 0, 1),
text_scale=0.15,
text_font=ToontownGlobals.getSignFont(),
pos=(0, 0, -0.30),
text_shadow=(1, 1, 1, 1))
self.notice = DirectLabel(aspect2d,
relief=None,
text='',
text_fg=(1, 0, 0, 1),
text_scale=0.11,
text_font=ToontownGlobals.getSignFont(),
pos=(0, 0, -0.45),
text_shadow=(1, 1, 1, 1))
self.color = DirectLabel(aspect2d,
relief=None,
text='',
text_scale=0.11,
text_font=ToontownGlobals.getSignFont(),
pos=(0, 0, -0.70),
text_shadow=(1, 1, 1, 1))
self.buyButton = DirectButton(
aspect2d,
relief=None,
image=buttonImage,
text=TTLocalizer.GloveGuiBuy,
text_font=ToontownGlobals.getInterfaceFont(),
text_scale=0.11,
text_pos=(0, -0.02),
pos=(-0.60, 0, -0.90),
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
command=self.__exit,
extraArgs=[GloveNPCGlobals.CHANGE])
self.cancelButton = DirectButton(
aspect2d,
relief=None,
image=buttonImage,
text=TTLocalizer.lCancel,
text_font=ToontownGlobals.getInterfaceFont(),
text_scale=0.11,
text_pos=(0, -0.02),
pos=(0.60, 0, -0.90),
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
command=self.__exit,
extraArgs=[GloveNPCGlobals.USER_CANCEL])
self.downArrow = DirectButton(aspect2d,
relief=None,
image=arrowImage,
pos=(-0.60, 0, -0.66))
self.upArrow = DirectButton(aspect2d,
relief=None,
image=arrowImage,
pos=(0.60, 0, -0.66),
scale=-1)
gui.removeNode()
def bindButtons(self):
self.downArrow.bind(DGG.B1PRESS, self.__taskUpdate, extraArgs=[-1])
self.downArrow.bind(DGG.B1RELEASE, self.__taskDone)
self.upArrow.bind(DGG.B1PRESS, self.__taskUpdate, extraArgs=[1])
self.upArrow.bind(DGG.B1RELEASE, self.__taskDone)
def destroy(self):
if self.timer:
self.timer.destroy()
if not hasattr(self, 'title'):
return
# TODO: DirectDialog-ify
self.title.destroy()
self.notice.destroy()
self.color.destroy()
self.buyButton.destroy()
self.cancelButton.destroy()
self.downArrow.destroy()
self.upArrow.destroy()
del self.title
del self.notice
del self.color
del self.buyButton
del self.cancelButton
del self.downArrow
del self.upArrow
taskMgr.remove('runGloveCounter-%s' % self.id)
def setClientGlove(self, color):
dna = base.localAvatar.style
dna.gloveColor = color
base.localAvatar.setDNA(dna)
def __exit(self, state):
self.destroy()
self.setClientGlove(self.lastGlove)
messenger.send(
'gloveShopDone',
[state, self.index if state == GloveNPCGlobals.CHANGE else 0])
def __updateIndex(self, offset):
self.index += offset
hitLimit = 0
if self.index <= 0:
self.downArrow['state'] = DGG.DISABLED
hitLimit = 1
else:
self.downArrow['state'] = DGG.NORMAL
if (self.index + 1) >= len(TTLocalizer.NumToColor):
self.upArrow['state'] = DGG.DISABLED
hitLimit = 1
else:
self.upArrow['state'] = DGG.NORMAL
if self.lastGlove == self.index:
self.buyButton['state'] = DGG.DISABLED
self.notice['text'] = TTLocalizer.GloveGuiSameColor
else:
self.buyButton['state'] = DGG.NORMAL
self.notice[
'text'] = TTLocalizer.GloveGuiNotice % ToontownGlobals.GloveCost
self.color['text'] = TTLocalizer.NumToColor[self.index]
self.color['text_fg'] = ToonDNA.allColorsList[self.index]
self.setClientGlove(self.index)
return hitLimit
def __runTask(self, task):
if task.time - task.prevTime < task.delayTime:
return Task.cont
else:
task.delayTime = max(0.05, task.delayTime * 0.75)
task.prevTime = task.time
hitLimit = self.__updateIndex(task.delta)
return Task.done if hitLimit else Task.cont
def __taskDone(self, event):
messenger.send('wakeup')
taskMgr.remove('runGloveCounter-%s' % self.id)
def __taskUpdate(self, delta, event):
messenger.send('wakeup')
task = Task(self.__runTask)
task.delayTime = 0.4
task.prevTime = 0.0
task.delta = delta
hitLimit = self.__updateIndex(delta)
if not hitLimit:
taskMgr.add(task, 'runGloveCounter-%s' % self.id)
class DistributedIceGame(DistributedMinigame.DistributedMinigame, DistributedIceWorld.DistributedIceWorld):
notify = directNotify.newCategory("DistributedIceGame")
MaxLocalForce = 100
MaxPhysicsForce = 25000
def __init__(self, cr):
DistributedMinigame.DistributedMinigame.__init__(self, cr)
DistributedIceWorld.DistributedIceWorld.__init__(self, cr)
self.gameFSM = ClassicFSM.ClassicFSM(
"DistributedIceGame",
[
State.State("off", self.enterOff, self.exitOff, ["inputChoice"]),
State.State(
"inputChoice",
self.enterInputChoice,
self.exitInputChoice,
["waitServerChoices", "moveTires", "displayVotes", "cleanup"],
),
State.State(
"waitServerChoices",
self.enterWaitServerChoices,
self.exitWaitServerChoices,
["moveTires", "cleanup"],
),
State.State("moveTires", self.enterMoveTires, self.exitMoveTires, ["synch", "cleanup"]),
State.State("synch", self.enterSynch, self.exitSynch, ["inputChoice", "scoring", "cleanup"]),
State.State("scoring", self.enterScoring, self.exitScoring, ["cleanup", "finalResults", "inputChoice"]),
State.State("finalResults", self.enterFinalResults, self.exitFinalResults, ["cleanup"]),
State.State("cleanup", self.enterCleanup, self.exitCleanup, []),
],
"off",
"cleanup",
)
self.addChildGameFSM(self.gameFSM)
self.cameraThreeQuarterView = (0, -22, 45, 0, -62.89, 0)
self.tireDict = {}
self.forceArrowDict = {}
self.canDrive = False
self.timer = None
self.timerStartTime = None
self.curForce = 0
self.curHeading = 0
self.headingMomentum = 0.0
self.forceMomentum = 0.0
self.allTireInputs = None
self.curRound = 0
self.curMatch = 0
self.controlKeyWarningLabel = DirectLabel(
text=TTLocalizer.IceGameControlKeyWarning,
text_fg=VBase4(1, 0, 0, 1),
relief=None,
pos=(0.0, 0, 0),
scale=0.15,
)
self.controlKeyWarningLabel.hide()
self.waitingMoveLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForPlayersToFinishMove,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.6, 0, -0.75),
scale=0.075,
)
self.waitingMoveLabel.hide()
self.waitingSyncLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForAISync,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.6, 0, -0.75),
scale=0.075,
)
self.waitingSyncLabel.hide()
self.infoLabel = DirectLabel(text="", text_fg=VBase4(0, 0, 0, 1), relief=None, pos=(0.0, 0, 0.7), scale=0.075)
self.updateInfoLabel()
self.lastForceArrowUpdateTime = 0
self.sendForceArrowUpdateAsap = False
self.treasures = []
self.penalties = []
self.obstacles = []
self.controlKeyPressed = False
self.controlKeyWarningIval = None
return
def delete(self):
DistributedIceWorld.DistributedIceWorld.delete(self)
DistributedMinigame.DistributedMinigame.delete(self)
if self.controlKeyWarningIval:
self.controlKeyWarningIval.finish()
self.controlKeyWarningIval = None
self.controlKeyWarningLabel.destroy()
del self.controlKeyWarningLabel
self.waitingMoveLabel.destroy()
del self.waitingMoveLabel
self.waitingSyncLabel.destroy()
del self.waitingSyncLabel
self.infoLabel.destroy()
del self.infoLabel
for treasure in self.treasures:
treasure.destroy()
del self.treasures
for penalty in self.penalties:
penalty.destroy()
del self.penalties
for obstacle in self.obstacles:
obstacle.removeNode()
del self.obstacles
del self.gameFSM
return
def announceGenerate(self):
DistributedMinigame.DistributedMinigame.announceGenerate(self)
DistributedIceWorld.DistributedIceWorld.announceGenerate(self)
self.debugTaskName = self.uniqueName("debugTask")
def getTitle(self):
return TTLocalizer.IceGameTitle
def getInstructions(self):
szId = self.getSafezoneId()
numPenalties = IceGameGlobals.NumPenalties[szId]
result = TTLocalizer.IceGameInstructions
if numPenalties == 0:
result = TTLocalizer.IceGameInstructionsNoTnt
return result
def getMaxDuration(self):
return 0
def load(self):
self.notify.debug("load")
DistributedMinigame.DistributedMinigame.load(self)
self.music = base.loadMusic("phase_4/audio/bgm/MG_IceGame.ogg")
self.gameBoard = loader.loadModel("phase_4/models/minigames/ice_game_icerink")
background = loader.loadModel("phase_4/models/minigames/ice_game_2d")
backgroundWide = loader.loadModel("phase_4/models/minigames/iceslide_ground")
background.reparentTo(self.gameBoard)
backgroundWide.reparentTo(self.gameBoard)
backgroundWide.setPos(0, -0.3, -0.5)
self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0)
self.gameBoard.setScale(1.0)
self.setupSimulation()
index = 0
for avId in self.avIdList:
self.setupTire(avId, index)
self.setupForceArrow(avId)
index += 1
for index in xrange(len(self.avIdList), 4):
self.setupTire(-index, index)
self.setupForceArrow(-index)
self.showForceArrows(realPlayersOnly=True)
self.westWallModel = NodePath()
if not self.westWallModel.isEmpty():
self.westWallModel.reparentTo(self.gameBoard)
self.westWallModel.setPos(IceGameGlobals.MinWall[0], IceGameGlobals.MinWall[1], 0)
self.westWallModel.setScale(4)
self.eastWallModel = NodePath()
if not self.eastWallModel.isEmpty():
self.eastWallModel.reparentTo(self.gameBoard)
self.eastWallModel.setPos(IceGameGlobals.MaxWall[0], IceGameGlobals.MaxWall[1], 0)
self.eastWallModel.setScale(4)
self.eastWallModel.setH(180)
self.arrowKeys = ArrowKeys.ArrowKeys()
self.target = loader.loadModel("phase_3/models/misc/sphere")
self.target.setScale(0.01)
self.target.reparentTo(self.gameBoard)
self.target.setPos(0, 0, 0)
self.scoreCircle = loader.loadModel("phase_4/models/minigames/ice_game_score_circle")
self.scoreCircle.setScale(0.01)
self.scoreCircle.reparentTo(self.gameBoard)
self.scoreCircle.setZ(IceGameGlobals.TireRadius / 2.0)
self.scoreCircle.setAlphaScale(0.5)
self.scoreCircle.setTransparency(1)
self.scoreCircle.hide()
self.treasureModel = loader.loadModel("phase_4/models/minigames/ice_game_barrel")
self.penaltyModel = loader.loadModel("phase_4/models/minigames/ice_game_tnt2")
self.penaltyModel.setScale(0.75, 0.75, 0.7)
szId = self.getSafezoneId()
obstacles = IceGameGlobals.Obstacles[szId]
index = 0
cubicObstacle = IceGameGlobals.ObstacleShapes[szId]
for pos in obstacles:
newPos = Point3(pos[0], pos[1], IceGameGlobals.TireRadius)
newObstacle = self.createObstacle(newPos, index, cubicObstacle)
self.obstacles.append(newObstacle)
index += 1
self.countSound = loader.loadSfx("phase_3.5/audio/sfx/tick_counter.ogg")
self.treasureGrabSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_vine_game_bananas.ogg")
self.penaltyGrabSound = loader.loadSfx("phase_4/audio/sfx/MG_cannon_fire_alt.ogg")
self.tireSounds = []
for tireIndex in xrange(4):
tireHit = loader.loadSfx("phase_4/audio/sfx/Golf_Hit_Barrier_1.ogg")
wallHit = loader.loadSfx("phase_4/audio/sfx/MG_maze_pickup.ogg")
obstacleHit = loader.loadSfx("phase_4/audio/sfx/Golf_Hit_Barrier_2.ogg")
self.tireSounds.append({"tireHit": tireHit, "wallHit": wallHit, "obstacleHit": obstacleHit})
self.arrowRotateSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_ice_force_rotate.ogg")
self.arrowUpSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_ice_force_increase_3sec.ogg")
self.arrowDownSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_ice_force_decrease_3sec.ogg")
self.scoreCircleSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_ice_scoring_1.ogg")
def unload(self):
self.notify.debug("unload")
DistributedMinigame.DistributedMinigame.unload(self)
del self.music
self.gameBoard.removeNode()
del self.gameBoard
for forceArrow in self.forceArrowDict.values():
forceArrow.removeNode()
del self.forceArrowDict
self.scoreCircle.removeNode()
del self.scoreCircle
del self.countSound
def onstage(self):
self.notify.debug("onstage")
DistributedMinigame.DistributedMinigame.onstage(self)
self.gameBoard.reparentTo(render)
self.__placeToon(self.localAvId)
self.moveCameraToTop()
self.scorePanels = []
base.playMusic(self.music, looping=1, volume=0.8)
def offstage(self):
self.notify.debug("offstage")
self.music.stop()
self.gameBoard.hide()
self.infoLabel.hide()
for avId in self.tireDict:
self.tireDict[avId]["tireNodePath"].hide()
for panel in self.scorePanels:
panel.cleanup()
del self.scorePanels
for obstacle in self.obstacles:
obstacle.hide()
for treasure in self.treasures:
treasure.nodePath.hide()
for penalty in self.penalties:
penalty.nodePath.hide()
for avId in self.avIdList:
av = self.getAvatar(avId)
if av:
av.dropShadow.show()
av.resetLOD()
taskMgr.remove(self.uniqueName("aimtask"))
self.arrowKeys.destroy()
del self.arrowKeys
DistributedMinigame.DistributedMinigame.offstage(self)
def handleDisabledAvatar(self, avId):
self.notify.debug("handleDisabledAvatar")
self.notify.debug("avatar " + str(avId) + " disabled")
DistributedMinigame.DistributedMinigame.handleDisabledAvatar(self, avId)
def setGameReady(self):
if not self.hasLocalToon:
return
self.notify.debug("setGameReady")
if DistributedMinigame.DistributedMinigame.setGameReady(self):
return
for index in xrange(self.numPlayers):
avId = self.avIdList[index]
toon = self.getAvatar(avId)
if toon:
toon.reparentTo(render)
self.__placeToon(avId)
toon.forwardSpeed = 0
toon.rotateSpeed = False
toon.dropShadow.hide()
toon.setAnimState("Sit")
if avId in self.tireDict:
tireNp = self.tireDict[avId]["tireNodePath"]
toon.reparentTo(tireNp)
toon.setY(1.0)
toon.setZ(-3)
toon.startLookAround()
def setGameStart(self, timestamp):
if not self.hasLocalToon:
return
self.notify.debug("setGameStart")
DistributedMinigame.DistributedMinigame.setGameStart(self, timestamp)
for avId in self.remoteAvIdList:
toon = self.getAvatar(avId)
if toon:
toon.stopLookAround()
self.scores = [0] * self.numPlayers
spacing = 0.4
for i in xrange(self.numPlayers):
avId = self.avIdList[i]
avName = self.getAvatarName(avId)
scorePanel = MinigameAvatarScorePanel.MinigameAvatarScorePanel(avId, avName)
scorePanel.setScale(0.9)
scorePanel.setPos(-0.583 - spacing * (self.numPlayers - 1 - i), 0.0, -0.15)
scorePanel.reparentTo(base.a2dTopRight)
scorePanel.makeTransparent(0.75)
self.scorePanels.append(scorePanel)
self.arrowKeys.setPressHandlers(
[
self.__upArrowPressed,
self.__downArrowPressed,
self.__leftArrowPressed,
self.__rightArrowPressed,
self.__controlPressed,
]
)
def isInPlayState(self):
if not self.gameFSM.getCurrentState():
return False
if not self.gameFSM.getCurrentState().getName() == "play":
return False
return True
def enterOff(self):
self.notify.debug("enterOff")
def exitOff(self):
pass
def enterInputChoice(self):
self.notify.debug("enterInputChoice")
self.forceLocalToonToTire()
self.controlKeyPressed = False
if self.curRound == 0:
self.setupStartOfMatch()
else:
self.notify.debug("self.curRound = %s" % self.curRound)
self.timer = ToontownTimer.ToontownTimer()
self.timer.hide()
if self.timerStartTime != None:
self.startTimer()
self.showForceArrows(realPlayersOnly=True)
self.localForceArrow().setPosHpr(0, 0, -1.0, 0, 0, 0)
self.localForceArrow().reparentTo(self.localTireNp())
self.localForceArrow().setY(IceGameGlobals.TireRadius)
self.localTireNp().headsUp(self.target)
self.notify.debug("self.localForceArrow() heading = %s" % self.localForceArrow().getH())
self.curHeading = self.localTireNp().getH()
self.curForce = 25
self.updateLocalForceArrow()
for avId in self.forceArrowDict:
forceArrow = self.forceArrowDict[avId]
forceArrow.setPosHpr(0, 0, -1.0, 0, 0, 0)
tireNp = self.tireDict[avId]["tireNodePath"]
forceArrow.reparentTo(tireNp)
forceArrow.setY(IceGameGlobals.TireRadius)
tireNp.headsUp(self.target)
self.updateForceArrow(avId, tireNp.getH(), 25)
taskMgr.add(self.__aimTask, self.uniqueName("aimtask"))
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.stop()
self.sendForceArrowUpdateAsap = False
return
def exitInputChoice(self):
if not self.controlKeyPressed:
if self.controlKeyWarningIval:
self.controlKeyWarningIval.finish()
self.controlKeyWarningIval = None
self.controlKeyWarningIval = Sequence(
Func(self.controlKeyWarningLabel.show),
self.controlKeyWarningLabel.colorScaleInterval(
10, VBase4(1, 1, 1, 0), startColorScale=VBase4(1, 1, 1, 1)
),
Func(self.controlKeyWarningLabel.hide),
)
self.controlKeyWarningIval.start()
if self.timer != None:
self.timer.destroy()
self.timer = None
self.timerStartTime = None
self.hideForceArrows()
self.arrowRotateSound.stop()
self.arrowUpSound.stop()
self.arrowDownSound.stop()
taskMgr.remove(self.uniqueName("aimtask"))
return
def enterWaitServerChoices(self):
self.waitingMoveLabel.show()
self.showForceArrows(True)
def exitWaitServerChoices(self):
self.waitingMoveLabel.hide()
self.hideForceArrows()
def enterMoveTires(self):
for key in self.tireDict:
body = self.tireDict[key]["tireBody"]
body.setAngularVel(0, 0, 0)
body.setLinearVel(0, 0, 0)
for index in xrange(len(self.allTireInputs)):
input = self.allTireInputs[index]
avId = self.avIdList[index]
body = self.getTireBody(avId)
degs = input[1] + 90
tireNp = self.getTireNp(avId)
tireH = tireNp.getH()
self.notify.debug("tireH = %s" % tireH)
radAngle = deg2Rad(degs)
foo = NodePath("foo")
dirVector = Vec3(math.cos(radAngle), math.sin(radAngle), 0)
self.notify.debug("dirVector is now=%s" % dirVector)
inputForce = input[0]
inputForce /= self.MaxLocalForce
inputForce *= self.MaxPhysicsForce
force = dirVector * inputForce
self.notify.debug("adding force %s to %d" % (force, avId))
body.addForce(force)
self.enableAllTireBodies()
self.totalPhysicsSteps = 0
self.startSim()
taskMgr.add(self.__moveTiresTask, self.uniqueName("moveTiresTtask"))
def exitMoveTires(self):
self.forceLocalToonToTire()
self.disableAllTireBodies()
self.stopSim()
self.notify.debug("total Physics steps = %d" % self.totalPhysicsSteps)
taskMgr.remove(self.uniqueName("moveTiresTtask"))
def enterSynch(self):
self.waitingSyncLabel.show()
def exitSynch(self):
self.waitingSyncLabel.hide()
def enterScoring(self):
sortedByDistance = []
for avId in self.avIdList:
np = self.getTireNp(avId)
pos = np.getPos()
pos.setZ(0)
sortedByDistance.append((avId, pos.length()))
def compareDistance(x, y):
if x[1] - y[1] > 0:
return 1
elif x[1] - y[1] < 0:
return -1
else:
return 0
sortedByDistance.sort(cmp=compareDistance)
self.scoreMovie = Sequence()
curScale = 0.01
curTime = 0
self.scoreCircle.setScale(0.01)
self.scoreCircle.show()
self.notify.debug("newScores = %s" % self.newScores)
circleStartTime = 0
for index in xrange(len(sortedByDistance)):
distance = sortedByDistance[index][1]
avId = sortedByDistance[index][0]
scorePanelIndex = self.avIdList.index(avId)
time = (distance - curScale) / IceGameGlobals.ExpandFeetPerSec
if time < 0:
time = 0.01
scaleXY = distance + IceGameGlobals.TireRadius
self.notify.debug("circleStartTime = %s" % circleStartTime)
self.scoreMovie.append(
Parallel(
LerpScaleInterval(self.scoreCircle, time, Point3(scaleXY, scaleXY, 1.0)),
SoundInterval(self.scoreCircleSound, duration=time, startTime=circleStartTime),
)
)
circleStartTime += time
startScore = self.scorePanels[scorePanelIndex].getScore()
destScore = self.newScores[scorePanelIndex]
self.notify.debug("for avId %d, startScore=%d, newScores=%d" % (avId, startScore, destScore))
def increaseScores(t, scorePanelIndex=scorePanelIndex, startScore=startScore, destScore=destScore):
oldScore = self.scorePanels[scorePanelIndex].getScore()
diff = destScore - startScore
newScore = int(startScore + diff * t)
if newScore > oldScore:
base.playSfx(self.countSound)
self.scorePanels[scorePanelIndex].setScore(newScore)
self.scores[scorePanelIndex] = newScore
duration = (destScore - startScore) * IceGameGlobals.ScoreCountUpRate
tireNp = self.tireDict[avId]["tireNodePath"]
self.scoreMovie.append(
Parallel(
LerpFunctionInterval(increaseScores, duration),
Sequence(
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 1, 1, 1)),
),
)
)
curScale += distance
self.scoreMovie.append(Func(self.sendUpdate, "reportScoringMovieDone", []))
self.scoreMovie.start()
def exitScoring(self):
self.scoreMovie.finish()
self.scoreMovie = None
self.scoreCircle.hide()
return
def enterFinalResults(self):
lerpTrack = Parallel()
lerpDur = 0.5
tY = 0.6
bY = -0.05
lX = -0.5
cX = 0
rX = 0.5
scorePanelLocs = (
((cX, bY),),
((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)),
((lX, tY), (rX, tY), (lX, bY), (rX, bY)),
)
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
panel.wrtReparentTo(aspect2d)
lerpTrack.append(
Parallel(
LerpPosInterval(panel, lerpDur, Point3(pos[0], 0, pos[1]), blendType="easeInOut"),
LerpScaleInterval(panel, lerpDur, Vec3(panel.getScale()) * 2.0, blendType="easeInOut"),
)
)
self.showScoreTrack = Parallel(
lerpTrack, Sequence(Wait(IceGameGlobals.ShowScoresDuration), Func(self.gameOver))
)
self.showScoreTrack.start()
def exitFinalResults(self):
self.showScoreTrack.pause()
del self.showScoreTrack
def enterCleanup(self):
self.notify.debug("enterCleanup")
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.start()
def exitCleanup(self):
pass
def __placeToon(self, avId):
toon = self.getAvatar(avId)
if toon:
toon.setPos(0, 0, 0)
toon.setHpr(0, 0, 0)
def moveCameraToTop(self):
camera.reparentTo(render)
p = self.cameraThreeQuarterView
camera.setPosHpr(p[0], p[1], p[2], p[3], p[4], p[5])
def setupTire(self, avId, index):
tireNp, tireBody, tireOdeGeom = self.createTire(index)
self.tireDict[avId] = {"tireNodePath": tireNp, "tireBody": tireBody, "tireOdeGeom": tireOdeGeom}
if avId <= 0:
tireBlocker = tireNp.find("**/tireblockermesh")
if not tireBlocker.isEmpty():
tireBlocker.hide()
if avId == self.localAvId:
tireNp = self.tireDict[avId]["tireNodePath"]
self.treasureSphereName = "treasureCollider"
self.treasureCollSphere = CollisionSphere(0, 0, 0, IceGameGlobals.TireRadius)
self.treasureCollSphere.setTangible(0)
self.treasureCollNode = CollisionNode(self.treasureSphereName)
self.treasureCollNode.setFromCollideMask(ToontownGlobals.PieBitmask)
self.treasureCollNode.addSolid(self.treasureCollSphere)
self.treasureCollNodePath = tireNp.attachNewNode(self.treasureCollNode)
self.treasureHandler = CollisionHandlerEvent()
self.treasureHandler.addInPattern("%fn-intoTreasure")
base.cTrav.addCollider(self.treasureCollNodePath, self.treasureHandler)
eventName = "%s-intoTreasure" % self.treasureCollNodePath.getName()
self.notify.debug("eventName = %s" % eventName)
self.accept(eventName, self.toonHitSomething)
def setupForceArrow(self, avId):
arrow = loader.loadModel("phase_4/models/minigames/ice_game_arrow")
priority = 0
if avId < 0:
priority = -avId
else:
priority = self.avIdList.index(avId)
if avId == self.localAvId:
priority = 10
self.forceArrowDict[avId] = arrow
def hideForceArrows(self):
for forceArrow in self.forceArrowDict.values():
forceArrow.hide()
def showForceArrows(self, realPlayersOnly=True):
for avId in self.forceArrowDict:
if realPlayersOnly:
if avId > 0:
self.forceArrowDict[avId].show()
else:
self.forceArrowDict[avId].hide()
else:
self.forceArrowDict[avId].show()
def localForceArrow(self):
if self.localAvId in self.forceArrowDict:
return self.forceArrowDict[self.localAvId]
else:
return None
return None
def setChoices(self, input0, input1, input2, input3):
pass
def startDebugTask(self):
taskMgr.add(self.debugTask, self.debugTaskName)
def stopDebugTask(self):
taskMgr.remove(self.debugTaskName)
def debugTask(self, task):
if self.canDrive and self.tireDict.has_key(localAvatar.doId):
dt = globalClock.getDt()
forceMove = 25000
forceMoveDt = forceMove
tireBody = self.tireDict[localAvatar.doId]["tireBody"]
if self.arrowKeys.upPressed() and not tireBody.isEnabled():
x = 0
y = 1
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.downPressed() and not tireBody.isEnabled():
x = 0
y = -1
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.leftPressed() and not tireBody.isEnabled():
x = -1
y = 0
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.rightPressed() and not tireBody.isEnabled():
x = 1
y = 0
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
return task.cont
def __upArrowPressed(self):
pass
def __downArrowPressed(self):
pass
def __leftArrowPressed(self):
pass
def __rightArrowPressed(self):
pass
def __controlPressed(self):
if self.gameFSM.getCurrentState().getName() == "inputChoice":
self.sendForceArrowUpdateAsap = True
self.updateLocalForceArrow()
self.controlKeyPressed = True
self.sendUpdate("setAvatarChoice", [self.curForce, self.curHeading])
self.gameFSM.request("waitServerChoices")
def startTimer(self):
now = globalClock.getFrameTime()
elapsed = now - self.timerStartTime
self.timer.posInTopRightCorner()
self.timer.setTime(IceGameGlobals.InputTimeout)
self.timer.countdown(IceGameGlobals.InputTimeout - elapsed, self.handleChoiceTimeout)
self.timer.show()
def setTimerStartTime(self, timestamp):
if not self.hasLocalToon:
return
self.timerStartTime = globalClockDelta.networkToLocalTime(timestamp)
if self.timer != None:
self.startTimer()
return
def handleChoiceTimeout(self):
self.sendUpdate("setAvatarChoice", [0, 0])
self.gameFSM.request("waitServerChoices")
def localTireNp(self):
ret = None
if self.localAvId in self.tireDict:
ret = self.tireDict[self.localAvId]["tireNodePath"]
return ret
def localTireBody(self):
ret = None
if self.localAvId in self.tireDict:
ret = self.tireDict[self.localAvId]["tireBody"]
return ret
def getTireBody(self, avId):
ret = None
if avId in self.tireDict:
ret = self.tireDict[avId]["tireBody"]
return ret
def getTireNp(self, avId):
ret = None
if avId in self.tireDict:
ret = self.tireDict[avId]["tireNodePath"]
return ret
def updateForceArrow(self, avId, curHeading, curForce):
forceArrow = self.forceArrowDict[avId]
tireNp = self.tireDict[avId]["tireNodePath"]
tireNp.setH(curHeading)
tireBody = self.tireDict[avId]["tireBody"]
tireBody.setQuaternion(tireNp.getQuat())
self.notify.debug("curHeading = %s" % curHeading)
yScale = curForce / 100.0
yScale *= 1
headY = yScale * 15
xScale = (yScale - 1) / 2.0 + 1.0
shaft = forceArrow.find("**/arrow_shaft")
head = forceArrow.find("**/arrow_head")
shaft.setScale(xScale, yScale, 1)
head.setPos(0, headY, 0)
head.setScale(xScale, xScale, 1)
def updateLocalForceArrow(self):
avId = self.localAvId
self.b_setForceArrowInfo(avId, self.curHeading, self.curForce)
def __aimTask(self, task):
if not hasattr(self, "arrowKeys"):
return task.done
dt = globalClock.getDt()
headingMomentumChange = dt * 60.0
forceMomentumChange = dt * 160.0
arrowUpdate = False
arrowRotating = False
arrowUp = False
arrowDown = False
if self.arrowKeys.upPressed() and not self.arrowKeys.downPressed():
self.forceMomentum += forceMomentumChange
if self.forceMomentum < 0:
self.forceMomentum = 0
if self.forceMomentum > 50:
self.forceMomentum = 50
oldForce = self.curForce
self.curForce += self.forceMomentum * dt
arrowUpdate = True
if oldForce < self.MaxLocalForce:
arrowUp = True
elif self.arrowKeys.downPressed() and not self.arrowKeys.upPressed():
self.forceMomentum += forceMomentumChange
if self.forceMomentum < 0:
self.forceMomentum = 0
if self.forceMomentum > 50:
self.forceMomentum = 50
oldForce = self.curForce
self.curForce -= self.forceMomentum * dt
arrowUpdate = True
if oldForce > 0.01:
arrowDown = True
else:
self.forceMomentum = 0
if self.arrowKeys.leftPressed() and not self.arrowKeys.rightPressed():
self.headingMomentum += headingMomentumChange
if self.headingMomentum < 0:
self.headingMomentum = 0
if self.headingMomentum > 50:
self.headingMomentum = 50
self.curHeading += self.headingMomentum * dt
arrowUpdate = True
arrowRotating = True
elif self.arrowKeys.rightPressed() and not self.arrowKeys.leftPressed():
self.headingMomentum += headingMomentumChange
if self.headingMomentum < 0:
self.headingMomentum = 0
if self.headingMomentum > 50:
self.headingMomentum = 50
self.curHeading -= self.headingMomentum * dt
arrowUpdate = True
arrowRotating = True
else:
self.headingMomentum = 0
if arrowUpdate:
self.normalizeHeadingAndForce()
self.updateLocalForceArrow()
if arrowRotating:
if not self.arrowRotateSound.status() == self.arrowRotateSound.PLAYING:
base.playSfx(self.arrowRotateSound, looping=True)
else:
self.arrowRotateSound.stop()
if arrowUp:
if not self.arrowUpSound.status() == self.arrowUpSound.PLAYING:
base.playSfx(self.arrowUpSound, looping=False)
else:
self.arrowUpSound.stop()
if arrowDown:
if not self.arrowDownSound.status() == self.arrowDownSound.PLAYING:
base.playSfx(self.arrowDownSound, looping=False)
else:
self.arrowDownSound.stop()
return task.cont
def normalizeHeadingAndForce(self):
if self.curForce > self.MaxLocalForce:
self.curForce = self.MaxLocalForce
if self.curForce < 0.01:
self.curForce = 0.01
def setTireInputs(self, tireInputs):
if not self.hasLocalToon:
return
self.allTireInputs = tireInputs
self.gameFSM.request("moveTires")
def enableAllTireBodies(self):
for avId in self.tireDict.keys():
self.tireDict[avId]["tireBody"].enable()
def disableAllTireBodies(self):
for avId in self.tireDict.keys():
self.tireDict[avId]["tireBody"].disable()
def areAllTiresDisabled(self):
for avId in self.tireDict.keys():
if self.tireDict[avId]["tireBody"].isEnabled():
return False
return True
def __moveTiresTask(self, task):
if self.areAllTiresDisabled():
self.sendTirePositions()
self.gameFSM.request("synch")
return task.done
return task.cont
def sendTirePositions(self):
tirePositions = []
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
tire = self.getTireBody(avId)
pos = Point3(tire.getPosition())
tirePositions.append([pos[0], pos[1], pos[2]])
for index in xrange(len(self.avIdList), 4):
avId = -index
tire = self.getTireBody(avId)
pos = Point3(tire.getPosition())
tirePositions.append([pos[0], pos[1], pos[2]])
self.sendUpdate("endingPositions", [tirePositions])
def setFinalPositions(self, finalPos):
if not self.hasLocalToon:
return
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
tire = self.getTireBody(avId)
np = self.getTireNp(avId)
pos = finalPos[index]
tire.setPosition(pos[0], pos[1], pos[2])
np.setPos(pos[0], pos[1], pos[2])
for index in xrange(len(self.avIdList), 4):
avId = -index
tire = self.getTireBody(avId)
np = self.getTireNp(avId)
pos = finalPos[index]
tire.setPosition(pos[0], pos[1], pos[2])
np.setPos(pos[0], pos[1], pos[2])
def updateInfoLabel(self):
self.infoLabel["text"] = TTLocalizer.IceGameInfo % {
"curMatch": self.curMatch + 1,
"numMatch": IceGameGlobals.NumMatches,
"curRound": self.curRound + 1,
"numRound": IceGameGlobals.NumRounds,
}
def setMatchAndRound(self, match, round):
if not self.hasLocalToon:
return
self.curMatch = match
self.curRound = round
self.updateInfoLabel()
def setScores(self, match, round, scores):
if not self.hasLocalToon:
return
self.newMatch = match
self.newRound = round
self.newScores = scores
def setNewState(self, state):
if not self.hasLocalToon:
return
self.notify.debug("setNewState gameFSM=%s newState=%s" % (self.gameFSM, state))
self.gameFSM.request(state)
def putAllTiresInStartingPositions(self):
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
np = self.tireDict[avId]["tireNodePath"]
np.setPos(IceGameGlobals.StartingPositions[index])
self.notify.debug("avId=%s newPos=%s" % (avId, np.getPos))
np.setHpr(0, 0, 0)
quat = np.getQuat()
body = self.tireDict[avId]["tireBody"]
body.setPosition(IceGameGlobals.StartingPositions[index])
body.setQuaternion(quat)
for index in xrange(len(self.avIdList), 4):
avId = -index
np = self.tireDict[avId]["tireNodePath"]
np.setPos(IceGameGlobals.StartingPositions[index])
self.notify.debug("avId=%s newPos=%s" % (avId, np.getPos))
np.setHpr(0, 0, 0)
quat = np.getQuat()
body = self.tireDict[avId]["tireBody"]
body.setPosition(IceGameGlobals.StartingPositions[index])
body.setQuaternion(quat)
def b_setForceArrowInfo(self, avId, force, heading):
self.setForceArrowInfo(avId, force, heading)
self.d_setForceArrowInfo(avId, force, heading)
def d_setForceArrowInfo(self, avId, force, heading):
sendIt = False
curTime = self.getCurrentGameTime()
if self.sendForceArrowUpdateAsap:
sendIt = True
elif curTime - self.lastForceArrowUpdateTime > 0.2:
sendIt = True
if sendIt:
self.sendUpdate("setForceArrowInfo", [avId, force, heading])
self.sendForceArrowUpdateAsap = False
self.lastForceArrowUpdateTime = self.getCurrentGameTime()
def setForceArrowInfo(self, avId, force, heading):
if not self.hasLocalToon:
return
self.updateForceArrow(avId, force, heading)
def setupStartOfMatch(self):
self.putAllTiresInStartingPositions()
szId = self.getSafezoneId()
self.numTreasures = IceGameGlobals.NumTreasures[szId]
if self.treasures:
for treasure in self.treasures:
treasure.destroy()
self.treasures = []
index = 0
treasureMargin = IceGameGlobals.TireRadius + 1.0
while len(self.treasures) < self.numTreasures:
xPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[0] + 5, IceGameGlobals.MaxWall[0] - 5)
yPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[1] + 5, IceGameGlobals.MaxWall[1] - 5)
self.notify.debug("yPos=%s" % yPos)
pos = Point3(xPos, yPos, IceGameGlobals.TireRadius)
newTreasure = IceTreasure.IceTreasure(self.treasureModel, pos, index, self.doId, penalty=False)
goodSpot = True
for obstacle in self.obstacles:
if newTreasure.nodePath.getDistance(obstacle) < treasureMargin:
goodSpot = False
break
if goodSpot:
for treasure in self.treasures:
if newTreasure.nodePath.getDistance(treasure.nodePath) < treasureMargin:
goodSpot = False
break
if goodSpot:
self.treasures.append(newTreasure)
index += 1
else:
newTreasure.destroy()
self.numPenalties = IceGameGlobals.NumPenalties[szId]
if self.penalties:
for penalty in self.penalties:
penalty.destroy()
self.penalties = []
index = 0
while len(self.penalties) < self.numPenalties:
xPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[0] + 5, IceGameGlobals.MaxWall[0] - 5)
yPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[1] + 5, IceGameGlobals.MaxWall[1] - 5)
self.notify.debug("yPos=%s" % yPos)
pos = Point3(xPos, yPos, IceGameGlobals.TireRadius)
newPenalty = IceTreasure.IceTreasure(self.penaltyModel, pos, index, self.doId, penalty=True)
goodSpot = True
for obstacle in self.obstacles:
if newPenalty.nodePath.getDistance(obstacle) < treasureMargin:
goodSpot = False
break
if goodSpot:
for treasure in self.treasures:
if newPenalty.nodePath.getDistance(treasure.nodePath) < treasureMargin:
goodSpot = False
break
if goodSpot:
for penalty in self.penalties:
if newPenalty.nodePath.getDistance(penalty.nodePath) < treasureMargin:
goodSpot = False
break
if goodSpot:
self.penalties.append(newPenalty)
index += 1
else:
newPenalty.destroy()
def toonHitSomething(self, entry):
self.notify.debug("---- treasure Enter ---- ")
self.notify.debug("%s" % entry)
name = entry.getIntoNodePath().getName()
parts = name.split("-")
if len(parts) < 3:
self.notify.debug("collided with %s, but returning" % name)
return
if not int(parts[1]) == self.doId:
self.notify.debug("collided with %s, but doId doesn't match" % name)
return
treasureNum = int(parts[2])
if "penalty" in parts[0]:
self.__penaltyGrabbed(treasureNum)
else:
self.__treasureGrabbed(treasureNum)
def __treasureGrabbed(self, treasureNum):
self.treasures[treasureNum].showGrab()
self.treasureGrabSound.play()
self.sendUpdate("claimTreasure", [treasureNum])
def setTreasureGrabbed(self, avId, treasureNum):
if not self.hasLocalToon:
return
self.notify.debug("treasure %s grabbed by %s" % (treasureNum, avId))
if avId != self.localAvId:
self.treasures[treasureNum].showGrab()
i = self.avIdList.index(avId)
self.scores[i] += 1
self.scorePanels[i].setScore(self.scores[i])
def __penaltyGrabbed(self, penaltyNum):
self.penalties[penaltyNum].showGrab()
self.sendUpdate("claimPenalty", [penaltyNum])
def setPenaltyGrabbed(self, avId, penaltyNum):
if not self.hasLocalToon:
return
self.notify.debug("penalty %s grabbed by %s" % (penaltyNum, avId))
if avId != self.localAvId:
self.penalties[penaltyNum].showGrab()
i = self.avIdList.index(avId)
self.scores[i] -= 1
self.scorePanels[i].setScore(self.scores[i])
def postStep(self):
DistributedIceWorld.DistributedIceWorld.postStep(self)
if not self.colCount:
return
for count in xrange(self.colCount):
c0, c1 = self.getOrderedContacts(count)
if c1 in self.tireCollideIds:
tireIndex = self.tireCollideIds.index(c1)
if c0 in self.tireCollideIds:
self.tireSounds[tireIndex]["tireHit"].play()
elif c0 == self.wallCollideId:
self.tireSounds[tireIndex]["wallHit"].play()
elif c0 == self.obstacleCollideId:
self.tireSounds[tireIndex]["obstacleHit"].play()
def forceLocalToonToTire(self):
toon = localAvatar
if toon and self.localAvId in self.tireDict:
tireNp = self.tireDict[self.localAvId]["tireNodePath"]
toon.reparentTo(tireNp)
toon.setPosHpr(0, 0, 0, 0, 0, 0)
toon.setY(1.0)
toon.setZ(-3)
class CalendarGuiDay(DirectFrame):
notify = directNotify.newCategory('CalendarGuiDay')
ScrollListTextSize = 0.03
def __init__(self, parent, myDate, startDate, dayClickCallback = None, onlyFutureDaysClickable = False):
self.origParent = parent
self.startDate = startDate
self.myDate = myDate
self.dayClickCallback = dayClickCallback
self.onlyFutureDaysClickable = onlyFutureDaysClickable
DirectFrame.__init__(self, parent=parent)
self.timedEvents = []
self.partiesInvitedToToday = []
self.hostedPartiesToday = []
self.yearlyHolidaysToday = []
self.showMarkers = base.config.GetBool('show-calendar-markers', 0)
self.filter = ToontownGlobals.CalendarFilterShowAll
self.load()
self.createGuiObjects()
self.update()
def createDummyLocators(self):
self.dayButtonLocator = self.attachNewNode('dayButtonLocator')
self.dayButtonLocator.setX(0.1)
self.dayButtonLocator.setZ(-0.05)
self.numberLocator = self.attachNewNode('numberLocator')
self.numberLocator.setX(0.09)
self.scrollLocator = self.attachNewNode('scrollLocator')
self.selectedLocator = self.attachNewNode('selectedLocator')
self.selectedLocator.setX(0.11)
self.selectedLocator.setZ(-0.06)
def load(self):
dayAsset = loader.loadModel('phase_4/models/parties/tt_m_gui_sbk_calendar_box')
dayAsset.reparentTo(self)
self.dayButtonLocator = self.find('**/loc_origin')
self.numberLocator = self.find('**/loc_number')
self.scrollLocator = self.find('**/loc_topLeftList')
self.selectedLocator = self.find('**/loc_origin')
self.todayBox = self.find('**/boxToday')
self.todayBox.hide()
self.selectedFrame = self.find('**/boxHover')
self.selectedFrame.hide()
self.defaultBox = self.find('**/boxBlank')
self.scrollBottomRightLocator = self.find('**/loc_bottomRightList')
self.scrollDownLocator = self.find('**/loc_scrollDown')
self.attachMarker(self.scrollDownLocator)
self.scrollUpLocator = self.find('**/loc_scrollUp')
self.attachMarker(self.scrollUpLocator)
def attachMarker(self, parent, scale = 0.005, color = (1, 0, 0)):
if self.showMarkers:
marker = loader.loadModel('phase_3/models/misc/sphere')
marker.reparentTo(parent)
marker.setScale(scale)
marker.setColor(*color)
def createGuiObjects(self):
self.dayButton = DirectButton(parent=self.dayButtonLocator, image=self.selectedFrame, relief=None, command=self.__clickedOnDay, pressEffect=1, rolloverSound=None, clickSound=None)
self.numberWidget = DirectLabel(parent=self.numberLocator, relief=None, text=str(self.myDate.day), text_scale=0.04, text_align=TextNode.ACenter, text_font=ToontownGlobals.getInterfaceFont(), text_fg=Vec4(110 / 255.0, 126 / 255.0, 255 / 255.0, 1))
self.attachMarker(self.numberLocator)
self.listXorigin = 0
self.listFrameSizeX = self.scrollBottomRightLocator.getX() - self.scrollLocator.getX()
self.scrollHeight = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ()
self.listZorigin = self.scrollBottomRightLocator.getZ()
self.listFrameSizeZ = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ()
self.arrowButtonXScale = 1
self.arrowButtonZScale = 1
self.itemFrameXorigin = 0
self.itemFrameZorigin = 0
self.buttonXstart = self.itemFrameXorigin + 0.21
self.gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui')
buttonOffSet = -0.01
incButtonPos = (0.0, 0, 0)
decButtonPos = (0.0, 0, 0)
itemFrameMinZ = self.listZorigin
itemFrameMaxZ = self.listZorigin + self.listFrameSizeZ
arrowUp = self.find('**/downScroll_up')
arrowDown = self.find('**/downScroll_down')
arrowHover = self.find('**/downScroll_hover')
self.scrollList = DirectScrolledList(parent=self.scrollLocator, relief=None, pos=(0, 0, 0), incButton_image=(arrowUp,
arrowDown,
arrowHover,
arrowUp), incButton_relief=None, incButton_scale=(self.arrowButtonXScale, 1, self.arrowButtonZScale), incButton_pos=incButtonPos, incButton_image3_color=(1, 1, 1, 0.2), decButton_image=(arrowUp,
arrowDown,
arrowHover,
arrowUp), decButton_relief=None, decButton_scale=(self.arrowButtonXScale, 1, -self.arrowButtonZScale), decButton_pos=decButtonPos, decButton_image3_color=(1, 1, 1, 0.2), itemFrame_pos=(self.itemFrameXorigin, 0, -0.03), numItemsVisible=4, incButtonCallback=self.scrollButtonPressed, decButtonCallback=self.scrollButtonPressed)
itemFrameParent = self.scrollList.itemFrame.getParent()
self.scrollList.incButton.reparentTo(self.scrollDownLocator)
self.scrollList.decButton.reparentTo(self.scrollUpLocator)
arrowUp.removeNode()
arrowDown.removeNode()
arrowHover.removeNode()
clipper = PlaneNode('clipper')
clipper.setPlane(Plane((-1, 0, 0), (0.23, 0, 0)))
clipNP = self.scrollList.component('itemFrame').attachNewNode(clipper)
self.scrollList.component('itemFrame').setClipPlane(clipNP)
return
def scrollButtonPressed(self):
self.__clickedOnDay()
def adjustForMonth(self):
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.onlyFutureDaysClickable:
if self.myDate.year < curServerDate.year or self.myDate.year == curServerDate.year and self.myDate.month < curServerDate.month or self.myDate.year == curServerDate.year and self.myDate.month == curServerDate.month and self.myDate.day < curServerDate.day:
self.numberWidget.setColorScale(0.5, 0.5, 0.5, 0.5)
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.numberWidget.setColorScale(1, 1, 1, 1)
if self.myDate.month != self.startDate.month:
self.setColorScale(0.75, 0.75, 0.75, 1.0)
if self.dayClickCallback is not None:
self.numberWidget['state'] = DirectGuiGlobals.DISABLED
else:
self.setColorScale(1, 1, 1, 1)
if self.myDate.date() == curServerDate.date():
self.defaultBox.hide()
self.todayBox.show()
else:
self.defaultBox.show()
self.todayBox.hide()
return
def destroy(self):
if self.dayClickCallback is not None:
self.numberWidget.destroy()
self.dayClickCallback = None
self.notify.debug('desroying %s' % self.myDate)
try:
for item in self.scrollList['items']:
if hasattr(item, 'description') and item.description and hasattr(item.description, 'destroy'):
self.notify.debug('desroying description of item %s' % item)
item.unbind(DGG.ENTER)
item.unbind(DGG.EXIT)
item.description.destroy()
except e:
self.notify.debug('pass %s' % self.myDate)
self.scrollList.removeAndDestroyAllItems()
self.scrollList.destroy()
self.dayButton.destroy()
DirectFrame.destroy(self)
def updateArrowButtons(self):
numItems = 0
try:
numItems = len(self.scrollList['items'])
except e:
numItems = 0
if numItems <= self.scrollList.numItemsVisible:
self.scrollList.incButton.hide()
self.scrollList.decButton.hide()
else:
self.scrollList.incButton.show()
self.scrollList.decButton.show()
def collectTimedEvents(self):
if self.filter == ToontownGlobals.CalendarFilterShowAll or self.filter == ToontownGlobals.CalendarFilterShowOnlyParties:
for party in localAvatar.partiesInvitedTo:
if party.startTime.date() == self.myDate.date():
self.addPartyToScrollList(party)
for party in localAvatar.hostedParties:
if party.startTime.date() == self.myDate.date():
self.addPartyToScrollList(party)
if self.filter == ToontownGlobals.CalendarFilterShowAll or self.filter == ToontownGlobals.CalendarFilterShowOnlyHolidays:
for id, holiday in HolidayGlobals.Holidays.iteritems():
title, description = TTLocalizer.HolidayNamesInCalendar[id]
if 'weekDay' in holiday:
if self.myDate.weekday() == holiday['weekDay']:
self.addTitleAndDescToScrollList(title, description)
elif 'startMonth' in holiday or 'startDay' in holiday:
startDate = HolidayGlobals.getStartDate(holiday, self.myDate)
endDate = HolidayGlobals.getEndDate(holiday, self.myDate)
if self.isDateMatch(self.myDate, startDate):
if self.isDateMatch(startDate, endDate):
description = '%s. %s' % (title, description)
else:
description = '%s. %s %s %s' % (title, description, TTLocalizer.CalendarEndsAt, endDate.strftime('%b %d'))
self.addTitleAndDescToScrollList(title, description)
elif self.isDateMatch(self.myDate, endDate):
title = '%s %s' % (TTLocalizer.CalendarEndOf, title)
description = '%s. %s %s' % (title, TTLocalizer.CalendarStartedOn, startDate.strftime('%b %d'))
self.addTitleAndDescToScrollList(title, description)
def isDateMatch(self, date1, date2):
return date1.day == date2.day and date1.month == date2.month
def addTitleAndDescToScrollList(self, title, desc):
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(relief=None, text=title, text_scale=textSize, text_align=TextNode.ALeft, rolloverSound=None, clickSound=None, pressEffect=0, command=self.__clickedOnScrollItem)
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = scrollItemHeight * descTextSize / textSize
descUnderItemZAdjust = max(0.0534, descUnderItemZAdjust)
descUnderItemZAdjust = -descUnderItemZAdjust
descZAdjust = descUnderItemZAdjust
newItem.description = DirectLabel(parent=newItem, pos=(0.115, 0, descZAdjust), text='', text_wordwrap=15, pad=(0.02, 0.02), text_scale=descTextSize, text_align=TextNode.ACenter, textMayChange=0)
newItem.description.checkedHeight = False
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(DGG.ENTER, self.enteredTextItem, extraArgs=[newItem, desc, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
self.scrollList.addItem(newItem)
return
def exitedTextItem(self, newItem, mousepos):
newItem.description.hide()
def enteredTextItem(self, newItem, descText, descUnderItemZAdjust, mousePos):
if not newItem.description.checkedHeight:
newItem.description.checkedHeight = True
newItem.description['text'] = descText
bounds = newItem.description.getBounds()
descHeight = newItem.description.getHeight()
scrollItemHeight = newItem.getHeight()
descOverItemZAdjust = descHeight - scrollItemHeight / 2.0
descZPos = self.getPos(aspect2d)[2] + descUnderItemZAdjust - descHeight
if descZPos < -1.0:
newItem.description.setZ(descOverItemZAdjust)
descWidth = newItem.description.getWidth()
brightFrame = loader.loadModel('phase_4/models/parties/tt_m_gui_sbk_calendar_popUp_bg')
newItem.description['geom'] = brightFrame
newItem.description['geom_scale'] = (descWidth, 1, descHeight)
descGeomZ = (bounds[2] - bounds[3]) / 2.0
descGeomZ += bounds[3]
newItem.description['geom_pos'] = (0, 0, descGeomZ)
newItem.description.show()
def addPartyToScrollList(self, party):
textSize = self.ScrollListTextSize
descTextSize = 0.05
partyTitle = myStrftime(party.startTime)
partyTitle = partyTitle + ' ' + TTLocalizer.EventsPageCalendarTabParty
textSize = self.ScrollListTextSize
descTextSize = 0.05
newItem = DirectButton(relief=None, text=partyTitle, text_scale=textSize, text_align=TextNode.ALeft, rolloverSound=None, clickSound=None, pressEffect=0, command=self.__clickedOnScrollItem)
scrollItemHeight = newItem.getHeight()
descUnderItemZAdjust = scrollItemHeight * descTextSize / textSize
descUnderItemZAdjust = max(0.0534, descUnderItemZAdjust)
descUnderItemZAdjust = -descUnderItemZAdjust
descZAdjust = descUnderItemZAdjust
self.scrollList.addItem(newItem)
newItem.description = MiniInviteVisual(newItem, party)
newItem.description.setBin('gui-popup', 0)
newItem.description.hide()
newItem.bind(DGG.ENTER, self.enteredTextItem, extraArgs=[newItem, newItem.description, descUnderItemZAdjust])
newItem.bind(DGG.EXIT, self.exitedTextItem, extraArgs=[newItem])
return
def __clickedOnScrollItem(self):
self.__clickedOnDay()
def __clickedOnDay(self):
acceptClick = True
if self.onlyFutureDaysClickable:
curServerDate = base.cr.toontownTimeManager.getCurServerDateTime()
if self.myDate.date() < curServerDate.date():
acceptClick = False
if not acceptClick:
return
if self.dayClickCallback:
self.dayClickCallback(self)
self.notify.debug('we got clicked on %s' % self.myDate.date())
messenger.send('clickedOnDay', [self.myDate.date()])
def updateSelected(self, selected):
multiplier = 1.1
if selected:
self.selectedFrame.show()
self.setScale(multiplier)
self.setPos(-0.01, 0, 0.01)
grandParent = self.origParent.getParent()
self.origParent.reparentTo(grandParent)
else:
self.selectedFrame.hide()
self.setScale(1.0)
self.setPos(0, 0, 0)
def changeDate(self, startDate, myDate):
self.startDate = startDate
self.myDate = myDate
self.scrollList.removeAndDestroyAllItems()
self.update()
def update(self):
self.numberWidget['text'] = str(self.myDate.day)
self.adjustForMonth()
self.collectTimedEvents()
self.updateArrowButtons()
def changeFilter(self, filter):
oldFilter = self.filter
self.filter = filter
if self.filter != oldFilter:
self.scrollList.removeAndDestroyAllItems()
self.update()
class RepairNail(NodePath, FSM.FSM):
def __init__(self, name, parent, nailModel):
self.config = RepairGlobals.Hammering
NodePath.__init__(self, name)
FSM.FSM.__init__(self, 'Nail_%sFSM' % name)
self.reparentTo(parent)
self.nailModel = nailModel
self._initVars()
self._initVisuals()
def _initVars(self):
self.totalClicks = 0
self.remainingPercent = 1.0
def _initVisuals(self):
self.visual = self.attachNewNode('RepairNail.visual')
self.nailModel.find('**/nail_collision').setPos(0.0, -35.0, 0.0)
self.nailModel.setScale(1.5)
self.nailModel.find('**/nail_collision').setCollideMask(NAIL_COLLIDE_MASK)
self.nailModel.find('**/nail_collision').setPythonTag('nail', self)
self.nailModel.find('**/nail_collision').hide()
self.nailModel.reparentTo(self.visual)
self.nailModel.find('**/nail_model').setHpr(0.0, 20.0, 0.0)
self.nailModel.setDepthTest(True)
self.nailModel.setDepthWrite(True)
self.shadow = self.nailModel.find('**/shadow')
self.shadow.reparentTo(self)
self.shadow.setPos(0.0, -0.040000000000000001, 0.02)
self.shadow.setDepthTest(True)
self.shadow.setDepthWrite(True)
self.shadow.setScale(2.0)
self.shadow.setTransparency(1)
self.shadow.setSa(0.59999999999999998)
self.resultLabel = DirectLabel(text = '', relief = None, text_fg = (1.0, 1.0, 1.0, 1.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), scale = (0.050000000000000003, 0.050000000000000003, 0.050000000000000003), pos = (0.0, 0.0, -0.089999999999999997), parent = self)
def removeNode(self):
self.visual.removeNode()
del self.visual
self.resultLabel.destroy()
NodePath.removeNode(self)
def setShadow(self, percent):
self.shadow.setScale(percent * 1.0 + 1.3999999999999999)
self.shadow.setSa(1.0 - percent * 0.20000000000000001 + 0.20000000000000001)
def hitNail(self, percentage):
self.remainingPercent = max(0.0, self.remainingPercent - percentage)
self.totalClicks += 1
self.setShadow(self.remainingPercent)
newDepth = (1.0 - self.remainingPercent) * HAMMERED_DEPTH
self.visual.setZ(newDepth)
if self.remainingPercent <= 0.0:
for i in range(len(self.config.rankingThresholds)):
if self.totalClicks >= self.config.rankingThresholds[i]:
break
continue
self.request('Hammered', PLocalizer.Minigame_Repair_Hammering_Thresholds[i])
return True
return False
def enterActive(self):
self.visual.setZ(0.0)
self.remainingPercent = 1.0
self.totalClicks = 0
self.setShadow(1.0)
def exitActive(self):
pass
def enterHammered(self, successText):
self.resultLabel['text'] = successText
self.resultLabel.setText()
def exitHammered(self):
self.resultLabel['text'] = ''
self.resultLabel.setText()
def enterIdle(self):
self.stash()
def exitIdle(self):
self.unstash()
class CIProgressScreen:
Color = (118 / 255.0, 121 / 255.0, 127 / 255.0, 1.0)
BarColor = (152 / 255.0, 129 / 255.0, 64 / 255.0, 1.0)
def __init__(self):
self.defaultLogoScale = 1
self.defaultLogoZ = 0.65
self.bgm = loader.loadModel(
"phase_3/models/gui/progress-background.bam")
self.bgm.find('**/logo').stash()
self.barShadow = OnscreenImage(image=self.bgm.find("**/bar_shadow"),
parent=hidden)
self.bgm.find("**/bar_shadow").removeNode()
self.bg = self.bgm.find('**/bg')
self.defaultBgTexture = self.bg.findTexture('*')
self.logoNode, self.logoImg = CIGlobals.getLogoImage(
hidden, self.defaultLogoScale, (0, 0, self.defaultLogoZ))
self.bg_img = OnscreenImage(image=self.bg, parent=hidden)
self.bg_img.setSx(1.35)
self.bg_img.hide()
self.progress_bar = DirectWaitBar(value=0,
pos=(0, 0, -0.85),
parent=hidden,
text_pos=(0, 0, 0.2))
self.progress_bar.setSx(1.064)
self.progress_bar.setSz(0.38)
toontipgui = loader.loadModel(
'phase_3.5/models/gui/stickerbook_gui.bam')
poster = toontipgui.find('**/questCard')
self.toontipFrame = DirectFrame(image=poster,
image_scale=(1.4, 1, 1),
parent=hidden,
relief=None,
pos=(0, 0, -0.1),
scale=0.85)
self.toontipLbl = OnscreenText(text="",
parent=self.toontipFrame,
fg=(89.0 / 255, 95.0 / 255, 98.0 / 255,
1),
font=CIGlobals.getToonFont(),
wordwrap=13,
pos=(-0.59, 0.25),
align=TextNode.ALeft,
scale=0.08)
self.loading_lbl = DirectLabel(text="",
relief=None,
scale=0.08,
pos=(-1.0725, 0, -0.79),
text_align=TextNode.ALeft,
sortOrder=100,
text_fg=(1, 1, 1, 1),
text_font=CIGlobals.getMinnieLogoFont(),
parent=hidden,
text_shadow=(0, 0, 0, 0))
# This is useful when the user has chosen to hide aspect2d before the loading screen.
# However, we want to show the loading screen all the time, so we need to restore the
# previous state after the loading screen ends.
self.mustRestoreHiddenAspect2d = False
def begin(self, hood, range, wantGui):
render.hide()
NametagGlobals.setWant2dNametags(False)
if base.aspect2d.isHidden():
base.aspect2d.show()
self.mustRestoreHiddenAspect2d = True
self.renderFrames()
base.setBackgroundColor(0, 0, 0)
if hood == "localAvatarEnterGame":
self.loading_lbl['text'] = "Entering..."
elif hood == "init":
self.loading_lbl['text'] = "Loading..."
else:
self.loading_lbl['text'] = "Heading to %s..." % hood
self.progress_bar['barColor'] = self.BarColor
self.progress_bar['range'] = range
self.bgm.reparentTo(aspect2d)
ZoneUtil.Hood2ZoneId.keys()
# We only want to show special loading screens for actual in-game locations.
if hood in ZoneUtil.Hood2ZoneId.keys():
abbr = ZoneUtil.ZoneId2HoodAbbr.get(
ZoneUtil.Hood2ZoneId.get(hood)).lower()
bgTexture = loader.loadTexture(
'phase_14/maps/{0}_loading.png'.format(abbr), okMissing=True)
if bgTexture:
self.bg.setTexture(bgTexture, 1)
self.barShadow.reparentTo(aspect2d)
self.bg.reparentTo(render2d)
self.bg_img.reparentTo(hidden)
self.loading_lbl.reparentTo(aspect2d)
self.logoNode.reparentTo(aspect2d)
self.progress_bar.reparentTo(aspect2d)
tip = random.choice(CIGlobals.ToonTips)
self.toontipLbl.setText("TOON TIP:\n" + tip)
self.toontipFrame.reparentTo(aspect2d)
self.__count = 0
self.__expectedCount = range
self.progress_bar.update(self.__count)
def renderFramesTask(self, task):
self.renderFrames()
return task.cont
def end(self):
base.setBackgroundColor(CIGlobals.DefaultBackgroundColor)
taskMgr.remove("renderFrames")
render.show()
if self.mustRestoreHiddenAspect2d:
base.aspect2d.hide()
self.mustRestoreHiddenAspect2d = False
self.progress_bar.finish()
self.bg_img.reparentTo(hidden)
self.logoNode.reparentTo(hidden)
self.barShadow.reparentTo(hidden)
self.bg.reparentTo(hidden)
# Let's get rid of the extra texture stage.
self.bg.setTexture(self.defaultBgTexture, 1)
self.bgm.reparentTo(hidden)
self.loading_lbl.reparentTo(hidden)
self.progress_bar.reparentTo(hidden)
self.toontipFrame.reparentTo(hidden)
base.transitions.fadeScreen(1.0)
NametagGlobals.setWant2dNametags(True)
self.renderFrames()
def destroy(self):
self.bg.removeNode()
del self.bg
self.bgm.removeNode()
del self.bgm
self.bg_img.destroy()
self.barShadow.destroy()
del self.barShadow
self.loading_lbl.destroy()
self.progress_bar.destroy()
self.bgm.destroy()
self.mustRestoreHiddenAspect2d = False
del self.bg_img
del self.loading_lbl
del self.progress_bar
del self.bgm
del self.defaultBgTexture
del self.mustRestoreHiddenAspect2d
def renderFrames(self):
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
def tick(self):
self.__count += 1
self.progress_bar.update(self.__count)
class GloveShopGui:
def __init__(self):
self.index = 0
self.id = time.time()
self.lastGlove = base.localAvatar.style.gloveColor
self.timer = ToontownTimer.ToontownTimer()
self.timer.reparentTo(aspect2d)
self.timer.posInTopRightCorner()
self.timer.countdown(GloveNPCGlobals.TIMER_SECONDS, self.__exit, [GloveNPCGlobals.TIMER_END])
self.setupButtons()
self.bindButtons()
self.__updateIndex(0)
def setupButtons(self):
gui = loader.loadModel('phase_3/models/gui/tt_m_gui_mat_mainGui')
arrowImage = (gui.find('**/tt_t_gui_mat_shuffleArrowUp'), gui.find('**/tt_t_gui_mat_shuffleArrowDown'))
buttonImage = (gui.find('**/tt_t_gui_mat_shuffleUp'), gui.find('**/tt_t_gui_mat_shuffleDown'))
self.title = DirectLabel(aspect2d, relief=None, text=TTLocalizer.GloveGuiTitle,
text_fg=(0, 1, 0, 1), text_scale=0.15, text_font=ToontownGlobals.getSignFont(),
pos=(0, 0, -0.30), text_shadow=(1, 1, 1, 1))
self.notice = DirectLabel(aspect2d, relief=None, text='', text_fg=(1, 0, 0, 1), text_scale=0.11,
text_font=ToontownGlobals.getSignFont(), pos=(0, 0, -0.45), text_shadow=(1, 1, 1, 1))
self.color = DirectLabel(aspect2d, relief=None, text='', text_scale=0.11, text_font=ToontownGlobals.getSignFont(),
pos=(0, 0, -0.70), text_shadow=(1, 1, 1, 1))
self.buyButton = DirectButton(aspect2d, relief=None, image=buttonImage, text=TTLocalizer.GloveGuiBuy,
text_font=ToontownGlobals.getInterfaceFont(), text_scale=0.11, text_pos=(0, -0.02),
pos=(-0.60, 0, -0.90), text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), command=self.__exit, extraArgs=[GloveNPCGlobals.CHANGE])
self.cancelButton = DirectButton(aspect2d, relief=None, image=buttonImage, text=TTLocalizer.lCancel,
text_font=ToontownGlobals.getInterfaceFont(), text_scale=0.11, text_pos=(0, -0.02),
pos=(0.60, 0, -0.90), text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), command=self.__exit, extraArgs=[GloveNPCGlobals.USER_CANCEL])
self.downArrow = DirectButton(aspect2d, relief=None, image=arrowImage, pos=(-0.60, 0, -0.66))
self.upArrow = DirectButton(aspect2d, relief=None, image=arrowImage, pos=(0.60, 0, -0.66), scale=-1)
gui.removeNode()
def bindButtons(self):
self.downArrow.bind(DGG.B1PRESS, self.__taskUpdate, extraArgs=[-1])
self.downArrow.bind(DGG.B1RELEASE, self.__taskDone)
self.upArrow.bind(DGG.B1PRESS, self.__taskUpdate, extraArgs=[1])
self.upArrow.bind(DGG.B1RELEASE, self.__taskDone)
def destroy(self):
if self.timer:
self.timer.destroy()
if not hasattr(self, 'title'):
return
# TODO: DirectDialog-ify
self.title.destroy()
self.notice.destroy()
self.color.destroy()
self.buyButton.destroy()
self.cancelButton.destroy()
self.downArrow.destroy()
self.upArrow.destroy()
del self.title
del self.notice
del self.color
del self.buyButton
del self.cancelButton
del self.downArrow
del self.upArrow
taskMgr.remove('runGloveCounter-%s' % self.id)
def setClientGlove(self, color):
dna = base.localAvatar.style
dna.gloveColor = color
base.localAvatar.setDNA(dna)
def __exit(self, state):
self.destroy()
self.setClientGlove(self.lastGlove)
messenger.send('gloveShopDone', [state, self.index if state == GloveNPCGlobals.CHANGE else 0])
def __updateIndex(self, offset):
self.index += offset
hitLimit = 0
if self.index <= 0:
self.downArrow['state'] = DGG.DISABLED
hitLimit = 1
else:
self.downArrow['state'] = DGG.NORMAL
if (self.index + 1) >= len(TTLocalizer.NumToColor):
self.upArrow['state'] = DGG.DISABLED
hitLimit = 1
else:
self.upArrow['state'] = DGG.NORMAL
if self.lastGlove == self.index:
self.buyButton['state'] = DGG.DISABLED
self.notice['text'] = TTLocalizer.GloveGuiSameColor
else:
self.buyButton['state'] = DGG.NORMAL
self.notice['text'] = TTLocalizer.GloveGuiNotice % ToontownGlobals.GloveCost
self.color['text'] = TTLocalizer.NumToColor[self.index]
self.color['text_fg'] = ToonDNA.allColorsList[self.index]
self.setClientGlove(self.index)
return hitLimit
def __runTask(self, task):
if task.time - task.prevTime < task.delayTime:
return Task.cont
else:
task.delayTime = max(0.05, task.delayTime * 0.75)
task.prevTime = task.time
hitLimit = self.__updateIndex(task.delta)
return Task.done if hitLimit else Task.cont
def __taskDone(self, event):
messenger.send('wakeup')
taskMgr.remove('runGloveCounter-%s' % self.id)
def __taskUpdate(self, delta, event):
messenger.send('wakeup')
task = Task(self.__runTask)
task.delayTime = 0.4
task.prevTime = 0.0
task.delta = delta
hitLimit = self.__updateIndex(delta)
if not hitLimit:
taskMgr.add(task, 'runGloveCounter-%s' % self.id)
class RepairNail(NodePath, FSM.FSM):
def __init__(self, name, parent, nailModel):
self.config = RepairGlobals.Hammering
NodePath.__init__(self, name)
FSM.FSM.__init__(self, 'Nail_%sFSM' % name)
self.reparentTo(parent)
self.nailModel = nailModel
self._initVars()
self._initVisuals()
def _initVars(self):
self.totalClicks = 0
self.remainingPercent = 1.0
def _initVisuals(self):
self.visual = self.attachNewNode('RepairNail.visual')
self.nailModel.find('**/nail_collision').setPos(0.0, -35.0, 0.0)
self.nailModel.setScale(1.5)
self.nailModel.find('**/nail_collision').setCollideMask(NAIL_COLLIDE_MASK)
self.nailModel.find('**/nail_collision').setPythonTag('nail', self)
self.nailModel.find('**/nail_collision').hide()
self.nailModel.reparentTo(self.visual)
self.nailModel.find('**/nail_model').setHpr(0.0, 20.0, 0.0)
self.nailModel.setDepthTest(True)
self.nailModel.setDepthWrite(True)
self.shadow = self.nailModel.find('**/shadow')
self.shadow.reparentTo(self)
self.shadow.setPos(0.0, -0.040000000000000001, 0.02)
self.shadow.setDepthTest(True)
self.shadow.setDepthWrite(True)
self.shadow.setScale(2.0)
self.shadow.setTransparency(1)
self.shadow.setSa(0.59999999999999998)
self.resultLabel = DirectLabel(text = '', relief = None, text_fg = (1.0, 1.0, 1.0, 1.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), scale = (0.050000000000000003, 0.050000000000000003, 0.050000000000000003), pos = (0.0, 0.0, -0.089999999999999997), parent = self)
def removeNode(self):
self.visual.removeNode()
del self.visual
self.resultLabel.destroy()
NodePath.removeNode(self)
def setShadow(self, percent):
self.shadow.setScale(percent * 1.0 + 1.3999999999999999)
self.shadow.setSa(1.0 - percent * 0.20000000000000001 + 0.20000000000000001)
def hitNail(self, percentage):
self.remainingPercent = max(0.0, self.remainingPercent - percentage)
self.totalClicks += 1
self.setShadow(self.remainingPercent)
newDepth = (1.0 - self.remainingPercent) * HAMMERED_DEPTH
self.visual.setZ(newDepth)
if self.remainingPercent <= 0.0:
for i in range(len(self.config.rankingThresholds)):
if self.totalClicks >= self.config.rankingThresholds[i]:
break
continue
self.request('Hammered', PLocalizer.Minigame_Repair_Hammering_Thresholds[i])
return True
return False
def enterActive(self):
self.visual.setZ(0.0)
self.remainingPercent = 1.0
self.totalClicks = 0
self.setShadow(1.0)
def exitActive(self):
pass
def enterHammered(self, successText):
self.resultLabel['text'] = successText
self.resultLabel.setText()
def exitHammered(self):
self.resultLabel['text'] = ''
self.resultLabel.setText()
def enterIdle(self):
self.stash()
def exitIdle(self):
self.unstash()
class DistCogdoGame(DistCogdoGameBase, DistributedObject):
notify = directNotify.newCategory('DistCogdoGame')
def __init__(self, cr):
DistributedObject.__init__(self, cr)
base.cogdoGame = self
cr.cogdoGame = self
self._waitingStartLabel = DirectLabel(text=TTL.MinigameWaitingForOtherPlayers, text_fg=VBase4(1, 1, 1, 1), relief=None, pos=(-0.6, 0, -0.75), scale=0.075)
self._waitingStartLabel.hide()
self.loadFSM = ClassicFSM.ClassicFSM('DistCogdoGame.loaded', [State.State('NotLoaded', self.enterNotLoaded, self.exitNotLoaded, ['Loaded']), State.State('Loaded', self.enterLoaded, self.exitLoaded, ['NotLoaded'])], 'NotLoaded', 'NotLoaded')
self.loadFSM.enterInitialState()
self.fsm = ClassicFSM.ClassicFSM('DistCogdoGame', [State.State('Visible', self.enterVisible, self.exitVisible, ['Intro']),
State.State('Intro', self.enterIntro, self.exitIntro, ['WaitServerStart']),
State.State('WaitServerStart', self.enterWaitServerStart, self.exitWaitServerStart, ['Game']),
State.State('Game', self.enterGame, self.exitGame, ['Finish']),
State.State('Finish', self.enterFinish, self.exitFinish, ['Off']),
State.State('Off', self.enterOff, self.exitOff, ['Visible'])], 'Off', 'Off')
self.fsm.enterInitialState()
self.difficultyOverride = None
self.exteriorZoneOverride = None
self._gotInterior = StateVar(False)
self._toonsInEntranceElev = StateVar(False)
self._wantStashElevator = StateVar(False)
self._stashElevatorFC = FunctionCall(self._doStashElevator, self._toonsInEntranceElev, self._gotInterior, self._wantStashElevator)
def getTitle(self):
pass
def getInstructions(self):
pass
def setInteriorId(self, interiorId):
self._interiorId = interiorId
def setExteriorZone(self, exteriorZone):
self.exteriorZone = exteriorZone
def setDifficultyOverrides(self, difficultyOverride, exteriorZoneOverride):
if difficultyOverride != CogdoGameConsts.NoDifficultyOverride:
self.difficultyOverride = difficultyOverride / float(CogdoGameConsts.DifficultyOverrideMult)
if exteriorZoneOverride != CogdoGameConsts.NoExteriorZoneOverride:
self.exteriorZoneOverride = exteriorZoneOverride
def getInterior(self):
return self.cr.getDo(self._interiorId)
def getEntranceElevator(self, callback):
return self.getInterior().getEntranceElevator(callback)
def getToonIds(self):
interior = self.getInterior()
if interior is not None:
return interior.getToonIds()
else:
return []
def getToon(self, toonId):
if self.cr.doId2do.has_key(toonId):
return self.cr.doId2do[toonId]
else:
return None
def getNumPlayers(self):
return len(self.getToonIds())
def isSinglePlayer(self):
if self.getNumPlayers() == 1:
return 1
else:
return 0
def announceGenerate(self):
DistributedObject.announceGenerate(self)
self.loadFSM.request('Loaded')
self._requestInterior()
self.notify.info('difficulty: %s, safezoneId: %s' % (self.getDifficulty(), self.getSafezoneId()))
def _requestInterior(self):
self.cr.relatedObjectMgr.requestObjects([self._interiorId], allCallback=self._handleGotInterior)
def _handleGotInterior(self, objs):
self._gotInterior.set(True)
self.getEntranceElevator(self.placeEntranceElev)
def stashEntranceElevator(self):
self._wantStashElevator.set(True)
def placeEntranceElev(self, elev):
pass
def _doStashElevator(self, toonsInEntranceElev, gotInterior, wantStashElevator):
if gotInterior:
interior = self.getInterior()
if interior:
if not toonsInEntranceElev and wantStashElevator:
interior.stashElevatorIn()
else:
interior.stashElevatorIn(False)
def disable(self):
base.cogdoGame = None
self.cr.cogdoGame = None
self.fsm.requestFinalState()
self.loadFSM.requestFinalState()
self.fsm = None
self.loadFSM = None
DistributedObject.disable(self)
def delete(self):
self._stashElevatorFC.destroy()
self._wantStashElevator.destroy()
self._toonsInEntranceElev.destroy()
self._gotInterior.destroy()
self._waitingStartLabel.destroy()
self._waitingStartLabel = None
DistributedObject.delete(self)
def getDifficulty(self):
if self.difficultyOverride is not None:
return self.difficultyOverride
if hasattr(base, 'cogdoGameDifficulty'):
return float(base.cogdoGameDifficulty)
return CogdoGameConsts.getDifficulty(self.getSafezoneId())
def getSafezoneId(self):
if self.exteriorZoneOverride is not None:
return self.exteriorZoneOverride
if hasattr(base, 'cogdoGameSafezoneId'):
return CogdoGameConsts.getSafezoneId(base.cogdoGameSafezoneId)
return CogdoGameConsts.getSafezoneId(self.exteriorZone)
def enterNotLoaded(self):
pass
def exitNotLoaded(self):
pass
def enterLoaded(self):
pass
def exitLoaded(self):
pass
def enterOff(self):
pass
def exitOff(self):
pass
def setVisible(self):
self.fsm.request('Visible')
def setIntroStart(self):
self.fsm.request('Intro')
def enterVisible(self):
self._toonsInEntranceElev.set(True)
def exitVisible(self):
pass
def enterIntro(self, duration = MinigameGlobals.rulesDuration):
base.cr.playGame.getPlace().fsm.request('Game')
self._rulesDoneEvent = self.uniqueName('cogdoGameRulesDone')
self.accept(self._rulesDoneEvent, self._handleRulesDone)
self._rulesPanel = CogdoGameRulesPanel('CogdoGameRulesPanel', self.getTitle(), '', self._rulesDoneEvent, timeout=duration)
self._rulesPanel.load()
self._rulesPanel.enter()
def exitIntro(self):
self._toonsInEntranceElev.set(False)
self.ignore(self._rulesDoneEvent)
if self._rulesPanel:
self._rulesPanel.exit()
self._rulesPanel.unload()
self._rulesPanel = None
def _handleRulesDone(self):
self.ignore(self._rulesDoneEvent)
self._rulesPanel.exit()
self._rulesPanel.unload()
self._rulesPanel = None
self.fsm.request('WaitServerStart')
self.d_setAvatarReady()
def d_setAvatarReady(self):
self.sendUpdate('setAvatarReady', [])
def enterWaitServerStart(self):
numToons = 1
interior = self.getInterior()
if interior:
numToons = len(interior.getToonIds())
if numToons > 1:
msg = TTL.MinigameWaitingForOtherPlayers
else:
msg = TTL.MinigamePleaseWait
self._waitingStartLabel['text'] = msg
self._waitingStartLabel.show()
def exitWaitServerStart(self):
self._waitingStartLabel.hide()
def setGameStart(self, timestamp):
self._startTime = globalClockDelta.networkToLocalTime(timestamp)
self.fsm.request('Game')
def getStartTime(self):
return self._startTime
def enterGame(self):
if SCHELLGAMES_DEV:
self.acceptOnce('escape', messenger.send, ['magicWord', ['~endMaze']])
def exitGame(self):
if SCHELLGAMES_DEV:
self.ignore('escape')
def setGameFinish(self, timestamp):
self._finishTime = globalClockDelta.networkToLocalTime(timestamp)
self.fsm.request('Finish')
def getFinishTime(self):
return self._finishTime
def enterFinish(self):
pass
def exitFinish(self):
pass
def setToonSad(self, toonId):
pass
def setToonDisconnect(self, toonId):
pass
class DistributedCinemaInterior(DistributedToonInterior.DistributedToonInterior
):
notify = directNotify.newCategory("DistributedCinemaInterior")
def __init__(self, cr):
DistributedToonInterior.DistributedToonInterior.__init__(self, cr)
self.fsm = ClassicFSM.ClassicFSM('DCinemaInterior', [
State.State('off', self.enterOff, self.exitOff),
State.State('show', self.enterShow, self.exitShow),
State.State('intermission', self.enterIntermission,
self.exitIntermission)
], 'off', 'off')
self.fsm.enterInitialState()
self.state = None
self.cinemaIndex = None
self.movieTex = None
self.movieCard = None
self.movieSound = None
self.movieTrack = None
self.intermissionText = None
def makeInterior(self):
# Always use the same room for cinemas.
DistributedToonInterior.DistributedToonInterior.makeInterior(
self, roomIndex=0)
def announceGenerate(self):
DistributedToonInterior.DistributedToonInterior.announceGenerate(self)
self.sendUpdate('requestStateAndTimestamp')
def disable(self):
self.fsm.requestFinalState()
self.fsm = None
self.state = None
self.cinemaIndex = None
self.movieTex = None
self.movieCard = None
self.movieSound = None
self.movieTrack = None
self.intermissionText = None
self.cr.playGame.hood.loader.interiorMusic.stop()
DistributedToonInterior.DistributedToonInterior.disable(self)
def darkenInterior(self):
darkenIval = self.interior.colorScaleInterval(
3.0,
colorScale=(0.3, 0.3, 0.3, 1.0),
startColorScale=(1.0, 1.0, 1.0, 1.0),
blendType='easeInOut')
darkenIval.start()
def lightenInterior(self):
lightenIval = self.interior.colorScaleInterval(
3.0,
colorScale=(1, 1, 1, 1.0),
startColorScale=(0.3, 0.3, 0.3, 1.0),
blendType='easeInOut')
lightenIval.start()
def enterShow(self, ts=0):
self.darkenInterior()
self.cr.playGame.hood.loader.interiorMusic.stop()
videoFile = CinemaGlobals.Cinemas[self.cinemaIndex][0]
audioFile = CinemaGlobals.Cinemas[self.cinemaIndex][1]
self.movieTex = MovieTexture(self.uniqueName("movieTex"))
self.movieTex.read(videoFile)
card = CardMaker(self.uniqueName('movieCard'))
card.setFrame(-1.5, 1.5, -1, 1)
self.movieCard = NodePath(card.generate())
self.movieCard.reparentTo(render)
self.movieCard.setPos(
self.interior.find('**/sign_origin;+s').getPos(render))
#self.movieCard.setX(self.movieCard, -0.05)
self.movieCard.setHpr(
self.interior.find('**/sign_origin;+s').getHpr(render))
self.movieCard.setDepthWrite(1, 1)
self.movieCard.setTwoSided(True)
self.movieCard.setTexture(self.movieTex)
self.movieCard.setTexScale(TextureStage.getDefault(),
self.movieTex.getTexScale())
self.movieCard.setScale(2.5)
self.movieSound = base.loadSfx(audioFile)
self.movieTex.synchronizeTo(self.movieSound)
self.movieTrack = SoundInterval(self.movieSound,
name=self.uniqueName('movieTrack'))
self.movieTrack.setDoneEvent(self.movieTrack.getName())
self.acceptOnce(self.movieTrack.getDoneEvent(), self.fsm.request,
['off'])
self.movieTrack.start(ts)
def exitShow(self):
self.ignore(self.movieTrack.getDoneEvent())
self.movieTrack.finish()
self.movieTrack = None
self.movieSound = None
self.movieCard.removeNode()
self.movieCard = None
self.movieTex = None
self.lightenInterior()
self.cr.playGame.hood.loader.interiorMusic.play()
def enterIntermission(self, ts=0):
self.intermissionText = DirectLabel(
relief=None,
text_decal=True,
text="",
scale=0.7,
parent=self.interior.find('**/sign_origin;+s'),
text_font=CIGlobals.getMickeyFont(),
text_fg=(1, 0.9, 0, 1))
self.movieTrack = Sequence(name=self.uniqueName('intermissionTrack'))
for second in range(CinemaGlobals.IntermissionLength + 1):
timeRemaining = CinemaGlobals.IntermissionLength - second
self.movieTrack.append(
Func(self.setIntermissionText,
"Next show in:\n%d" % timeRemaining))
self.movieTrack.append(Wait(1.0))
self.movieTrack.setDoneEvent(self.movieTrack.getName())
self.acceptOnce(self.movieTrack.getDoneEvent(), self.fsm.request,
['off'])
self.movieTrack.start(ts)
def setIntermissionText(self, text):
self.intermissionText['text'] = text
def exitIntermission(self):
self.ignore(self.movieTrack.getDoneEvent())
self.movieTrack.finish()
self.movieTrack = None
self.intermissionText.destroy()
self.intermissionText = None
def enterOff(self):
pass
def exitOff(self):
pass
def setCinemaIndex(self, index):
self.cinemaIndex = index
def getCinemaIndex(self):
return self.cinemaIndex
def setState(self, state, timestamp):
ts = globalClockDelta.localElapsedTime(timestamp)
self.state = state
self.fsm.request(state, [ts])
def getState(self):
return self.state
class DistributedIceGame(DistributedMinigame.DistributedMinigame,
DistributedIceWorld.DistributedIceWorld):
notify = directNotify.newCategory('DistributedIceGame')
MaxLocalForce = 100
MaxPhysicsForce = 25000
def __init__(self, cr):
DistributedMinigame.DistributedMinigame.__init__(self, cr)
DistributedIceWorld.DistributedIceWorld.__init__(self, cr)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedIceGame', [
State.State('off', self.enterOff, self.exitOff, ['inputChoice']),
State.State(
'inputChoice', self.enterInputChoice, self.exitInputChoice,
['waitServerChoices', 'moveTires', 'displayVotes', 'cleanup']),
State.State('waitServerChoices', self.enterWaitServerChoices,
self.exitWaitServerChoices, ['moveTires', 'cleanup']),
State.State('moveTires', self.enterMoveTires, self.exitMoveTires,
['synch', 'cleanup']),
State.State('synch', self.enterSynch, self.exitSynch,
['inputChoice', 'scoring', 'cleanup']),
State.State('scoring', self.enterScoring, self.exitScoring,
['cleanup', 'finalResults', 'inputChoice']),
State.State('finalResults', self.enterFinalResults,
self.exitFinalResults, ['cleanup']),
State.State('cleanup', self.enterCleanup, self.exitCleanup, [])
], 'off', 'cleanup')
self.addChildGameFSM(self.gameFSM)
self.cameraThreeQuarterView = (0, -22, 45, 0, -62.890000000000001, 0)
self.tireDict = {}
self.forceArrowDict = {}
self.canDrive = False
self.timer = None
self.timerStartTime = None
self.curForce = 0
self.curHeading = 0
self.headingMomentum = 0.0
self.forceMomentum = 0.0
self.allTireInputs = None
self.curRound = 0
self.curMatch = 0
self.controlKeyWarningLabel = DirectLabel(
text=TTLocalizer.IceGameControlKeyWarning,
text_fg=VBase4(1, 0, 0, 1),
relief=None,
pos=(0.0, 0, 0),
scale=0.14999999999999999)
self.controlKeyWarningLabel.hide()
self.waitingMoveLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForPlayersToFinishMove,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.59999999999999998, 0, -0.75),
scale=0.074999999999999997)
self.waitingMoveLabel.hide()
self.waitingSyncLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForAISync,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.59999999999999998, 0, -0.75),
scale=0.074999999999999997)
self.waitingSyncLabel.hide()
self.infoLabel = DirectLabel(text='',
text_fg=VBase4(0, 0, 0, 1),
relief=None,
pos=(0.0, 0, 0.69999999999999996),
scale=0.074999999999999997)
self.updateInfoLabel()
self.lastForceArrowUpdateTime = 0
self.sendForceArrowUpdateAsap = False
self.treasures = []
self.penalties = []
self.obstacles = []
self.controlKeyPressed = False
self.controlKeyWarningIval = None
def delete(self):
DistributedIceWorld.DistributedIceWorld.delete(self)
DistributedMinigame.DistributedMinigame.delete(self)
if self.controlKeyWarningIval:
self.controlKeyWarningIval.finish()
self.controlKeyWarningIval = None
self.controlKeyWarningLabel.destroy()
del self.controlKeyWarningLabel
self.waitingMoveLabel.destroy()
del self.waitingMoveLabel
self.waitingSyncLabel.destroy()
del self.waitingSyncLabel
self.infoLabel.destroy()
del self.infoLabel
for treasure in self.treasures:
treasure.destroy()
del self.treasures
for penalty in self.penalties:
penalty.destroy()
del self.penalties
for obstacle in self.obstacles:
obstacle.removeNode()
del self.obstacles
del self.gameFSM
def announceGenerate(self):
DistributedMinigame.DistributedMinigame.announceGenerate(self)
DistributedIceWorld.DistributedIceWorld.announceGenerate(self)
self.debugTaskName = self.uniqueName('debugTask')
def getTitle(self):
return TTLocalizer.IceGameTitle
def getInstructions(self):
szId = self.getSafezoneId()
numPenalties = IceGameGlobals.NumPenalties[szId]
result = TTLocalizer.IceGameInstructions
if numPenalties == 0:
result = TTLocalizer.IceGameInstructionsNoTnt
return result
def getMaxDuration(self):
return 0
def load(self):
self.notify.debug('load')
DistributedMinigame.DistributedMinigame.load(self)
self.music = base.loadMusic('phase_4/audio/bgm/MG_IceGame.mid')
self.gameBoard = loader.loadModel(
'phase_4/models/minigames/ice_game_icerink')
background = loader.loadModel('phase_4/models/minigames/ice_game_2d')
background.reparentTo(self.gameBoard)
self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0)
self.gameBoard.setScale(1.0)
self.setupSimulation()
index = 0
for avId in self.avIdList:
self.setupTire(avId, index)
self.setupForceArrow(avId)
index += 1
for index in xrange(len(self.avIdList), 4):
self.setupTire(-index, index)
self.setupForceArrow(-index)
self.showForceArrows(realPlayersOnly=True)
self.westWallModel = NodePath()
if not self.westWallModel.isEmpty():
self.westWallModel.reparentTo(self.gameBoard)
self.westWallModel.setPos(IceGameGlobals.MinWall[0],
IceGameGlobals.MinWall[1], 0)
self.westWallModel.setScale(4)
self.eastWallModel = NodePath()
if not self.eastWallModel.isEmpty():
self.eastWallModel.reparentTo(self.gameBoard)
self.eastWallModel.setPos(IceGameGlobals.MaxWall[0],
IceGameGlobals.MaxWall[1], 0)
self.eastWallModel.setScale(4)
self.eastWallModel.setH(180)
self.arrowKeys = ArrowKeys.ArrowKeys()
self.target = loader.loadModel('phase_3/models/misc/sphere')
self.target.setScale(0.01)
self.target.reparentTo(self.gameBoard)
self.target.setPos(0, 0, 0)
self.scoreCircle = loader.loadModel(
'phase_4/models/minigames/ice_game_score_circle')
self.scoreCircle.setScale(0.01)
self.scoreCircle.reparentTo(self.gameBoard)
self.scoreCircle.setZ(IceGameGlobals.TireRadius / 2.0)
self.scoreCircle.setAlphaScale(0.5)
self.scoreCircle.setTransparency(1)
self.scoreCircle.hide()
self.treasureModel = loader.loadModel(
'phase_4/models/minigames/ice_game_barrel')
self.penaltyModel = loader.loadModel(
'phase_4/models/minigames/ice_game_tnt2')
self.penaltyModel.setScale(0.75, 0.75, 0.69999999999999996)
szId = self.getSafezoneId()
obstacles = IceGameGlobals.Obstacles[szId]
index = 0
cubicObstacle = IceGameGlobals.ObstacleShapes[szId]
for pos in obstacles:
newPos = Point3(pos[0], pos[1], IceGameGlobals.TireRadius)
newObstacle = self.createObstacle(newPos, index, cubicObstacle)
self.obstacles.append(newObstacle)
index += 1
self.countSound = loader.loadSfx(
'phase_3.5/audio/sfx/tick_counter.mp3')
self.treasureGrabSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_vine_game_bananas.mp3')
self.penaltyGrabSound = loader.loadSfx(
'phase_4/audio/sfx/MG_cannon_fire_alt.mp3')
self.tireSounds = []
for tireIndex in xrange(4):
tireHit = loader.loadSfx(
'phase_4/audio/sfx/Golf_Hit_Barrier_1.mp3')
wallHit = loader.loadSfx('phase_4/audio/sfx/MG_maze_pickup.mp3')
obstacleHit = loader.loadSfx(
'phase_4/audio/sfx/Golf_Hit_Barrier_2.mp3')
self.tireSounds.append({
'tireHit': tireHit,
'wallHit': wallHit,
'obstacleHit': obstacleHit
})
self.arrowRotateSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_ice_force_rotate.wav')
self.arrowUpSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_ice_force_increase_3sec.mp3')
self.arrowDownSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_ice_force_decrease_3sec.mp3')
self.scoreCircleSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_ice_scoring_1.mp3')
def unload(self):
self.notify.debug('unload')
DistributedMinigame.DistributedMinigame.unload(self)
del self.music
self.gameBoard.removeNode()
del self.gameBoard
for forceArrow in self.forceArrowDict.values():
forceArrow.removeNode()
del self.forceArrowDict
self.scoreCircle.removeNode()
del self.scoreCircle
del self.countSound
def onstage(self):
self.notify.debug('onstage')
DistributedMinigame.DistributedMinigame.onstage(self)
self.gameBoard.reparentTo(render)
self._DistributedIceGame__placeToon(self.localAvId)
self.moveCameraToTop()
self.scorePanels = []
base.playMusic(self.music, looping=1, volume=0.80000000000000004)
def offstage(self):
self.notify.debug('offstage')
self.music.stop()
self.gameBoard.hide()
self.infoLabel.hide()
for avId in self.tireDict:
self.tireDict[avId]['tireNodePath'].hide()
for panel in self.scorePanels:
panel.cleanup()
del self.scorePanels
for obstacle in self.obstacles:
obstacle.hide()
for treasure in self.treasures:
treasure.nodePath.hide()
for penalty in self.penalties:
penalty.nodePath.hide()
for avId in self.avIdList:
av = self.getAvatar(avId)
if av:
av.dropShadow.show()
av.resetLOD()
continue
taskMgr.remove(self.uniqueName('aimtask'))
self.arrowKeys.destroy()
del self.arrowKeys
DistributedMinigame.DistributedMinigame.offstage(self)
def handleDisabledAvatar(self, avId):
self.notify.debug('handleDisabledAvatar')
self.notify.debug('avatar ' + str(avId) + ' disabled')
DistributedMinigame.DistributedMinigame.handleDisabledAvatar(
self, avId)
def setGameReady(self):
if not self.hasLocalToon:
return None
self.notify.debug('setGameReady')
if DistributedMinigame.DistributedMinigame.setGameReady(self):
return None
for index in xrange(self.numPlayers):
avId = self.avIdList[index]
toon = self.getAvatar(avId)
if toon:
toon.reparentTo(render)
self._DistributedIceGame__placeToon(avId)
toon.forwardSpeed = 0
toon.rotateSpeed = False
toon.dropShadow.hide()
toon.setAnimState('Sit')
if avId in self.tireDict:
tireNp = self.tireDict[avId]['tireNodePath']
toon.reparentTo(tireNp)
toon.setY(1.0)
toon.setZ(-3)
toon.startLookAround()
continue
def setGameStart(self, timestamp):
if not self.hasLocalToon:
return None
self.notify.debug('setGameStart')
DistributedMinigame.DistributedMinigame.setGameStart(self, timestamp)
for avId in self.remoteAvIdList:
toon = self.getAvatar(avId)
if toon:
toon.stopLookAround()
continue
self.scores = [0] * self.numPlayers
spacing = 0.40000000000000002
for i in xrange(self.numPlayers):
avId = self.avIdList[i]
avName = self.getAvatarName(avId)
scorePanel = MinigameAvatarScorePanel.MinigameAvatarScorePanel(
avId, avName)
scorePanel.setScale(0.90000000000000002)
scorePanel.setPos(0.75 - spacing * (self.numPlayers - 1 - i), 0.0,
0.875)
scorePanel.makeTransparent(0.75)
self.scorePanels.append(scorePanel)
self.arrowKeys.setPressHandlers([
self._DistributedIceGame__upArrowPressed,
self._DistributedIceGame__downArrowPressed,
self._DistributedIceGame__leftArrowPressed,
self._DistributedIceGame__rightArrowPressed,
self._DistributedIceGame__controlPressed
])
def isInPlayState(self):
if not self.gameFSM.getCurrentState():
return False
if not self.gameFSM.getCurrentState().getName() == 'play':
return False
return True
def enterOff(self):
self.notify.debug('enterOff')
def exitOff(self):
pass
def enterInputChoice(self):
self.notify.debug('enterInputChoice')
self.forceLocalToonToTire()
self.controlKeyPressed = False
if self.curRound == 0:
self.setupStartOfMatch()
else:
self.notify.debug('self.curRound = %s' % self.curRound)
self.timer = ToontownTimer.ToontownTimer()
self.timer.hide()
if self.timerStartTime != None:
self.startTimer()
self.showForceArrows(realPlayersOnly=True)
self.localForceArrow().setPosHpr(0, 0, -1.0, 0, 0, 0)
self.localForceArrow().reparentTo(self.localTireNp())
self.localForceArrow().setY(IceGameGlobals.TireRadius)
self.localTireNp().headsUp(self.target)
self.notify.debug('self.localForceArrow() heading = %s' %
self.localForceArrow().getH())
self.curHeading = self.localTireNp().getH()
self.curForce = 25
self.updateLocalForceArrow()
for avId in self.forceArrowDict:
forceArrow = self.forceArrowDict[avId]
forceArrow.setPosHpr(0, 0, -1.0, 0, 0, 0)
tireNp = self.tireDict[avId]['tireNodePath']
forceArrow.reparentTo(tireNp)
forceArrow.setY(IceGameGlobals.TireRadius)
tireNp.headsUp(self.target)
self.updateForceArrow(avId, tireNp.getH(), 25)
taskMgr.add(self._DistributedIceGame__aimTask,
self.uniqueName('aimtask'))
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.stop()
self.sendForceArrowUpdateAsap = False
def exitInputChoice(self):
if not self.controlKeyPressed:
if self.controlKeyWarningIval:
self.controlKeyWarningIval.finish()
self.controlKeyWarningIval = None
self.controlKeyWarningIval = Sequence(
Func(self.controlKeyWarningLabel.show),
self.controlKeyWarningLabel.colorScaleInterval(
10, VBase4(1, 1, 1, 0), startColorScale=VBase4(1, 1, 1,
1)),
Func(self.controlKeyWarningLabel.hide))
self.controlKeyWarningIval.start()
if self.timer != None:
self.timer.destroy()
self.timer = None
self.timerStartTime = None
self.hideForceArrows()
self.arrowRotateSound.stop()
self.arrowUpSound.stop()
self.arrowDownSound.stop()
taskMgr.remove(self.uniqueName('aimtask'))
def enterWaitServerChoices(self):
self.waitingMoveLabel.show()
self.showForceArrows(True)
def exitWaitServerChoices(self):
self.waitingMoveLabel.hide()
self.hideForceArrows()
def enterMoveTires(self):
for key in self.tireDict:
body = self.tireDict[key]['tireBody']
body.setAngularVel(0, 0, 0)
body.setLinearVel(0, 0, 0)
for index in xrange(len(self.allTireInputs)):
input = self.allTireInputs[index]
avId = self.avIdList[index]
body = self.getTireBody(avId)
degs = input[1] + 90
tireNp = self.getTireNp(avId)
tireH = tireNp.getH()
self.notify.debug('tireH = %s' % tireH)
radAngle = deg2Rad(degs)
foo = NodePath('foo')
dirVector = Vec3(math.cos(radAngle), math.sin(radAngle), 0)
self.notify.debug('dirVector is now=%s' % dirVector)
inputForce = input[0]
inputForce /= self.MaxLocalForce
inputForce *= self.MaxPhysicsForce
force = dirVector * inputForce
self.notify.debug('adding force %s to %d' % (force, avId))
body.addForce(force)
self.enableAllTireBodies()
self.totalPhysicsSteps = 0
self.startSim()
taskMgr.add(self._DistributedIceGame__moveTiresTask,
self.uniqueName('moveTiresTtask'))
def exitMoveTires(self):
self.forceLocalToonToTire()
self.disableAllTireBodies()
self.stopSim()
self.notify.debug('total Physics steps = %d' % self.totalPhysicsSteps)
taskMgr.remove(self.uniqueName('moveTiresTtask'))
def enterSynch(self):
self.waitingSyncLabel.show()
def exitSynch(self):
self.waitingSyncLabel.hide()
def enterScoring(self):
sortedByDistance = []
for avId in self.avIdList:
np = self.getTireNp(avId)
pos = np.getPos()
pos.setZ(0)
sortedByDistance.append((avId, pos.length()))
def compareDistance(x, y):
if x[1] - y[1] > 0:
return 1
elif x[1] - y[1] < 0:
return -1
else:
return 0
sortedByDistance.sort(cmp=compareDistance)
self.scoreMovie = Sequence()
curScale = 0.01
curTime = 0
self.scoreCircle.setScale(0.01)
self.scoreCircle.show()
self.notify.debug('newScores = %s' % self.newScores)
circleStartTime = 0
for index in xrange(len(sortedByDistance)):
distance = sortedByDistance[index][1]
avId = sortedByDistance[index][0]
scorePanelIndex = self.avIdList.index(avId)
time = (distance - curScale) / IceGameGlobals.ExpandFeetPerSec
if time < 0:
time = 0.01
scaleXY = distance + IceGameGlobals.TireRadius
self.notify.debug('circleStartTime = %s' % circleStartTime)
self.scoreMovie.append(
Parallel(
LerpScaleInterval(self.scoreCircle, time,
Point3(scaleXY, scaleXY, 1.0)),
SoundInterval(self.scoreCircleSound,
duration=time,
startTime=circleStartTime)))
circleStartTime += time
startScore = self.scorePanels[scorePanelIndex].getScore()
destScore = self.newScores[scorePanelIndex]
self.notify.debug('for avId %d, startScore=%d, newScores=%d' %
(avId, startScore, destScore))
def increaseScores(t,
scorePanelIndex=scorePanelIndex,
startScore=startScore,
destScore=destScore):
oldScore = self.scorePanels[scorePanelIndex].getScore()
diff = destScore - startScore
newScore = int(startScore + diff * t)
if newScore > oldScore:
base.playSfx(self.countSound)
self.scorePanels[scorePanelIndex].setScore(newScore)
self.scores[scorePanelIndex] = newScore
duration = (destScore -
startScore) * IceGameGlobals.ScoreCountUpRate
tireNp = self.tireDict[avId]['tireNodePath']
self.scoreMovie.append(
Parallel(
LerpFunctionInterval(increaseScores, duration),
Sequence(
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)))))
curScale += distance
self.scoreMovie.append(
Func(self.sendUpdate, 'reportScoringMovieDone', []))
self.scoreMovie.start()
def exitScoring(self):
self.scoreMovie.finish()
self.scoreMovie = None
self.scoreCircle.hide()
def enterFinalResults(self):
lerpTrack = Parallel()
lerpDur = 0.5
tY = 0.59999999999999998
bY = -0.050000000000000003
lX = -0.5
cX = 0
rX = 0.5
scorePanelLocs = (((cX, bY), ), ((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)), ((lX, tY), (rX, tY),
(lX, bY), (rX, bY)))
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
lerpTrack.append(
Parallel(
LerpPosInterval(panel,
lerpDur,
Point3(pos[0], 0, pos[1]),
blendType='easeInOut'),
LerpScaleInterval(panel,
lerpDur,
Vec3(panel.getScale()) * 2.0,
blendType='easeInOut')))
self.showScoreTrack = Parallel(
lerpTrack,
Sequence(Wait(IceGameGlobals.ShowScoresDuration),
Func(self.gameOver)))
self.showScoreTrack.start()
def exitFinalResults(self):
self.showScoreTrack.pause()
del self.showScoreTrack
def enterCleanup(self):
self.notify.debug('enterCleanup')
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.start()
def exitCleanup(self):
pass
def _DistributedIceGame__placeToon(self, avId):
toon = self.getAvatar(avId)
if toon:
toon.setPos(0, 0, 0)
toon.setHpr(0, 0, 0)
def moveCameraToTop(self):
camera.reparentTo(render)
p = self.cameraThreeQuarterView
camera.setPosHpr(p[0], p[1], p[2], p[3], p[4], p[5])
def setupTire(self, avId, index):
(tireNp, tireBody, tireOdeGeom) = self.createTire(index)
self.tireDict[avId] = {
'tireNodePath': tireNp,
'tireBody': tireBody,
'tireOdeGeom': tireOdeGeom
}
if avId <= 0:
tireBlocker = tireNp.find('**/tireblockermesh')
if not tireBlocker.isEmpty():
tireBlocker.hide()
if avId == self.localAvId:
tireNp = self.tireDict[avId]['tireNodePath']
self.treasureSphereName = 'treasureCollider'
self.treasureCollSphere = CollisionSphere(
0, 0, 0, IceGameGlobals.TireRadius)
self.treasureCollSphere.setTangible(0)
self.treasureCollNode = CollisionNode(self.treasureSphereName)
self.treasureCollNode.setFromCollideMask(
ToontownGlobals.PieBitmask)
self.treasureCollNode.addSolid(self.treasureCollSphere)
self.treasureCollNodePath = tireNp.attachNewNode(
self.treasureCollNode)
self.treasureHandler = CollisionHandlerEvent()
self.treasureHandler.addInPattern('%fn-intoTreasure')
base.cTrav.addCollider(self.treasureCollNodePath,
self.treasureHandler)
eventName = '%s-intoTreasure' % self.treasureCollNodePath.getName()
self.notify.debug('eventName = %s' % eventName)
self.accept(eventName, self.toonHitSomething)
def setupForceArrow(self, avId):
arrow = loader.loadModel('phase_4/models/minigames/ice_game_arrow')
priority = 0
if avId < 0:
priority = -avId
else:
priority = self.avIdList.index(avId)
if avId == self.localAvId:
priority = 10
self.forceArrowDict[avId] = arrow
def hideForceArrows(self):
for forceArrow in self.forceArrowDict.values():
forceArrow.hide()
def showForceArrows(self, realPlayersOnly=True):
for avId in self.forceArrowDict:
if realPlayersOnly:
if avId > 0:
self.forceArrowDict[avId].show()
else:
self.forceArrowDict[avId].hide()
avId > 0
self.forceArrowDict[avId].show()
def localForceArrow(self):
if self.localAvId in self.forceArrowDict:
return self.forceArrowDict[self.localAvId]
else:
return None
def setChoices(self, input0, input1, input2, input3):
pass
def startDebugTask(self):
taskMgr.add(self.debugTask, self.debugTaskName)
def stopDebugTask(self):
taskMgr.remove(self.debugTaskName)
def debugTask(self, task):
if self.canDrive and self.tireDict.has_key(localAvatar.doId):
dt = globalClock.getDt()
forceMove = 25000
forceMoveDt = forceMove
tireBody = self.tireDict[localAvatar.doId]['tireBody']
if self.arrowKeys.upPressed() and not tireBody.isEnabled():
x = 0
y = 1
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.downPressed() and not tireBody.isEnabled():
x = 0
y = -1
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.leftPressed() and not tireBody.isEnabled():
x = -1
y = 0
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.rightPressed() and not tireBody.isEnabled():
x = 1
y = 0
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
return task.cont
def _DistributedIceGame__upArrowPressed(self):
pass
def _DistributedIceGame__downArrowPressed(self):
pass
def _DistributedIceGame__leftArrowPressed(self):
pass
def _DistributedIceGame__rightArrowPressed(self):
pass
def _DistributedIceGame__controlPressed(self):
if self.gameFSM.getCurrentState().getName() == 'inputChoice':
self.sendForceArrowUpdateAsap = True
self.updateLocalForceArrow()
self.controlKeyPressed = True
self.sendUpdate('setAvatarChoice',
[self.curForce, self.curHeading])
self.gameFSM.request('waitServerChoices')
def startTimer(self):
now = globalClock.getFrameTime()
elapsed = now - self.timerStartTime
self.timer.posInTopRightCorner()
self.timer.setTime(IceGameGlobals.InputTimeout)
self.timer.countdown(IceGameGlobals.InputTimeout - elapsed,
self.handleChoiceTimeout)
self.timer.show()
def setTimerStartTime(self, timestamp):
if not self.hasLocalToon:
return None
self.timerStartTime = globalClockDelta.networkToLocalTime(timestamp)
if self.timer != None:
self.startTimer()
def handleChoiceTimeout(self):
self.sendUpdate('setAvatarChoice', [0, 0])
self.gameFSM.request('waitServerChoices')
def localTireNp(self):
ret = None
if self.localAvId in self.tireDict:
ret = self.tireDict[self.localAvId]['tireNodePath']
return ret
def localTireBody(self):
ret = None
if self.localAvId in self.tireDict:
ret = self.tireDict[self.localAvId]['tireBody']
return ret
def getTireBody(self, avId):
ret = None
if avId in self.tireDict:
ret = self.tireDict[avId]['tireBody']
return ret
def getTireNp(self, avId):
ret = None
if avId in self.tireDict:
ret = self.tireDict[avId]['tireNodePath']
return ret
def updateForceArrow(self, avId, curHeading, curForce):
forceArrow = self.forceArrowDict[avId]
tireNp = self.tireDict[avId]['tireNodePath']
tireNp.setH(curHeading)
tireBody = self.tireDict[avId]['tireBody']
tireBody.setQuaternion(tireNp.getQuat())
self.notify.debug('curHeading = %s' % curHeading)
yScale = curForce / 100.0
yScale *= 1
headY = yScale * 15
xScale = (yScale - 1) / 2.0 + 1.0
shaft = forceArrow.find('**/arrow_shaft')
head = forceArrow.find('**/arrow_head')
shaft.setScale(xScale, yScale, 1)
head.setPos(0, headY, 0)
head.setScale(xScale, xScale, 1)
def updateLocalForceArrow(self):
avId = self.localAvId
self.b_setForceArrowInfo(avId, self.curHeading, self.curForce)
def _DistributedIceGame__aimTask(self, task):
if not hasattr(self, 'arrowKeys'):
return task.done
dt = globalClock.getDt()
headingMomentumChange = dt * 60.0
forceMomentumChange = dt * 160.0
arrowUpdate = False
arrowRotating = False
arrowUp = False
arrowDown = False
if self.arrowKeys.upPressed() and not self.arrowKeys.downPressed():
self.forceMomentum += forceMomentumChange
if self.forceMomentum < 0:
self.forceMomentum = 0
if self.forceMomentum > 50:
self.forceMomentum = 50
oldForce = self.curForce
self.curForce += self.forceMomentum * dt
arrowUpdate = True
if oldForce < self.MaxLocalForce:
arrowUp = True
elif self.arrowKeys.downPressed() and not self.arrowKeys.upPressed():
self.forceMomentum += forceMomentumChange
if self.forceMomentum < 0:
self.forceMomentum = 0
if self.forceMomentum > 50:
self.forceMomentum = 50
oldForce = self.curForce
self.curForce -= self.forceMomentum * dt
arrowUpdate = True
if oldForce > 0.01:
arrowDown = True
else:
self.forceMomentum = 0
if self.arrowKeys.leftPressed() and not self.arrowKeys.rightPressed():
self.headingMomentum += headingMomentumChange
if self.headingMomentum < 0:
self.headingMomentum = 0
if self.headingMomentum > 50:
self.headingMomentum = 50
self.curHeading += self.headingMomentum * dt
arrowUpdate = True
arrowRotating = True
elif self.arrowKeys.rightPressed(
) and not self.arrowKeys.leftPressed():
self.headingMomentum += headingMomentumChange
if self.headingMomentum < 0:
self.headingMomentum = 0
if self.headingMomentum > 50:
self.headingMomentum = 50
self.curHeading -= self.headingMomentum * dt
arrowUpdate = True
arrowRotating = True
else:
self.headingMomentum = 0
if arrowUpdate:
self.normalizeHeadingAndForce()
self.updateLocalForceArrow()
if arrowRotating:
if not self.arrowRotateSound.status(
) == self.arrowRotateSound.PLAYING:
base.playSfx(self.arrowRotateSound, looping=True)
else:
self.arrowRotateSound.stop()
if arrowUp:
if not self.arrowUpSound.status() == self.arrowUpSound.PLAYING:
base.playSfx(self.arrowUpSound, looping=False)
else:
self.arrowUpSound.stop()
if arrowDown:
if not self.arrowDownSound.status() == self.arrowDownSound.PLAYING:
base.playSfx(self.arrowDownSound, looping=False)
else:
self.arrowDownSound.stop()
return task.cont
def normalizeHeadingAndForce(self):
if self.curForce > self.MaxLocalForce:
self.curForce = self.MaxLocalForce
if self.curForce < 0.01:
self.curForce = 0.01
def setTireInputs(self, tireInputs):
if not self.hasLocalToon:
return None
self.allTireInputs = tireInputs
self.gameFSM.request('moveTires')
def enableAllTireBodies(self):
for avId in self.tireDict.keys():
self.tireDict[avId]['tireBody'].enable()
def disableAllTireBodies(self):
for avId in self.tireDict.keys():
self.tireDict[avId]['tireBody'].disable()
def areAllTiresDisabled(self):
for avId in self.tireDict.keys():
if self.tireDict[avId]['tireBody'].isEnabled():
return False
continue
return True
def _DistributedIceGame__moveTiresTask(self, task):
if self.areAllTiresDisabled():
self.sendTirePositions()
self.gameFSM.request('synch')
return task.done
return task.cont
def sendTirePositions(self):
tirePositions = []
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
tire = self.getTireBody(avId)
pos = Point3(tire.getPosition())
tirePositions.append([pos[0], pos[1], pos[2]])
for index in xrange(len(self.avIdList), 4):
avId = -index
tire = self.getTireBody(avId)
pos = Point3(tire.getPosition())
tirePositions.append([pos[0], pos[1], pos[2]])
self.sendUpdate('endingPositions', [tirePositions])
def setFinalPositions(self, finalPos):
if not self.hasLocalToon:
return None
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
tire = self.getTireBody(avId)
np = self.getTireNp(avId)
pos = finalPos[index]
tire.setPosition(pos[0], pos[1], pos[2])
np.setPos(pos[0], pos[1], pos[2])
for index in xrange(len(self.avIdList), 4):
avId = -index
tire = self.getTireBody(avId)
np = self.getTireNp(avId)
pos = finalPos[index]
tire.setPosition(pos[0], pos[1], pos[2])
np.setPos(pos[0], pos[1], pos[2])
def updateInfoLabel(self):
self.infoLabel['text'] = TTLocalizer.IceGameInfo % {
'curMatch': self.curMatch + 1,
'numMatch': IceGameGlobals.NumMatches,
'curRound': self.curRound + 1,
'numRound': IceGameGlobals.NumRounds
}
def setMatchAndRound(self, match, round):
if not self.hasLocalToon:
return None
self.curMatch = match
self.curRound = round
self.updateInfoLabel()
def setScores(self, match, round, scores):
if not self.hasLocalToon:
return None
self.newMatch = match
self.newRound = round
self.newScores = scores
def setNewState(self, state):
if not self.hasLocalToon:
return None
self.notify.debug('setNewState gameFSM=%s newState=%s' %
(self.gameFSM, state))
self.gameFSM.request(state)
def putAllTiresInStartingPositions(self):
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
np = self.tireDict[avId]['tireNodePath']
np.setPos(IceGameGlobals.StartingPositions[index])
self.notify.debug('avId=%s newPos=%s' % (avId, np.getPos))
np.setHpr(0, 0, 0)
quat = np.getQuat()
body = self.tireDict[avId]['tireBody']
body.setPosition(IceGameGlobals.StartingPositions[index])
body.setQuaternion(quat)
for index in xrange(len(self.avIdList), 4):
avId = -index
np = self.tireDict[avId]['tireNodePath']
np.setPos(IceGameGlobals.StartingPositions[index])
self.notify.debug('avId=%s newPos=%s' % (avId, np.getPos))
np.setHpr(0, 0, 0)
quat = np.getQuat()
body = self.tireDict[avId]['tireBody']
body.setPosition(IceGameGlobals.StartingPositions[index])
body.setQuaternion(quat)
def b_setForceArrowInfo(self, avId, force, heading):
self.setForceArrowInfo(avId, force, heading)
self.d_setForceArrowInfo(avId, force, heading)
def d_setForceArrowInfo(self, avId, force, heading):
sendIt = False
curTime = self.getCurrentGameTime()
if self.sendForceArrowUpdateAsap:
sendIt = True
elif curTime - self.lastForceArrowUpdateTime > 0.20000000000000001:
sendIt = True
if sendIt:
self.sendUpdate('setForceArrowInfo', [avId, force, heading])
self.sendForceArrowUpdateAsap = False
self.lastForceArrowUpdateTime = self.getCurrentGameTime()
def setForceArrowInfo(self, avId, force, heading):
if not self.hasLocalToon:
return None
self.updateForceArrow(avId, force, heading)
def setupStartOfMatch(self):
self.putAllTiresInStartingPositions()
szId = self.getSafezoneId()
self.numTreasures = IceGameGlobals.NumTreasures[szId]
if self.treasures:
for treasure in self.treasures:
treasure.destroy()
self.treasures = []
index = 0
treasureMargin = IceGameGlobals.TireRadius + 1.0
while len(self.treasures) < self.numTreasures:
xPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[0] + 5,
IceGameGlobals.MaxWall[0] - 5)
yPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[1] + 5,
IceGameGlobals.MaxWall[1] - 5)
self.notify.debug('yPos=%s' % yPos)
pos = Point3(xPos, yPos, IceGameGlobals.TireRadius)
newTreasure = IceTreasure.IceTreasure(self.treasureModel,
pos,
index,
self.doId,
penalty=False)
goodSpot = True
for obstacle in self.obstacles:
if newTreasure.nodePath.getDistance(obstacle) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
for treasure in self.treasures:
if newTreasure.nodePath.getDistance(
treasure.nodePath) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
self.treasures.append(newTreasure)
index += 1
continue
newTreasure.destroy()
self.numPenalties = IceGameGlobals.NumPenalties[szId]
if self.penalties:
for penalty in self.penalties:
penalty.destroy()
self.penalties = []
index = 0
while len(self.penalties) < self.numPenalties:
xPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[0] + 5,
IceGameGlobals.MaxWall[0] - 5)
yPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[1] + 5,
IceGameGlobals.MaxWall[1] - 5)
self.notify.debug('yPos=%s' % yPos)
pos = Point3(xPos, yPos, IceGameGlobals.TireRadius)
newPenalty = IceTreasure.IceTreasure(self.penaltyModel,
pos,
index,
self.doId,
penalty=True)
goodSpot = True
for obstacle in self.obstacles:
if newPenalty.nodePath.getDistance(obstacle) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
for treasure in self.treasures:
if newPenalty.nodePath.getDistance(
treasure.nodePath) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
for penalty in self.penalties:
if newPenalty.nodePath.getDistance(
penalty.nodePath) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
self.penalties.append(newPenalty)
index += 1
continue
newPenalty.destroy()
def toonHitSomething(self, entry):
self.notify.debug('---- treasure Enter ---- ')
self.notify.debug('%s' % entry)
name = entry.getIntoNodePath().getName()
parts = name.split('-')
if len(parts) < 3:
self.notify.debug('collided with %s, but returning' % name)
return None
if not int(parts[1]) == self.doId:
self.notify.debug("collided with %s, but doId doesn't match" %
name)
return None
treasureNum = int(parts[2])
if 'penalty' in parts[0]:
self._DistributedIceGame__penaltyGrabbed(treasureNum)
else:
self._DistributedIceGame__treasureGrabbed(treasureNum)
def _DistributedIceGame__treasureGrabbed(self, treasureNum):
self.treasures[treasureNum].showGrab()
self.treasureGrabSound.play()
self.sendUpdate('claimTreasure', [treasureNum])
def setTreasureGrabbed(self, avId, treasureNum):
if not self.hasLocalToon:
return None
self.notify.debug('treasure %s grabbed by %s' % (treasureNum, avId))
if avId != self.localAvId:
self.treasures[treasureNum].showGrab()
i = self.avIdList.index(avId)
self.scores[i] += 1
self.scorePanels[i].setScore(self.scores[i])
def _DistributedIceGame__penaltyGrabbed(self, penaltyNum):
self.penalties[penaltyNum].showGrab()
self.sendUpdate('claimPenalty', [penaltyNum])
def setPenaltyGrabbed(self, avId, penaltyNum):
if not self.hasLocalToon:
return None
self.notify.debug('penalty %s grabbed by %s' % (penaltyNum, avId))
if avId != self.localAvId:
self.penalties[penaltyNum].showGrab()
i = self.avIdList.index(avId)
self.scores[i] -= 1
self.scorePanels[i].setScore(self.scores[i])
def postStep(self):
DistributedIceWorld.DistributedIceWorld.postStep(self)
for count in range(self.colCount):
(c0, c1) = self.getOrderedContacts(count)
if c1 in self.tireCollideIds:
tireIndex = self.tireCollideIds.index(c1)
if c0 in self.tireCollideIds:
self.tireSounds[tireIndex]['tireHit'].play()
elif c0 == self.wallCollideId:
self.tireSounds[tireIndex]['wallHit'].play()
elif c0 == self.obstacleCollideId:
self.tireSounds[tireIndex]['obstacleHit'].play()
c0 in self.tireCollideIds
def forceLocalToonToTire(self):
toon = localAvatar
if toon and self.localAvId in self.tireDict:
tireNp = self.tireDict[self.localAvId]['tireNodePath']
toon.reparentTo(tireNp)
toon.setPosHpr(0, 0, 0, 0, 0, 0)
toon.setY(1.0)
toon.setZ(-3)
class DistributedBuilding(DistributedObject, Precacheable):
notify = directNotify.newCategory('DistributedBuilding')
SUIT_INIT_HEIGHT = 125
TAKEOVER_SFX_PREFIX = 'phase_5/audio/sfx/'
# for precaching
ELEVATOR_MDL = 'phase_4/models/modules/elevator.bam'
ICONS_MDL = 'phase_3/models/gui/cog_icons.bam'
SIGN_MDL = 'phase_5/models/modules/suit_sign.bam'
def __init__(self, cr):
DistributedObject.__init__(self, cr)
self.suitDoorOrigin = None
self.elevatorModel = None
self.fsm = ClassicFSM.ClassicFSM('DistributedBuilding', [
State.State('off', self.enterOff, self.exitOff),
State.State('waitForVictors', self.enterWaitForVictors,
self.exitWaitForVictors),
State.State('becomingToon', self.enterBecomingToon,
self.exitBecomingToon),
State.State('toon', self.enterToon, self.exitToon),
State.State('becomingSuit', self.enterBecomingSuit,
self.exitBecomingSuit),
State.State('suit', self.enterSuit, self.exitSuit)
], 'off', 'off')
self.fsm.enterInitialState()
self.elevatorNodePath = None
self.transitionTrack = None
self.victorList = [0, 0, 0, 0]
self.waitingMessage = None
self.cogDropSound = None
self.cogLandSound = None
self.cogSettleSound = None
self.cogWeakenSound = None
self.toonGrowSound = None
self.toonSettleSound = None
self.leftDoor = None
self.setLights = False
@classmethod
def doPrecache(cls):
precacheModel(cls.ELEVATOR_MDL)
precacheModel(cls.ICONS_MDL)
precacheModel(cls.SIGN_MDL)
def getDeptClassFromAbbr(self, abbr):
if abbr == 's':
return Dept.SALES
elif abbr == 'l':
return Dept.LAW
elif abbr == 'c':
return Dept.BOSS
elif abbr == 'm':
return Dept.CASH
def generate(self):
DistributedObject.generate(self)
self.mode = 'toon'
self.townTopLevel = self.cr.playGame.hood.loader.geom
def disable(self):
self.fsm.requestFinalState()
del self.townTopLevel
self.stopTransition()
DistributedObject.disable(self)
def delete(self):
self.victorList = None
if self.elevatorNodePath:
base.disablePhysicsNodes(self.elevatorNodePath)
self.elevatorNodePath.removeNode()
del self.elevatorNodePath
del self.elevatorModel
if hasattr(self, 'cab'):
del self.cab
del self.leftDoor
del self.rightDoor
self.leftDoor = None
del self.suitDoorOrigin
self.cleanupSuitBuilding()
self.unloadSfx()
del self.fsm
DistributedObject.delete(self)
def setBlock(self, block, interiorZoneId):
self.block = block
self.interiorZoneId = interiorZoneId
def setSuitData(self, suitDept, difficulty, numFloors):
self.suitDept = suitDept
self.difficulty = difficulty
self.numFloors = numFloors
def setState(self, state, timestamp):
self.fsm.request(state, [globalClockDelta.localElapsedTime(timestamp)])
def getSuitElevatorNodePath(self):
if self.mode != 'suit':
self.setToSuit()
return self.elevatorNodePath
def getSuitDoorOrigin(self):
if self.mode != 'suit':
self.setToSuit()
return self.suitDoorOrigin
def setVictorList(self, victorList):
self.victorList = victorList
def enterOff(self):
pass
def exitOff(self):
pass
def enterWaitForVictors(self, ts):
if self.mode != 'suit':
self.setToSuit()
victorCount = self.victorList.count(base.localAvatar.doId)
if victorCount == 1:
self.acceptOnce('insideVictorElevator',
self.handleInsideVictorElevator)
camera.reparentTo(render)
camera.setPosHpr(self.elevatorNodePath, 0, -32.5, 9.4, 0, 348, 0)
base.camLens.setMinFov(CIGlobals.DefaultCameraFov / (4. / 3.))
anyOthers = 0
for v in self.victorList:
if v != 0 and v != base.localAvatar.doId:
anyOthers = 1
if anyOthers:
self.waitingMessage = DirectLabel(
text="Waiting for other players...",
text_fg=VBase4(1, 1, 1, 1),
text_align=TextNode.ACenter,
relief=None,
pos=(0, 0, 0.35),
scale=0.1,
text_shadow=(0, 0, 0, 1))
elif victorCount == 0:
pass
else:
self.error('localToon is on the victorList %d times' % victorCount)
closeDoors(self.leftDoor, self.rightDoor)
for light in self.floorIndicator:
if light != None:
light.setColor(LIGHT_OFF_COLOR)
def handleInsideVictorElevator(self):
self.sendUpdate('setVictorReady', [])
def exitWaitForVictors(self):
self.ignore('insideVictorElevator')
if self.waitingMessage != None:
self.waitingMessage.destroy()
self.waitingMessage = None
def enterBecomingToon(self, ts):
self.animToToon(ts)
def exitBecomingToon(self):
pass
def enterToon(self, ts):
self.setToToon()
def exitToon(self):
pass
def enterBecomingSuit(self, ts):
self.animToSuit(ts)
def exitBecomingSuit(self):
pass
def enterSuit(self, ts):
self.setToSuit()
def exitSuit(self):
pass
def getNodePaths(self):
nodePath = []
npc = self.townTopLevel.findAllMatches('**/?b' + str(self.block) +
':*_DNARoot;+s')
npc.addPathsFrom(
self.townTopLevel.findAllMatches("**/toonBuildingsBlock" +
str(self.block) + ";+s"))
for i in xrange(npc.getNumPaths()):
nodePath.append(npc.getPath(i))
return nodePath
def getElevatorModel(self):
return self.elevatorModel
def loadElevator(self, newNP):
self.floorIndicator = [None, None, None, None, None]
self.elevatorNodePath = hidden.attachNewNode('elevatorNodePath')
self.elevatorModel = loader.loadModel(self.ELEVATOR_MDL)
npc = self.elevatorModel.findAllMatches('**/floor_light_?;+s')
for i in xrange(npc.getNumPaths()):
np = npc.getPath(i)
floor = int(np.getName()[-1:]) - 1
self.floorIndicator[floor] = np
if floor < self.numFloors:
np.setColor(LIGHT_OFF_COLOR)
else:
np.hide()
self.elevatorModel.reparentTo(self.elevatorNodePath)
self.cab = self.elevatorModel.find('**/elevator')
cogIcons = loader.loadModel(self.ICONS_MDL)
dept = self.getDeptClassFromAbbr(self.suitDept)
if dept == Dept.BOSS:
corpIcon = cogIcons.find('**/CorpIcon').copyTo(self.cab)
elif dept == Dept.SALES:
corpIcon = cogIcons.find('**/SalesIcon').copyTo(self.cab)
elif dept == Dept.LAW:
corpIcon = cogIcons.find('**/LegalIcon').copyTo(self.cab)
elif dept == Dept.CASH:
corpIcon = cogIcons.find('**/MoneyIcon').copyTo(self.cab)
corpIcon.setPos(0, 6.79, 6.8)
corpIcon.setScale(3)
corpIcon.setColor(dept.getMedallionColor())
cogIcons.removeNode()
self.leftDoor = self.elevatorModel.find('**/left-door')
if self.leftDoor.isEmpty():
self.leftDoor = self.elevatorModel.find('**/left_door')
self.rightDoor = self.elevatorModel.find('**/right-door')
if self.rightDoor.isEmpty():
self.rightDoor = self.elevatorModel.find('**/right_door')
self.suitDoorOrigin = newNP.find('**/*_door_origin')
self.elevatorNodePath.reparentTo(self.suitDoorOrigin)
base.createPhysicsNodes(self.elevatorNodePath)
base.enablePhysicsNodes(self.elevatorNodePath)
#self.elevatorNodePath.flattenStrong()
self.normalizeElevator()
def loadAnimToSuitSfx(self):
if self.cogDropSound is None:
self.cogDropSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX +
'cogbldg_drop.ogg')
self.cogLandSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX +
'cogbldg_land.ogg')
self.cogSettleSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX +
'cogbldg_settle.ogg')
self.openSfx = base.loadSfx(
'phase_5/audio/sfx/elevator_door_open.ogg')
def loadAnimToToonSfx(self):
if self.cogWeakenSound is None:
self.cogWeakenSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX +
'cogbldg_weaken.ogg')
self.toonGrowSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX +
'toonbldg_grow.ogg')
self.toonSettleSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX +
'toonbldg_settle.ogg')
self.openSfx = base.loadSfx(
'phase_5/audio/sfx/elevator_door_open.ogg')
def unloadSfx(self):
if self.cogDropSound != None:
self.cogDropSound = None
self.cogLandSound = None
self.cogSettleSound = None
self.openSfx = None
if self.cogWeakenSound != None:
self.cogWeakenSound = None
self.toonGrowSound = None
self.toonSettleSound = None
self.openSfx = None
def _deleteTransitionTrack(self):
if self.transitionTrack:
DelayDelete.cleanupDelayDeletes(self.transitionTrack)
self.transitionTrack = None
def animToSuit(self, timeStamp):
self.stopTransition()
if self.mode != 'toon':
self.setToToon()
self.loadAnimToSuitSfx()
sideBldgNodes = self.getNodePaths()
nodePath = hidden.find(self.getSbSearchString())
newNP = self.setupSuitBuilding(nodePath)
if not self.leftDoor:
return
closeDoors(self.leftDoor, self.rightDoor)
newNP.stash()
sideBldgNodes.append(newNP)
soundPlayed = 0
tracks = Parallel(name=self.taskName('toSuitTrack'))
for i in sideBldgNodes:
name = i.getName()
timeForDrop = TO_SUIT_BLDG_TIME * 0.85
if name[0] == 's':
showTrack = Sequence(name=self.taskName('ToSuitFlatsTrack') +
'-' + str(sideBldgNodes.index(i)))
initPos = Point3(0, 0, self.SUIT_INIT_HEIGHT) + i.getPos()
showTrack.append(Func(i.setPos, initPos))
showTrack.append(Func(i.unstash))
showTrack.append(Func(base.enablePhysicsNodes, i))
if i == sideBldgNodes[len(sideBldgNodes) - 1]:
showTrack.append(Func(self.normalizeElevator))
if not soundPlayed:
showTrack.append(
Func(base.playSfx, self.cogDropSound, 0, 1, None, 0.0))
showTrack.append(
LerpPosInterval(i,
timeForDrop,
i.getPos(),
name=self.taskName('ToSuitAnim') + '-' +
str(sideBldgNodes.index(i))))
if not soundPlayed:
showTrack.append(
Func(base.playSfx, self.cogLandSound, 0, 1, None, 0.0))
showTrack.append(
self.createBounceTrack(i,
2,
0.65,
TO_SUIT_BLDG_TIME - timeForDrop,
slowInitBounce=1.0))
if not soundPlayed:
showTrack.append(
Func(base.playSfx, self.cogSettleSound, 0, 1, None,
0.0))
tracks.append(showTrack)
if not soundPlayed:
soundPlayed = 1
elif name[0] == 't':
hideTrack = Sequence(
name=self.taskName('ToSuitToonFlatsTrack'))
timeTillSquish = (self.SUIT_INIT_HEIGHT -
20.0) / self.SUIT_INIT_HEIGHT
timeTillSquish *= timeForDrop
hideTrack.append(
LerpFunctionInterval(self.adjustColorScale,
fromData=1,
toData=0.25,
duration=timeTillSquish,
extraArgs=[i]))
hideTrack.append(
LerpScaleInterval(i, timeForDrop - timeTillSquish,
Vec3(1, 1, 0.01)))
hideTrack.append(Func(base.disablePhysicsNodes, i))
hideTrack.append(Func(i.stash))
hideTrack.append(Func(i.setScale, Vec3(1)))
hideTrack.append(Func(i.clearColorScale))
tracks.append(hideTrack)
self.stopTransition()
self._deleteTransitionTrack()
self.transitionTrack = tracks
self.transitionTrack.start(timeStamp)
def setupSuitBuilding(self, nodePath):
if nodePath.isEmpty():
return
dnaStore = self.cr.playGame.dnaStore
level = int(self.difficulty / 2) + 1
suitNP = dnaStore.findNode(
'suit_landmark_' +
self.getDeptClassFromAbbr(self.suitDept).getClothingPrefix() +
str(level))
zoneId = dnaStore.getZoneFromBlockNumber(self.block)
zoneId = ZoneUtil.getTrueZoneId(zoneId, self.interiorZoneId)
newParentNP = base.cr.playGame.hood.loader.zoneDict[zoneId]
suitBuildingNP = suitNP.copyTo(newParentNP)
base.createPhysicsNodes(suitBuildingNP)
buildingTitle = dnaStore.getTitleFromBlockNumber(self.block)
if not buildingTitle:
buildingTitle = "Cogs, Inc."
else:
buildingTitle += ", Inc."
buildingTitle += "\n%s" % self.getDeptClassFromAbbr(
self.suitDept).getName()
textNode = TextNode('sign')
textNode.setTextColor(1.0, 1.0, 1.0, 1.0)
textNode.setFont(CIGlobals.getSuitFont())
textNode.setAlign(TextNode.ACenter)
textNode.setWordwrap(17.0)
textNode.setText(buildingTitle)
textHeight = textNode.getHeight()
zScale = (textHeight + 2) / 3.0
signOrigin = suitBuildingNP.find('**/sign_origin;+s')
backgroundNP = loader.loadModel(self.SIGN_MDL)
backgroundNP.reparentTo(signOrigin)
backgroundNP.setPosHprScale(0.0, 0.0, textHeight * 0.8 / zScale, 0.0,
0.0, 0.0, 8.0, 8.0, 8.0 * zScale)
#backgroundNP.node().setEffect(DecalEffect.make())
signTextNodePath = backgroundNP.attachNewNode(textNode.generate())
signTextNodePath.setPosHprScale(0.0, -0.02,
-0.21 + textHeight * 0.1 / zScale, 0.0,
0.0, 0.0, 0.1, 0.1, 0.1 / zScale)
signTextNodePath.setColor(1.0, 1.0, 1.0, 1.0)
frontNP = suitBuildingNP.find('**/*_front/+GeomNode;+s')
backgroundNP.wrtReparentTo(frontNP)
frontNP.node().setEffect(DecalEffect.make())
suitBuildingNP.setName('sb' + str(self.block) + ':_landmark__DNARoot')
suitBuildingNP.setPosHprScale(nodePath, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
1.0, 1.0, 1.0)
suitBuildingNP.flattenStrong()
self.loadElevator(suitBuildingNP)
#CIGlobals.replaceDecalEffectsWithDepthOffsetAttrib(suitBuildingNP)
#CIGlobals.flattenModelNodes(suitBuildingNP)
base.enablePhysicsNodes(suitBuildingNP)
#suitBuildingNP.ls()
return suitBuildingNP
def cleanupSuitBuilding(self):
if hasattr(self, 'floorIndicator'):
del self.floorIndicator
def adjustColorScale(self, scale, node):
node.setColorScale(scale, scale, scale, 1)
def animToToon(self, timeStamp):
self.stopTransition()
if self.mode != 'suit':
self.setToSuit()
self.loadAnimToToonSfx()
suitSoundPlayed = 0
toonSoundPlayed = 0
bldgNodes = self.getNodePaths()
tracks = Parallel()
for i in bldgNodes:
name = i.getName()
if name[0] == 's':
hideTrack = Sequence(
name=self.taskName('ToToonSuitFlatsTrack'))
landmark = name.find('_landmark_') != -1
if not suitSoundPlayed:
hideTrack.append(
Func(base.playSfx, self.cogWeakenSound, 0, 1, None,
0.0))
hideTrack.append(
self.createBounceTrack(i,
3,
1.2,
TO_TOON_BLDG_TIME * 0.05,
slowInitBounce=0.0))
hideTrack.append(
self.createBounceTrack(i,
5,
0.8,
TO_TOON_BLDG_TIME * 0.1,
slowInitBounce=0.0))
hideTrack.append(
self.createBounceTrack(i,
7,
1.2,
TO_TOON_BLDG_TIME * 0.17,
slowInitBounce=0.0))
hideTrack.append(
self.createBounceTrack(i,
9,
1.2,
TO_TOON_BLDG_TIME * 0.18,
slowInitBounce=0.0))
realScale = i.getScale()
hideTrack.append(
LerpScaleInterval(i, TO_TOON_BLDG_TIME * 0.1,
Vec3(realScale[0], realScale[1], 0.01)))
hideTrack.append(Func(base.disablePhysicsNodes, i))
if landmark:
hideTrack.append(Func(i.removeNode))
else:
hideTrack.append(Func(i.stash))
hideTrack.append(Func(i.setScale, Vec3(1)))
if not suitSoundPlayed:
suitSoundPlayed = 1
tracks.append(hideTrack)
elif name[0] == 't':
hideTrack = Sequence(name=self.taskName('ToToonFlatsTrack'))
hideTrack.append(Wait(TO_TOON_BLDG_TIME * 0.5))
if not toonSoundPlayed:
hideTrack.append(
Func(base.playSfx, self.toonGrowSound, 0, 1, None,
0.0))
hideTrack.append(Func(i.unstash))
hideTrack.append(Func(base.enablePhysicsNodes, i))
hideTrack.append(Func(i.setScale, Vec3(1, 1, 0.01)))
if not toonSoundPlayed:
hideTrack.append(
Func(base.playSfx, self.toonSettleSound, 0, 1, None,
0.0))
hideTrack.append(
self.createBounceTrack(i,
11,
1.2,
TO_TOON_BLDG_TIME * 0.5,
slowInitBounce=4.0))
tracks.append(hideTrack)
if not toonSoundPlayed:
toonSoundPlayed = 1
self.stopTransition()
bldgMTrack = tracks
localToonIsVictor = self.localToonIsVictor()
if localToonIsVictor:
base.localAvatar.loop('neutral')
camTrack = self.walkOutCameraTrack()
victoryRunTrack, delayDeletes = self.getVictoryRunTrack()
trackName = self.taskName('toToonTrack')
self._deleteTransitionTrack()
if localToonIsVictor:
freedomTrack1 = Func(self.cr.playGame.getPlace().fsm.request,
'walk')
freedomTrack2 = Func(base.localAvatar.d_setParent,
CIGlobals.SPRender)
freedomTrack3 = Func(messenger.send,
BattleGlobals.BATTLE_COMPLETE_EVENT)
self.transitionTrack = Parallel(camTrack,
Sequence(victoryRunTrack,
bldgMTrack, freedomTrack1,
freedomTrack2,
freedomTrack3),
name=trackName)
else:
self.transitionTrack = Sequence(victoryRunTrack,
bldgMTrack,
name=trackName)
self.transitionTrack.delayDeletes = delayDeletes
if localToonIsVictor:
self.transitionTrack.start(0)
else:
self.transitionTrack.start(timeStamp)
def walkOutCameraTrack(self):
track = Sequence(
Func(camera.reparentTo, render),
Func(camera.setPosHpr, self.elevatorNodePath, 0, -32.5, 9.4, 0,
348, 0),
Func(base.camLens.setMinFov,
CIGlobals.DefaultCameraFov / (4. / 3.)),
Wait(VICTORY_RUN_TIME),
Func(camera.setPosHpr, self.elevatorNodePath, 0, -32.5, 17, 0, 347,
0), Func(base.camLens.setMinFov, 75.0 / (4. / 3)),
Wait(TO_TOON_BLDG_TIME),
Func(base.camLens.setMinFov,
CIGlobals.DefaultCameraFov / (4. / 3.)))
return track
def plantVictorsOutsideBldg(self):
retVal = 0
for victor in self.victorList:
if victor != 0 and victor in self.cr.doId2do:
toon = self.cr.doId2do[victor]
toon.setPosHpr(self.elevatorModel, 0, -10, 0, 0, 0, 0)
toon.startSmooth()
if victor == base.localAvatar.doId:
retVal = 1
self.cr.playGame.getPlace().fsm.request('walk')
return retVal
def getVictoryRunTrack(self):
origPosTrack = Sequence()
delayDeletes = []
i = 0
for victor in self.victorList:
if victor != 0 and victor in self.cr.doId2do:
toon = self.cr.doId2do[victor]
delayDeletes.append(
DelayDelete.DelayDelete(toon, 'getVictoryRunTrack'))
toon.stopSmooth()
toon.setParent(CIGlobals.SPHidden)
origPosTrack.append(
Func(toon.setPosHpr, self.elevatorNodePath,
apply(Point3, ElevatorPoints[i]), Point3(180, 0, 0)))
origPosTrack.append(Func(toon.setParent, CIGlobals.SPRender))
i += 1
openDoors = getOpenInterval(self, self.leftDoor, self.rightDoor,
self.openSfx, None)
toonDoorPosHpr = self.cr.playGame.dnaStore.getDoorPosHprFromBlockNumber(
self.block)
useFarExitPoints = toonDoorPosHpr.getPos(render).getZ() > 1.0
runOutAll = Parallel()
i = 0
for victor in self.victorList:
if victor != 0 and victor in self.cr.doId2do:
toon = self.cr.doId2do[victor]
p0 = Point3(0, 0, 0)
p1 = Point3(ElevatorPoints[i][0], ElevatorPoints[i][1] - 5.0,
ElevatorPoints[i][2])
if useFarExitPoints:
p2 = Point3(ElevatorOutPointsFar[i][0],
ElevatorOutPointsFar[i][1],
ElevatorOutPointsFar[i][2])
else:
p2 = Point3(ElevatorOutPoints[i][0],
ElevatorOutPoints[i][1],
ElevatorOutPoints[i][2])
runOutSingle = Sequence(
Func(toon.animFSM.request, 'run'),
LerpPosInterval(toon,
TOON_VICTORY_EXIT_TIME * 0.25,
p1,
other=self.elevatorNodePath),
Func(toon.headsUp, self.elevatorNodePath, p2),
LerpPosInterval(toon,
TOON_VICTORY_EXIT_TIME * 0.5,
p2,
other=self.elevatorNodePath),
LerpHprInterval(toon,
TOON_VICTORY_EXIT_TIME * 0.25,
Point3(0, 0, 0),
other=self.elevatorNodePath),
Func(toon.animFSM.request, 'neutral'),
Func(toon.startSmooth))
runOutAll.append(runOutSingle)
i += 1
victoryRunTrack = Sequence(origPosTrack, openDoors, runOutAll)
return (victoryRunTrack, delayDeletes)
def localToonIsVictor(self):
retVal = 0
for victor in self.victorList:
if victor == base.localAvatar.doId:
retVal = 1
return retVal
def createBounceTrack(self,
nodeObj,
numBounces,
startScale,
totalTime,
slowInitBounce=0.0):
if not nodeObj or numBounces < 1 or startScale == 0.0 or totalTime == 0:
self.notify.warning(
'createBounceTrack called with invalid parameter(s)')
return
result = Sequence()
numBounces += 1
if slowInitBounce:
bounceTime = totalTime / (numBounces + slowInitBounce - 1.0)
else:
bounceTime = totalTime / float(numBounces)
if slowInitBounce:
currTime = bounceTime * float(slowInitBounce)
else:
currTime = bounceTime
realScale = nodeObj.getScale()
currScaleDiff = startScale - realScale[2]
for currBounceScale in xrange(numBounces):
if currBounceScale == numBounces - 1:
currScale = realScale[2]
elif currBounceScale % 2:
currScale = realScale[2] - currScaleDiff
else:
currScale = realScale[2] + currScaleDiff
result.append(
LerpScaleInterval(nodeObj,
currTime,
Vec3(realScale[0], realScale[1], currScale),
blendType='easeInOut'))
currScaleDiff *= 0.5
currTime = bounceTime
return result
def stopTransition(self):
if self.transitionTrack:
self.transitionTrack.finish()
self._deleteTransitionTrack()
def setToSuit(self):
self.stopTransition()
if self.mode == 'suit':
return
self.mode = 'suit'
nodes = self.getNodePaths()
for i in nodes:
name = i.getName()
if name[0] == 's':
if name.find('_landmark_') != -1:
base.disablePhysicsNodes(i)
i.removeNode()
else:
base.enablePhysicsNodes(i)
i.unstash()
elif name[0] == 't':
for spl in i.findAllMatches("**/+Spotlight"):
render.clearLight(spl)
base.disablePhysicsNodes(i)
i.stash()
elif name[0] == 'c':
base.disablePhysicsNodes(i)
if name.find('_landmark_') != -1:
i.removeNode()
else:
i.stash()
if self.setLights and hasattr(self.cr.playGame.hood.loader,
'lampLights'):
blockLamps = self.cr.playGame.hood.loader.lampLights.get(
int(self.block), [])
for lamp in blockLamps:
render.clearLight(lamp)
self.setLights = False
npc = hidden.findAllMatches(self.getSbSearchString())
for i in xrange(npc.getNumPaths()):
nodePath = npc.getPath(i)
self.adjustSbNodepathScale(nodePath)
self.setupSuitBuilding(nodePath)
def setToToon(self):
self.stopTransition()
if not self.setLights and hasattr(self.cr.playGame.hood.loader,
'lampLights'):
blockLamps = self.cr.playGame.hood.loader.lampLights.get(
self.block, [])
for lamp in blockLamps:
render.setLight(lamp)
self.setLights = True
if self.mode == 'toon':
return
self.mode = 'toon'
self.suitDoorOrigin = None
nodes = self.getNodePaths()
for i in nodes:
i.clearColorScale()
name = i.getName()
if name[0] in ['s', 'c']:
base.disablePhysicsNodes(i)
if name.find('_landmark_') != -1:
for spl in i.findAllMatches("**/+Spotlight"):
render.clearLight(spl)
i.removeNode()
else:
i.stash()
elif name[0] == 't':
for spl in i.findAllMatches("**/+Spotlight"):
render.setLight(spl)
base.enablePhysicsNodes(i)
i.unstash()
def normalizeElevator(self):
self.elevatorNodePath.setScale(render, Vec3(1, 1, 1))
self.elevatorNodePath.setPosHpr(0, 0, 0, 0, 0, 0)
def getSbSearchString(self):
result = 'landmarkBlocks/sb' + str(
self.block) + ':*_landmark_*_DNARoot'
return result
def adjustSbNodepathScale(self, nodePath):
pass
def getVisZoneId(self):
exteriorZoneId = self.cr.playGame.dnaStore.getZoneFromBlockNumber(
self.block)
visZoneId = ZoneUtil.getTrueZoneId(exteriorZoneId, self.zoneId)
return visZoneId
class DistributedMaze(DistributedNodePathEntity):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedMaze')
ScheduleTaskName = 'mazeScheduler'
RemoveBlocksDict = {2: ('HedgeBlock_0_1',),
4: (('HedgeBlock_0_1', 'HedgeBlock_1_3', 'HedgeBlock_2_3'), ('HedgeBlock_0_2', 'HedgeBlock_2_3', 'HedgeBlock_1_3'), ('HedgeBlock_0_1', 'HedgeBlock_0_2', 'HedgeBlock_1_3', 'HedgeBlock_2_3'))}
def __init__(self, cr):
DistributedNodePathEntity.__init__(self, cr)
self.numSections = 0
self.GameDuration = 35.0 + self.numSections * 15.0
self.timer = None
self.frame2D = None
self.gameLabel = None
self.gameStarted = 0
self.finished = 0
self.timedOut = 0
self.toonFinishedText = TTLocalizer.toonFinishedHedgeMaze
self.toonEnteredText = TTLocalizer.enterHedgeMaze
return
def announceGenerate(self):
DistributedNodePathEntity.announceGenerate(self)
self.addHints(self.roomHold)
self.loadGui()
def disable(self):
DistributedNodePathEntity.disable(self)
self.unloadGui()
self.cleanupTimer()
self.ignoreAll()
def delete(self):
self.cleanupTimer()
DistributedNodePathEntity.delete(self)
def setRoomDoId(self, roomDoId):
self.roomDoId = roomDoId
room = self.cr.doId2do.get(roomDoId)
if room:
self.gotRoom([room])
else:
self.roomRequest = self.cr.relatedObjectMgr.requestObjects([roomDoId], allCallback=self.gotRoom, timeout=5)
def gotRoom(self, rooms):
self.roomRequest = None
room = rooms[0]
self.roomHold = room
rotations = [0,
0,
90,
90,
180,
180,
270,
270]
self.getRng().shuffle(rotations)
self.numSections = 0
for i in xrange(0, 4):
maze = room.getGeom().find('**/Maze_Inside_%d' % i)
if not maze.isEmpty():
self.numSections += 1
if rotations:
maze.setH(rotations.pop())
self.GameDuration = 35.0 + self.numSections * 15.0
self.removeHedgeBlocks(room)
return
def addHints(self, room):
self.focusPoint = self.attachNewNode('GolfGreenGameFrame')
hintList = room.getGeom().findAllMatches('**/dead*')
for hint in hintList:
self.actSphere = CollisionSphere(0, 0, 0, 7.0)
self.actSphereNode = CollisionNode('mazegame_hint-%s-%s' % (self.level.getLevelId(), self.entId))
self.actSphereNode.addSolid(self.actSphere)
self.actSphereNodePath = hint.attachNewNode(self.actSphereNode)
self.actSphereNode.setCollideMask(WallBitmask)
self.actSphere.setTangible(0)
self.enterEvent = 'enter' + self.actSphereNode.getName()
self.accept(self.enterEvent, self.__handleToonEnterHint)
self.exitEvent = 'exit' + self.actSphereNode.getName()
self.accept(self.exitEvent, self.__handleToonExitHint)
enterance = room.getGeom().find('**/ENTRANCE')
self.enterSphere = CollisionSphere(0, 0, 0, 8.0)
self.enterSphereNode = CollisionNode('mazegame_enter-%s-%s' % (self.level.getLevelId(), self.entId))
self.enterSphereNode.addSolid(self.enterSphere)
self.enterSphereNodePath = enterance.attachNewNode(self.enterSphereNode)
self.enterSphereNode.setCollideMask(WallBitmask)
self.enterSphere.setTangible(0)
self.enteranceEvent = 'enter' + self.enterSphereNode.getName()
self.accept(self.enteranceEvent, self.__handleToonEnterance)
finish = room.getGeom().find('**/finish')
self.finishSphere = CollisionSphere(0, 0, 0, 15.0)
self.finishSphereNode = CollisionNode('mazegame_finish-%s-%s' % (self.level.getLevelId(), self.entId))
self.finishSphereNode.addSolid(self.finishSphere)
self.finishSphereNodePath = finish.attachNewNode(self.finishSphereNode)
self.finishSphereNode.setCollideMask(WallBitmask)
self.finishSphere.setTangible(0)
self.finishEvent = 'enter' + self.finishSphereNode.getName()
self.accept(self.finishEvent, self.__handleToonFinish)
def __handleToonEnterance(self, collEntry):
if not self.gameStarted:
self.notify.debug('sending clientTriggered for %d' % self.doId)
self.sendUpdate('setClientTriggered', [])
self.level.countryClub.showInfoText(self.toonEnteredText)
def __handleToonFinish(self, collEntry):
self.sendUpdate('setFinishedMaze', [])
self.finished = 1
def __handleToonEnterHint(self, collEntry):
camHeight = base.localAvatar.getClampedAvatarHeight()
heightScaleFactor = camHeight * 0.3333333333
defLookAt = Point3(0.0, 1.5, camHeight)
cameraPoint = Point3(0.0, -22.0 * heightScaleFactor, camHeight + 54.0)
base.localAvatar.stopUpdateSmartCamera()
base.localAvatar.startUpdateSmartCamera(push=0)
base.localAvatar.setIdealCameraPos(cameraPoint)
def __handleToonExitHint(self, collEntry):
base.localAvatar.stopUpdateSmartCamera()
base.localAvatar.startUpdateSmartCamera()
base.localAvatar.setCameraPositionByIndex(base.localAvatar.cameraIndex)
self.cameraHold = None
return
def getRng(self):
return random.Random(self.entId * self.doId)
def removeHedgeBlocks(self, room):
if self.numSections in self.RemoveBlocksDict:
blocksToRemove = self.getRng().choice(self.RemoveBlocksDict[self.numSections])
for blockName in blocksToRemove:
block = room.getGeom().find('**/%s' % blockName)
if not block.isEmpty():
block.removeNode()
def setGameStart(self, timestamp):
self.notify.debug('%d setGameStart: Starting game' % self.doId)
self.gameStartTime = globalClockDelta.networkToLocalTime(timestamp)
self.gameStarted = True
curGameTime = self.getCurrentGameTime()
timeLeft = self.GameDuration - curGameTime
self.cleanupTimer()
self.timer = ToontownTimer.ToontownTimer()
self.timer.posBelowTopRightCorner()
self.timer.setTime(timeLeft)
self.timer.countdown(timeLeft, self.timerExpired)
self.startScheduleTask()
self.frame2D.show()
def setGameOver(self):
self.timedOut = 1
if not self.finished:
self.sendUpdate('damageMe', [])
roomNum = self.level.roomNum
club = self.level.countryClub
self.gameOverTrack = Sequence()
self.gameOverTrack.append(localAvatar.getTeleportOutTrack())
self.gameOverTrack.append(Func(localAvatar.setPos, self.finishSphereNodePath.getPos(render)))
self.gameOverTrack.append(Func(localAvatar.play, 'jump'))
self.gameOverTrack.append(Func(self.level.countryClub.camEnterRoom, roomNum))
self.gameOverTrack.start()
self.timerExpired()
def local2GameTime(self, timestamp):
return timestamp - self.gameStartTime
def game2LocalTime(self, timestamp):
return timestamp + self.gameStartTime
def getCurrentGameTime(self):
return self.local2GameTime(globalClock.getFrameTime())
def startScheduleTask(self):
taskMgr.add(self.scheduleTask, self.ScheduleTaskName)
def stopScheduleTask(self):
taskMgr.remove(self.ScheduleTaskName)
def scheduleTask(self, task):
curTime = self.getCurrentGameTime()
def cleanupTimer(self):
if self.timer:
self.timer.stop()
self.timer.destroy()
self.timer = None
return
def timerExpired(self):
self.cleanupTimer()
self.unloadGui()
def loadGui(self):
self.frame2D = DirectFrame(scale=1.0, pos=(0.0, 0, 0.9), relief=DGG.FLAT, parent=aspect2d, frameSize=(-0.3,
0.3,
-0.05,
0.05), frameColor=(0.737, 0.573, 0.345, 0.3))
self.frame2D.hide()
self.gameLabel = DirectLabel(parent=self.frame2D, relief=None, pos=(0, 0, 0), scale=1.0, text=TTLocalizer.mazeLabel, text_font=ToontownGlobals.getSignFont(), text0_fg=(1, 1, 1, 1), text_scale=0.075, text_pos=(0, -0.02))
return
def unloadGui(self):
if self.frame2D:
self.frame2D.destroy()
self.frame2D = None
if self.gameLabel:
self.gameLabel.destroy()
self.gameLabel = None
return
def toonFinished(self, avId, place, lastToon):
toon = base.cr.doId2do.get(avId)
if toon and not self.timedOut:
self.level.countryClub.showInfoText(self.toonFinishedText % (toon.getName(), TTLocalizer.hedgeMazePlaces[place]))
if lastToon:
self.setGameOver()
class DistributedCinemaInterior(DistributedToonInterior.DistributedToonInterior):
notify = directNotify.newCategory('DistributedCinemaInterior')
def __init__(self, cr):
DistributedToonInterior.DistributedToonInterior.__init__(self, cr)
self.fsm = ClassicFSM.ClassicFSM('DCinemaInterior', [State.State('off', self.enterOff, self.exitOff), State.State('show', self.enterShow, self.exitShow), State.State('intermission', self.enterIntermission, self.exitIntermission)], 'off', 'off')
self.fsm.enterInitialState()
self.state = None
self.cinemaIndex = None
self.movieTex = None
self.movieCard = None
self.movieSound = None
self.movieTrack = None
self.intermissionText = None
return
def makeInterior(self):
DistributedToonInterior.DistributedToonInterior.makeInterior(self, roomIndex=0)
def announceGenerate(self):
DistributedToonInterior.DistributedToonInterior.announceGenerate(self)
self.sendUpdate('requestStateAndTimestamp')
def disable(self):
self.fsm.requestFinalState()
self.fsm = None
self.state = None
self.cinemaIndex = None
self.movieTex = None
self.movieCard = None
self.movieSound = None
self.movieTrack = None
self.intermissionText = None
self.cr.playGame.hood.loader.interiorMusic.stop()
DistributedToonInterior.DistributedToonInterior.disable(self)
return
def darkenInterior(self):
darkenIval = self.interior.colorScaleInterval(3.0, colorScale=(0.3, 0.3, 0.3, 1.0), startColorScale=(1.0, 1.0, 1.0, 1.0), blendType='easeInOut')
darkenIval.start()
def lightenInterior(self):
lightenIval = self.interior.colorScaleInterval(3.0, colorScale=(1, 1, 1, 1.0), startColorScale=(0.3, 0.3, 0.3, 1.0), blendType='easeInOut')
lightenIval.start()
def enterShow(self, ts = 0):
self.darkenInterior()
self.cr.playGame.hood.loader.interiorMusic.stop()
videoFile = CinemaGlobals.Cinemas[self.cinemaIndex][0]
audioFile = CinemaGlobals.Cinemas[self.cinemaIndex][1]
self.movieTex = MovieTexture(self.uniqueName('movieTex'))
self.movieTex.read(videoFile)
card = CardMaker(self.uniqueName('movieCard'))
card.setFrame(-1.5, 1.5, -1, 1)
self.movieCard = NodePath(card.generate())
self.movieCard.reparentTo(render)
self.movieCard.setPos(self.interior.find('**/sign_origin;+s').getPos(render))
self.movieCard.setHpr(self.interior.find('**/sign_origin;+s').getHpr(render))
self.movieCard.setDepthWrite(1, 1)
self.movieCard.setTwoSided(True)
self.movieCard.setTexture(self.movieTex)
self.movieCard.setTexScale(TextureStage.getDefault(), self.movieTex.getTexScale())
self.movieCard.setScale(2.5)
self.movieSound = base.loadSfx(audioFile)
self.movieTex.synchronizeTo(self.movieSound)
self.movieTrack = SoundInterval(self.movieSound, name=self.uniqueName('movieTrack'))
self.movieTrack.setDoneEvent(self.movieTrack.getName())
self.acceptOnce(self.movieTrack.getDoneEvent(), self.fsm.request, ['off'])
self.movieTrack.start(ts)
def exitShow(self):
self.ignore(self.movieTrack.getDoneEvent())
self.movieTrack.finish()
self.movieTrack = None
self.movieSound = None
self.movieCard.removeNode()
self.movieCard = None
self.movieTex = None
self.lightenInterior()
self.cr.playGame.hood.loader.interiorMusic.play()
return
def enterIntermission(self, ts = 0):
self.intermissionText = DirectLabel(relief=None, text_decal=True, text='', scale=0.7, parent=self.interior.find('**/sign_origin;+s'), text_font=CIGlobals.getMickeyFont(), text_fg=(1, 0.9, 0, 1))
self.movieTrack = Sequence(name=self.uniqueName('intermissionTrack'))
for second in range(CinemaGlobals.IntermissionLength + 1):
timeRemaining = CinemaGlobals.IntermissionLength - second
self.movieTrack.append(Func(self.setIntermissionText, 'Next show in:\n%d' % timeRemaining))
self.movieTrack.append(Wait(1.0))
self.movieTrack.setDoneEvent(self.movieTrack.getName())
self.acceptOnce(self.movieTrack.getDoneEvent(), self.fsm.request, ['off'])
self.movieTrack.start(ts)
return
def setIntermissionText(self, text):
self.intermissionText['text'] = text
def exitIntermission(self):
self.ignore(self.movieTrack.getDoneEvent())
self.movieTrack.finish()
self.movieTrack = None
self.intermissionText.destroy()
self.intermissionText = None
return
def enterOff(self):
pass
def exitOff(self):
pass
def setCinemaIndex(self, index):
self.cinemaIndex = index
def getCinemaIndex(self):
return self.cinemaIndex
def setState(self, state, timestamp):
ts = globalClockDelta.localElapsedTime(timestamp)
self.state = state
self.fsm.request(state, [ts])
def getState(self):
return self.state
