def update(self):
self.syst = time.clock()
if self.mode == Simulation.init:
self.operate()
# Closk for run(=op) mode
if self.mode == Simulation.op:
# Not fast forward: variable dt
if not self.ffmode:
self.tprev = self.simt
self.simt = self.syst - self.syst0
self.simdt = self.simt - self.tprev
# Protect against incidental dt's larger than 1 second,
# due to window moving, switch to/from full screen, etc.
if self.simdt > 1.0:
extra = self.simdt - 1.0
self.simdt = 1.0
self.simt = self.simt - extra
self.syst0 = self.syst - self.simt
# Fast forward: fixed dt until ffstop time, goto pause
else:
self.simdt = self.fixdt
self.simt = self.simt + self.fixdt
self.syst0 = self.syst - self.simt
if self.ffstop > 0. and self.simt >= self.ffstop:
self.ffmode = False
self.mode = self.hold
# Update UTC time
self.utc += datetime.timedelta(seconds=self.simdt)
# Datalog pre-update (communicate current sim time to loggers)
datalog.preupdate(self.simt)
# Plugins pre-update
plugin.preupdate(self.simt)
# For measuring game loop frequency
self.dts.append(self.simdt)
if len(self.dts) > 20:
del self.dts[0]
stack.checkfile(self.simt)
# Always process stack
stack.process()
if self.mode == Simulation.op:
bs.traf.update(self.simt, self.simdt)
# Update metrics
self.metric.update()
# Update plugins
plugin.update(self.simt)
# Update loggers
datalog.postupdate()
# HOLD/Pause mode
else:
self.syst0 = self.syst - self.simt
self.simdt = 0.0
return
def step(self):
''' Perform a simulation timestep. '''
# When running at a fixed rate, or when in hold/init,
# increment system time with sysdt and calculate remainder to sleep.
if not self.ffmode or not self.state == bs.OP:
remainder = self.syst - time.time()
if remainder > MINSLEEP:
time.sleep(remainder)
elif self.ffstop is not None and self.simt >= self.ffstop:
if self.benchdt > 0.0:
bs.scr.echo('Benchmark complete: %d samples in %.3f seconds.' % \
(bs.scr.samplecount, time.time() - self.bencht))
self.benchdt = -1.0
self.pause()
else:
self.op()
if self.state == bs.OP:
# Plugins pre-update
plugin.preupdate(self.simt)
# Update screen logic
bs.scr.update()
# Simulation starts as soon as there is traffic, or pending commands
if self.state == bs.INIT:
if self.syst < 0.0:
self.syst = time.time()
if bs.traf.ntraf > 0 or len(stack.get_scendata()[0]) > 0:
self.op()
if self.benchdt > 0.0:
self.fastforward(self.benchdt)
self.bencht = time.time()
if self.state == bs.OP:
stack.checkfile(self.simt)
# Always update stack
stack.process()
if self.state == bs.OP:
bs.traf.update(self.simt, self.simdt)
# Update plugins
plugin.update(self.simt)
# Update Plotter
plotter.update(self.simt)
# Update loggers
datalog.postupdate()
# Update sim and UTC time for the next timestep
self.simt += self.simdt
self.utc += datetime.timedelta(seconds=self.simdt)
# Always update syst
self.syst += self.sysdt
# Inform main of our state change
if not self.state == self.prevstate:
self.sendState()
self.prevstate = self.state
def update(self):
self.syst = time.clock()
if self.mode == Simulation.init:
self.operate()
# Closk for run(=op) mode
if self.mode == Simulation.op:
# Not fast forward: variable dt
if not self.ffmode:
self.tprev = self.simt
self.simt = self.syst - self.syst0
self.simdt = self.simt - self.tprev
# Protect against incidental dt's larger than 1 second,
# due to window moving, switch to/from full screen, etc.
if self.simdt > 1.0:
extra = self.simdt-1.0
self.simt = self.simt - extra
self.syst0 = self.syst-self.simt
# Fast forward: fixed dt until ffstop time, goto pause
else:
self.simdt = self.fixdt
self.simt = self.simt+self.fixdt
self.syst0 = self.syst - self.simt
if self.ffstop > 0. and self.simt >= self.ffstop:
self.ffmode = False
self.mode = self.hold
# Update simulated clock time
self.simtclock = (self.simt + self.deltclock)%onedayinsec
# Datalog pre-update (communicate current sim time to loggers)
datalog.preupdate(self.simt)
# Plugins pre-update
plugin.preupdate(self.simt)
# For measuring game loop frequency
self.dts.append(self.simdt)
if len(self.dts) > 20:
del self.dts[0]
stack.checkfile(self.simt)
# Always process stack
stack.process()
if self.mode == Simulation.op:
bs.traf.update(self.simt, self.simdt)
# Update metrics
self.metric.update()
# Update plugins
plugin.update(self.simt)
# Update loggers
datalog.postupdate()
# HOLD/Pause mode
else:
self.syst0 = self.syst-self.simt
self.simdt = 0.0
return
def step(self):
''' Perform a simulation timestep. '''
# Simulation starts as soon as there is traffic, or pending commands
if self.state == bs.INIT:
if self.syst < 0.0:
self.syst = time.time()
if bs.traf.ntraf > 0 or len(bs.stack.get_scendata()[0]) > 0:
self.op()
if self.benchdt > 0.0:
self.fastforward(self.benchdt)
self.bencht = time.time()
# When running at a fixed rate, or when in hold/init,
# increment system time with sysdt and calculate remainder to sleep.
remainder = self.syst - time.time()
if (not self.ffmode or self.state != bs.OP) and remainder > MINSLEEP:
time.sleep(remainder)
# Always update stack
bs.stack.process()
if self.state == bs.OP:
# Plot/log the current timestep, and call preupdate for plugins that
# have it
plotter.update()
datalog.update()
plugin.preupdate()
# Determine interval towards next timestep
if remainder < 0.0 and self.rtmode:
self.simt, self.simdt = simtime.step(-remainder)
else:
# Don't accumulate delay when we aren't running realtime
if remainder < 0.0:
self.syst -= remainder
self.simt, self.simdt = simtime.step()
# Update UTC time
self.utc += datetime.timedelta(seconds=self.simdt)
# Update traffic and plugins for the next timestep
bs.traf.update()
plugin.update()
# Always update syst
self.syst += self.simdt / self.dtmult
# Stop fast-time/benchmark if enabled and set interval has passed
if self.ffstop is not None and self.simt >= self.ffstop:
if self.benchdt > 0.0:
bs.scr.echo('Benchmark complete: %d samples in %.3f seconds.' %
(bs.scr.samplecount, time.time() - self.bencht))
self.benchdt = -1.0
self.hold()
else:
self.op()
# Inform main of our state change
if self.state != self.prevstate:
bs.net.send_event(b'STATECHANGE', self.state)
self.prevstate = self.state
def step(self):
''' Perform a simulation timestep. '''
# When running at a fixed rate, or when in hold/init,
# increment system time with sysdt and calculate remainder to sleep.
if not self.ffmode or not self.state == bs.OP:
remainder = self.syst - time.time()
if remainder > MINSLEEP:
time.sleep(remainder)
elif self.ffstop is not None and self.simt >= self.ffstop:
if self.benchdt > 0.0:
bs.scr.echo('Benchmark complete: %d samples in %.3f seconds.' % \
(bs.scr.samplecount, time.time() - self.bencht))
self.benchdt = -1.0
self.pause()
else:
self.op()
if self.state == bs.OP:
# Plugins pre-update
plugin.preupdate(self.simt)
# Update screen logic
bs.scr.update()
# Simulation starts as soon as there is traffic, or pending commands
if self.state == bs.INIT:
if self.syst < 0.0:
self.syst = time.time()
if bs.traf.ntraf > 0 or len(stack.get_scendata()[0]) > 0:
self.op()
if self.benchdt > 0.0:
self.fastforward(self.benchdt)
self.bencht = time.time()
if self.state == bs.OP:
stack.checkfile(self.simt)
# Always update stack
stack.process()
if self.state == bs.OP:
bs.traf.update(self.simt, self.simdt)
# Update plugins
plugin.update(self.simt)
# Update Plotter
plotter.update(self.simt)
# Update loggers
datalog.postupdate()
# Update sim and UTC time for the next timestep
self.simt += self.simdt
self.utc += datetime.timedelta(seconds=self.simdt)
# Always update syst
self.syst += self.sysdt
# Inform main of our state change
if not self.state == self.prevstate:
self.sendState()
self.prevstate = self.state
def doWork(self):
self.syst = int(time.time() * 1000.0)
# Send list of stack functions available in this sim to gui at start
stackdict = {
cmd: val[0][len(cmd) + 1:]
for cmd, val in stack.cmddict.items()
}
manager.sendEvent(StackInitEvent(stackdict))
while self.running:
if self.state == Simulation.op:
# Plugins pre-update
plugin.preupdate(self.simt)
# Datalog pre-update (communicate current sim time to loggers)
datalog.preupdate(self.simt)
# Update screen logic
bs.scr.update()
# Simulation starts as soon as there is traffic, or pending commands
if self.state == Simulation.init:
if bs.traf.ntraf > 0 or len(stack.get_scendata()[0]) > 0:
self.start()
if self.benchdt > 0.0:
self.fastforward(self.benchdt)
self.bencht = time.time()
if self.state == Simulation.op:
stack.checkfile(self.simt)
# Always update stack
stack.process()
if self.state == Simulation.op:
bs.traf.update(self.simt, self.simdt)
# Update metrics
# self.metric.update()
# Update plugins
plugin.update(self.simt)
# Update loggers
datalog.postupdate()
# Update time for the next timestep
self.simt += self.simdt
# Update clock
self.simtclock = (self.deltclock + self.simt) % onedayinsec
# Process Qt events
manager.processEvents()
# When running at a fixed rate, or when in hold/init, increment
# system time with sysdt and calculate remainder to sleep
if not self.ffmode or not self.state == Simulation.op:
self.syst += self.sysdt
remainder = self.syst - int(1000.0 * time.time())
if remainder > 0:
QThread.msleep(remainder)
# If running in fast-time with an end-time that has passed, go back to
# real-time running.
elif self.ffstop is not None and self.simt >= self.ffstop:
# If this fast-time section was part of a benchmark, send
# message with benchmark results
if self.benchdt > 0.0:
bs.scr.echo(
'Benchmark complete: %d samples in %.3f seconds.' %
(bs.scr.samplecount, time.time() - self.bencht))
self.benchdt = -1.0
self.pause()
else:
self.start()
# Inform main of our state change
if not self.state == self.prevstate:
self.sendState()
self.prevstate = self.state
