199 lines
7.3 KiB
Python
199 lines
7.3 KiB
Python
from direct.distributed.ClockDelta import globalClockDelta
|
|
from pandac.PandaModules import Point3
|
|
from toontown.toonbase import TTLocalizer
|
|
import PartyGlobals
|
|
from DistributedPartyTeamActivity import DistributedPartyTeamActivity
|
|
from PartyCogActivity import PartyCogActivity
|
|
|
|
class DistributedPartyCogActivity(DistributedPartyTeamActivity):
|
|
notify = directNotify.newCategory('DistributedPartyCogActivity')
|
|
players = {}
|
|
localPlayer = None
|
|
view = None
|
|
|
|
def __init__(self, cr, arenaModel = 'phase_13/models/parties/cogPieArena_model', texture = None):
|
|
DistributedPartyTeamActivity.__init__(self, cr, PartyGlobals.ActivityIds.PartyCog, startDelay=PartyGlobals.CogActivityStartDelay, balanceTeams=PartyGlobals.CogActivityBalanceTeams)
|
|
self.arenaModel = arenaModel
|
|
self.texture = texture
|
|
|
|
def load(self):
|
|
DistributedPartyTeamActivity.load(self)
|
|
self.view = PartyCogActivity(self, self.arenaModel, self.texture)
|
|
self.view.load()
|
|
|
|
def announceGenerate(self):
|
|
DistributedPartyTeamActivity.announceGenerate(self)
|
|
for i in xrange(len(self.toonIds)):
|
|
for toonId in self.toonIds[i]:
|
|
toon = base.cr.doId2do.get(toonId, None)
|
|
if toon:
|
|
self.view.handleToonJoined(toon, i, lateEntry=True)
|
|
|
|
return
|
|
|
|
def unload(self):
|
|
if hasattr(self, 'view') and self.view is not None:
|
|
self.view.unload()
|
|
del self.view
|
|
DistributedPartyTeamActivity.unload(self)
|
|
return
|
|
|
|
def enable(self):
|
|
DistributedPartyTeamActivity.enable(self)
|
|
|
|
def disable(self):
|
|
DistributedPartyTeamActivity.disable(self)
|
|
|
|
def getTitle(self):
|
|
return TTLocalizer.PartyCogTitle
|
|
|
|
def getInstructions(self):
|
|
return TTLocalizer.PartyCogInstructions
|
|
|
|
def pieThrow(self, toonId, timestamp, h, x, y, z, power):
|
|
if toonId not in self.toonIds:
|
|
return
|
|
if toonId != base.localAvatar.doId:
|
|
self.view.pieThrow(toonId, timestamp, h, Point3(x, y, z), power)
|
|
|
|
def b_pieThrow(self, toon, power):
|
|
timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime(), bits=32)
|
|
pos = toon.getPos()
|
|
h = toon.getH()
|
|
toonId = toon.doId
|
|
self.view.pieThrow(toonId, timestamp, h, pos, power)
|
|
self.d_broadcastPieThrow(toonId, timestamp, h, pos[0], pos[1], pos[2], power)
|
|
|
|
def d_broadcastPieThrow(self, toonId, timestamp, h, x, y, z, power):
|
|
self.sendUpdate('pieThrow', [toonId,
|
|
timestamp,
|
|
h,
|
|
x,
|
|
y,
|
|
z,
|
|
power])
|
|
|
|
def pieHitsToon(self, toonId, timestamp, x, y, z):
|
|
if toonId not in self.toonIds:
|
|
return
|
|
self.view.pieHitsToon(toonId, timestamp, Point3(x, y, z))
|
|
|
|
def d_broadcastPieHitsToon(self, toonId, timestamp, pos):
|
|
self.sendUpdate('pieHitsToon', [toonId,
|
|
timestamp,
|
|
pos[0],
|
|
pos[1],
|
|
pos[2]])
|
|
|
|
def b_pieHitsToon(self, toonId, timestamp, pos):
|
|
self.view.pieHitsToon(toonId, timestamp, pos)
|
|
self.d_broadcastPieHitsToon(toonId, timestamp, pos)
|
|
|
|
def pieHitsCog(self, toonId, timestamp, hitCogNum, x, y, z, direction, part):
|
|
if toonId not in self.toonIds:
|
|
return
|
|
if toonId != base.localAvatar.doId:
|
|
self.view.pieHitsCog(timestamp, hitCogNum, Point3(x, y, z), direction, part)
|
|
|
|
def b_pieHitsCog(self, timestamp, hitCogNum, pos, direction, part):
|
|
self.view.pieHitsCog(timestamp, hitCogNum, pos, direction, part)
|
|
self.d_broadcastSendPieHitsCog(timestamp, hitCogNum, pos, direction, part)
|
|
|
|
def d_broadcastSendPieHitsCog(self, timestamp, hitCogNum, pos, direction, part):
|
|
self.sendUpdate('pieHitsCog', [base.localAvatar.doId,
|
|
timestamp,
|
|
hitCogNum,
|
|
pos[0],
|
|
pos[1],
|
|
pos[2],
|
|
direction,
|
|
part])
|
|
|
|
def setCogDistances(self, distances):
|
|
self.view.setCogDistances(distances)
|
|
|
|
def setHighScore(self, toonName, score):
|
|
self.setSignNote(TTLocalizer.PartyCogSignNote % (toonName, score))
|
|
|
|
def handleToonJoined(self, toonId):
|
|
DistributedPartyTeamActivity.handleToonJoined(self, toonId)
|
|
toon = base.cr.doId2do.get(toonId, None)
|
|
team = self.getTeam(toonId)
|
|
if toon is not None and self.view is not None:
|
|
self.view.handleToonJoined(toon, team)
|
|
return
|
|
|
|
def handleToonExited(self, toonId):
|
|
toon = base.cr.doId2do.get(toonId, None)
|
|
if toon is None:
|
|
return
|
|
if self.view is not None:
|
|
self.view.handleToonExited(toon)
|
|
DistributedPartyTeamActivity.handleToonExited(self, toonId)
|
|
return
|
|
|
|
def handleToonShifted(self, toonId):
|
|
toon = base.cr.doId2do.get(toonId, None)
|
|
if toon is None:
|
|
return
|
|
if self.view is not None:
|
|
self.view.handleToonShifted(toon)
|
|
return
|
|
|
|
def handleToonSwitchedTeams(self, toonId):
|
|
DistributedPartyTeamActivity.handleToonSwitchedTeams(self, toonId)
|
|
toon = base.cr.doId2do.get(toonId, None)
|
|
if toon is None:
|
|
return
|
|
if self.view is not None:
|
|
self.view.handleToonSwitchedTeams(toon)
|
|
return
|
|
|
|
def handleToonDisabled(self, toonId):
|
|
if self.view is not None:
|
|
self.view.handleToonDisabled(toonId)
|
|
return
|
|
|
|
def startWaitForEnough(self):
|
|
DistributedPartyTeamActivity.startWaitForEnough(self)
|
|
self.view.openArenaDoors()
|
|
self.view.hideCogs()
|
|
|
|
def startRules(self):
|
|
DistributedPartyTeamActivity.startRules(self)
|
|
self.view.closeArenaDoors()
|
|
self.view.showCogs()
|
|
|
|
def startActive(self):
|
|
DistributedPartyTeamActivity.startActive(self)
|
|
self.view.startActivity(self.getCurrentActivityTime())
|
|
self.view.closeArenaDoors()
|
|
if not self.isLocalToonPlaying:
|
|
self.view.showArenaDoorTimers(self._duration + PartyGlobals.CogActivityConclusionDuration + 1.0 - self.getCurrentActivityTime())
|
|
|
|
def finishActive(self):
|
|
DistributedPartyTeamActivity.finishActive(self)
|
|
self.view.stopActivity()
|
|
|
|
def startConclusion(self, data):
|
|
DistributedPartyTeamActivity.startConclusion(self, data)
|
|
if self.isLocalToonPlaying:
|
|
score = (int(data / 10000), data % 10000)
|
|
winner = 2
|
|
if score[PartyGlobals.TeamActivityTeams.LeftTeam] > score[PartyGlobals.TeamActivityTeams.RightTeam]:
|
|
winner = PartyGlobals.TeamActivityTeams.LeftTeam
|
|
elif score[PartyGlobals.TeamActivityTeams.LeftTeam] < score[PartyGlobals.TeamActivityTeams.RightTeam]:
|
|
winner = PartyGlobals.TeamActivityTeams.RightTeam
|
|
if winner < 2:
|
|
if self.getTeam(base.localAvatar.doId) == winner:
|
|
resultsText = TTLocalizer.PartyTeamActivityLocalAvatarTeamWins
|
|
else:
|
|
resultsText = TTLocalizer.PartyTeamActivityWins % TTLocalizer.PartyCogTeams[winner]
|
|
else:
|
|
resultsText = TTLocalizer.PartyTeamActivityGameTie
|
|
self.view.showResults(resultsText, winner, score)
|
|
|
|
def finishConclusion(self):
|
|
self.view.hideResults()
|
|
DistributedPartyTeamActivity.finishConclusion(self)
|
|
self.view.hideArenaDoorTimers()
|