def __updateCanvasZpos(self,Zpos): newZ=clampScalar(Zpos, .0, self.canvasLen-self.frameHeight+.015) self.canvas.setZ(newZ) thumbZ=-newZ*self.canvasRatio self.vertSliderThumb.setZ(thumbZ) self.pageUpRegion['frameSize']=(-.015,.015,thumbZ-.01,-.01) self.pageDnRegion['frameSize']=(-.015,.015,-self.frameHeight+.01,thumbZ+self.vertSliderThumb['frameSize'][2])
def __prevItem(self): if self.numItems: self.sel = clampScalar(0, self.numItems - 1, (self.sel - 1) if self.sel > -1 else self.numItems - 1) self.__putPointerAtItem() self.selByKey = True
def cameraZoom( self, zoomFactor, ): """Scale and clamp zoom level, then set distance by it.""" self.zoomLvl = clampScalar(self.zoomLvl * zoomFactor, *self.zoomClamp) self.setDist(self.zoomLvl)
def dartTask(self, task): for dart in self.dartList: desiredPos = dart.getDefaultPos() (newPos, theta) = self.clampSpherePtToHorizon(desiredPos) framePos = self._transSphereToFramePt(newPos) if -1.1000000000000001 < framePos[0]: pass framePos[0] < 1.1000000000000001 if 1: if -1.1000000000000001 < framePos[1]: pass framePos[1] < 1.1000000000000001 if 1: dart.setEdgeMode(False) dart.setPos(newPos) if theta: theta = clampScalar(0, math.pi / 4, theta) dart.setScale(-2 * theta / math.pi + 1) else: dart.setScale(1) dart.setPos(newPos) angle = math.atan2(-framePos[0], -framePos[1]) angle = angle * 180 / math.pi dart.setEdgeMode(True) dart.edgeModeNode.setR(angle) absFramePos = (abs(framePos[0]), abs(framePos[1])) markerFramePos = framePos / max(absFramePos) dart.edgeModeNode.setPos(markerFramePos[0], 0, markerFramePos[1]) return task.cont
def dartTask(self, task): for dart in self.dartList: desiredPos = dart.getDefaultPos() newPos, theta = self.clampSpherePtToHorizon(desiredPos) framePos = self._transSphereToFramePt(newPos) if -1.1 < framePos[0] < 1.1: if -1.1 < framePos[1] < 1.1: dart.setEdgeMode(False) dart.setPos(newPos) theta = theta and clampScalar(0, math.pi / 4, theta) dart.setScale(-2 * theta / math.pi + 1) else: dart.setScale(1) else: dart.setPos(newPos) angle = math.atan2(-framePos[0], -framePos[1]) angle = angle * 180 / math.pi dart.setEdgeMode(True) dart.edgeModeNode.setR(angle) absFramePos = (abs(framePos[0]), abs(framePos[1])) markerFramePos = framePos / max(absFramePos) dart.edgeModeNode.setPos(markerFramePos[0], 0, markerFramePos[1]) return task.cont
def _mouseUpdateTask(self, task): if OrbitCamera._mouseUpdateTask(self, task) == task.cont or self.mouseDelta[0] or self.mouseDelta[1]: sensitivity = 0.5 self.setRotation(self.getRotation() - self.mouseDelta[0] * sensitivity) self.setEscapement(clampScalar(self.escapement + self.mouseDelta[1] * sensitivity * 0.59999999999999998, self._minEsc, self._maxEsc)) return task.cont
def __updateNonlocalVehicle(self, task = None): self.curSpeed = self.smoother.getSmoothForwardVelocity() rotSpeed = -1 * self.smoother.getSmoothRotationalVelocity() self.leanAmount = self.curSpeed * rotSpeed / 500.0 self.leanAmount = clampScalar(self.leanAmount, -10, 10) self.__animate() return Task.cont
def __animate(self): speed = self.curSpeed self.spinWheels(speed / 10) enginePitch = clampScalar(speed / 120.0, 0.5, 15) self.kartLoopSfx.setPlayRate(enginePitch) if not self.localVehicle: dist = (self.getPos() - localAvatar.getPos()).length() if self.localVehicle: if self.lifter.isOnGround(): if self.offGround > 10: kart = self.geom[0].find('**/main*') bumpDown1 = kart.posInterval(0.1, Vec3(0, 0, -1)) bumpUp1 = kart.posInterval(0.15, Vec3(0, 0, 0)) bumpDown2 = kart.posInterval(0.5, Vec3(0, 0, -.4)) bumpUp2 = kart.posInterval(0.7, Vec3(0, 0, 0)) bumpSeq = Sequence(bumpDown1, bumpUp1, bumpDown2, bumpUp2) bumpSeq.start() self.offGround = 0 else: self.offGround += 1 if self.offGround == 0: modifier = self.surfaceModifiers[self.groundType]['shake'] * (speed / 50.0) else: modifier = 1 roll = self.leanAmount * 1.5 roll += (random.random() * 2 - 1) * modifier pitch = self.acceleration * -.005 pitch += (random.random() * 2 - 1) * modifier self.rollSuspension(roll) self.pitchSuspension(pitch) return Task.cont
def doDrift(curValue, timeToMedian, dt=float(dt)): # mood = mood + secs/((hrs/2*(mood/2))*(secs/hr)) """ use this to make sure that the numbers are even moving print curValue - (curValue + dt/(timeToMedian*7200)) """ newValue = curValue + dt / (timeToMedian * 7200) #3600)#60*60) return clampScalar(newValue, 0., 1.)
def getExtremeness(self, traitValue): percent = self._getTraitPercent(traitValue) if percent < 0.5: howExtreme = (0.5 - percent) * 2.0 else: howExtreme = (percent - 0.5) * 2.0 return clampScalar(howExtreme, 0.0, 1.0)
def applyIdealDistance(self): if self.isActive(): self.idealDistance = clampScalar(self.idealDistance, self._minDistance, self._maxDistance) if self._practicalDistance is None: self._zoomToDistance(self.idealDistance)
def addToMood(self, component, delta): # delta is in [-1..1] # delta will be added to component, and result is clamped to [0..1] assert -1. <= delta <= 1. value = self.mood.getComponent(component) value += delta self.setMoodComponent(component, clampScalar(value, 0., 1.))
def clampSpherePtToHorizon(self, pt): camRaySpherePt = self.findCamRaySpherePt(pt) if camRaySpherePt and not pt.almostEqual(camRaySpherePt, 0.0001): camToSphere = self.cam.getTransform(self._rNode) OC = camToSphere.getMat().xformPoint(Vec3(0, 0, 0)) theta = math.acos(clampScalar(-1.0, 1.0, self._radius / OC.length())) axis = OC.cross(pt) axis.normalize() q = Quat(math.cos(theta / 2), axis * math.sin(theta / 2)) ts = TransformState.makeQuat(q) OC.normalize() OC *= self._radius newPt = ts.getMat().xformPoint(OC) dTheta = math.acos(clampScalar(-1.0, 1.0, pt.dot(newPt))) return (newPt, dTheta) else: return (pt, 0)
def getExtremeness(self, traitValue): # returns 'extremeness' value in [0..1] for a particular trait value percent = self._getTraitPercent(traitValue) if percent < .5: howExtreme = (.5 - percent) * 2. else: howExtreme = (percent - .5) * 2. return clampScalar(howExtreme, 0., 1.)
def clampSpherePtToHorizon(self, pt): camRaySpherePt = self.findCamRaySpherePt(pt) if camRaySpherePt and not pt.almostEqual(camRaySpherePt, 0.0001): camToSphere = self.cam.getTransform(self._rNode) OC = camToSphere.getMat().xformPoint(Vec3(0, 0, 0)) theta = math.acos( clampScalar(-1.0, 1.0, self._radius / OC.length())) axis = OC.cross(pt) axis.normalize() q = Quat(math.cos(theta / 2), axis * math.sin(theta / 2)) ts = TransformState.makeQuat(q) OC.normalize() OC *= self._radius newPt = ts.getMat().xformPoint(OC) dTheta = math.acos(clampScalar(-1.0, 1.0, pt.dot(newPt))) return (newPt, dTheta) else: return (pt, 0)
def __init__(self, name, worldMap, maxTilt=math.pi / 4, mapSize=2.0, *args, **kwargs): ArcBall.__init__(self, name, *args, **kwargs) self.worldMap = worldMap maxTilt = clampScalar(0, math.pi / 4.0, maxTilt) _maxDist = math.tan(maxTilt * 2) self.tsMat = Mat3(TransformState.makeScale2d(Vec2(_maxDist / mapSize / 2.0)).getMat3()) self.tsMatInv = invert(self.tsMat) self._mapOrigin = self.mapPosToSpherePt(Point2(0)) self._worldNorth = Point3(0, 1, 0) self._loadModels()
def __init__(self, name, worldMap, maxTilt = math.pi / 4, mapSize = 2.0, *args, **kwargs): ArcBall.__init__(self, name, *args, **args) self.worldMap = worldMap maxTilt = clampScalar(0, math.pi / 4.0, maxTilt) _maxDist = math.tan(maxTilt * 2) self.tsMat = Mat3(TransformState.makeScale2d(Vec2(_maxDist / mapSize / 2.0)).getMat3()) self.tsMatInv = invert(self.tsMat) self._mapOrigin = self.mapPosToSpherePt(Point2(0)) self._worldNorth = Point3(0, 1, 0) self._loadModels()
def _lerpEscapement(self, escapement, duration = None): curEsc = self.getEscapement() escapement = clampScalar(escapement, self._minEsc, self._maxEsc) if duration is None: diff = abs(curEsc - escapement) speed = (max(curEsc, self._maxEsc) - min(curEsc, self._minEsc)) * 0.025000000000000001 duration = diff / speed self._stopEscapementLerp() self._escLerpIval = LerpFunctionInterval(self.setEscapement, fromData = curEsc, toData = escapement, duration = duration, blendType = 'easeOut', name = 'OrbitCamera.escapementLerp') self._escLerpIval.start()
def setTrickAptitude(self, trickId, aptitude, send = 1): aptitude = clampScalar(aptitude, 0.0, 1.0) aptitudes = self.trickAptitudes while len(aptitudes) - 1 < trickId: aptitudes.append(0.0) if aptitudes[trickId] != aptitude: aptitudes[trickId] = aptitude if send: self.b_setTrickAptitudes(aptitudes) else: self.setTrickAptitudes(aptitudes, local = 1)
def _getRotateAboutAxisQuat(self, axis, p0, p1, factor = 1.0): axis = axis / axis.length() dot0 = axis.dot(p0) proj0 = p0 - axis * dot0 dot1 = axis.dot(p1) proj1 = p1 - axis * dot1 axis = proj0.cross(proj1) area = axis.length() axis.normalize() theta = math.acos(clampScalar(-1, 1, proj0.dot(proj1) / proj0.length() * proj1.length())) return (Quat(math.cos(theta / 2.0), axis * math.sin(theta / 2.0)), area)
def stickCarToGround(self): posList = [] nWheels = len(self.wheelData) for nWheel in range(nWheels): cQueue = self.cQueue[nWheel] cQueue.sortEntries() if cQueue.getNumEntries() == 0: return entry = cQueue.getEntry(0) self.shakeWheel(nWheel, entry.getIntoNodePath()) pos = entry.getSurfacePoint(render) wheelPos = self.wheelBases[nWheel].getPos(render) pos = wheelPos - pos posList.append(pos) cQueue.clearEntries() rf = posList[0].getZ() lf = posList[1].getZ() rr = posList[2].getZ() lr = posList[3].getZ() right = (rf + rr) / 2 left = (lf + lr) / 2 rollVal = right - left rollVal = clampScalar(rollVal, -1, 1) curRoll = self.getR() newRoll = curRoll + rollVal * 2.0 self.setR(newRoll) if not self.stopped: camera.setR(-newRoll) front = (rf + lf) / 2 rear = (rr + lr) / 2 center = (front + rear) / 2 pitchVal = front - rear pitchVal = clampScalar(pitchVal, -1, 1) curPitch = self.getP() newPitch = curPitch - pitchVal * 2.0 self.setP((newPitch + curPitch) / 2.0) if self.proRacer: self.cameraNode.setP(-newPitch) elif not self.stopped: self.cameraNode.setP(-newPitch)
def getOrthTiltLimitQuat(self, thetaLimit=10): X = Vec3.unitX() Y = Vec3.unitY() Z = Vec3.unitZ() upSpaceNodePath = self rNodeNorth = Z arcballNorth = -Y baseQuat = self._rNode.getQuat(upSpaceNodePath) quatX = Quat.identQuat() quatY = Quat.identQuat() rNodeToUpSpace = TransformState.makeQuat(baseQuat) northPole = rNodeToUpSpace.getMat().xformPoint(rNodeNorth) dot = northPole.dot(X) proj = northPole - X * dot theta = math.acos( clampScalar(-1.0, 1.0, proj.dot(arcballNorth) / proj.length())) if theta > thetaLimit: theta -= thetaLimit if northPole.dot(Z) < 0.0: theta *= -1 quatX = Quat(math.cos(theta / 2.0), X * math.sin(theta / 2.0)) baseQuat *= quatX rNodeToUpSpace = TransformState.makeQuat(baseQuat) northPole = rNodeToUpSpace.getMat().xformPoint(rNodeNorth) dot = northPole.dot(Z) proj = northPole - Z * dot theta = math.acos( clampScalar(-1.0, 1.0, proj.dot(arcballNorth) / proj.length())) if theta > thetaLimit: theta -= thetaLimit if northPole.dot(X) >= 0.0: theta *= -1 quatY = Quat(math.cos(theta / 2.0), Z * math.sin(theta / 2.0)) baseQuat *= quatY return quatX * quatY
def setTrickAptitude(self, trickId, aptitude, send=1): aptitude = clampScalar(aptitude, 0.0, 1.0) aptitudes = self.trickAptitudes while len(aptitudes) - 1 < trickId: aptitudes.append(0.0) if aptitudes[trickId] != aptitude: aptitudes[trickId] = aptitude if send: self.b_setTrickAptitudes(aptitudes) else: self.setTrickAptitudes(aptitudes, local=1)
def _getPtToPtQuat(self, p0, p1, factor = 1.0): p0.normalize() p1.normalize() theta = math.acos(clampScalar(-1, 1, p0.dot(p1))) axis = p0.cross(p1) axis.normalize() if factor == 1.0: return Quat(math.cos(theta / 2.0), axis * math.sin(theta / 2.0)) elif 0.0 < factor: pass elif factor == 1.0: q = nLerp(Quat.identQuat(), Quat(math.cos(theta / 2.0), axis * math.sin(theta / 2.0)), factor) return q
def _mouseUpdateTask(self, task): if OrbitCamera._mouseUpdateTask( self, task ) == task.cont and self.mouseDelta[0] or self.mouseDelta[1]: sensitivity = 0.5 self.camTimer = -1.0 self.setRotation(self.getRotation() - self.mouseDelta[0] * sensitivity) self.setEscapement( clampScalar( self.escapement + self.mouseDelta[1] * sensitivity * 0.6, self._minEsc, self._maxEsc)) return task.cont
def _getPtToPtQuat(self, p0, p1, factor=1.0): p0.normalize() p1.normalize() theta = math.acos(clampScalar(-1, 1, p0.dot(p1))) axis = p0.cross(p1) axis.normalize() if factor == 1.0: return Quat(math.cos(theta / 2.0), axis * math.sin(theta / 2.0)) elif 0.0 < factor < 1.0: q = nLerp( Quat.identQuat(), Quat(math.cos(theta / 2.0), axis * math.sin(theta / 2.0)), factor) return q
def _getRotateAboutAxisQuat(self, axis, p0, p1, factor=1.0): axis = axis / axis.length() dot0 = axis.dot(p0) proj0 = p0 - axis * dot0 dot1 = axis.dot(p1) proj1 = p1 - axis * dot1 axis = proj0.cross(proj1) area = axis.length() axis.normalize() theta = math.acos( clampScalar(-1, 1, proj0.dot(proj1) / proj0.length() * proj1.length())) return (Quat(math.cos(theta / 2.0), axis * math.sin(theta / 2.0)), area)
def rotateCam(self, arc): """Setup a lerp interval to rotate the camera about the target.""" newP = clampScalar(self.target.getP() - arc.getY(), *self.clampP) #Clamped. newH = self.target.getH() + arc.getX() #Not clamped, just added. LERP.LerpHprInterval( self.target, self.speed, #Setup the interval\ P.Vec3( newH, newP, self.target.getR(), ), ).start() #and start it.
def getOrthTiltLimitQuat(self, thetaLimit = 10): X = Vec3.unitX() Y = Vec3.unitY() Z = Vec3.unitZ() upSpaceNodePath = self rNodeNorth = Z arcballNorth = -Y baseQuat = self._rNode.getQuat(upSpaceNodePath) quatX = Quat.identQuat() quatY = Quat.identQuat() rNodeToUpSpace = TransformState.makeQuat(baseQuat) northPole = rNodeToUpSpace.getMat().xformPoint(rNodeNorth) dot = northPole.dot(X) proj = northPole - X * dot theta = math.acos(clampScalar(-1.0, 1.0, proj.dot(arcballNorth) / proj.length())) if theta > thetaLimit: theta -= thetaLimit if northPole.dot(Z) < 0.0: theta *= -1 quatX = Quat(math.cos(theta / 2.0), X * math.sin(theta / 2.0)) baseQuat *= quatX rNodeToUpSpace = TransformState.makeQuat(baseQuat) northPole = rNodeToUpSpace.getMat().xformPoint(rNodeNorth) dot = northPole.dot(Z) proj = northPole - Z * dot theta = math.acos(clampScalar(-1.0, 1.0, proj.dot(arcballNorth) / proj.length())) if theta > thetaLimit: theta -= thetaLimit if northPole.dot(X) >= 0.0: theta *= -1 quatY = Quat(math.cos(theta / 2.0), Z * math.sin(theta / 2.0)) baseQuat *= quatY return quatX * quatY
def zoom(self, amount): if self.game.isChatting: return self.targetY = clampScalar(self.targetY + amount, -2, -15) if self.interval is not None: self.interval.pause() self.interval = LerpPosInterval( base.camera, duration=0.6, pos=Vec3(base.camera.getX(), self.targetY, base.camera.getZ()), blendType="easeOut", name="Camera.zoom", ) self.interval.start()
def getTiltLimitQuat(self, thetaLimit): Y = Vec3.unitY() Z = Vec3.unitZ() upSpaceNodePath = self rNodeNorth = Z arcballNorth = -Y rNodeToUpSpace = TransformState.makeHpr(self._rNode.getHpr(upSpaceNodePath)) northPole = rNodeToUpSpace.getMat().xformPoint(rNodeNorth) dot = northPole.dot(arcballNorth) theta = math.acos(clampScalar(-1, 1, dot)) if theta < thetaLimit: return Quat.identQuat() else: axis = northPole.cross(arcballNorth) axis.normalize() theta -= thetaLimit return Quat(math.cos(theta / 2.0), axis * math.sin(theta / 2.0))
def getTiltLimitQuat(self, thetaLimit): Y = Vec3.unitY() Z = Vec3.unitZ() upSpaceNodePath = self rNodeNorth = Z arcballNorth = -Y rNodeToUpSpace = TransformState.makeHpr( self._rNode.getHpr(upSpaceNodePath)) northPole = rNodeToUpSpace.getMat().xformPoint(rNodeNorth) dot = northPole.dot(arcballNorth) theta = math.acos(clampScalar(-1, 1, dot)) if theta < thetaLimit: return Quat.identQuat() else: axis = northPole.cross(arcballNorth) axis.normalize() theta -= thetaLimit return Quat(math.cos(theta / 2.0), axis * math.sin(theta / 2.0))
def _lerpEscapement(self, escapement, duration=None): curEsc = self.getEscapement() escapement = clampScalar(escapement, self._minEsc, self._maxEsc) if duration is None: diff = abs(curEsc - escapement) speed = (max(curEsc, self._maxEsc) - min(curEsc, self._minEsc)) * 0.025000000000000001 duration = diff / speed self._stopEscapementLerp() self._escLerpIval = LerpFunctionInterval( self.setEscapement, fromData=curEsc, toData=escapement, duration=duration, blendType='easeOut', name='OrbitCamera.escapementLerp') self._escLerpIval.start()
def getUprightCorrectionQuat(self, pt): Y = Vec3.unitY() Z = Vec3.unitZ() rNodeNorth = self._north upSpaceNodePath = self axis = pt / pt.length() up = Z rNodeToUpSpace = TransformState.makeHpr(self._rNode.getHpr(upSpaceNodePath)) northPole = rNodeToUpSpace.getMat().xformPoint(rNodeNorth) right = up.cross(axis) final = axis.cross(right) dot = northPole.dot(axis) proj = northPole - axis * dot theta = math.acos(clampScalar(-1.0, 1.0, proj.dot(final) / proj.length() * final.length())) if northPole.dot(right) < 0.0: theta *= -1 return Quat(math.cos(theta / 2.0), Vec3(axis) * math.sin(theta / 2.0))
def getUprightCorrectionQuat(self, pt): Y = Vec3.unitY() Z = Vec3.unitZ() rNodeNorth = self._north upSpaceNodePath = self axis = pt / pt.length() up = Z rNodeToUpSpace = TransformState.makeHpr( self._rNode.getHpr(upSpaceNodePath)) northPole = rNodeToUpSpace.getMat().xformPoint(rNodeNorth) right = up.cross(axis) final = axis.cross(right) dot = northPole.dot(axis) proj = northPole - axis * dot theta = math.acos( clampScalar(-1.0, 1.0, proj.dot(final) / (proj.length() * final.length()))) if northPole.dot(right) < 0.0: theta *= -1 return Quat(math.cos(theta / 2.0), Vec3(axis) * math.sin(theta / 2.0))
def setTrickAptitude(self, trickId, aptitude, send=1): # use this func to set aptitudes individually; you can prevent # a message from being sent out by setting send=0, but don't forget # to then call one of the above functions to distribute the new # values to clients when you're done assert trickId != PetTricks.Tricks.BALK aptitude = clampScalar(aptitude, 0., 1.) aptitudes = self.trickAptitudes # This while loop produces the old behavior: the array will be only # as long as it needs to be. So a pet with no aptitude on any trick # will have an empty aptitude array instead of a populated array of # zeroes (i.e. [0, 0, 0, 0, 0, 0, 0]), and a pet with aptitude only # for trick 3 will have an array like [0, 0, 0, 1] instead of the # full array, i.e. [0, 0, 0, 1, 0, 0, 0]. This 'sparse' array has # caused confusion. See the changes above that fill out the entire # array. while ((len(aptitudes)-1) < trickId): aptitudes.append(0.) if aptitudes[trickId] != aptitude: aptitudes[trickId] = aptitude if send: self.b_setTrickAptitudes(aptitudes) else: self.setTrickAptitudes(aptitudes, local=1)
def update(self, time): placeSorter = [] placeCount = 0 # begin updates for all racers for key in self.racerDict.keys(): racer = self.racerDict[key] curvetime = racer.curvetime face = racer.face mapspot = racer.mapspot maxlaphit = racer.maxlaphit if (not racer.finished and racer.enabled): placeSorter.append((curvetime, key)) if (racer.finished or racer.enabled): placeCount += 1 pt = Vec3(0, 0, 0) mapT = ( (curvetime % 1 + self.race.startT / self.race.curve.getMaxT()) % 1) * self.race.curve.getMaxT() self.race.curve.getPoint(mapT, pt) self.race.curve.getPoint((mapT % self.race.curve.getMaxT()), pt) lapT = clampScalar(curvetime / self.race.lapCount, 0.0, 1.0) faceX = self.faceStartPos[0] * (1 - lapT) + self.faceEndPos[0] * lapT racer.update(faceX=faceX, mapspotPt=pt) # subtract out previous lap times t = time - self.race.baseTime - self.raceTimeDelta # begin updates for self only if (key == localAvatar.doId): if (self.race.laps > maxlaphit): racer.update(maxlaphit=self.race.laps) self.maxLapHit = racer.maxlaphit if (self.maxLapHit < self.race.lapCount): for y in self.timeLabels[self.maxLapHit - 1]: y.configure( text_font=ToontownGlobals.getSignFont()) for y in self.timeLabels[self.maxLapHit]: y.show() for y in self.timeLabels[self.maxLapHit]: y.configure( text_font=ToontownGlobals.getSignFont()) self.raceTimeDelta = globalClock.getFrameTime( ) - self.race.baseTime lapNotice = DirectLabel() lapNotice.setScale(.1) if (self.maxLapHit == self.race.lapCount - 1): lapNotice[ 'text'] = TTLocalizer.KartRace_FinalLapText else: lapNotice[ 'text'] = TTLocalizer.KartRace_LapText % str( self.maxLapHit + 1) taskMgr.doMethodLater(2, lapNotice.remove, "removeIt", extraArgs=[]) self.lapLabel['text'] = str( clampScalar(self.maxLapHit + 1, 1, self.race.lapCount)) + '/' + str( self.race.lapCount) suffix = { 1: TTLocalizer.KartRace_FirstSuffix, 2: TTLocalizer.KartRace_SecondSuffix, 3: TTLocalizer.KartRace_ThirdSuffix, 4: TTLocalizer.KartRace_FourthSuffix, } placeSorter.sort() for x, p in zip(placeSorter, xrange(len(placeSorter), 0, -1)): self.racerDict[x[1]].update(place=(p + placeCount - len(placeSorter))) # if we are close to the finish line, and so is someone else, # declare a 'photo finish' localRacer = self.racerDict[localAvatar.doId] (nearDiff, farDiff) = RaceGlobals.TrackDict[self.race.trackId][8] if (not localRacer.finished) and ( self.faceEndPos[0] - localRacer.face.getX() < nearDiff): for racerId in self.racerDict.keys(): racer = self.racerDict[racerId] if (not racer.enabled or (racerId == localAvatar.doId) or (racer.face.getX() >= self.faceEndPos[0])): continue if (self.faceEndPos[0] - racer.face.getX()) < farDiff: self.photoFinish = True if self.photoFinish: self.photoFinishLabel.show() self.placeLabelNum['text'] = "" self.placeLabelStr['text'] = "" else: self.photoFinishLabel.hide() self.placeLabelNum['text'] = str( self.racerDict[localAvatar.doId].place) self.placeLabelStr['text'] = suffix[self.racerDict[ localAvatar.doId].place] # convert the time into a label displayable string minutes = int(t / 60) t -= minutes * 60 seconds = int(t) # quick python ternary operator padding = (seconds < 10 and ['0'] or [''])[0] t -= seconds fraction = str(t)[2:4] fraction = fraction + '0' * (2 - len(fraction)) if (self.timerEnabled and self.maxLapHit < self.race.lapCount): self.timeLabels[self.maxLapHit][0]['text'] = '%d\'' % (minutes) self.timeLabels[self.maxLapHit][1]['text'] = '%s%d\'\'' % (padding, seconds) self.timeLabels[self.maxLapHit][2]['text'] = '%s' % (fraction) if (self.race.wrongWay and not self.wrongWaySeq.isPlaying()): self.wrongWaySeq.loop() elif (not self.race.wrongWay and self.wrongWaySeq.isPlaying()): self.wrongWaySeq.finish()
def update(self, time): placeSorter = [] placeCount = 0 for key in self.racerDict.keys(): racer = self.racerDict[key] curvetime = racer.curvetime face = racer.face mapspot = racer.mapspot maxlaphit = racer.maxlaphit if not racer.finished and racer.enabled: placeSorter.append((curvetime, key)) if racer.finished or racer.enabled: placeCount += 1 pt = Vec3(0, 0, 0) mapT = (curvetime % 1 + self.race.startT / self.race.curve.getMaxT()) % 1 * self.race.curve.getMaxT() self.race.curve.getPoint(mapT, pt) self.race.curve.getPoint(mapT % self.race.curve.getMaxT(), pt) lapT = clampScalar(curvetime / self.race.lapCount, 0.0, 1.0) faceX = self.faceStartPos[0] * (1 - lapT) + self.faceEndPos[0] * lapT racer.update(faceX=faceX, mapspotPt=pt) t = time - self.race.baseTime - self.raceTimeDelta if key == localAvatar.doId: if self.race.laps > maxlaphit: racer.update(maxlaphit=self.race.laps) self.maxLapHit = racer.maxlaphit if self.maxLapHit < self.race.lapCount: for y in self.timeLabels[self.maxLapHit - 1]: y.configure(text_font=ToontownGlobals.getSignFont()) for y in self.timeLabels[self.maxLapHit]: y.show() for y in self.timeLabels[self.maxLapHit]: y.configure(text_font=ToontownGlobals.getSignFont()) self.raceTimeDelta = globalClock.getFrameTime() - self.race.baseTime lapNotice = DirectLabel() lapNotice.setScale(0.1) if self.maxLapHit == self.race.lapCount - 1: lapNotice['text'] = TTLocalizer.KartRace_FinalLapText else: lapNotice['text'] = TTLocalizer.KartRace_LapText % str(self.maxLapHit + 1) taskMgr.doMethodLater(2, lapNotice.remove, 'removeIt', extraArgs=[]) self.lapLabel['text'] = str(clampScalar(self.maxLapHit + 1, 1, self.race.lapCount)) + '/' + str(self.race.lapCount) suffix = {1: TTLocalizer.KartRace_FirstSuffix, 2: TTLocalizer.KartRace_SecondSuffix, 3: TTLocalizer.KartRace_ThirdSuffix, 4: TTLocalizer.KartRace_FourthSuffix} placeSorter.sort() for x, p in zip(placeSorter, xrange(len(placeSorter), 0, -1)): self.racerDict[x[1]].update(place=p + placeCount - len(placeSorter)) localRacer = self.racerDict[localAvatar.doId] nearDiff, farDiff = RaceGlobals.TrackDict[self.race.trackId][8] if not localRacer.finished and self.faceEndPos[0] - localRacer.face.getX() < nearDiff: for racerId in self.racerDict.keys(): racer = self.racerDict[racerId] if not racer.enabled or racerId == localAvatar.doId or racer.face.getX() >= self.faceEndPos[0]: continue if self.faceEndPos[0] - racer.face.getX() < farDiff: self.photoFinish = True if self.photoFinish: self.photoFinishLabel.show() self.placeLabelNum['text'] = '' self.placeLabelStr['text'] = '' else: self.photoFinishLabel.hide() self.placeLabelNum['text'] = str(self.racerDict[localAvatar.doId].place) self.placeLabelStr['text'] = suffix[self.racerDict[localAvatar.doId].place] minutes = int(t / 60) t -= minutes * 60 seconds = int(t) padding = (seconds < 10 and ['0'] or [''])[0] t -= seconds fraction = str(t)[2:4] fraction = fraction + '0' * (2 - len(fraction)) if self.timerEnabled and self.maxLapHit < self.race.lapCount: self.timeLabels[self.maxLapHit][0]['text'] = "%d'" % minutes self.timeLabels[self.maxLapHit][1]['text'] = "%s%d''" % (padding, seconds) self.timeLabels[self.maxLapHit][2]['text'] = '%s' % fraction if self.race.wrongWay and not self.wrongWaySeq.isPlaying(): self.wrongWaySeq.loop() elif not self.race.wrongWay and self.wrongWaySeq.isPlaying(): self.wrongWaySeq.finish()
def __watchControls(self, task): dt = globalClock.getDt() curVelocity = self.actorNode.getPhysicsObject().getVelocity() curSpeed = curVelocity.length() fvec = self.forward.getPos(render) - self.getPos(render) fvec.normalize() dotProduct = curVelocity.dot(fvec) goingBack = -1 if dotProduct < 0: goingBack = 1 if self.proRacer: self.__computeTurnRatio(curSpeed) self.__updateWheelPos(dt, curSpeed) newHForTurning = self.getH() if self.proRacer or not self.stopped and self.arrowHorz and curSpeed > 1: if self.proRacer: turnHelp = 0 if self.hittingWall or goingBack == 1: turnHelp = self.arrowHorz effectiveSpeed = curSpeed if effectiveSpeed > self.speedMinTurn: effectiveSpeed = self.speedMinTurn rotation = -goingBack * (self.wheelPosition * dt * self.turnRatio * -1.8 * curSpeed / 100 + turnHelp * dt * self.turnRatio * -1.2) self.outPutCounter += 1 if self.outPutCounter > 5: self.outPutCounter = 0 else: rotation = self.arrowHorz * dt * self.turnRatio * -1.2 oldH = self.getH() newH = (oldH + rotation) % 360 self.setH(newH) newHForTurning = newH if self.groundType == 'ice': newHForTurning = (oldH + rotation * iceTurnFactor) % 360 pitch = -self.getP() + 5 accelBase = self.accelerationBase pitch += accelBase pitch = clampScalar(pitch, accelBase - 5, accelBase + 5) self.accelerationMult = pitch * 2 if self.groundType == 'ice': self.accelerationMult *= iceAccelFactor if self.stopped: self.acceleration = 0 else: self.acceleration = self.arrowVert * self.accelerationMult * self.cheatFactor if self.proRacer: if self.skidding: self.acceleration = self.arrowVert * self.accelerationMult * self.cheatFactor * 0.5 if self.turbo: self.acceleration += self.accelerationMult * 1.5 self.engine.setVector(Vec3(0, self.acceleration, 0)) if self.groundType == 'ice': rotMat = Mat3.rotateMatNormaxis(newHForTurning, Vec3.up()) else: rotMat = Mat3.rotateMatNormaxis(self.getH(), Vec3.up()) curHeading = rotMat.xform(Vec3.forward()) push = (3 - self.getP()) * 0.02 curHeading.setZ(curHeading.getZ() - min(0.2, max(-.2, push))) onScreenDebug.append('vehicle curHeading = %s\n' % curHeading.pPrintValues()) onScreenDebug.append('vehicle H = %s newHForTurning=%f\n' % (self.getH(), newHForTurning)) windResistance = self.surfaceModifiers[self.groundType]['windResistance'] self.windResistance.setCoef(windResistance) physicsFrame = int((globalClock.getFrameTime() - self.physicsEpoch) * self.physicsCalculationsPerSecond) numFrames = min(physicsFrame - self.lastPhysicsFrame, self.maxPhysicsFrames) self.lastPhysicsFrame = physicsFrame leanIncrement = self.arrowHorz * self.physicsDt * self.turnRatio if self.stopped: leanIncrement = 0 driftMin = self.surfaceModifiers[self.groundType]['driftMin'] if self.proRacer: driftMin = self.surfaceModifiers[self.groundType]['driftMin'] * 0.2 if self.skidding: driftMin = self.surfaceModifiers[self.groundType]['driftMin'] for i in range(numFrames): self.physicsMgr.doPhysics(self.physicsDt) curVelocity = self.actorNode.getPhysicsObject().getVelocity() idealVelocity = curHeading * curSpeed curVelocity *= self.imHitMult driftVal = abs(self.leanAmount) * 16 / self.cheatFactor + 15 / self.cheatFactor curVelocity = Vec3((curVelocity * driftVal + idealVelocity) / (driftVal + 1)) curSpeed = curVelocity.length() curVelocity.normalize() curVelocity *= min(curSpeed, 600) self.actorNode.getPhysicsObject().setVelocity(curVelocity) curSpeed = curVelocity.length() speedFactor = min(curSpeed, 150) / 162.0 self.leanAmount = (self.leanAmount + leanIncrement) * speedFactor self.leanAmount = clampScalar(self.leanAmount, -10, 10) self.cWallTrav.traverse(render) self.curSpeed = curSpeed if self.proRacer: self.turnWheels(self.wheelPosition * -45) else: self.turnWheels(self.arrowHorz * -10) self.__animate() if self.proRacer: speedProporation = 1.0 if curSpeed < self.speedMaxTurn: speedProporation = 0.0 else: speedProporation = (curSpeed - self.speedMaxTurn) / self.speedMinTurn cameraDist = self.cameraArmBase + self.cameraArmExtend * speedProporation cameraOffset = Point3(0, -cameraDist, 0) self.cameraNode.setPos(cameraOffset) behindPos = render.getRelativePoint(self, Point3(0, -30, 0)) self.proCameraDummyNode.setPos(render, behindPos) self.proCameraDummyNode.lookAt(self) self.cameraNode.lookAt(self) dir1 = self.proCameraDummyNode.getH() dir2 = self.proCameraHeading if dir1 > 180: dir1 -= 360 elif dir1 < -180: dir1 += 360 if dir2 > 180: dir2 -= 360 elif dir2 < -180: dir2 += 360 self.proCameraHeading = dir2 dif = dir1 - dir2 if dif > 180: dif -= 360 elif dif < -180: dif += 360 speedDif = abs(dif) if speedDif > 90: speedDif = 90 cameraTightener = 1.0 if curSpeed > self.speedMinTurn: cameraTightener = self.cameraTightener else: cameraTightener = 1.0 + curSpeed / self.speedMinTurn * (self.cameraTightener - 1.0) swingSpeedRatio = speedDif / 90 swingSpeed = self.armSwingSpeedPerp * swingSpeedRatio + self.armSwingSpeedPara * (1 - swingSpeedRatio) self.proCameraHeading += dif * cameraTightener * (dt / swingSpeed) self.cameraArmNode.setH(self.proCameraHeading - self.getH()) elif not self.stopped: self.cameraNode.setH(self.leanAmount) self.updateParticles(self.leanAmount) if (self.leanAmount > 8 or self.leanAmount < -8) and self.offGround <= 0: self.startSkid() else: self.stopSkid() if self.speedometer: self.speedometer['text'] = str(int(curSpeed / 3)) self.speedGauge.setR(min(110, max(0, curSpeed / 3 / 120 * 110))) if not self.stopped: self.stickCarToGround() if self.__clampPosition(): self.notify.debug('did a clampPosition on %d' % self.doId) return Task.cont
def createCurvedArrow(self, axis, p0, p1, width, numPanels = 10): N = numPanels self.tail_geom_node.removeAllGeoms() self.head_geom_node.removeAllGeoms() axis = axis / axis.length() dot0 = axis.dot(p0) proj0 = p0 - axis * dot0 dot1 = axis.dot(p1) proj1 = p1 - axis * dot1 theta = math.acos(clampScalar(-1, 1, proj0.dot(proj1) / proj0.length() * proj1.length())) if not proj0.almostEqual(proj1, 0.0001) and theta != 0: if proj0.lengthSquared() >= proj1.lengthSquared(): A = proj0 C = proj1 else: A = proj1 C = proj0 a = A.length() aUnit = A / a x = A.dot(C) / a yy = C.lengthSquared() - x * x bUnit = A.cross(C).cross(A) bUnit.normalize() b = math.sqrt(max(0.0, yy / (1 - x * x / a * a))) t = math.atan2(a, b / math.tan(theta)) aUnit *= a bUnit *= b pts = [ aUnit * math.cos(x * t / N) + bUnit * math.sin(x * t / N) for x in range(N + 1) ] pts = [ pt + axis * math.sqrt(self._radius * self._radius - pt.lengthSquared()) for pt in pts ] if A != proj0: pts.reverse() format = GeomVertexFormat.getV3c4t2() vertex_data = GeomVertexData('arc_ball', format, Geom.UHStatic) vertex_writer = GeomVertexWriter(vertex_data, 'vertex') color_writer = GeomVertexWriter(vertex_data, 'color') texture_writer = GeomVertexWriter(vertex_data, 'texcoord') triStrip = GeomTristrips(Geom.UHStatic) cross = pts[0].cross(pts[1] - pts[0]) cross.normalize() cross *= width / 2.0 pt = pts[0] vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) texture_writer.addData2f(0, 1) texture_writer.addData2f(1, 1) diffA = pts[1] - pts[0] diffB = pts[2] - pts[1] cross = pts[1].cross((diffB + diffA) / 2.0) cross.normalize() cross *= width / 2.0 pt = pts[1] vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) texture_writer.addData2f(0, 0) texture_writer.addData2f(1, 0) triStrip.addNextVertices(4) geometry = Geom(vertex_data) geometry.addPrimitive(triStrip) self.head_geom_node.addGeom(geometry) format = GeomVertexFormat.getV3c4t2() vertex_data = GeomVertexData('arc_ball', format, Geom.UHStatic) vertex_writer = GeomVertexWriter(vertex_data, 'vertex') color_writer = GeomVertexWriter(vertex_data, 'color') texture_writer = GeomVertexWriter(vertex_data, 'texcoord') triStrip = GeomTristrips(Geom.UHStatic) for x in range(len(pts[1:-1])): cross = pts[x + 1].cross(pts[x + 2] - pts[x]) cross.normalize() cross *= width / 2.0 pt = pts[x + 1] vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) if x % 2: texture_writer.addData2f(0, 1) texture_writer.addData2f(1, 1) else: texture_writer.addData2f(0, 0) texture_writer.addData2f(1, 0) triStrip.addNextVertices(2) cross = pts[-1].cross(pts[-1] - pts[-2]) cross.normalize() cross *= width / 2.0 pt = pts[-1] vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) if N % 2: texture_writer.addData2f(0, 0) texture_writer.addData2f(1, 0) else: texture_writer.addData2f(0, 1) texture_writer.addData2f(1, 1) triStrip.addNextVertices(2) geometry = Geom(vertex_data) geometry.addPrimitive(triStrip) self.tail_geom_node.addGeom(geometry)
def __watchControls(self, task): dt = globalClock.getDt() curVelocity = self.actorNode.getPhysicsObject().getVelocity() curSpeed = curVelocity.length() fvec = self.forward.getPos(render) - self.getPos(render) fvec.normalize() dotProduct = curVelocity.dot(fvec) goingBack = -1 if dotProduct < 0: goingBack = 1 if self.proRacer: self.__computeTurnRatio(curSpeed) self.__updateWheelPos(dt, curSpeed) newHForTurning = self.getH() if self.proRacer or not self.stopped and self.arrowHorz and curSpeed > 1: if self.proRacer: turnHelp = 0 if self.hittingWall or goingBack == 1: turnHelp = self.arrowHorz effectiveSpeed = curSpeed if effectiveSpeed > self.speedMinTurn: effectiveSpeed = self.speedMinTurn rotation = -goingBack * (self.wheelPosition * dt * self.turnRatio * -1.8 * curSpeed / 100 + turnHelp * dt * self.turnRatio * -1.2) self.outPutCounter += 1 if self.outPutCounter > 5: self.outPutCounter = 0 else: rotation = self.arrowHorz * dt * self.turnRatio * -1.2 oldH = self.getH() newH = (oldH + rotation) % 360 self.setH(newH) newHForTurning = newH if self.groundType == 'ice': newHForTurning = (oldH + rotation * iceTurnFactor) % 360 pitch = -self.getP() + 5 accelBase = self.accelerationBase pitch += accelBase pitch = clampScalar(pitch, accelBase - 5, accelBase + 5) self.accelerationMult = pitch * 2 if self.groundType == 'ice': self.accelerationMult *= iceAccelFactor if self.stopped: self.acceleration = 0 else: self.acceleration = self.arrowVert * self.accelerationMult * self.cheatFactor if self.proRacer: if self.skidding: self.acceleration = self.arrowVert * self.accelerationMult * self.cheatFactor * 0.5 if self.turbo: self.acceleration += self.accelerationMult * 1.5 self.engine.setVector(Vec3(0, self.acceleration, 0)) if self.groundType == 'ice': rotMat = Mat3.rotateMatNormaxis(newHForTurning, Vec3.up()) else: rotMat = Mat3.rotateMatNormaxis(self.getH(), Vec3.up()) curHeading = rotMat.xform(Vec3.forward()) push = (3 - self.getP()) * 0.02 curHeading.setZ(curHeading.getZ() - min(0.2, max(-.2, push))) onScreenDebug.append('vehicle curHeading = %s\n' % curHeading.pPrintValues()) onScreenDebug.append('vehicle H = %s newHForTurning=%f\n' % (self.getH(), newHForTurning)) windResistance = self.surfaceModifiers[self.groundType]['windResistance'] self.windResistance.setCoef(windResistance) physicsFrame = int((globalClock.getFrameTime() - self.physicsEpoch) * self.physicsCalculationsPerSecond) numFrames = min(physicsFrame - self.lastPhysicsFrame, self.maxPhysicsFrames) self.lastPhysicsFrame = physicsFrame leanIncrement = self.arrowHorz * self.physicsDt * self.turnRatio if self.stopped: leanIncrement = 0 driftMin = self.surfaceModifiers[self.groundType]['driftMin'] if self.proRacer: driftMin = self.surfaceModifiers[self.groundType]['driftMin'] * 0.2 if self.skidding: driftMin = self.surfaceModifiers[self.groundType]['driftMin'] for i in range(int(numFrames)): self.physicsMgr.doPhysics(self.physicsDt) curVelocity = self.actorNode.getPhysicsObject().getVelocity() idealVelocity = curHeading * curSpeed curVelocity *= self.imHitMult driftVal = abs(self.leanAmount) * 16 / self.cheatFactor + 15 / self.cheatFactor curVelocity = Vec3((curVelocity * driftVal + idealVelocity) / (driftVal + 1)) curSpeed = curVelocity.length() curVelocity.normalize() curVelocity *= min(curSpeed, 600) self.actorNode.getPhysicsObject().setVelocity(curVelocity) curSpeed = curVelocity.length() speedFactor = min(curSpeed, 150) / 162.0 self.leanAmount = (self.leanAmount + leanIncrement) * speedFactor self.leanAmount = clampScalar(self.leanAmount, -10, 10) self.cWallTrav.traverse(render) self.curSpeed = curSpeed if self.proRacer: self.turnWheels(self.wheelPosition * -45) else: self.turnWheels(self.arrowHorz * -10) self.__animate() if self.proRacer: speedProporation = 1.0 if curSpeed < self.speedMaxTurn: speedProporation = 0.0 else: speedProporation = (curSpeed - self.speedMaxTurn) / self.speedMinTurn cameraDist = self.cameraArmBase + self.cameraArmExtend * speedProporation cameraOffset = Point3(0, -cameraDist, 0) self.cameraNode.setPos(cameraOffset) behindPos = render.getRelativePoint(self, Point3(0, -30, 0)) self.proCameraDummyNode.setPos(render, behindPos) self.proCameraDummyNode.lookAt(self) self.cameraNode.lookAt(self) dir1 = self.proCameraDummyNode.getH() dir2 = self.proCameraHeading if dir1 > 180: dir1 -= 360 elif dir1 < -180: dir1 += 360 if dir2 > 180: dir2 -= 360 elif dir2 < -180: dir2 += 360 self.proCameraHeading = dir2 dif = dir1 - dir2 if dif > 180: dif -= 360 elif dif < -180: dif += 360 speedDif = abs(dif) if speedDif > 90: speedDif = 90 cameraTightener = 1.0 if curSpeed > self.speedMinTurn: cameraTightener = self.cameraTightener else: cameraTightener = 1.0 + curSpeed / self.speedMinTurn * (self.cameraTightener - 1.0) swingSpeedRatio = speedDif / 90 swingSpeed = self.armSwingSpeedPerp * swingSpeedRatio + self.armSwingSpeedPara * (1 - swingSpeedRatio) self.proCameraHeading += dif * cameraTightener * (dt / swingSpeed) self.cameraArmNode.setH(self.proCameraHeading - self.getH()) elif not self.stopped: self.cameraNode.setH(self.leanAmount) self.updateParticles(self.leanAmount) if (self.leanAmount > 8 or self.leanAmount < -8) and self.offGround <= 0: self.startSkid() else: self.stopSkid() if self.speedometer: self.speedometer['text'] = str(int(curSpeed / 3)) self.speedGauge.setR(min(110, max(0, curSpeed / 3 / 120 * 110))) if not self.stopped: self.stickCarToGround() if self.__clampPosition(): self.notify.debug('did a clampPosition on %d' % self.doId) return Task.cont
def createStraightArrow(self, p0, p1, width): p0.normalize() p1.normalize() dot = p0.dot(p1) cross = p0.cross(p1) arcLen = math.acos(clampScalar(-1, 1, dot)) self.tail_geom_node.removeAllGeoms() self.head_geom_node.removeAllGeoms() if arcLen > 0.0: cross.normalize() cross *= width / 2.0 theta = 2 * math.asin(width / 2.0) div = arcLen / theta steps = int(div) remainder = div - steps pts = [] for n in range(steps + 1): pts.append(sLerp(p1, p0, n / div, arcLen) * self._radius) format = GeomVertexFormat.getV3c4t2() vertex_data = GeomVertexData('arc_ball', format, Geom.UHStatic) vertex_writer = GeomVertexWriter(vertex_data, 'vertex') color_writer = GeomVertexWriter(vertex_data, 'color') texture_writer = GeomVertexWriter(vertex_data, 'texcoord') triStrip = GeomTristrips(Geom.UHStatic) if len(pts) == 1: vertex_writer.addData3f(p1[0] - cross[0], p1[1] - cross[1], p1[2] - cross[2]) vertex_writer.addData3f(p1[0] + cross[0], p1[1] + cross[1], p1[2] + cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) texture_writer.addData2f(1, 1) texture_writer.addData2f(0, 1) vertex_writer.addData3f(p0[0] - cross[0], p0[1] - cross[1], p0[2] - cross[2]) vertex_writer.addData3f(p0[0] + cross[0], p0[1] + cross[1], p0[2] + cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) texture_writer.addData2f(1, 1 - remainder) texture_writer.addData2f(0, 1 - remainder) triStrip.addNextVertices(4) else: for pt in pts[:2]: vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) texture_writer.addData2f(1, 1) texture_writer.addData2f(0, 1) texture_writer.addData2f(1, 0) texture_writer.addData2f(0, 0) triStrip.addNextVertices(4) geometry = Geom(vertex_data) geometry.addPrimitive(triStrip) self.head_geom_node.addGeom(geometry) format = GeomVertexFormat.getV3c4t2() vertex_data = GeomVertexData('arc_ball', format, Geom.UHStatic) vertex_writer = GeomVertexWriter(vertex_data, 'vertex') color_writer = GeomVertexWriter(vertex_data, 'color') texture_writer = GeomVertexWriter(vertex_data, 'texcoord') triStrip = GeomTristrips(Geom.UHStatic) for pt in pts[1:]: vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) numPts = len(pts[1:]) for x in range(numPts / 2): texture_writer.addData2f(1, 1) texture_writer.addData2f(0, 1) texture_writer.addData2f(1, 0) texture_writer.addData2f(0, 0) if numPts % 2: texture_writer.addData2f(1, 1) texture_writer.addData2f(0, 1) vertex_writer.addData3f(p0[0] - cross[0], p0[1] - cross[1], p0[2] - cross[2]) vertex_writer.addData3f(p0[0] + cross[0], p0[1] + cross[1], p0[2] + cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) if numPts % 2: texture_writer.addData2f(1, 1 - remainder) texture_writer.addData2f(0, 1 - remainder) else: texture_writer.addData2f(1, remainder) texture_writer.addData2f(0, remainder) triStrip.addNextVertices(numPts * 2 + 2) geometry = Geom(vertex_data) geometry.addPrimitive(triStrip) self.tail_geom_node.addGeom(geometry)
def updatePlayer(self, task): if self.pause: return task.cont if self.can_move == False: return task.cont if getTile( self.node.getPos() ) == self.parent.level.finish_tile: self.parent.gameWin() #monsters only think once per second so we need to keep gunshots remembered for at least 2 seconds if self.gunshot_at: if time.time() - self.gunshot_at[1] > GUNSHOT_TIMEOUT: self.gunshot_at = None self.cooldown( globalClock.getDt() ) if self.parent.type == 'FPS': md = base.win.getPointer(0) x = md.getX() y = md.getY() if self.mouse_owner and base.win.movePointer(0, self.centerx, self.centery): h, p, r = self.node.getHpr() h += (x - self.centerx) * -0.2 p += (y - self.centery) * -0.2 p = clampScalar(p, -80.0, 80.0) self.node.setHpr(h, p, 0) speed1 = 0 speed2 = 0 if self.keys['sprint']: player_speed = self.sprint_speed else: player_speed = self.speed if self.keys['forward']: speed1 = player_speed * globalClock.getDt() if self.keys['back']: speed1 = -player_speed * globalClock.getDt() if self.keys['strafe_left']: speed2 = -player_speed * globalClock.getDt() if self.keys['strafe_right']: speed2 = player_speed * globalClock.getDt() if speed1 or speed2: if self.keys['sprint']: self.sprint = True else: self.sprint = False self.moving = True else: self.moving = False self.sprint = False self.node.setFluidZ(TILE_SIZE*ASPECT/1.5) self.node.setFluidPos(self.node, speed2, speed1, 0) elif self.parent.type == 'DEBUG': speed1 = 0 speed2 = 0 if self.keys['forward']: speed1 = self.speed * globalClock.getDt() if self.keys['back']: speed1 = -self.speed * globalClock.getDt() if self.keys['strafe_left']: speed2 = -self.speed * globalClock.getDt() if self.keys['strafe_right']: speed2 = self.speed * globalClock.getDt() if speed1 or speed2: self.moving = True else: self.moving = False self.node.setFluidZ(TILE_SIZE*ASPECT/1.5) self.node.setFluidPos(self.node, speed2, speed1, 0) return task.cont
def createCurvedArrow(self, axis, p0, p1, width, numPanels=10): N = numPanels self.tail_geom_node.removeAllGeoms() self.head_geom_node.removeAllGeoms() axis = axis / axis.length() dot0 = axis.dot(p0) proj0 = p0 - axis * dot0 dot1 = axis.dot(p1) proj1 = p1 - axis * dot1 theta = math.acos( clampScalar(-1, 1, proj0.dot(proj1) / proj0.length() * proj1.length())) if not proj0.almostEqual(proj1, 0.0001) and theta != 0: if proj0.lengthSquared() >= proj1.lengthSquared(): A = proj0 C = proj1 else: A = proj1 C = proj0 a = A.length() aUnit = A / a x = A.dot(C) / a yy = C.lengthSquared() - x * x bUnit = A.cross(C).cross(A) bUnit.normalize() b = math.sqrt(max(0.0, yy / (1 - x * x / a * a))) t = math.atan2(a, b / math.tan(theta)) aUnit *= a bUnit *= b pts = [ aUnit * math.cos(x * t / N) + bUnit * math.sin(x * t / N) for x in range(N + 1) ] pts = [ pt + axis * math.sqrt(self._radius * self._radius - pt.lengthSquared()) for pt in pts ] if A != proj0: pts.reverse() format = GeomVertexFormat.getV3c4t2() vertex_data = GeomVertexData('arc_ball', format, Geom.UHStatic) vertex_writer = GeomVertexWriter(vertex_data, 'vertex') color_writer = GeomVertexWriter(vertex_data, 'color') texture_writer = GeomVertexWriter(vertex_data, 'texcoord') triStrip = GeomTristrips(Geom.UHStatic) cross = pts[0].cross(pts[1] - pts[0]) cross.normalize() cross *= width / 2.0 pt = pts[0] vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) texture_writer.addData2f(0, 1) texture_writer.addData2f(1, 1) diffA = pts[1] - pts[0] diffB = pts[2] - pts[1] cross = pts[1].cross((diffB + diffA) / 2.0) cross.normalize() cross *= width / 2.0 pt = pts[1] vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) texture_writer.addData2f(0, 0) texture_writer.addData2f(1, 0) triStrip.addNextVertices(4) geometry = Geom(vertex_data) geometry.addPrimitive(triStrip) self.head_geom_node.addGeom(geometry) format = GeomVertexFormat.getV3c4t2() vertex_data = GeomVertexData('arc_ball', format, Geom.UHStatic) vertex_writer = GeomVertexWriter(vertex_data, 'vertex') color_writer = GeomVertexWriter(vertex_data, 'color') texture_writer = GeomVertexWriter(vertex_data, 'texcoord') triStrip = GeomTristrips(Geom.UHStatic) for x in range(len(pts[1:-1])): cross = pts[x + 1].cross(pts[x + 2] - pts[x]) cross.normalize() cross *= width / 2.0 pt = pts[x + 1] vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) if x % 2: texture_writer.addData2f(0, 1) texture_writer.addData2f(1, 1) else: texture_writer.addData2f(0, 0) texture_writer.addData2f(1, 0) triStrip.addNextVertices(2) cross = pts[-1].cross(pts[-1] - pts[-2]) cross.normalize() cross *= width / 2.0 pt = pts[-1] vertex_writer.addData3f(pt[0] + cross[0], pt[1] + cross[1], pt[2] + cross[2]) vertex_writer.addData3f(pt[0] - cross[0], pt[1] - cross[1], pt[2] - cross[2]) color_writer.addData4f(0, 1, 0, 1) color_writer.addData4f(0, 1, 0, 1) if N % 2: texture_writer.addData2f(0, 0) texture_writer.addData2f(1, 0) else: texture_writer.addData2f(0, 1) texture_writer.addData2f(1, 1) triStrip.addNextVertices(2) geometry = Geom(vertex_data) geometry.addPrimitive(triStrip) self.tail_geom_node.addGeom(geometry)
def cameraZoom(self,zoomFactor,): """Scale and clamp zoom level, then set distance by it.""" self.zoomLvl=clampScalar(self.zoomLvl*zoomFactor,*self.zoomClamp) self.setDist(self.zoomLvl)
def rotateCam(self,arc): """Setup a lerp interval to rotate the camera about the target.""" newP=clampScalar(self.target.getP()-arc.getY(),*self.clampP)#Clamped. newH=self.target.getH()+arc.getX()#Not clamped, just added. LERP.LerpHprInterval(self.target, self.speed,#Setup the interval\ P.Vec3(newH,newP,self.target.getR(), ), ).start()#and start it.
def update(self, time): placeSorter = [] placeCount = 0 for key in self.racerDict.keys(): racer = self.racerDict[key] curvetime = racer.curvetime face = racer.face mapspot = racer.mapspot maxlaphit = racer.maxlaphit if not racer.finished and racer.enabled: placeSorter.append((curvetime, key)) if racer.finished or racer.enabled: placeCount += 1 pt = Vec3(0, 0, 0) mapT = (curvetime % 1 + self.race.startT / self.race.curve.getMaxT()) % 1 * self.race.curve.getMaxT() self.race.curve.getPoint(mapT, pt) self.race.curve.getPoint(mapT % self.race.curve.getMaxT(), pt) lapT = clampScalar(curvetime / self.race.lapCount, 0.0, 1.0) faceX = self.faceStartPos[0] * (1 - lapT) + self.faceEndPos[0] * lapT racer.update(faceX=faceX, mapspotPt=pt) t = time - self.race.baseTime - self.raceTimeDelta if key == localAvatar.doId: if self.race.laps > maxlaphit: racer.update(maxlaphit=self.race.laps) self.maxLapHit = racer.maxlaphit if self.maxLapHit < self.race.lapCount: for y in self.timeLabels[self.maxLapHit - 1]: y.configure( text_font=ToontownGlobals.getSignFont()) for y in self.timeLabels[self.maxLapHit]: y.show() for y in self.timeLabels[self.maxLapHit]: y.configure( text_font=ToontownGlobals.getSignFont()) self.raceTimeDelta = globalClock.getFrameTime( ) - self.race.baseTime lapNotice = DirectLabel() lapNotice.setScale(0.1) if self.maxLapHit == self.race.lapCount - 1: lapNotice[ 'text'] = TTLocalizer.KartRace_FinalLapText else: lapNotice[ 'text'] = TTLocalizer.KartRace_LapText % str( self.maxLapHit + 1) taskMgr.doMethodLater(2, lapNotice.remove, 'removeIt', extraArgs=[]) self.lapLabel['text'] = str( clampScalar(self.maxLapHit + 1, 1, self.race.lapCount)) + '/' + str( self.race.lapCount) suffix = { 1: TTLocalizer.KartRace_FirstSuffix, 2: TTLocalizer.KartRace_SecondSuffix, 3: TTLocalizer.KartRace_ThirdSuffix, 4: TTLocalizer.KartRace_FourthSuffix } placeSorter.sort() for x, p in zip(placeSorter, xrange(len(placeSorter), 0, -1)): self.racerDict[x[1]].update(place=p + placeCount - len(placeSorter)) localRacer = self.racerDict[localAvatar.doId] nearDiff, farDiff = RaceGlobals.TrackDict[self.race.trackId][8] if not localRacer.finished and self.faceEndPos[ 0] - localRacer.face.getX() < nearDiff: for racerId in self.racerDict.keys(): racer = self.racerDict[racerId] if not racer.enabled or racerId == localAvatar.doId or racer.face.getX( ) >= self.faceEndPos[0]: continue if self.faceEndPos[0] - racer.face.getX() < farDiff: self.photoFinish = True if self.photoFinish: self.photoFinishLabel.show() self.placeLabelNum['text'] = '' self.placeLabelStr['text'] = '' else: self.photoFinishLabel.hide() self.placeLabelNum['text'] = str( self.racerDict[localAvatar.doId].place) self.placeLabelStr['text'] = suffix[self.racerDict[ localAvatar.doId].place] minutes = int(t / 60) t -= minutes * 60 seconds = int(t) padding = (seconds < 10 and ['0'] or [''])[0] t -= seconds fraction = str(t)[2:4] fraction = fraction + '0' * (2 - len(fraction)) if self.timerEnabled and self.maxLapHit < self.race.lapCount: self.timeLabels[self.maxLapHit][0]['text'] = "%d'" % minutes self.timeLabels[self.maxLapHit][1]['text'] = "%s%d''" % (padding, seconds) self.timeLabels[self.maxLapHit][2]['text'] = '%s' % fraction if self.race.wrongWay and not self.wrongWaySeq.isPlaying(): self.wrongWaySeq.loop() elif not self.race.wrongWay and self.wrongWaySeq.isPlaying(): self.wrongWaySeq.finish()
def addToMood(self, component, delta): value = self.mood.getComponent(component) value += delta self.setMoodComponent(component, clampScalar(value, 0.0, 1.0))
def doDrift(curValue, timeToMedian, dt = float(dt)): newValue = curValue + dt / (timeToMedian * 7200) return clampScalar(newValue, 0.0, 1.0)
def setZoom(self, zoom): self._zoom = clampScalar(0.0, 0.75, zoom) self.buffer.camera.setY(lerp(self.camY[0], self.camY[1], self._zoom)) self.mapBall._setTiltLimit(lerp(self.tiltLimit[0], self.tiltLimit[1], self._zoom)) self.mapBall.updateTextZoom(self._zoom)