def snek(hueRotation=0.0, saturationBoost=0.0): animationIndex = random.randint(0, 4) if pygame.key.get_mods() & pygame.locals.KMOD_LSHIFT: hueRotation = random.random() saturationBoost = random.random() * 0.2 images = spriteRow(16 + (32 * animationIndex), hueRotation, saturationBoost) sprite = Sprite(images, random.randint(0, 400), random.randint(0, 400)) moveSpeed = random.randint(50, 100) animateSpeed = random.randint(5, 35) animator = LoopingCall.withCount(sprite.animate) animator.start(1.0 / animateSpeed) mover = LoopingCall.withCount(Mover(sprite).move) mover.start(1.0 / moveSpeed) engine.drawables.append(sprite) sneks.append((animator, mover, sprite))
def start(self): """ Start the simulated advancement of time. """ self._call = LoopingCall.withCount(self._update) self._call.clock = self.platformClock self._call.start(1.0 / self.granularity, now=False)
def start(self): screen = pygame.display.set_mode(self.screen_size, vsync=1) def handle_events(): if self.game_state.state == locals.GAME_PLAY: if self.player.is_touching(self.goal): print("Touching!") self.game_state.state = locals.GAME_WIN for event in pygame.event.get(): if event.type == pygame.locals.KEYDOWN: handler = self.keydown_handlers.get(event.key) if handler: handler() elif event.type == pygame.locals.KEYUP: handler = self.keyup_handlers.get(event.key) if handler: handler() def draw_screen(): screen.fill(self.game_state.background_color) for drawable in self.drawables: drawable.draw(screen) pygame.display.flip() player_mover = LoopingCall.withCount(self.player.move) player_mover.start(1 / 60.0) LoopingCall(draw_screen).start(1.0 / 60.0) LoopingCall(handle_events).start(1.0 / 120.0)
def __init__(self, *args, **kwargs): self.dead = False self.type = None self.secure = False self.data = 0 self.data_checker = LoopingCall(self.checkData) self.pinger = LoopingCall.withCount(self.ping)
def __init__( self, reactor, request, request_rate=10, sample_size=DEFAULT_SAMPLE_SIZE, timeout=45, tolerance_percentage=0.2 ): """ ``RequestLoadScenario`` constructor. :param tolerance_percentage: error percentage in the rate that is considered valid. For example, if we request a ``request_rate`` of 20, and we give a tolerance_percentage of 0.2 (20%), anything in [16,20] will be a valid rate. """ self.reactor = reactor self.request = request self.request_rate = request_rate self.timeout = timeout self._maintained = Deferred() self.rate_measurer = RateMeasurer(sample_size) self.max_outstanding = 10 * request_rate self.tolerated_errors = 5 * request_rate # Send requests per second self.loop = LoopingCall.withCount(self._request_and_measure) self.loop.clock = self.reactor # Monitor the status of the scenario self.monitor_loop = LoopingCall(self.check_rate) self.monitor_loop.clock = self.reactor self.is_started = False self.rate_tolerated = ( float(request_rate) - (request_rate*tolerance_percentage) )
def start(self): """ Start the simulated advancement of time. """ self._call = LoopingCall.withCount(self._update) self._call.clock = reactor self._call.start(1.0 / self.framerate, now=False) self._running = True
def start(self): """ Start the simulated advancement of time. """ self._call = LoopingCall.withCount(self._update) self._call.clock = reactor self._call.start(1.0 / self.framerate, now=False) self._running = True
def start(self): """ Start the simulated advancement of time. """ print "Simulation Time Starting" self._call = LoopingCall.withCount(self._update) self._call.clock = self.platformClock self._call.start(1.0 / self.granularity, now=False)
def __init__(self, ip): self.dead = False self.type = None self.secure = False self.data = 0 self.data_checker = LoopingCall(self.checkData) self.pinger = LoopingCall.withCount(self.ping) self.connection_expire = reactor.callLater(15, self.connectionLost, None) self.ip = ip
def configure(self, config): room = self.original self._loop = LoopingCall.withCount(self.update) self._interval = 0.1 self.map, self.walk = gen_map() self.tick = 0 self.enemies = [] self.towers = [] self.spawned = 0 self.stats = defaultdict(int)
def configure(self, config): room = self.original self._loop = LoopingCall.withCount(self.update) self._interval = 0.1 self.map, self.walk = gen_map() self.tick = 0 self.enemies = [] self.towers = [] self.spawned = 0 self.stats = defaultdict(int)
def _start_audio_processing_loop(self, interval): looping_call = LoopingCall.withCount(self.process_audio_frame) d = looping_call.start(interval) def on_stop(data): print("The audio processing loop was stopped") def on_error(data): print("ERROR: An error occurred during the audio processing loop:", data) raise Exception("An error occurred during the audio processing loop:" + str(data)) d.addCallback(on_stop) d.addErrback(on_error) return d
def __init__( self, reactor, cluster, request_rate=10, sample_size=DEFAULT_SAMPLE_SIZE, timeout=45 ): self._maintained = Deferred() self.reactor = reactor self.control_service = cluster.get_control_service(reactor) self.request_rate = request_rate self.timeout = timeout self.rate_measurer = RateMeasurer(sample_size) self.max_outstanding = 10 * request_rate # Send requests per second self.loop = LoopingCall.withCount(self._request_and_measure) self.loop.clock = self.reactor self.monitor_loop = LoopingCall(self.check_rate) self.monitor_loop.clock = self.reactor
def __init__(self, reactor, cluster, request_rate=10, sample_size=DEFAULT_SAMPLE_SIZE, timeout=45): self._maintained = Deferred() self.reactor = reactor self.control_service = cluster.get_control_service(reactor) self.request_rate = request_rate self.timeout = timeout self.rate_measurer = RateMeasurer(sample_size) self.max_outstanding = 10 * request_rate # Send requests per second self.loop = LoopingCall.withCount(self._request_and_measure) self.loop.clock = self.reactor self.monitor_loop = LoopingCall(self.check_rate) self.monitor_loop.clock = self.reactor
def __init__( self, reactor, cluster, request_rate=10, sample_size=DEFAULT_SAMPLE_SIZE, timeout=45 ): self._maintained = Deferred() self.reactor = reactor self.control_service = cluster.get_control_service(reactor) self.request_rate = request_rate self.timeout = timeout self.rate_measurer = RateMeasurer(sample_size) self.max_outstanding = 10 * request_rate self._dataset_id = "" # Send requests per second self.loop = LoopingCall.withCount(self._request_and_measure) self.loop.clock = self.reactor # Once the expected rate is reached, we will start monitoring # the scenario inside this loop self.monitor_loop = LoopingCall(self.check_rate) self.monitor_loop.clock = self.reactor
def __init__(self, reactor, scenario_setup_instance, request_rate=10, sample_size=DEFAULT_SAMPLE_SIZE, timeout=45, tolerance_percentage=0.2): """ ``RequestLoadScenario`` constructor. :param reactor: Reactor to use. :param scenario_setup_instance: provider of the ``IRequestScenarioSetup`` interface. :param request_rate: target number of request per second. :param sample_size: number of samples to collect when measuring the rate. :param tolerance_percentage: error percentage in the rate that is considered valid. For example, if we request a ``request_rate`` of 20, and we give a tolerance_percentage of 0.2 (20%), anything in [16,20] will be a valid rate. """ self.reactor = reactor self.scenario_setup = scenario_setup_instance self.request_rate = request_rate self.timeout = timeout self._maintained = Deferred() self.rate_measurer = RateMeasurer(sample_size) self.max_outstanding = 10 * request_rate # Send requests per second self.loop = LoopingCall.withCount(self._request_and_measure) self.loop.clock = self.reactor # Monitor the status of the scenario self.monitor_loop = LoopingCall(self.check_rate) self.monitor_loop.clock = self.reactor self.is_started = False self.rate_tolerated = (float(request_rate) - (request_rate * tolerance_percentage))
def __init__( self, reactor, scenario_setup_instance, request_rate=10, sample_size=DEFAULT_SAMPLE_SIZE, timeout=45, tolerance_percentage=0.2 ): """ ``RequestLoadScenario`` constructor. :param reactor: Reactor to use. :param scenario_setup_instance: provider of the ``IRequestScenarioSetup`` interface. :param request_rate: target number of request per second. :param sample_size: number of samples to collect when measuring the rate. :param tolerance_percentage: error percentage in the rate that is considered valid. For example, if we request a ``request_rate`` of 20, and we give a tolerance_percentage of 0.2 (20%), anything in [16,20] will be a valid rate. """ self.reactor = reactor self.scenario_setup = scenario_setup_instance self.request_rate = request_rate self.timeout = timeout self._maintained = Deferred() self.rate_measurer = RateMeasurer(sample_size) self.max_outstanding = 10 * request_rate # Send requests per second self.loop = LoopingCall.withCount(self._request_and_measure) self.loop.clock = self.reactor # Monitor the status of the scenario self.monitor_loop = LoopingCall(self.check_rate) self.monitor_loop.clock = self.reactor self.is_started = False self.rate_tolerated = ( float(request_rate) - (request_rate*tolerance_percentage) )
def configure(self, config): self._loop = LoopingCall.withCount(self.update) self._interval = 1 self.points = 0
def __init__(self, logger): self._logger = logger self._tasks = [] self._impl = LoopingCall.withCount(self._update)
def start(self): self._call = LoopingCall.withCount(self._update) self._call.clock = self.platformClock self._call.start(1.0 / self.granularity, now=False) print 'start clock'
def __init__(self, *args, **kwargs): super(Furnace, self).__init__(*args, **kwargs) self.inventory = FurnaceStorage() self.burning = LoopingCall.withCount(self.burn)
def __init__(self, *args, **kwargs): super(Furnace, self).__init__(*args, **kwargs) self.inventory = FurnaceStorage() self.burning = LoopingCall.withCount(self.burn)
def __init__(self): # Mapping of user commands to handlers self.command_handlers = { Commands.CONNECTION_PASSWORD: self.on_connection_password, } self.info_collector = LoopingCall.withCount(self.collect_info)
def __init__(self, delay=0.01): self.delay = delay self.loop_call = LoopingCall.withCount(self.watch) self.blocked = 0 self.checks = [] self.d = None
def configure(self, config): self._loop = LoopingCall.withCount(self.update) self._interval = 1 self.points = 0
def __init__(self, tile, coords): self.tile = tile self.coords = coords self.running = False self.burning = LoopingCall.withCount(self.burn)