def startSuitWalkTask(self):
ival = Parallel(name = 'catchGameMetaSuitWalk')
rng = RandomNumGen.RandomNumGen(self.randomNumGen)
delay = 0.0
while delay < CatchGameGlobals.GameDuration:
delay += lerp(self.SuitPeriodRange[0], self.SuitPeriodRange[0], rng.random())
walkIval = Sequence(name = 'catchGameSuitWalk')
walkIval.append(Wait(delay))
def pickY(self = self, rng = rng):
return lerp(-(self.StageHalfHeight), self.StageHalfHeight, rng.random())
m = [
2.5,
2.5,
2.2999999999999998,
2.1000000000000001][self.getNumPlayers() - 1]
startPos = Point3(-(self.StageHalfWidth * m), pickY(), 0)
stopPos = Point3(self.StageHalfWidth * m, pickY(), 0)
if rng.choice([
0,
1]):
(startPos, stopPos) = (stopPos, startPos)
walkIval.append(self.getSuitWalkIval(startPos, stopPos, rng))
ival.append(walkIval)
ival.start()
self.suitWalkIval = ival
def pickY(self = self, rng = rng):
return lerp(-(self.StageHalfHeight), self.StageHalfHeight, rng.random())
def getDropIval(self, x, y, dropObjName, num):
objType = Name2DropObjectType[dropObjName]
dropNode = hidden.attachNewNode('catchDropNode%s' % num)
dropNode.setPos(x, y, 0)
shadow = self.dropShadow.copyTo(dropNode)
shadow.setZ(0.20000000000000001)
shadow.setColor(1, 1, 1, 1)
object = self.getObjModel(dropObjName)
object.reparentTo(dropNode)
if dropObjName in [
'watermelon',
'anvil']:
objH = object.getH()
absDelta = {
'watermelon': 12,
'anvil': 15 }[dropObjName]
delta = (self.randomNumGen.random() * 2.0 - 1.0) * absDelta
newH = objH + delta
else:
newH = self.randomNumGen.random() * 360.0
object.setH(newH)
sphereName = 'FallObj%s' % num
radius = self.ObjRadius
if objType.good:
radius *= lerp(1.0, 1.3, self.getDifficulty())
collSphere = CollisionSphere(0, 0, 0, radius)
collSphere.setTangible(0)
collNode = CollisionNode(sphereName)
collNode.setCollideMask(ToontownGlobals.CatchGameBitmask)
collNode.addSolid(collSphere)
collNodePath = object.attachNewNode(collNode)
collNodePath.hide()
if self.ShowObjSpheres:
collNodePath.show()
catchEventName = 'ltCatch' + sphereName
def eatCollEntry(forward, collEntry):
forward()
self.accept(catchEventName, Functor(eatCollEntry, Functor(self._DistributedCatchGame__handleCatch, num)))
def cleanup(self = self, dropNode = dropNode, num = num, event = catchEventName):
self.ignore(event)
dropNode.removeNode()
duration = objType.fallDuration
onscreenDuration = objType.onscreenDuration
dropHeight = self.MinOffscreenHeight
targetShadowScale = 0.29999999999999999
if self.TrickShadows:
intermedScale = targetShadowScale * (self.OffscreenTime / self.BaselineDropDuration)
shadowScaleIval = Sequence(LerpScaleInterval(shadow, self.OffscreenTime, intermedScale, startScale = 0))
shadowScaleIval.append(LerpScaleInterval(shadow, duration - self.OffscreenTime, targetShadowScale, startScale = intermedScale))
else:
shadowScaleIval = LerpScaleInterval(shadow, duration, targetShadowScale, startScale = 0)
targetShadowAlpha = 0.40000000000000002
shadowAlphaIval = LerpColorScaleInterval(shadow, self.OffscreenTime, Point4(1, 1, 1, targetShadowAlpha), startColorScale = Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
if self.UseGravity:
def setObjPos(t, objType = objType, object = object):
z = objType.trajectory.calcZ(t)
object.setZ(z)
setObjPos(0)
dropIval = LerpFunctionInterval(setObjPos, fromData = 0, toData = onscreenDuration, duration = onscreenDuration)
else:
startPos = Point3(0, 0, self.MinOffscreenHeight)
object.setPos(startPos)
dropIval = LerpPosInterval(object, onscreenDuration, Point3(0, 0, 0), startPos = startPos, blendType = 'easeIn')
ival = Sequence(Func(Functor(dropNode.reparentTo, render)), Parallel(Sequence(WaitInterval(self.OffscreenTime), dropIval), shadowIval), Func(cleanup), name = 'drop%s' % num)
landSound = None
if objType == Name2DropObjectType['anvil']:
landSound = self.sndAnvilLand
if landSound:
ival.append(SoundInterval(landSound))
return ival
def calcDifficultyConstants(self, difficulty, numPlayers):
ToonSpeedRange = [
16.0,
25.0]
self.ToonSpeed = lerp(ToonSpeedRange[0], ToonSpeedRange[1], difficulty)
self.SuitSpeed = self.ToonSpeed / 2.0
self.SuitPeriodRange = [
lerp(5.0, 3.0, self.getDifficulty()),
lerp(15.0, 8.0, self.getDifficulty())]
def scaledDimensions(widthHeight, scale):
(w, h) = widthHeight
return [
math.sqrt(scale * w * w),
math.sqrt(scale * h * h)]
BaseStageDimensions = [
20,
15]
areaScales = [
1.0,
1.0,
3.0 / 2,
4.0 / 2]
self.StageAreaScale = areaScales[numPlayers - 1]
self.StageLinearScale = math.sqrt(self.StageAreaScale)
self.notify.debug('StageLinearScale: %s' % self.StageLinearScale)
self.StageDimensions = scaledDimensions(BaseStageDimensions, self.StageAreaScale)
self.notify.debug('StageDimensions: %s' % self.StageDimensions)
self.StageHalfWidth = self.StageDimensions[0] / 2.0
self.StageHalfHeight = self.StageDimensions[1] / 2.0
MOHs = [
24] * 2 + [
26,
28]
self.MinOffscreenHeight = MOHs[self.getNumPlayers() - 1]
distance = math.sqrt(self.StageDimensions[0] * self.StageDimensions[0] + self.StageDimensions[1] * self.StageDimensions[1])
distance /= self.StageLinearScale
if self.DropPlacerType == PathDropPlacer:
distance /= 1.5
ToonRunDuration = distance / self.ToonSpeed
offScreenOnScreenRatio = 1.0
fraction = (1.0 / 3) * 0.84999999999999998
self.BaselineOnscreenDropDuration = ToonRunDuration / fraction * (1.0 + offScreenOnScreenRatio)
self.notify.debug('BaselineOnscreenDropDuration=%s' % self.BaselineOnscreenDropDuration)
self.OffscreenTime = offScreenOnScreenRatio * self.BaselineOnscreenDropDuration
self.notify.debug('OffscreenTime=%s' % self.OffscreenTime)
self.BaselineDropDuration = self.BaselineOnscreenDropDuration + self.OffscreenTime
self.MaxDropDuration = self.BaselineDropDuration
self.DropPeriod = self.BaselineDropDuration / 2.0
scaledNumPlayers = (numPlayers - 1.0) * 0.75 + 1.0
self.DropPeriod /= scaledNumPlayers
typeProbs = {
'fruit': 3,
'anvil': 1 }
probSum = reduce(lambda x, y: x + y, typeProbs.values())
for key in typeProbs.keys():
typeProbs[key] = float(typeProbs[key]) / probSum
scheduler = DropScheduler(CatchGameGlobals.GameDuration, self.FirstDropDelay, self.DropPeriod, self.MaxDropDuration, self.FasterDropDelay, self.FasterDropPeriodMult)
self.totalDrops = 0
while not scheduler.doneDropping():
scheduler.stepT()
self.totalDrops += 1
self.numFruits = int(self.totalDrops * typeProbs['fruit'])
self.numAnvils = int(self.totalDrops - self.numFruits)