def run(self):
"""
Process PyGame events until halt is true.
"""
self.halt = False
print("Starting heartbeat.")
time_elapsed = 0
while True:
AppState.get_state().get_event_manager().post_event(
events.ControlEvent())
ticked = False
if AppState.get_state().is_running(
) and time_elapsed >= settings.SIMULATION_STEP_TIME:
print "------- t = %s" % AppState.get_state().get_t()
AppState.get_state().get_event_manager().post_event(
events.TickEvent())
time_elapsed = 0
ticked = True
AppState.get_state().get_event_manager().post_event(
events.DrawEvent(
ticked
and AppState.get_state().get_save_simulation_renders()))
time_elapsed += AppState.get_state().get_clock().tick(
settings.MAX_FPS)
if ticked:
AppState.get_state().increment_t()
def run(self):
"""Run CPUSpinner and send tick events."""
while self.keep_going:
dt = self.clock.tick(self.fps)
''' ??? dt = self.clock.tick(60) / 1000. '''
event = events.TickEvent(dt)
self.event_manager.post(event)
def run(self):
while self.on:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.evManager.Post(e.QuitEvent())
else:
self.evManager.Post(e.PygameEvent(event))
self.evManager.Post(e.TickEvent())
def __init__(self, clients, game_over_callback):
self.clients = clients
self.game_over_callback = game_over_callback
self.game_stack = None # needs to be set
self.model = None # needs to be set
self.looping_call_clients = None
self.looping_call_self = LoopingCall(self.post, e.TickEvent())
self.event_queue = deque()
self.__in_loop = False
def getMktData(self, contract, genericTickList, snapshot,
regulatorySnapshot, mktDataOptions):
reqId = self.getNextId()
tickEvent = events.TickEvent(contract=contract,
genericTickList=genericTickList,
snapshot=snapshot,
regulatorySnapshot=regulatorySnapshot,
mktDataOptions=mktDataOptions)
self.tickHandler.createRecord(reqId, tickEvent)
self.reqMktData(reqId, contract, genericTickList, snapshot,
regulatorySnapshot, mktDataOptions)
def run(self):
"""
Process PyGame events until halt is true.
"""
self.halt = False
print("Starting heartbeat.")
while not self.halt:
event = events.TickEvent()
AppState.get_state().get_event_manager().post_event(event)
AppState.get_state().get_clock().tick(settings.MAX_FPS)
def __init__(self, clients, game_over_callback, player_observers):
#externally stuff refers to done in setup_catch_phrase
self.clients = clients #list of clients
for client in self.clients:
client.observers.append(self)
self.game_over_callback = game_over_callback
self.game_stack = None # needs to be set externally
self.model = None # needs to be set externally
#self.looping_call_clients = None #check for dead clients.
self.looping_call_self = LoopingCall(self.post, e.TickEvent()) #give myself TickEvents
#needs to be started externally
self.event_queue = deque()# O(1) leftpop()
self.__in_loop = False
self.player_observers = player_observers
self.lobby_id = None #REMOVE WHEN DONE DEBUGGING
def run(self):
displayTick = 0
while self.gameLoop:
startTick = pygame.time.get_ticks()
displayTick += 1
if displayTick >= DISPLAY_DELAY:
displayTickEvent = events.DisplayTickEvent()
self.eventManager.post(displayTickEvent)
displayTick = 0
else:
tickEvent = events.TickEvent(pygame.event.get())
self.eventManager.post(tickEvent)
pygame.event.pump()
while pygame.time.get_ticks() - startTick < TURN_TICKS:
#Using sleep doesn't busy wait, but the system is less responsive
time.sleep(SLEEP_DELAY)
def run(self, slow = True, halt_fun = None, metrics_fun = None):
"""
Process PyGame events until halt is true.
:param slow: whether the simulation should be slowed for
visible ticks and renders.
:param halt_fun: A callable taking as input the current
simulation time in ticks, and returning
a boolean indicating whether the simulation
should halt.
:param metrics_fun: A callable returning a dictionary of named
metrics.
"""
self.metrics = []
self.halt = False
print("Starting heartbeat.")
time_elapsed = 0
while not self.halt:
if callable(halt_fun) and halt_fun(AppState.get_state().get_t()):
self.halt = True
continue
AppState.get_state().get_event_manager().post_event(events.ControlEvent())
ticked = False
if not slow or (AppState.get_state().is_running() and time_elapsed >= settings.SIMULATION_STEP_TIME):
AppState.get_state().get_logger().info("------- t = %s" % AppState.get_state().get_t())
AppState.get_state().get_event_manager().post_event(events.TickEvent())
time_elapsed = 0
ticked = True
if callable(metrics_fun):
self.metrics.append(metrics_fun())
AppState.get_state().get_event_manager().post_event(events.DrawEvent(ticked and AppState.get_state().get_save_simulation_renders()))
if slow:
time_elapsed += AppState.get_state().get_clock().tick(settings.MAX_FPS)
if ticked:
AppState.get_state().increment_t()
from twisted.internet.task import LoopingCall
from time import sleep
from random import randint
class client:
class RootObj:
def callRemote(self, crap, event):
print event.name
if isinstance(event, e.BeginTurnEvent):
sleep(.5)
print " Player: ", event.player, " /// word: ", event.word
time_used = float(randint(3, 8))
print " I had: ", event.time_left, "s. After going I have: ", str(
event.time_left - time_used)
fun = evm.post
value = e.EndTurnEvent(event.player,
event.time_left - time_used)
reactor.callLater(1.5, fun, value)
#evm.remote_post(e.EndTurnEvent(event.player, event.time_left - 1.0))
def __init__(self):
self.root_obj = self.RootObj()
evm = setup_catch_phrase(
{"client": client()},
["cat", "dog", "back", "in", "town", "didn't", "care how"],
['client1', 'client2'])
evm.post(e.StartRoundEvent())
looping_call = LoopingCall(evm.post, e.TickEvent())
looping_call.start(2.0)
reactor.run()
60,
draw_canvas.set_state,
gameDisplay,
evManager=controller),
events.KeyboardController(evManager=controller), draw_canvas,
render_canvas,
gui.Button('SAVE',
input_func,
gameDisplay,
evManager=controller,
rect=gui.Rect(537, 410, 176, 40)),
gui.Button('CLEAR',
draw_canvas.clear,
gameDisplay,
evManager=controller,
rect=gui.Rect(537, 460, 176, 40))
]
for obj in sketch_objects:
controller.registerListener(obj)
while True:
gameDisplay.fill((0, 0, 0))
controller.push(events.TickEvent())
controller.push(events.RenderEvent())
pygame.display.update()
clock.tick(30)
def run(self):
while self.on:
self.evManager.Post(e.TickEvent())
