def _move_car_to_street(self):
"""
Moves the next car from the main stack to the street stack it wants to go to next.
"""
from Grid import MovementEvent, GRID_EVENT as GE
t = TimeLord()
time= t.get_timestamp()
if len(self._car_stack) > 0:
car = self._car_stack[0]
next_dir, next_stop = car.get_next_dir(), car.get_next_stop()
#print("car %s" % car)
#print("next stop: %s (%i), route: %s" % (next_stop, next_dir, car._path))
if next_stop is None:
#print("Route done.")
return False
street_stack = self._streets[next_dir]
# print("room for car on street? %s" % (len(street_stack) < self._max_cars_on_street))
if len(street_stack) < self._max_cars_on_street:
street_stack.append(car)
self._car_stack.pop(0)
#print('moving')
car.handle_movement_event(MovementEvent(GE.STREET_ARRIVED, time, self))
return True
else:
car.handle_movement_event(MovementEvent(GE.STREET_REJECTED, time, self))
self._add_center_jam(time)
return False
else:
return True
def set_route(self, sp, ep):
from TimeLord import TimeLord
t = TimeLord()
"""
If sp has room for a new car, set given nodes as start and end points
and teleport to start.
"""
assert sp is not None and ep is not None, "route start and/or end point not set"
if sp.has_room():
self._start = sp
self._end = ep
# print(" Agent %s: teleporting to start point %s (from %s)" % (self._name, sp, self._position))
if self._position:
self._position.remove_car(self)
self._position = self._start
self._start.add_car(self, False)
self._determine_path()
self._travel_start_time = t.get_timestamp()
self._waiting_times[self._travel_start_time] = []
return True
return False
def _move_car_to_street(self):
"""
Moves the next car from the main stack to the street stack it wants to go to next.
"""
from Grid import MovementEvent, GRID_EVENT as GE
t = TimeLord()
time = t.get_timestamp()
if len(self._car_stack) > 0:
car = self._car_stack[0]
next_dir, next_stop = car.get_next_dir(), car.get_next_stop()
#print("car %s" % car)
#print("next stop: %s (%i), route: %s" % (next_stop, next_dir, car._path))
if next_stop is None:
#print("Route done.")
return False
street_stack = self._streets[next_dir]
# print("room for car on street? %s" % (len(street_stack) < self._max_cars_on_street))
if len(street_stack) < self._max_cars_on_street:
street_stack.append(car)
self._car_stack.pop(0)
#print('moving')
car.handle_movement_event(
MovementEvent(GE.STREET_ARRIVED, time, self))
return True
else:
car.handle_movement_event(
MovementEvent(GE.STREET_REJECTED, time, self))
self._add_center_jam(time)
return False
else:
return True
def set_route(self, sp, ep):
from TimeLord import TimeLord
t = TimeLord()
"""
If sp has room for a new car, set given nodes as start and end points
and teleport to start.
"""
assert sp is not None and ep is not None, "route start and/or end point not set"
if sp.has_room():
self._start = sp
self._end = ep
# print(" Agent %s: teleporting to start point %s (from %s)" % (self._name, sp, self._position))
if self._position:
self._position.remove_car(self)
self._position = self._start
self._start.add_car(self, False)
self._determine_path()
self._travel_start_time = t.get_timestamp()
self._waiting_times[self._travel_start_time] = []
return True
return False
def setup(self, parameters):
self._parameters = parameters
print("** Simulation parameters: %s" % self._parameters)
self.jam_counter = 0
self._grid = Grid(parameters.grid_width, parameters.grid_height)
self._agents = [Agent(i, self) for i in xrange(parameters.n_agents)]
self._timelord = TimeLord()
self._timelord.setup(self._parameters.steps_per_day)
def setup(self, parameters):
self._parameters = parameters
print("** Simulation parameters: %s" % self._parameters)
self.jam_counter = 0
self._grid = Grid(parameters.grid_width, parameters.grid_height)
self._agents = [Agent(i, self) for i in xrange(parameters.n_agents)]
self._timelord = TimeLord()
self._timelord.setup(self._parameters.steps_per_day)
class World():
# avoid ctor parameters since this is a singleton
def __init__(self):
pass
def update_counter(self):
self.jam_counter+=1
def get_counter(self):
return self.jam_counter
def reset_counter(self):
self.jam_counter = 0
def setup(self, parameters):
self._parameters = parameters
print("** Simulation parameters: %s" % self._parameters)
self.jam_counter = 0
self._grid = Grid(parameters.grid_width, parameters.grid_height)
self._agents = [Agent(i, self) for i in xrange(parameters.n_agents)]
self._timelord = TimeLord()
self._timelord.setup(self._parameters.steps_per_day)
def get_parameters(self):
return self._parameters
def get_grid(self):
return self._grid
def print_grid(self):
return self._grid.print_grid()
def update_grid(self):
self._grid.update_grid()
def get_agents(self):
return self._agents
class World():
# avoid ctor parameters since this is a singleton
def __init__(self):
pass
def update_counter(self):
self.jam_counter += 1
def get_counter(self):
return self.jam_counter
def reset_counter(self):
self.jam_counter = 0
def setup(self, parameters):
self._parameters = parameters
print("** Simulation parameters: %s" % self._parameters)
self.jam_counter = 0
self._grid = Grid(parameters.grid_width, parameters.grid_height)
self._agents = [Agent(i, self) for i in xrange(parameters.n_agents)]
self._timelord = TimeLord()
self._timelord.setup(self._parameters.steps_per_day)
def get_parameters(self):
return self._parameters
def get_grid(self):
return self._grid
def print_grid(self):
return self._grid.print_grid()
def update_grid(self):
self._grid.update_grid()
def get_agents(self):
return self._agents
def _transfer_car(self, direction):
"""
Moves the next car from the street stack to the mainstack of node in the given direction.
"""
from Grid import MovementEvent, GRID_EVENT as GE
t = TimeLord()
time = t.get_day_time()
street_stack = self._streets[direction]
if street_stack and len(street_stack) > 0:
car = street_stack[0]
to_node = self._neighbours[direction]
if to_node.add_car(car):
street_stack.pop(0)
car.handle_movement_event(MovementEvent(GE.JUNCTION_ARRIVED, time, self))
# print('car_transfered')
return True
else:
car.handle_movement_event(MovementEvent(GE.JUNCTION_REJECTED, time, self))
self._add_street_jam(direction,time)
return False
return True
def main(args):
import signal
global simulation, t, w
global verbose_mode
verbose_mode = args.verbose
signal.signal(signal.SIGINT, signal_handler)
simulation = Simulation(SimulationParameters())
t, w = TimeLord(), World() # globals for request handler
httpd = HTTPServer((args.host, args.port), HTTPRequestHandler)
print('** starting http server on port %s:%i...' % (args.host, args.port))
httpd.serve_forever()
def _transfer_car(self, direction):
"""
Moves the next car from the street stack to the mainstack of node in the given direction.
"""
from Grid import MovementEvent, GRID_EVENT as GE
t = TimeLord()
time = t.get_day_time()
street_stack = self._streets[direction]
if street_stack and len(street_stack) > 0:
car = street_stack[0]
to_node = self._neighbours[direction]
if to_node.add_car(car):
street_stack.pop(0)
car.handle_movement_event(
MovementEvent(GE.JUNCTION_ARRIVED, time, self))
# print('car_transfered')
return True
else:
car.handle_movement_event(
MovementEvent(GE.JUNCTION_REJECTED, time, self))
self._add_street_jam(direction, time)
return False
return True
def do_step(self):
"""
Runs one simulation step and returns True, unless the simulation is
finished (params.max_days has been reached).
"""
w, g = self._world, self._world.get_grid()
cars = w.get_agents()
t = TimeLord()
w.update_grid()
start = dt.now()
if t.get_day_time() == 0:
duration = dt.now() - start
print("===== Day: %i (%.2f secs) =====" %
(t.get_day(), duration.seconds +
(duration.microseconds / 1000000)))
#self.print_grid(self._world.print_grid())
ct, cnt = 0, 0
for car in cars:
if not car.is_travelling():
car.restart_route(
) # or car.reverse_route() to have them travel home
ct += 1
else:
cnt += 1
print("** Restarted %i cars, %i still travelling" % (ct, cnt))
start = dt.now()
t.next_time_step()
self._jam_progression.append(g.get_jam_amount())
if self._parameters.max_days > -1 and t.get_day(
) >= self._parameters.max_days:
return False
else:
return True
