def remove(self, job): jobId = job._getJobId() # look up the job's priority pri = self._jobId2pri.pop(jobId) # TODO: this removal is a linear search self._pri2jobIds[pri].remove(jobId) # remove the job from the main table del self._pri2jobId2job[pri][jobId] # clean up the job's generator, if any job._cleanupGenerator() # remove the job's timeslice count self._jobId2timeslices.pop(jobId) # remove the overflow time self._jobId2overflowTime.pop(jobId) if len(self._pri2jobId2job[pri]) == 0: del self._pri2jobId2job[pri] if pri == self._highestPriority: if len(self._jobId2pri) > 0: # calculate a new highest priority # TODO: this is not very fast priorities = self._getSortedPriorities() self._highestPriority = priorities[-1] else: taskMgr.remove(JobManager.TaskName) self._highestPriority = 0 self.notify.debug('removed job: %s' % job.getJobName())
def shutdown(self): taskMgr.remove('eventManager') # Flush the event queue. We do this after removing the task # since the task removal itself might also fire off an event. if self.eventQueue is not None: self.eventQueue.clear()
def prepareForPickle(self): self.colTraverser = None # Traversers are not picklable self.defaultBitMask = None # BitMasks "..." # self.grabIntoBitMask = None # "..." self.colHandlerQueue = None # CollisonHandlerQueue "..." self.grabModelNP.removeNode() self.grabModelNP = None taskMgr.remove('scaleGrabber')
def disable(self): """ Detaches any existing sounds and removes the update task """ taskMgr.remove("Audio3DManager-updateTask") self.detachListener() for object in list(self.sound_dict.keys()): for sound in self.sound_dict[object]: self.detachSound(sound)
def __removeTask(self): # Kill old task(s), including those from a similarly-named but # different interval. taskName = self.getName() + '-play' oldTasks = taskMgr.getTasksNamed(taskName) for task in oldTasks: if hasattr(task, "interval"): task.interval.privInterrupt() taskMgr.remove(task)
def handleM1Up(self): """Stop dragging the selected object.""" taskMgr.remove('mouse1Dragging') self.isDragging = False self.currTransformOperation = None # NOTE other references have been added, but no other object references them # record the mouse1 operation BBGlobalVars.undoHandler.record(self.selected, CommandUndo([self.initialCommandTrgVal], self.selected.setMat, self.selected.getMat(render))) messenger.ignore('mouse1-up', self)
def avatarChoseQuest(self, avId, npc, questId, rewardId, building): toon = self.air.doId2do.get(avId) if not toon: return fromNpc = Quests.getQuestFromNpcId(questId) toNpc = Quests.getQuestToNpcId(questId) toon.addQuest([questId, fromNpc, toNpc, rewardId, 0], 0, recordHistory = 0) npc.assignQuest(avId, questId, rewardId, toNpc) taskMgr.remove(npc.uniqueName('clearMovie'))
def setDeferInterval(self, deferInterval): """Specifies the minimum amount of time, in seconds, that must elapse before generating any two DistributedObjects whose class type is marked "deferrable". Set this to 0 to indicate no deferring will occur.""" self.deferInterval = deferInterval self.setHandleCUpdates(self.deferInterval == 0) if self.deferredGenerates: taskMgr.remove('deferredGenerate') taskMgr.doMethodLater(self.deferInterval, self.doDeferredGenerate, 'deferredGenerate')
def shrink(db): db['text2_text'] = 'Hi!' taskMgr.remove('shrink') taskMgr.remove('expand') # Get a handle on the geometry for the rollover state rolloverSmiley = db.component('geom2') rolloverSmiley.setScale(db.component('geom0').getScale()[0]) rolloverSmiley.lerpScale(.1, .1, .1, 1.0, blendType='easeInOut', task='shrink')
def destroy(self): if hasattr(self, '_leakTaskName'): taskMgr.remove(self._leakTaskName) for leaker in self._leakers: leaker.ignoreAll() self._leakers = None if self._createJob: self._createJob.destroy() self._createJob = None for typeName, detector in self._typeName2detector.items(): detector.destroy() del self._typeName2detector LeakDetector.destroy(self)
def editStart(self, event): taskMgr.remove('guiEditTask') vWidget2render2d = self.getPos(ShowBaseGlobal.render2d) vMouse2render2d = Point3(event.getMouse()[0], 0, event.getMouse()[1]) editVec = Vec3(vWidget2render2d - vMouse2render2d) if base.mouseWatcherNode.getModifierButtons().isDown( KeyboardButton.control()): t = taskMgr.add(self.guiScaleTask, 'guiEditTask') t.refPos = vWidget2render2d t.editVecLen = editVec.length() t.initScale = self.getScale() else: t = taskMgr.add(self.guiDragTask, 'guiEditTask') t.editVec = editVec
def startSmooth(self): """ This function starts the task that ensures the node is positioned correctly every frame. However, while the task is running, you won't be able to lerp the node or directly position it. """ if not self.wantsSmoothing() or self.isDisabled() or self.isLocal(): return if not self.smoothStarted: taskName = self.taskName("smooth") taskMgr.remove(taskName) self.reloadPosition() taskMgr.add(self.doSmoothTask, taskName) self.smoothStarted = 1
def remove_task(): if MotionTrail.task_added: total_motion_trails = len(MotionTrail.motion_trail_list) if total_motion_trails > 0: print( "warning: %d motion trails still exist when motion trail task is removed" % (total_motion_trails)) MotionTrail.motion_trail_list = [] taskMgr.remove(MotionTrail.motion_trail_task_name) print("MotionTrail task removed") MotionTrail.task_added = False
def abortRequest(self, tuple): """ Aborts a previous request. The parameter is the return value from a previous call to requestObjects(). The pending request is removed from the queue and no further callbacks will be called. See Also: requestObjects() """ if tuple: allCallback, eachCallback, timeoutCallback, doIdsPending, doIdList, doLaterName = tuple assert self.notify.debug( "aborting request for %s (remaining: %s)" % (doIdList, doIdsPending)) if doLaterName: taskMgr.remove(doLaterName) self.__removePending(tuple, doIdsPending)
def remove(self, job): jobId = job._getJobId() pri = self._jobId2pri.pop(jobId) self._pri2jobIds[pri].remove(jobId) del self._pri2jobId2job[pri][jobId] job._cleanupGenerator() self._jobId2timeslices.pop(jobId) self._jobId2overflowTime.pop(jobId) if len(self._pri2jobId2job[pri]) == 0: del self._pri2jobId2job[pri] if pri == self._highestPriority: if len(self._jobId2pri) > 0: priorities = self._getSortedPriorities() self._highestPriority = priorities[-1] else: taskMgr.remove(JobManager.TaskName) self._highestPriority = 0 self.notify.debug('removed job: %s' % job.getJobName())
def remove_task(): if MotionTrail.task_added: total_motion_trails = len(MotionTrail.motion_trail_list) if total_motion_trails > 0: if __debug__: warnings.warn( "%d motion trails still exist when motion trail task is removed" % (total_motion_trails), RuntimeWarning, stacklevel=2) MotionTrail.motion_trail_list = [] taskMgr.remove(MotionTrail.motion_trail_task_name) print("MotionTrail task removed") MotionTrail.task_added = False
def abortAllRequests(self): """ Call this method to abruptly abort all pending requests, but leave the RelatedObjectMgr in a state for accepting more requests. """ # Stop listening for all events. self.ignoreAll() # Iterate through all the pendingObjects and stop any pending # tasks. for pendingList in self.pendingObjects.values(): for tuple in pendingList: allCallback, eachCallback, timeoutCallback, doIdsPending, doIdList, doLaterName = tuple if doLaterName: taskMgr.remove(doLaterName) self.pendingObjects = {}
def cleanup(self): if not self.cleanedUp: self.cleanedUp = True # Remove the window. base.graphicsEngine.removeWindow(self.win) self.win = None self.gsg = None self.pipe = None # Remove the mouse. self.mouse.detachNode() taskMgr.remove(self.task) self.ignoreAll() self.canvas.getChildren().detach() self.texRecordsByTex = {} self.texRecordsByKey = {} self.texPlacements = {}
def startPosHprBroadcast(self, period=.2, stagger=0, type=None): if self.cnode is None: self.initializeCnode() BT = DistributedSmoothNodeBase.BroadcastTypes if type is None: type = BT.FULL # set the broadcast type self.broadcastType = type broadcastFuncs = { BT.FULL: self.cnode.broadcastPosHprFull, BT.XYH: self.cnode.broadcastPosHprXyh, BT.XY: self.cnode.broadcastPosHprXy, } # this comment is here so it will show up in a grep for 'def d_broadcastPosHpr' self.d_broadcastPosHpr = broadcastFuncs[self.broadcastType] # Set stagger to non-zero to randomly delay the initial task execution # over 'period' seconds, to spread out task processing over time # when a large number of SmoothNodes are created simultaneously. taskName = self.getPosHprBroadcastTaskName() # Set up telemetry optimization variables self.cnode.initialize(self, self.dclass, self.doId) self.setPosHprBroadcastPeriod(period) # Broadcast our initial position self.b_clearSmoothing() self.cnode.sendEverything() # remove any old tasks taskMgr.remove(taskName) # spawn the new task delay = 0. if stagger: delay = randFloat(period) if self.wantSmoothPosBroadcastTask(): taskMgr.doMethodLater(self.__broadcastPeriod + delay, self._posHprBroadcast, taskName)
def arbitraryShadow(node): # Turn off the existing drop shadow, if any if hasattr(node, "dropShadow"): # stash it so that when the game hides and shows it, it will still be gone node.dropShadow.stash() # Set up a new node to hold the "light": this is an abitrary point # somewhere above the node, looking down, as if from the sun. objectPath = node shadowCamera = objectPath.attachNewNode('shadowCamera') lightPath = shadowCamera.attachNewNode('lightPath') # We can change this position at will to change the angle of the # sun. lightPath.setPos(50, 0, 50) # We need a task to keep the shadowCamera rotated in the same # direction relative to render (otherwise, the shadow seems to # rotate when you rotate your avatar, which is strange). We can't # just use a compass effect, since that doesn't work on cameras. def shadowCameraRotate(task, shadowCamera = shadowCamera): shadowCamera.setHpr(render, 0, 0, 0) lightPath.lookAt(shadowCamera, 0, 0, 3) return Task.cont taskMgr.remove('shadowCamera') taskMgr.add(shadowCameraRotate, 'shadowCamera') global sc if sc is not None: sc.clear() sc = ShadowCaster(lightPath, objectPath, 100, 100) # Naively, just apply the shadow to everything in the world. It # would probably be better to use a little restraint. sc.setGround(render) return sc
def __generated(self, object): # The indicated object has been generated. doId = object.doId assert self.notify.debug("Got generate from %s" % (doId)) pendingList = self.pendingObjects[doId] del self.pendingObjects[doId] for tuple in pendingList: allCallback, eachCallback, timeoutCallback, doIdsPending, doIdList, doLaterName = tuple # Here we are depending on Python to unify this one list # across all objects that share it. When we remove our # doId from our reference to the list, it is also removed # from all the other references. doIdsPending.remove(doId) if eachCallback: eachCallback(object) if len(doIdsPending) == 0: # That was the last doId on the list. Call the # allCallback! assert self.notify.debug("All objects generated on list: %s" % (doIdList, )) if doLaterName: taskMgr.remove(doLaterName) objects, doIdsPending = self.__generateObjectList(doIdList) if None in objects: assert self.notify.warning( 'calling %s with None.\n objects=%s\n doIdsPending=%s\n doIdList=%s\n' % (allCallback, objects, doIdsPending, doIdList)) if allCallback: allCallback(objects) else: assert self.notify.debug("Objects still pending: %s" % (doIdsPending))
def lerpBackgroundColor(r, g, b, duration): """ Function to lerp background color to a new value """ def lerpColor(state): dt = base.clock.getDt() state.time += dt sf = state.time / state.duration if sf >= 1.0: base.setBackgroundColor(state.ec[0], state.ec[1], state.ec[2]) return Task.done else: r = sf * state.ec[0] + (1 - sf) * state.sc[0] g = sf * state.ec[1] + (1 - sf) * state.sc[1] b = sf * state.ec[2] + (1 - sf) * state.sc[2] base.setBackgroundColor(r, g, b) return Task.cont taskMgr.remove('lerpBackgroundColor') t = taskMgr.add(lerpColor, 'lerpBackgroundColor') t.time = 0.0 t.duration = duration t.sc = base.getBackgroundColor() t.ec = VBase4(r, g, b, 1)
def ouch(db): taskMgr.remove('shrink') taskMgr.remove('expand') taskMgr.remove('runAway') db.component('geom0').setScale(db.component('geom2').getScale()[0]) db.component('geom1').setScale(db.component('geom2').getScale()[0]) db['text2_text'] = 'Ouch!' db['geom2_color'] = (1, 0, 0, 1) newX = -1.0 + random() * 2.0 newZ = -1.0 + random() * 2.0 db.lerpPos(Point3(newX, 0, newZ), 1.0, task='runAway', blendType='easeOut')
def cleanup(self): """ Interrupts all pending downloads. No further callbacks will be made. """ self.packageLock.acquire() try: if self.descFileTask: taskMgr.remove(self.descFileTask) self.descFileTask = None if self.downloadTask: taskMgr.remove(self.downloadTask) self.downloadTask = None finally: self.packageLock.release() if self.progressTask: taskMgr.remove(self.progressTask) self.progressTask = None self.ignoreAll()
def destroy(self): messenger.ignoreAll(self) self.detachNode() taskMgr.remove(self.task)
def __buttonUp(self, event): assert self.notify.debugStateCall(self) taskName = self.taskName('repeatStep') #print 'buttonUp: removing ', taskName taskMgr.remove(taskName)
def exit(self): taskMgr.remove(self.task_) if self.elapsed_ < PLAY_TASK_DELAY: logging.info("Exited task early after %f seconds instead of %f"%(self.elapsed_,PLAY_TASK_DELAY)) else: logging.info("Exited task at %f seconds"%(self.elapsed_))
def tearDownClass(cls): taskMgr.remove('Joystick Polling') cls.cb.close() del cls.cb print 'tore down'
def startCheckingIncomingHTTP(self, interval=0.3): taskMgr.remove('pollHTTPTask') taskMgr.doMethodLater(interval,self.pollHTTPTask,'pollHTTPTask')
def avatarCancelled(self, npcId): npc = self.air.doId2do.get(npcId) if not npc: return taskMgr.remove(npc.uniqueName('clearMovie'))
def editStop(self, event): taskMgr.remove('guiEditTask')
def stop(self): taskMgr.remove('Update Timer Object')
def destroy(self): taskMgr.remove(JobManager.TaskName) del self._pri2jobId2job
def shutdown(self): taskMgr.remove('eventManager')
def removeTask(self): taskMgr.remove("EnemyUpdateTask#" + str(self.numNpc))
def stopPosHprBroadcast(self): taskMgr.remove(self.getPosHprBroadcastTaskName()) # Delete this callback because it maintains a reference to self self.d_broadcastPosHpr = None
def shutdown(self): # Should be safe to import the global taskMgr by now. from direct.task.TaskManagerGlobal import taskMgr taskMgr.remove('eventManager')
def collide2(self,f,collEntry): for i in self.highlighted_indices: if self.contacts[i] == False: return taskMgr.remove('too_long%d' % f)
def disable(self): taskMgr.remove(self.name + '-updateTask')
def collide3(self,f,collEntry): taskMgr.remove('too_long%d' % f) self.reset_fing(f) self.tar.setColorScale(0.1,0.1,0.1,1) self.tar.setAlphaScale(0.7)
def stopCheckingIncomingHTTP(self): taskMgr.remove('pollHTTPTask')
def destroy(self): if hasattr(self, '_leakTaskName'): taskMgr.remove(self._leakTaskName) del self._render LeakDetector.destroy(self)
def stopUpdateGridTask(self): taskMgr.remove(self.taskName("updateGridTask")) self.updateTaskStarted = 0
def stopActorControls(self): taskMgr.remove(self.id + '_UpdateTask')
def stopHeartbeat(self): taskMgr.remove("heartBeat") self.heartbeatStarted = 0
def shutdown(self): from direct.task.TaskManagerGlobal import taskMgr taskMgr.remove('eventManager')