diff --git a/.gitignore b/.gitignore
index ce15e015aebdfab2e4b8a07f3633104ed3d2107b..4cb6198545bd57d0337545f900556b4986dc1c5f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -120,4 +120,6 @@ test_save.dat
playground/
**/tmp
-**/TEMP
\ No newline at end of file
+**/TEMP
+
+*.pkl
diff --git a/flatland/action_plan/action_plan.py b/flatland/action_plan/action_plan.py
index 249c4c0ee12bb8a79c06842a59108bd4f3ce6c5c..96a441299fd68b9d8f0e51e6d3e2b543ec15ba57 100644
--- a/flatland/action_plan/action_plan.py
+++ b/flatland/action_plan/action_plan.py
@@ -150,7 +150,7 @@ class ControllerFromTrainruns():
def _create_action_plan_for_agent(self, agent_id, trainrun) -> ActionPlan:
action_plan = []
agent = self.env.agents[agent_id]
- minimum_cell_time = int(np.ceil(1.0 / agent.speed_data['speed']))
+ minimum_cell_time = agent.speed_counter.max_count + 1
for path_loop, trainrun_waypoint in enumerate(trainrun):
trainrun_waypoint: TrainrunWaypoint = trainrun_waypoint
diff --git a/flatland/action_plan/action_plan_player.py b/flatland/action_plan/action_plan_player.py
index f3deee133d8c99ffc5993005f1500e227be87b7e..f9b82ba967392816319a8203b136524a1abba0fa 100644
--- a/flatland/action_plan/action_plan_player.py
+++ b/flatland/action_plan/action_plan_player.py
@@ -31,7 +31,6 @@ class ControllerFromTrainrunsReplayer():
"before {}, agent {} at {}, expected {}".format(i, agent_id, agent.position,
waypoint.position)
actions = ctl.act(i)
- print("actions for {}: {}".format(i, actions))
obs, all_rewards, done, _ = env.step(actions)
diff --git a/flatland/envs/agent_chains.py b/flatland/envs/agent_chains.py
index 3e566ad0617a3c49ec69e1049be36231b705916f..e99b1dae3e02a08c333bf245a54ecb724881ca33 100644
--- a/flatland/envs/agent_chains.py
+++ b/flatland/envs/agent_chains.py
@@ -218,21 +218,21 @@ class MotionCheck(object):
if "color" in dAttr:
sColor = dAttr["color"]
if sColor in [ "red", "purple" ]:
- return (False, rcPos)
+ return False
dSucc = self.G.succ[rcPos]
# This should never happen - only the next cell of an agent has no successor
if len(dSucc)==0:
print(f"error condition - agent {iAgent} node {rcPos} has no successor")
- return (False, rcPos)
+ return False
# This agent has a successor
rcNext = self.G.successors(rcPos).__next__()
if rcNext == rcPos: # the agent didn't want to move
- return (False, rcNext)
+ return False
# The agent wanted to move, and it can
- return (True, rcNext)
+ return True
diff --git a/flatland/envs/agent_utils.py b/flatland/envs/agent_utils.py
index fffe7ff786a32a6796af9667f1dfb9a3eb92ce9c..20dc0325cd9d1e786cd179b56df9b5527ba68b66 100644
--- a/flatland/envs/agent_utils.py
+++ b/flatland/envs/agent_utils.py
@@ -1,8 +1,7 @@
from flatland.envs.rail_trainrun_data_structures import Waypoint
import numpy as np
+import warnings
-from enum import IntEnum
-from itertools import starmap
from typing import Tuple, Optional, NamedTuple, List
from attr import attr, attrs, attrib, Factory
@@ -10,13 +9,11 @@ from attr import attr, attrs, attrib, Factory
from flatland.core.grid.grid4 import Grid4TransitionsEnum
from flatland.envs.timetable_utils import Line
-class RailAgentStatus(IntEnum):
- WAITING = 0
- READY_TO_DEPART = 1 # not in grid yet (position is None) -> prediction as if it were at initial position
- ACTIVE = 2 # in grid (position is not None), not done -> prediction is remaining path
- DONE = 3 # in grid (position is not None), but done -> prediction is stay at target forever
- DONE_REMOVED = 4 # removed from grid (position is None) -> prediction is None
-
+from flatland.envs.step_utils.action_saver import ActionSaver
+from flatland.envs.step_utils.speed_counter import SpeedCounter
+from flatland.envs.step_utils.state_machine import TrainStateMachine
+from flatland.envs.step_utils.states import TrainState
+from flatland.envs.step_utils.malfunction_handler import MalfunctionHandler
Agent = NamedTuple('Agent', [('initial_position', Tuple[int, int]),
('initial_direction', Grid4TransitionsEnum),
@@ -25,15 +22,38 @@ Agent = NamedTuple('Agent', [('initial_position', Tuple[int, int]),
('moving', bool),
('earliest_departure', int),
('latest_arrival', int),
- ('speed_data', dict),
('malfunction_data', dict),
('handle', int),
- ('status', RailAgentStatus),
('position', Tuple[int, int]),
('arrival_time', int),
('old_direction', Grid4TransitionsEnum),
- ('old_position', Tuple[int, int])])
-
+ ('old_position', Tuple[int, int]),
+ ('speed_counter', SpeedCounter),
+ ('action_saver', ActionSaver),
+ ('state_machine', TrainStateMachine),
+ ('malfunction_handler', MalfunctionHandler),
+ ])
+
+
+def load_env_agent(agent_tuple: Agent):
+ return EnvAgent(
+ initial_position = agent_tuple.initial_position,
+ initial_direction = agent_tuple.initial_direction,
+ direction = agent_tuple.direction,
+ target = agent_tuple.target,
+ moving = agent_tuple.moving,
+ earliest_departure = agent_tuple.earliest_departure,
+ latest_arrival = agent_tuple.latest_arrival,
+ handle = agent_tuple.handle,
+ position = agent_tuple.position,
+ arrival_time = agent_tuple.arrival_time,
+ old_direction = agent_tuple.old_direction,
+ old_position = agent_tuple.old_position,
+ speed_counter = agent_tuple.speed_counter,
+ action_saver = agent_tuple.action_saver,
+ state_machine = agent_tuple.state_machine,
+ malfunction_handler = agent_tuple.malfunction_handler,
+ )
@attrs
class EnvAgent:
@@ -48,13 +68,6 @@ class EnvAgent:
earliest_departure = attrib(default=None, type=int) # default None during _from_line()
latest_arrival = attrib(default=None, type=int) # default None during _from_line()
- # speed_data: speed is added to position_fraction on each moving step, until position_fraction>=1.0,
- # after which 'transition_action_on_cellexit' is executed (equivalent to executing that action in the previous
- # cell if speed=1, as default)
- # N.B. we need to use factory since default arguments are not recreated on each call!
- speed_data = attrib(
- default=Factory(lambda: dict({'position_fraction': 0.0, 'speed': 1.0, 'transition_action_on_cellexit': 0})))
-
# if broken>0, the agent's actions are ignored for 'broken' steps
# number of time the agent had to stop, since the last time it broke down
malfunction_data = attrib(
@@ -65,7 +78,13 @@ class EnvAgent:
handle = attrib(default=None)
# INIT TILL HERE IN _from_line()
- status = attrib(default=RailAgentStatus.WAITING, type=RailAgentStatus)
+ # Env step facelift
+ speed_counter = attrib(default = Factory(lambda: SpeedCounter(1.0)), type=SpeedCounter)
+ action_saver = attrib(default = Factory(lambda: ActionSaver()), type=ActionSaver)
+ state_machine = attrib(default= Factory(lambda: TrainStateMachine(initial_state=TrainState.WAITING)) ,
+ type=TrainStateMachine)
+ malfunction_handler = attrib(default = Factory(lambda: MalfunctionHandler()), type=MalfunctionHandler)
+
position = attrib(default=None, type=Optional[Tuple[int, int]])
# NEW : EnvAgent Reward Handling
@@ -75,6 +94,7 @@ class EnvAgent:
old_direction = attrib(default=None)
old_position = attrib(default=None)
+
def reset(self):
"""
Resets the agents to their initial values of the episode. Called after ScheduleTime generation.
@@ -82,28 +102,38 @@ class EnvAgent:
self.position = None
# TODO: set direction to None: https://gitlab.aicrowd.com/flatland/flatland/issues/280
self.direction = self.initial_direction
-
- if (self.earliest_departure == 0):
- self.status = RailAgentStatus.READY_TO_DEPART
- else:
- self.status = RailAgentStatus.WAITING
-
- self.arrival_time = None
-
self.old_position = None
self.old_direction = None
self.moving = False
- # Reset agent values for speed
- self.speed_data['position_fraction'] = 0.
- self.speed_data['transition_action_on_cellexit'] = 0.
-
# Reset agent malfunction values
self.malfunction_data['malfunction'] = 0
self.malfunction_data['nr_malfunctions'] = 0
self.malfunction_data['moving_before_malfunction'] = False
- # NEW : Callables
+ self.action_saver.clear_saved_action()
+ self.speed_counter.reset_counter()
+ self.state_machine.reset()
+
+ def to_agent(self) -> Agent:
+ return Agent(initial_position=self.initial_position,
+ initial_direction=self.initial_direction,
+ direction=self.direction,
+ target=self.target,
+ moving=self.moving,
+ earliest_departure=self.earliest_departure,
+ latest_arrival=self.latest_arrival,
+ malfunction_data=self.malfunction_data,
+ handle=self.handle,
+ position=self.position,
+ old_direction=self.old_direction,
+ old_position=self.old_position,
+ speed_counter=self.speed_counter,
+ action_saver=self.action_saver,
+ arrival_time=self.arrival_time,
+ state_machine=self.state_machine,
+ malfunction_handler=self.malfunction_handler)
+
def get_shortest_path(self, distance_map) -> List[Waypoint]:
from flatland.envs.rail_env_shortest_paths import get_shortest_paths # Circular dep fix
return get_shortest_paths(distance_map=distance_map, agent_handle=self.handle)[self.handle]
@@ -114,7 +144,7 @@ class EnvAgent:
distance = len(shortest_path)
else:
distance = 0
- speed = self.speed_data['speed']
+ speed = self.speed_counter.speed
return int(np.ceil(distance / speed))
def get_time_remaining_until_latest_arrival(self, elapsed_steps: int) -> int:
@@ -128,42 +158,40 @@ class EnvAgent:
return self.get_time_remaining_until_latest_arrival(elapsed_steps) - \
self.get_travel_time_on_shortest_path(distance_map)
- def to_agent(self) -> Agent:
- return Agent(initial_position=self.initial_position, initial_direction=self.initial_direction,
- direction=self.direction, target=self.target, moving=self.moving, earliest_departure=self.earliest_departure,
- latest_arrival=self.latest_arrival, speed_data=self.speed_data, malfunction_data=self.malfunction_data,
- handle=self.handle, status=self.status, position=self.position, arrival_time=self.arrival_time,
- old_direction=self.old_direction, old_position=self.old_position)
@classmethod
def from_line(cls, line: Line):
""" Create a list of EnvAgent from lists of positions, directions and targets
"""
- speed_datas = []
-
- for i in range(len(line.agent_positions)):
- speed_datas.append({'position_fraction': 0.0,
- 'speed': line.agent_speeds[i] if line.agent_speeds is not None else 1.0,
- 'transition_action_on_cellexit': 0})
-
- malfunction_datas = []
- for i in range(len(line.agent_positions)):
- malfunction_datas.append({'malfunction': 0,
- 'malfunction_rate': line.agent_malfunction_rates[
- i] if line.agent_malfunction_rates is not None else 0.,
- 'next_malfunction': 0,
- 'nr_malfunctions': 0})
-
- return list(starmap(EnvAgent, zip(line.agent_positions,
- line.agent_directions,
- line.agent_directions,
- line.agent_targets,
- [False] * len(line.agent_positions),
- [None] * len(line.agent_positions), # earliest_departure
- [None] * len(line.agent_positions), # latest_arrival
- speed_datas,
- malfunction_datas,
- range(len(line.agent_positions)))))
+ num_agents = len(line.agent_positions)
+
+ agent_list = []
+ for i_agent in range(num_agents):
+ speed = line.agent_speeds[i_agent] if line.agent_speeds is not None else 1.0
+
+ if line.agent_malfunction_rates is not None:
+ malfunction_rate = line.agent_malfunction_rates[i_agent]
+ else:
+ malfunction_rate = 0.
+
+ malfunction_data = {'malfunction': 0,
+ 'malfunction_rate': malfunction_rate,
+ 'next_malfunction': 0,
+ 'nr_malfunctions': 0
+ }
+ agent = EnvAgent(initial_position = line.agent_positions[i_agent],
+ initial_direction = line.agent_directions[i_agent],
+ direction = line.agent_directions[i_agent],
+ target = line.agent_targets[i_agent],
+ moving = False,
+ earliest_departure = None,
+ latest_arrival = None,
+ malfunction_data = malfunction_data,
+ handle = i_agent,
+ speed_counter = SpeedCounter(speed=speed))
+ agent_list.append(agent)
+
+ return agent_list
@classmethod
def load_legacy_static_agent(cls, static_agents_data: Tuple):
@@ -172,17 +200,46 @@ class EnvAgent:
if len(static_agent) >= 6:
agent = EnvAgent(initial_position=static_agent[0], initial_direction=static_agent[1],
direction=static_agent[1], target=static_agent[2], moving=static_agent[3],
- speed_data=static_agent[4], malfunction_data=static_agent[5], handle=i)
+ speed_counter=SpeedCounter(static_agent[4]['speed']), malfunction_data=static_agent[5],
+ handle=i)
else:
agent = EnvAgent(initial_position=static_agent[0], initial_direction=static_agent[1],
direction=static_agent[1], target=static_agent[2],
moving=False,
- speed_data={"speed":1., "position_fraction":0., "transition_action_on_cell_exit":0.},
malfunction_data={
'malfunction': 0,
'nr_malfunctions': 0,
'moving_before_malfunction': False
},
+ speed_counter=SpeedCounter(1.0),
handle=i)
agents.append(agent)
return agents
+
+ def __str__(self):
+ return f"\n \
+ handle(agent index): {self.handle} \n \
+ initial_position: {self.initial_position} initial_direction: {self.initial_direction} \n \
+ position: {self.position} direction: {self.direction} target: {self.target} \n \
+ old_position: {self.old_position} old_direction {self.old_direction} \n \
+ earliest_departure: {self.earliest_departure} latest_arrival: {self.latest_arrival} \n \
+ state: {str(self.state)} \n \
+ malfunction_handler: {self.malfunction_handler} \n \
+ action_saver: {self.action_saver} \n \
+ speed_counter: {self.speed_counter}"
+
+ @property
+ def state(self):
+ return self.state_machine.state
+
+ @state.setter
+ def state(self, state):
+ self._set_state(state)
+
+ def _set_state(self, state):
+ warnings.warn("Not recommended to set the state with this function unless completely required")
+ self.state_machine.set_state(state)
+
+
+
+
diff --git a/flatland/envs/line_generators.py b/flatland/envs/line_generators.py
index 74d01e6f23856e9f14d2fbe70eb2bdbfb85175be..79241f2489b4a7b3ab3008f269d2c03fbafd27c8 100644
--- a/flatland/envs/line_generators.py
+++ b/flatland/envs/line_generators.py
@@ -84,11 +84,6 @@ class SparseLineGen(BaseLineGen):
train_stations = hints['train_stations']
city_positions = hints['city_positions']
city_orientation = hints['city_orientations']
- max_num_agents = hints['num_agents']
- city_orientations = hints['city_orientations']
- if num_agents > max_num_agents:
- num_agents = max_num_agents
- warnings.warn("Too many agents! Changes number of agents.")
# Place agents and targets within available train stations
agents_position = []
agents_target = []
@@ -189,7 +184,7 @@ def line_from_file(filename, load_from_package=None) -> LineGenerator:
#agents_direction = [a.direction for a in agents]
agents_direction = [a.initial_direction for a in agents]
agents_target = [a.target for a in agents]
- agents_speed = [a.speed_data['speed'] for a in agents]
+ agents_speed = [a.speed_counter.speed for a in agents]
# Malfunctions from here are not used. They have their own generator.
#agents_malfunction = [a.malfunction_data['malfunction_rate'] for a in agents]
diff --git a/flatland/envs/malfunction_generators.py b/flatland/envs/malfunction_generators.py
index 0d27913d6f27fb5df301960655d90baa42ef1ac0..086fd9cef348ff8de6b6c358876926804dc673e5 100644
--- a/flatland/envs/malfunction_generators.py
+++ b/flatland/envs/malfunction_generators.py
@@ -5,7 +5,8 @@ from typing import Callable, NamedTuple, Optional, Tuple
import numpy as np
from numpy.random.mtrand import RandomState
-from flatland.envs.agent_utils import EnvAgent, RailAgentStatus
+from flatland.envs.agent_utils import EnvAgent
+from flatland.envs.step_utils.states import TrainState
from flatland.envs import persistence
@@ -18,7 +19,7 @@ MalfunctionProcessData = NamedTuple('MalfunctionProcessData',
Malfunction = NamedTuple('Malfunction', [('num_broken_steps', int)])
# Why is the return value Optional? We always return a Malfunction.
-MalfunctionGenerator = Callable[[EnvAgent, RandomState, bool], Optional[Malfunction]]
+MalfunctionGenerator = Callable[[RandomState, bool], Malfunction]
def _malfunction_prob(rate: float) -> float:
"""
@@ -42,21 +43,14 @@ class ParamMalfunctionGen(object):
#self.max_number_of_steps_broken = parameters.max_duration
self.MFP = parameters
- def generate(self,
- agent: EnvAgent = None,
- np_random: RandomState = None,
- reset=False) -> Optional[Malfunction]:
-
- # Dummy reset function as we don't implement specific seeding here
- if reset:
- return Malfunction(0)
+ def generate(self, np_random: RandomState) -> Malfunction:
- if agent.malfunction_data['malfunction'] < 1:
- if np_random.rand() < _malfunction_prob(self.MFP.malfunction_rate):
- num_broken_steps = np_random.randint(self.MFP.min_duration,
- self.MFP.max_duration + 1) + 1
- return Malfunction(num_broken_steps)
- return Malfunction(0)
+ if np_random.rand() < _malfunction_prob(self.MFP.malfunction_rate):
+ num_broken_steps = np_random.randint(self.MFP.min_duration,
+ self.MFP.max_duration + 1) + 1
+ else:
+ num_broken_steps = 0
+ return Malfunction(num_broken_steps)
def get_process_data(self):
return MalfunctionProcessData(*self.MFP)
@@ -103,7 +97,7 @@ def no_malfunction_generator() -> Tuple[MalfunctionGenerator, MalfunctionProcess
min_number_of_steps_broken = 0
max_number_of_steps_broken = 0
- def generator(agent: EnvAgent = None, np_random: RandomState = None, reset=False) -> Optional[Malfunction]:
+ def generator(np_random: RandomState = None) -> Malfunction:
return Malfunction(0)
return generator, MalfunctionProcessData(mean_malfunction_rate, min_number_of_steps_broken,
@@ -162,7 +156,8 @@ def single_malfunction_generator(earlierst_malfunction: int, malfunction_duratio
malfunction_calls[agent.handle] = 1
# Break an agent that is active at the time of the malfunction
- if agent.status == RailAgentStatus.ACTIVE and malfunction_calls[agent.handle] >= earlierst_malfunction:
+ if (agent.state == TrainState.MOVING or agent.state == TrainState.STOPPED) \
+ and malfunction_calls[agent.handle] >= earlierst_malfunction: #TODO : Dipam : Is this needed?
global_nr_malfunctions += 1
return Malfunction(malfunction_duration)
else:
@@ -258,7 +253,7 @@ def malfunction_from_params(parameters: MalfunctionParameters) -> Tuple[Malfunct
min_number_of_steps_broken = parameters.min_duration
max_number_of_steps_broken = parameters.max_duration
- def generator(agent: EnvAgent = None, np_random: RandomState = None, reset=False) -> Optional[Malfunction]:
+ def generator(np_random: RandomState = None, reset=False) -> Optional[Malfunction]:
"""
Generate malfunctions for agents
Parameters
@@ -275,11 +270,10 @@ def malfunction_from_params(parameters: MalfunctionParameters) -> Tuple[Malfunct
if reset:
return Malfunction(0)
- if agent.malfunction_data['malfunction'] < 1:
- if np_random.rand() < _malfunction_prob(mean_malfunction_rate):
- num_broken_steps = np_random.randint(min_number_of_steps_broken,
- max_number_of_steps_broken + 1) + 1
- return Malfunction(num_broken_steps)
+ if np_random.rand() < _malfunction_prob(mean_malfunction_rate):
+ num_broken_steps = np_random.randint(min_number_of_steps_broken,
+ max_number_of_steps_broken + 1)
+ return Malfunction(num_broken_steps)
return Malfunction(0)
return generator, MalfunctionProcessData(mean_malfunction_rate, min_number_of_steps_broken,
diff --git a/flatland/envs/observations.py b/flatland/envs/observations.py
index 4de36060f2864f6f33cfefd8ac46816da566dbc6..0b5f2a845d525f36456ce3c770fe4453d2c8a0e5 100644
--- a/flatland/envs/observations.py
+++ b/flatland/envs/observations.py
@@ -11,7 +11,8 @@ from flatland.core.env_observation_builder import ObservationBuilder
from flatland.core.env_prediction_builder import PredictionBuilder
from flatland.core.grid.grid4_utils import get_new_position
from flatland.core.grid.grid_utils import coordinate_to_position
-from flatland.envs.agent_utils import RailAgentStatus, EnvAgent
+from flatland.envs.agent_utils import EnvAgent
+from flatland.envs.step_utils.states import TrainState
from flatland.utils.ordered_set import OrderedSet
@@ -93,16 +94,16 @@ class TreeObsForRailEnv(ObservationBuilder):
self.location_has_agent_ready_to_depart = {}
for _agent in self.env.agents:
- if _agent.status in [RailAgentStatus.ACTIVE, RailAgentStatus.DONE] and \
+ if not _agent.state.is_off_map_state() and \
_agent.position:
self.location_has_agent[tuple(_agent.position)] = 1
self.location_has_agent_direction[tuple(_agent.position)] = _agent.direction
- self.location_has_agent_speed[tuple(_agent.position)] = _agent.speed_data['speed']
+ self.location_has_agent_speed[tuple(_agent.position)] = _agent.speed_counter.speed
self.location_has_agent_malfunction[tuple(_agent.position)] = _agent.malfunction_data[
'malfunction']
# [NIMISH] WHAT IS THIS
- if _agent.status in [RailAgentStatus.READY_TO_DEPART, RailAgentStatus.WAITING] and \
+ if _agent.state.is_off_map_state() and \
_agent.initial_position:
self.location_has_agent_ready_to_depart.setdefault(tuple(_agent.initial_position), 0)
self.location_has_agent_ready_to_depart[tuple(_agent.initial_position)] += 1
@@ -195,14 +196,12 @@ class TreeObsForRailEnv(ObservationBuilder):
if handle > len(self.env.agents):
print("ERROR: obs _get - handle ", handle, " len(agents)", len(self.env.agents))
agent = self.env.agents[handle] # TODO: handle being treated as index
-
- if agent.status == RailAgentStatus.WAITING:
- agent_virtual_position = agent.initial_position
- elif agent.status == RailAgentStatus.READY_TO_DEPART:
+
+ if agent.state.is_off_map_state():
agent_virtual_position = agent.initial_position
- elif agent.status == RailAgentStatus.ACTIVE:
+ elif agent.state.is_on_map_state():
agent_virtual_position = agent.position
- elif agent.status == RailAgentStatus.DONE:
+ elif agent.state == TrainState.DONE:
agent_virtual_position = agent.target
else:
return None
@@ -222,7 +221,7 @@ class TreeObsForRailEnv(ObservationBuilder):
agent.direction)],
num_agents_same_direction=0, num_agents_opposite_direction=0,
num_agents_malfunctioning=agent.malfunction_data['malfunction'],
- speed_min_fractional=agent.speed_data['speed'],
+ speed_min_fractional=agent.speed_counter.speed,
num_agents_ready_to_depart=0,
childs={})
#print("root node type:", type(root_node_observation))
@@ -276,7 +275,7 @@ class TreeObsForRailEnv(ObservationBuilder):
visited = OrderedSet()
agent = self.env.agents[handle]
- time_per_cell = np.reciprocal(agent.speed_data["speed"])
+ time_per_cell = np.reciprocal(agent.speed_counter.speed)
own_target_encountered = np.inf
other_agent_encountered = np.inf
other_target_encountered = np.inf
@@ -342,7 +341,7 @@ class TreeObsForRailEnv(ObservationBuilder):
self._reverse_dir(
self.predicted_dir[predicted_time][ca])] == 1 and tot_dist < potential_conflict:
potential_conflict = tot_dist
- if self.env.agents[ca].status == RailAgentStatus.DONE and tot_dist < potential_conflict:
+ if self.env.agents[ca].state == TrainState.DONE and tot_dist < potential_conflict:
potential_conflict = tot_dist
# Look for conflicting paths at distance num_step-1
@@ -353,7 +352,7 @@ class TreeObsForRailEnv(ObservationBuilder):
and cell_transitions[self._reverse_dir(self.predicted_dir[pre_step][ca])] == 1 \
and tot_dist < potential_conflict: # noqa: E125
potential_conflict = tot_dist
- if self.env.agents[ca].status == RailAgentStatus.DONE and tot_dist < potential_conflict:
+ if self.env.agents[ca].state == TrainState.DONE and tot_dist < potential_conflict:
potential_conflict = tot_dist
# Look for conflicting paths at distance num_step+1
@@ -364,7 +363,7 @@ class TreeObsForRailEnv(ObservationBuilder):
self.predicted_dir[post_step][ca])] == 1 \
and tot_dist < potential_conflict: # noqa: E125
potential_conflict = tot_dist
- if self.env.agents[ca].status == RailAgentStatus.DONE and tot_dist < potential_conflict:
+ if self.env.agents[ca].state == TrainState.DONE and tot_dist < potential_conflict:
potential_conflict = tot_dist
if position in self.location_has_target and position != agent.target:
@@ -569,13 +568,11 @@ class GlobalObsForRailEnv(ObservationBuilder):
def get(self, handle: int = 0) -> (np.ndarray, np.ndarray, np.ndarray):
agent = self.env.agents[handle]
- if agent.status == RailAgentStatus.WAITING:
- agent_virtual_position = agent.initial_position
- elif agent.status == RailAgentStatus.READY_TO_DEPART:
+ if agent.state.is_off_map_state():
agent_virtual_position = agent.initial_position
- elif agent.status == RailAgentStatus.ACTIVE:
+ elif agent.state.is_on_map_state():
agent_virtual_position = agent.position
- elif agent.status == RailAgentStatus.DONE:
+ elif agent.state == TrainState.DONE:
agent_virtual_position = agent.target
else:
return None
@@ -596,7 +593,7 @@ class GlobalObsForRailEnv(ObservationBuilder):
other_agent: EnvAgent = self.env.agents[i]
# ignore other agents not in the grid any more
- if other_agent.status == RailAgentStatus.DONE_REMOVED:
+ if other_agent.state == TrainState.DONE:
continue
obs_targets[other_agent.target][1] = 1
@@ -607,9 +604,9 @@ class GlobalObsForRailEnv(ObservationBuilder):
if i != handle:
obs_agents_state[other_agent.position][1] = other_agent.direction
obs_agents_state[other_agent.position][2] = other_agent.malfunction_data['malfunction']
- obs_agents_state[other_agent.position][3] = other_agent.speed_data['speed']
+ obs_agents_state[other_agent.position][3] = other_agent.speed_counter.speed
# fifth channel: all ready to depart on this position
- if other_agent.status == RailAgentStatus.READY_TO_DEPART or other_agent.status == RailAgentStatus.WAITING:
+ if other_agent.state.is_off_map_state():
obs_agents_state[other_agent.initial_position][4] += 1
return self.rail_obs, obs_agents_state, obs_targets
diff --git a/flatland/envs/persistence.py b/flatland/envs/persistence.py
index 188ac7c2f1ea2e0c9ea9f637670f154bb54e2518..29ad4760001b4d94394ffc848a7b778d36d4c7a3 100644
--- a/flatland/envs/persistence.py
+++ b/flatland/envs/persistence.py
@@ -2,28 +2,21 @@
import pickle
import msgpack
-import msgpack_numpy
import numpy as np
+import msgpack_numpy
+msgpack_numpy.patch()
from flatland.envs import rail_env
-#from flatland.core.env import Environment
from flatland.core.env_observation_builder import DummyObservationBuilder
-#from flatland.core.grid.grid4 import Grid4TransitionsEnum, Grid4Transitions
-#from flatland.core.grid.grid4_utils import get_new_position
-#from flatland.core.grid.grid_utils import IntVector2D
from flatland.core.transition_map import GridTransitionMap
-from flatland.envs.agent_utils import Agent, EnvAgent, RailAgentStatus
-from flatland.envs.distance_map import DistanceMap
-
-#from flatland.envs.observations import GlobalObsForRailEnv
+from flatland.envs.agent_utils import EnvAgent, load_env_agent
# cannot import objects / classes directly because of circular import
from flatland.envs import malfunction_generators as mal_gen
from flatland.envs import rail_generators as rail_gen
from flatland.envs import line_generators as line_gen
-msgpack_numpy.patch()
class RailEnvPersister(object):
@@ -163,7 +156,8 @@ class RailEnvPersister(object):
# remove the legacy key
del env_dict["agents_static"]
elif "agents" in env_dict:
- env_dict["agents"] = [EnvAgent(*d[0:len(d)]) for d in env_dict["agents"]]
+ # env_dict["agents"] = [EnvAgent(*d[0:len(d)]) for d in env_dict["agents"]]
+ env_dict["agents"] = [load_env_agent(d) for d in env_dict["agents"]]
return env_dict
diff --git a/flatland/envs/predictions.py b/flatland/envs/predictions.py
index 3cd3b71443b33398a8cc02bfec8bf51c682238ef..8bdb9a5e2d28a4870434dbba67603e31551fe2d5 100644
--- a/flatland/envs/predictions.py
+++ b/flatland/envs/predictions.py
@@ -5,11 +5,12 @@ Collection of environment-specific PredictionBuilder.
import numpy as np
from flatland.core.env_prediction_builder import PredictionBuilder
-from flatland.envs.agent_utils import RailAgentStatus
from flatland.envs.distance_map import DistanceMap
from flatland.envs.rail_env_action import RailEnvActions
from flatland.envs.rail_env_shortest_paths import get_shortest_paths
from flatland.utils.ordered_set import OrderedSet
+from flatland.envs.step_utils.states import TrainState
+from flatland.envs.step_utils import transition_utils
class DummyPredictorForRailEnv(PredictionBuilder):
@@ -48,7 +49,7 @@ class DummyPredictorForRailEnv(PredictionBuilder):
prediction_dict = {}
for agent in agents:
- if agent.status != RailAgentStatus.ACTIVE:
+ if not agent.state.is_on_map_state():
# TODO make this generic
continue
action_priorities = [RailEnvActions.MOVE_FORWARD, RailEnvActions.MOVE_LEFT, RailEnvActions.MOVE_RIGHT]
@@ -64,8 +65,8 @@ class DummyPredictorForRailEnv(PredictionBuilder):
continue
for action in action_priorities:
- cell_is_free, new_cell_isValid, new_direction, new_position, transition_isValid = \
- self.env._check_action_on_agent(action, agent)
+ new_cell_isValid, new_direction, new_position, transition_isValid = \
+ transition_utils.check_action_on_agent(action, self.env.rail, agent.position, agent.direction)
if all([new_cell_isValid, transition_isValid]):
# move and change direction to face the new_direction that was
# performed
@@ -126,13 +127,11 @@ class ShortestPathPredictorForRailEnv(PredictionBuilder):
prediction_dict = {}
for agent in agents:
- if agent.status == RailAgentStatus.WAITING:
+ if agent.state.is_off_map_state():
agent_virtual_position = agent.initial_position
- elif agent.status == RailAgentStatus.READY_TO_DEPART:
- agent_virtual_position = agent.initial_position
- elif agent.status == RailAgentStatus.ACTIVE:
+ elif agent.state.is_on_map_state():
agent_virtual_position = agent.position
- elif agent.status == RailAgentStatus.DONE:
+ elif agent.state == TrainState.DONE:
agent_virtual_position = agent.target
else:
@@ -143,7 +142,7 @@ class ShortestPathPredictorForRailEnv(PredictionBuilder):
continue
agent_virtual_direction = agent.direction
- agent_speed = agent.speed_data["speed"]
+ agent_speed = agent.speed_counter.speed
times_per_cell = int(np.reciprocal(agent_speed))
prediction = np.zeros(shape=(self.max_depth + 1, 5))
prediction[0] = [0, *agent_virtual_position, agent_virtual_direction, 0]
diff --git a/flatland/envs/rail_env.py b/flatland/envs/rail_env.py
index 69c6cd2f6e31436fcf70d49697d0afc7a7328a6b..9854e722b9be10769a59d6f2ed0e9ccc2c9f890f 100644
--- a/flatland/envs/rail_env.py
+++ b/flatland/envs/rail_env.py
@@ -2,24 +2,26 @@
Definition of the RailEnv environment.
"""
import random
-# TODO: _ this is a global method --> utils or remove later
-from enum import IntEnum
-from typing import List, NamedTuple, Optional, Dict, Tuple
-import numpy as np
+from typing import List, Optional, Dict, Tuple
+<<<<<<< HEAD
from flatland.utils.rendertools import RenderTool, AgentRenderVariant
+=======
+import numpy as np
+from gym.utils import seeding
+from dataclasses import dataclass
+
+>>>>>>> env-step-facelift
from flatland.core.env import Environment
from flatland.core.env_observation_builder import ObservationBuilder
-from flatland.core.grid.grid4 import Grid4TransitionsEnum, Grid4Transitions
+from flatland.core.grid.grid4 import Grid4Transitions
from flatland.core.grid.grid4_utils import get_new_position
-from flatland.core.grid.grid_utils import IntVector2D
from flatland.core.transition_map import GridTransitionMap
-from flatland.envs.agent_utils import Agent, EnvAgent, RailAgentStatus
+from flatland.envs.agent_utils import EnvAgent
from flatland.envs.distance_map import DistanceMap
from flatland.envs.rail_env_action import RailEnvActions
-# Need to use circular imports for persistence.
from flatland.envs import malfunction_generators as mal_gen
from flatland.envs import rail_generators as rail_gen
from flatland.envs import line_generators as line_gen
@@ -28,46 +30,11 @@ from flatland.envs import persistence
from flatland.envs import agent_chains as ac
from flatland.envs.observations import GlobalObsForRailEnv
-from gym.utils import seeding
-
-# Direct import of objects / classes does not work with circular imports.
-# from flatland.envs.malfunction_generators import no_malfunction_generator, Malfunction, MalfunctionProcessData
-# from flatland.envs.observations import GlobalObsForRailEnv
-# from flatland.envs.rail_generators import random_rail_generator, RailGenerator
-# from flatland.envs.line_generators import random_line_generator, LineGenerator
-
-
-
-# Adrian Egli performance fix (the fast methods brings more than 50%)
-def fast_isclose(a, b, rtol):
- return (a < (b + rtol)) or (a < (b - rtol))
-
-
-def fast_clip(position: (int, int), min_value: (int, int), max_value: (int, int)) -> bool:
- return (
- max(min_value[0], min(position[0], max_value[0])),
- max(min_value[1], min(position[1], max_value[1]))
- )
-
-
-def fast_argmax(possible_transitions: (int, int, int, int)) -> bool:
- if possible_transitions[0] == 1:
- return 0
- if possible_transitions[1] == 1:
- return 1
- if possible_transitions[2] == 1:
- return 2
- return 3
-
-
-def fast_position_equal(pos_1: (int, int), pos_2: (int, int)) -> bool:
- return pos_1[0] == pos_2[0] and pos_1[1] == pos_2[1]
-
-
-def fast_count_nonzero(possible_transitions: (int, int, int, int)):
- return possible_transitions[0] + possible_transitions[1] + possible_transitions[2] + possible_transitions[3]
-
+from flatland.envs.timetable_generators import timetable_generator
+from flatland.envs.step_utils.states import TrainState, StateTransitionSignals
+from flatland.envs.step_utils import transition_utils
+from flatland.envs.step_utils import action_preprocessing
class RailEnv(Environment):
"""
@@ -255,6 +222,8 @@ class RailEnv(Environment):
self.close_following = close_following # use close following logic
self.motionCheck = ac.MotionCheck()
+ self.agent_helpers = {}
+
def _seed(self, seed=None):
self.np_random, seed = seeding.np_random(seed)
random.seed(seed)
@@ -274,11 +243,6 @@ class RailEnv(Environment):
self.agents.append(agent)
return len(self.agents) - 1
- def set_agent_active(self, agent: EnvAgent):
- if agent.status == RailAgentStatus.READY_TO_DEPART or agent.status == RailAgentStatus.WAITING and self.cell_free(agent.initial_position): ## Dipam : Why is this code even there???
- agent.status = RailAgentStatus.ACTIVE
- self._set_agent_to_initial_position(agent, agent.initial_position)
-
def reset_agents(self):
""" Reset the agents to their starting positions
"""
@@ -300,11 +264,10 @@ class RailEnv(Environment):
True: Agent needs to provide an action
False: Agent cannot provide an action
"""
- return (agent.status == RailAgentStatus.READY_TO_DEPART or (
- agent.status == RailAgentStatus.ACTIVE and fast_isclose(agent.speed_data['position_fraction'], 0.0,
- rtol=1e-03)))
+ return agent.state == TrainState.READY_TO_DEPART or \
+ ( agent.state.is_on_map_state() and agent.speed_counter.is_cell_entry )
- def reset(self, regenerate_rail: bool = True, regenerate_schedule: bool = True, activate_agents: bool = False,
+ def reset(self, regenerate_rail: bool = True, regenerate_schedule: bool = True, *,
random_seed: bool = None) -> Tuple[Dict, Dict]:
"""
reset(regenerate_rail, regenerate_schedule, activate_agents, random_seed)
@@ -317,8 +280,6 @@ class RailEnv(Environment):
regenerate the rails
regenerate_schedule : bool, optional
regenerate the schedule and the static agents
- activate_agents : bool, optional
- activate the agents
random_seed : bool, optional
random seed for environment
@@ -386,19 +347,6 @@ class RailEnv(Environment):
# Reset agents to initial states
self.reset_agents()
- for agent in self.agents:
- # Induce malfunctions
- if activate_agents:
- self.set_agent_active(agent)
-
- self._break_agent(agent)
-
- if agent.malfunction_data["malfunction"] > 0:
- agent.speed_data['transition_action_on_cellexit'] = RailEnvActions.DO_NOTHING
-
- # Fix agents that finished their malfunction
- self._fix_agent_after_malfunction(agent)
-
self.num_resets += 1
self._elapsed_steps = 0
@@ -408,74 +356,51 @@ class RailEnv(Environment):
# Reset the state of the observation builder with the new environment
self.obs_builder.reset()
- # Reset the malfunction generator
- if "generate" in dir(self.malfunction_generator):
- self.malfunction_generator.generate(reset=True)
- else:
- self.malfunction_generator(reset=True)
-
# Empty the episode store of agent positions
self.cur_episode = []
- info_dict: Dict = {
- 'action_required': {i: self.action_required(agent) for i, agent in enumerate(self.agents)},
- 'malfunction': {
- i: agent.malfunction_data['malfunction'] for i, agent in enumerate(self.agents)
- },
- 'speed': {i: agent.speed_data['speed'] for i, agent in enumerate(self.agents)},
- 'status': {i: agent.status for i, agent in enumerate(self.agents)}
- }
+ info_dict = self.get_info_dict()
# Return the new observation vectors for each agent
observation_dict: Dict = self._get_observations()
if hasattr(self, "renderer") and self.renderer is not None:
self.renderer = None
return observation_dict, info_dict
+
+ def apply_action_independent(self, action, rail, position, direction):
+ if action.is_moving_action():
+ new_direction, _ = transition_utils.check_action(action, position, direction, rail)
+ new_position = get_new_position(position, new_direction)
+ else:
+ new_position, new_direction = position, direction
+ return new_position, new_direction
+
+ def generate_state_transition_signals(self, agent, preprocessed_action, movement_allowed):
+ """ Generate State Transitions Signals used in the state machine """
+ st_signals = StateTransitionSignals()
+
+ # Malfunction starts when in_malfunction is set to true
+ st_signals.in_malfunction = agent.malfunction_handler.in_malfunction
- def _fix_agent_after_malfunction(self, agent: EnvAgent):
- """
- Updates agent malfunction variables and fixes broken agents
-
- Parameters
- ----------
- agent
- """
-
- # Ignore agents that are OK
- if self._is_agent_ok(agent):
- return
+ # Malfunction counter complete - Malfunction ends next timestep
+ st_signals.malfunction_counter_complete = agent.malfunction_handler.malfunction_counter_complete
- # Reduce number of malfunction steps left
- if agent.malfunction_data['malfunction'] > 1:
- agent.malfunction_data['malfunction'] -= 1
- return
+ # Earliest departure reached - Train is allowed to move now
+ st_signals.earliest_departure_reached = self._elapsed_steps >= agent.earliest_departure
- # Restart agents at the end of their malfunction
- agent.malfunction_data['malfunction'] -= 1
- if 'moving_before_malfunction' in agent.malfunction_data:
- agent.moving = agent.malfunction_data['moving_before_malfunction']
- return
+ # Stop Action Given
+ st_signals.stop_action_given = (preprocessed_action == RailEnvActions.STOP_MOVING)
- def _break_agent(self, agent: EnvAgent):
- """
- Malfunction generator that breaks agents at a given rate.
+ # Valid Movement action Given
+ st_signals.valid_movement_action_given = preprocessed_action.is_moving_action() and movement_allowed
- Parameters
- ----------
- agent
-
- """
-
- if "generate" in dir(self.malfunction_generator):
- malfunction: mal_gen.Malfunction = self.malfunction_generator.generate(agent, self.np_random)
- else:
- malfunction: mal_gen.Malfunction = self.malfunction_generator(agent, self.np_random)
+ # Target Reached
+ st_signals.target_reached = fast_position_equal(agent.position, agent.target)
- if malfunction.num_broken_steps > 0:
- agent.malfunction_data['malfunction'] = malfunction.num_broken_steps
- agent.malfunction_data['moving_before_malfunction'] = agent.moving
- agent.malfunction_data['nr_malfunctions'] += 1
+ # Movement conflict - Multiple trains trying to move into same cell
+ # If speed counter is not in cell exit, the train can enter the cell
+ st_signals.movement_conflict = (not movement_allowed) and agent.speed_counter.is_cell_exit
- return
+ return st_signals
def _handle_end_reward(self, agent: EnvAgent) -> int:
'''
@@ -487,7 +412,7 @@ class RailEnv(Environment):
'''
reward = None
# agent done? (arrival_time is not None)
- if agent.status == RailAgentStatus.DONE or agent.status == RailAgentStatus.DONE_REMOVED:
+ if agent.state == TrainState.DONE:
# if agent arrived earlier or on time = 0
# if agent arrived later = -ve reward based on how late
reward = min(agent.latest_arrival - agent.arrival_time, 0)
@@ -495,533 +420,183 @@ class RailEnv(Environment):
# Agents not done (arrival_time is None)
else:
# CANCELLED check (never departed)
- if (agent.status == RailAgentStatus.READY_TO_DEPART):
+ if (agent.state.is_off_map_state()):
reward = -1 * self.cancellation_factor * \
(agent.get_travel_time_on_shortest_path(self.distance_map) + self.cancellation_time_buffer)
# Departed but never reached
- if (agent.status == RailAgentStatus.ACTIVE):
+ if (agent.state.is_on_map_state()):
reward = agent.get_current_delay(self._elapsed_steps, self.distance_map)
return reward
- def step(self, action_dict_: Dict[int, RailEnvActions]):
+ def preprocess_action(self, action, agent):
"""
- Updates rewards for the agents at a step.
-
- Parameters
- ----------
- action_dict_ : Dict[int,RailEnvActions]
-
+ Preprocess the provided action
+ * Change to DO_NOTHING if illegal action
+ * Block all actions when in waiting state
+ * Check MOVE_LEFT/MOVE_RIGHT actions on current position else try MOVE_FORWARD
"""
- self._elapsed_steps += 1
-
- # If we're done, set reward and info_dict and step() is done.
- if self.dones["__all__"]:
- raise Exception("Episode is done, cannot call step()")
+ action = action_preprocessing.preprocess_raw_action(action, agent.state, agent.action_saver.saved_action)
+ action = action_preprocessing.preprocess_action_when_waiting(action, agent.state)
- # Reset the step rewards
- self.rewards_dict = dict()
+ # Try moving actions on current position
+ current_position, current_direction = agent.position, agent.direction
+ if current_position is None: # Agent not added on map yet
+ current_position, current_direction = agent.initial_position, agent.initial_direction
+
+ action = action_preprocessing.preprocess_moving_action(action, self.rail, current_position, current_direction)
+ return action
+
+ def clear_rewards_dict(self):
+ """ Reset the rewards dictionary """
+ self.rewards_dict = {i_agent: 0 for i_agent in range(len(self.agents))}
+
+ def get_info_dict(self): # TODO Important : Update this
info_dict = {
- "action_required": {},
- "malfunction": {},
- "speed": {},
- "status": {},
+ 'action_required': {i: self.action_required(agent) for i, agent in enumerate(self.agents)},
+ 'malfunction': {
+ i: agent.malfunction_data['malfunction'] for i, agent in enumerate(self.agents)
+ },
+ 'speed': {i: agent.speed_counter.speed for i, agent in enumerate(self.agents)},
+ 'state': {i: agent.state for i, agent in enumerate(self.agents)}
}
- have_all_agents_ended = True # boolean flag to check if all agents are done
+ return info_dict
+
+ def update_step_rewards(self, i_agent):
+ pass
- self.motionCheck = ac.MotionCheck() # reset the motion check
+ def end_of_episode_update(self, have_all_agents_ended):
+ if have_all_agents_ended or \
+ ( (self._max_episode_steps is not None) and (self._elapsed_steps >= self._max_episode_steps)):
- if not self.close_following:
for i_agent, agent in enumerate(self.agents):
- # Reset the step rewards
- self.rewards_dict[i_agent] = 0
-
- # Induce malfunction before we do a step, thus a broken agent can't move in this step
- self._break_agent(agent)
+
+ reward = self._handle_end_reward(agent)
+ self.rewards_dict[i_agent] += reward
+
+ self.dones[i_agent] = True
- # Perform step on the agent
- self._step_agent(i_agent, action_dict_.get(i_agent))
+ self.dones["__all__"] = True
- # manage the boolean flag to check if all agents are indeed done (or done_removed)
- have_all_agents_ended &= (agent.status in [RailAgentStatus.DONE, RailAgentStatus.DONE_REMOVED])
+ def handle_done_state(self, agent):
+ if agent.state == TrainState.DONE:
+ agent.arrival_time = self._elapsed_steps
+ if self.remove_agents_at_target:
+ agent.position = None
- # Build info dict
- info_dict["action_required"][i_agent] = self.action_required(agent)
- info_dict["malfunction"][i_agent] = agent.malfunction_data['malfunction']
- info_dict["speed"][i_agent] = agent.speed_data['speed']
- info_dict["status"][i_agent] = agent.status
+ def step(self, action_dict_: Dict[int, RailEnvActions]):
+ """
+ Updates rewards for the agents at a step.
+ """
+ self._elapsed_steps += 1
- # Fix agents that finished their malfunction such that they can perform an action in the next step
- self._fix_agent_after_malfunction(agent)
+ # Not allowed to step further once done
+ if self.dones["__all__"]:
+ raise Exception("Episode is done, cannot call step()")
+ self.clear_rewards_dict()
- else:
- for i_agent, agent in enumerate(self.agents):
- # Reset the step rewards
- self.rewards_dict[i_agent] = 0
+ have_all_agents_ended = True # Boolean flag to check if all agents are done
- # Induce malfunction before we do a step, thus a broken agent can't move in this step
- self._break_agent(agent)
+ self.motionCheck = ac.MotionCheck() # reset the motion check
- # Perform step on the agent
- self._step_agent_cf(i_agent, action_dict_.get(i_agent))
+ temp_transition_data = {}
+
+ for agent in self.agents:
+ i_agent = agent.handle
+ agent.old_position = agent.position
+ agent.old_direction = agent.direction
+ # Generate malfunction
+ agent.malfunction_handler.generate_malfunction(self.malfunction_generator, self.np_random)
- # second loop: check for collisions / conflicts
- self.motionCheck.find_conflicts()
+ # Get action for the agent
+ action = action_dict_.get(i_agent, RailEnvActions.DO_NOTHING)
- # third loop: update positions
- for i_agent, agent in enumerate(self.agents):
- self._step_agent2_cf(i_agent)
+ preprocessed_action = self.preprocess_action(action, agent)
- # manage the boolean flag to check if all agents are indeed done (or done_removed)
- have_all_agents_ended &= (agent.status in [RailAgentStatus.DONE, RailAgentStatus.DONE_REMOVED])
+ # Save moving actions in not already saved
+ agent.action_saver.save_action_if_allowed(preprocessed_action, agent.state)
- # Build info dict
- info_dict["action_required"][i_agent] = self.action_required(agent)
- info_dict["malfunction"][i_agent] = agent.malfunction_data['malfunction']
- info_dict["speed"][i_agent] = agent.speed_data['speed']
- info_dict["status"][i_agent] = agent.status
+ # Train's next position can change if current stopped in a fractional speed or train is at cell's exit
+ position_update_allowed = (agent.speed_counter.is_cell_exit or agent.state == TrainState.STOPPED)
- # Fix agents that finished their malfunction such that they can perform an action in the next step
- self._fix_agent_after_malfunction(agent)
+ # Calculate new position
+ # Add agent to the map if not on it yet
+ if agent.position is None and agent.action_saver.is_action_saved:
+ new_position = agent.initial_position
+ new_direction = agent.initial_direction
+
+ # If movement is allowed apply saved action independent of other agents
+ elif agent.action_saver.is_action_saved and position_update_allowed:
+ saved_action = agent.action_saver.saved_action
+ # Apply action independent of other agents and get temporary new position and direction
+ new_position, new_direction = self.apply_action_independent(saved_action,
+ self.rail,
+ agent.position,
+ agent.direction)
+ preprocessed_action = saved_action
+ else:
+ new_position, new_direction = agent.position, agent.direction
-
- # NEW : REW: (END)
- if ((self._max_episode_steps is not None) and (self._elapsed_steps >= self._max_episode_steps)) \
- or have_all_agents_ended :
+ temp_transition_data[i_agent] = AgentTransitionData(position=new_position,
+ direction=new_direction,
+ preprocessed_action=preprocessed_action)
- for i_agent, agent in enumerate(self.agents):
-
- reward = self._handle_end_reward(agent)
- self.rewards_dict[i_agent] += reward
-
- self.dones[i_agent] = True
+ # This is for storing and later checking for conflicts of agents trying to occupy same cell
+ self.motionCheck.addAgent(i_agent, agent.position, new_position)
- self.dones["__all__"] = True
+ # Find conflicts between trains trying to occupy same cell
+ self.motionCheck.find_conflicts()
+ for agent in self.agents:
+ i_agent = agent.handle
+ agent_transition_data = temp_transition_data[i_agent]
- if self.record_steps:
- self.record_timestep(action_dict_)
-
- return self._get_observations(), self.rewards_dict, self.dones, info_dict
-
- def _step_agent(self, i_agent, action: Optional[RailEnvActions] = None):
- """
- Performs a step and step, start and stop penalty on a single agent in the following sub steps:
- - malfunction
- - action handling if at the beginning of cell
- - movement
-
- Parameters
- ----------
- i_agent : int
- action_dict_ : Dict[int,RailEnvActions]
-
- """
- agent = self.agents[i_agent]
- if agent.status in [RailAgentStatus.DONE, RailAgentStatus.DONE_REMOVED]: # this agent has already completed...
- return
-
- # agent gets active by a MOVE_* action and if c
- if agent.status == RailAgentStatus.READY_TO_DEPART:
- initial_cell_free = self.cell_free(agent.initial_position)
- is_action_starting = action in [
- RailEnvActions.MOVE_LEFT, RailEnvActions.MOVE_RIGHT, RailEnvActions.MOVE_FORWARD]
-
- if action in [RailEnvActions.MOVE_LEFT, RailEnvActions.MOVE_RIGHT,
- RailEnvActions.MOVE_FORWARD] and self.cell_free(agent.initial_position):
- agent.status = RailAgentStatus.ACTIVE
- self._set_agent_to_initial_position(agent, agent.initial_position)
- self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed']
- return
- else:
- # TODO: Here we need to check for the departure time in future releases with full schedules
- self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed']
- return
-
- agent.old_direction = agent.direction
- agent.old_position = agent.position
-
- # if agent is broken, actions are ignored and agent does not move.
- # full step penalty in this case
- if agent.malfunction_data['malfunction'] > 0:
- self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed']
- return
-
- # Is the agent at the beginning of the cell? Then, it can take an action.
- # As long as the agent is malfunctioning or stopped at the beginning of the cell,
- # different actions may be taken!
- if fast_isclose(agent.speed_data['position_fraction'], 0.0, rtol=1e-03):
- # No action has been supplied for this agent -> set DO_NOTHING as default
- if action is None:
- action = RailEnvActions.DO_NOTHING
-
- if action < 0 or action > len(RailEnvActions):
- print('ERROR: illegal action=', action,
- 'for agent with index=', i_agent,
- '"DO NOTHING" will be executed instead')
- action = RailEnvActions.DO_NOTHING
-
- if action == RailEnvActions.DO_NOTHING and agent.moving:
- # Keep moving
- action = RailEnvActions.MOVE_FORWARD
-
- if action == RailEnvActions.STOP_MOVING and agent.moving:
- # Only allow halting an agent on entering new cells.
- agent.moving = False
- self.rewards_dict[i_agent] += self.stop_penalty
-
- if not agent.moving and not (
- action == RailEnvActions.DO_NOTHING or
- action == RailEnvActions.STOP_MOVING):
- # Allow agent to start with any forward or direction action
- agent.moving = True
- self.rewards_dict[i_agent] += self.start_penalty
-
- # Store the action if action is moving
- # If not moving, the action will be stored when the agent starts moving again.
- if agent.moving:
- _action_stored = False
- _, new_cell_valid, new_direction, new_position, transition_valid = \
- self._check_action_on_agent(action, agent)
-
- if all([new_cell_valid, transition_valid]):
- agent.speed_data['transition_action_on_cellexit'] = action
- _action_stored = True
- else:
- # But, if the chosen invalid action was LEFT/RIGHT, and the agent is moving,
- # try to keep moving forward!
- if (action == RailEnvActions.MOVE_LEFT or action == RailEnvActions.MOVE_RIGHT):
- _, new_cell_valid, new_direction, new_position, transition_valid = \
- self._check_action_on_agent(RailEnvActions.MOVE_FORWARD, agent)
-
- if all([new_cell_valid, transition_valid]):
- agent.speed_data['transition_action_on_cellexit'] = RailEnvActions.MOVE_FORWARD
- _action_stored = True
-
- if not _action_stored:
- # If the agent cannot move due to an invalid transition, we set its state to not moving
- self.rewards_dict[i_agent] += self.invalid_action_penalty
- self.rewards_dict[i_agent] += self.stop_penalty
- agent.moving = False
-
- # Now perform a movement.
- # If agent.moving, increment the position_fraction by the speed of the agent
- # If the new position fraction is >= 1, reset to 0, and perform the stored
- # transition_action_on_cellexit if the cell is free.
- if agent.moving:
- agent.speed_data['position_fraction'] += agent.speed_data['speed']
- if agent.speed_data['position_fraction'] > 1.0 or fast_isclose(agent.speed_data['position_fraction'], 1.0,
- rtol=1e-03):
- # Perform stored action to transition to the next cell as soon as cell is free
- # Notice that we've already checked new_cell_valid and transition valid when we stored the action,
- # so we only have to check cell_free now!
-
- # Traditional check that next cell is free
- # cell and transition validity was checked when we stored transition_action_on_cellexit!
- cell_free, new_cell_valid, new_direction, new_position, transition_valid = self._check_action_on_agent(
- agent.speed_data['transition_action_on_cellexit'], agent)
-
- # N.B. validity of new_cell and transition should have been verified before the action was stored!
- assert new_cell_valid
- assert transition_valid
- if cell_free:
- self._move_agent_to_new_position(agent, new_position)
- agent.direction = new_direction
- agent.speed_data['position_fraction'] = 0.0
-
- # has the agent reached its target?
- if np.equal(agent.position, agent.target).all():
- agent.status = RailAgentStatus.DONE
- self.dones[i_agent] = True
- self.active_agents.remove(i_agent)
- agent.moving = False
- self._remove_agent_from_scene(agent)
+ ## Update positions
+ if agent.malfunction_handler.in_malfunction:
+ movement_allowed = False
else:
- self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed']
- else:
- # step penalty if not moving (stopped now or before)
- self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed']
+ movement_allowed = self.motionCheck.check_motion(i_agent, agent.position)
- def _step_agent_cf(self, i_agent, action: Optional[RailEnvActions] = None):
- """ "close following" version of step_agent.
- """
- agent = self.agents[i_agent]
- if agent.status in [RailAgentStatus.DONE, RailAgentStatus.DONE_REMOVED]: # this agent has already completed...
- return
-
- # NEW : STEP: WAITING > WAITING or WAITING > READY_TO_DEPART
- if (agent.status == RailAgentStatus.WAITING):
- if ( self._elapsed_steps >= agent.earliest_departure ):
- agent.status = RailAgentStatus.READY_TO_DEPART
- self.motionCheck.addAgent(i_agent, None, None)
- return
-
- # agent gets active by a MOVE_* action and if c
- if agent.status == RailAgentStatus.READY_TO_DEPART:
- is_action_starting = action in [
- RailEnvActions.MOVE_LEFT, RailEnvActions.MOVE_RIGHT, RailEnvActions.MOVE_FORWARD]
-
- if is_action_starting: # agent is trying to start
- self.motionCheck.addAgent(i_agent, None, agent.initial_position)
- else: # agent wants to remain unstarted
- self.motionCheck.addAgent(i_agent, None, None)
- return
-
- agent.old_direction = agent.direction
- agent.old_position = agent.position
-
- # if agent is broken, actions are ignored and agent does not move.
- # full step penalty in this case
- # TODO: this means that deadlocked agents which suffer a malfunction are marked as
- # stopped rather than deadlocked.
- if agent.malfunction_data['malfunction'] > 0:
- self.motionCheck.addAgent(i_agent, agent.position, agent.position)
- # agent will get penalty in step_agent2_cf
- # self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed']
- return
-
- # Is the agent at the beginning of the cell? Then, it can take an action.
- # As long as the agent is malfunctioning or stopped at the beginning of the cell,
- # different actions may be taken!
- if np.isclose(agent.speed_data['position_fraction'], 0.0, rtol=1e-03):
- # No action has been supplied for this agent -> set DO_NOTHING as default
- if action is None:
- action = RailEnvActions.DO_NOTHING
-
- if action < 0 or action > len(RailEnvActions):
- print('ERROR: illegal action=', action,
- 'for agent with index=', i_agent,
- '"DO NOTHING" will be executed instead')
- action = RailEnvActions.DO_NOTHING
-
- if action == RailEnvActions.DO_NOTHING and agent.moving:
- # Keep moving
- action = RailEnvActions.MOVE_FORWARD
-
- if action == RailEnvActions.STOP_MOVING and agent.moving:
- # Only allow halting an agent on entering new cells.
- agent.moving = False
- self.rewards_dict[i_agent] += self.stop_penalty
-
- if not agent.moving and not (
- action == RailEnvActions.DO_NOTHING or
- action == RailEnvActions.STOP_MOVING):
- # Allow agent to start with any forward or direction action
- agent.moving = True
- self.rewards_dict[i_agent] += self.start_penalty
-
- # Store the action if action is moving
- # If not moving, the action will be stored when the agent starts moving again.
- new_position = None
- if agent.moving:
- _action_stored = False
- _, new_cell_valid, new_direction, new_position, transition_valid = \
- self._check_action_on_agent(action, agent)
-
- if all([new_cell_valid, transition_valid]):
- agent.speed_data['transition_action_on_cellexit'] = action
- _action_stored = True
- else:
- # But, if the chosen invalid action was LEFT/RIGHT, and the agent is moving,
- # try to keep moving forward!
- if (action == RailEnvActions.MOVE_LEFT or action == RailEnvActions.MOVE_RIGHT):
- _, new_cell_valid, new_direction, new_position, transition_valid = \
- self._check_action_on_agent(RailEnvActions.MOVE_FORWARD, agent)
-
- if all([new_cell_valid, transition_valid]):
- agent.speed_data['transition_action_on_cellexit'] = RailEnvActions.MOVE_FORWARD
- _action_stored = True
-
- if not _action_stored:
- # If the agent cannot move due to an invalid transition, we set its state to not moving
- self.rewards_dict[i_agent] += self.invalid_action_penalty
- self.rewards_dict[i_agent] += self.stop_penalty
- agent.moving = False
- self.motionCheck.addAgent(i_agent, agent.position, agent.position)
- return
-
- if new_position is None:
- self.motionCheck.addAgent(i_agent, agent.position, agent.position)
- if agent.moving:
- print("Agent", i_agent, "new_pos none, but moving")
-
- # Check the pos_frac position fraction
- if agent.moving:
- agent.speed_data['position_fraction'] += agent.speed_data['speed']
- if agent.speed_data['position_fraction'] > 0.999:
- stored_action = agent.speed_data["transition_action_on_cellexit"]
-
- # find the next cell using the stored action
- _, new_cell_valid, new_direction, new_position, transition_valid = \
- self._check_action_on_agent(stored_action, agent)
-
- # if it's valid, record it as the new position
- if all([new_cell_valid, transition_valid]):
- self.motionCheck.addAgent(i_agent, agent.position, new_position)
- else: # if the action wasn't valid then record the agent as stationary
- self.motionCheck.addAgent(i_agent, agent.position, agent.position)
- else: # This agent hasn't yet crossed the cell
- self.motionCheck.addAgent(i_agent, agent.position, agent.position)
-
- def _step_agent2_cf(self, i_agent):
- agent = self.agents[i_agent]
-
- # NEW : REW: (WAITING) no reward during WAITING...
- if agent.status in [RailAgentStatus.DONE, RailAgentStatus.DONE_REMOVED, RailAgentStatus.WAITING]:
- return
-
- (move, rc_next) = self.motionCheck.check_motion(i_agent, agent.position)
-
- if agent.position is not None:
- sbTrans = format(self.rail.grid[agent.position], "016b")
- trans_block = sbTrans[agent.direction * 4: agent.direction * 4 + 4]
- if (trans_block == "0000"):
- print (i_agent, agent.position, agent.direction, sbTrans, trans_block)
-
- # if agent cannot enter env, then we should have move=False
-
- if move:
- if agent.position is None: # agent is entering the env
- # print(i_agent, "writing new pos ", rc_next, " into agent position (None)")
- agent.position = rc_next
- agent.status = RailAgentStatus.ACTIVE
- agent.speed_data['position_fraction'] = 0.0
-
- else: # normal agent move
- cell_free, new_cell_valid, new_direction, new_position, transition_valid = self._check_action_on_agent(
- agent.speed_data['transition_action_on_cellexit'], agent)
-
- if not all([transition_valid, new_cell_valid]):
- print(f"ERRROR: step_agent2 invalid transition ag {i_agent} dir {new_direction} pos {agent.position} next {rc_next}")
-
- if new_position != rc_next:
- print(f"ERROR: agent {i_agent} new_pos {new_position} != rc_next {rc_next} " +
- f"pos {agent.position} dir {agent.direction} new_dir {new_direction}" +
- f"stored action: {agent.speed_data['transition_action_on_cellexit']}")
-
- sbTrans = format(self.rail.grid[agent.position], "016b")
- trans_block = sbTrans[agent.direction * 4: agent.direction * 4 + 4]
- if (trans_block == "0000"):
- print ("ERROR: ", i_agent, agent.position, agent.direction, sbTrans, trans_block)
-
- agent.position = rc_next
- agent.direction = new_direction
- agent.speed_data['position_fraction'] = 0.0
-
- # NEW : STEP: Check DONE before / after LA & Check if RUNNING before / after LA
- # has the agent reached its target?
- if np.equal(agent.position, agent.target).all():
- # arrived before or after Latest Arrival
- agent.status = RailAgentStatus.DONE
- self.dones[i_agent] = True
- self.active_agents.remove(i_agent)
- agent.moving = False
- agent.arrival_time = self._elapsed_steps
- self._remove_agent_from_scene(agent)
-
- else: # not reached its target and moving
- # running before Latest Arrival
- if (self._elapsed_steps <= agent.latest_arrival):
- self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed']
- else: # running after Latest Arrival
- self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed'] # + # NEGATIVE REWARD? per step?
- else:
- # stopped (!move) before Latest Arrival
- if (self._elapsed_steps <= agent.latest_arrival):
- self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed']
- else: # stopped (!move) after Latest Arrival
- self.rewards_dict[i_agent] += self.step_penalty * agent.speed_data['speed'] # + # NEGATIVE REWARD? per step?
+ # Position can be changed only if other cell is empty
+ # And either the speed counter completes or agent is being added to map
+ if movement_allowed and \
+ (agent.speed_counter.is_cell_exit or agent.position is None):
+ agent.position = agent_transition_data.position
+ agent.direction = agent_transition_data.direction
- def _set_agent_to_initial_position(self, agent: EnvAgent, new_position: IntVector2D):
- """
- Sets the agent to its initial position. Updates the agent object and the position
- of the agent inside the global agent_position numpy array
+ preprocessed_action = agent_transition_data.preprocessed_action
- Parameters
- -------
- agent: EnvAgent object
- new_position: IntVector2D
- """
- agent.position = new_position
- self.agent_positions[agent.position] = agent.handle
-
- def _move_agent_to_new_position(self, agent: EnvAgent, new_position: IntVector2D):
- """
- Move the agent to the a new position. Updates the agent object and the position
- of the agent inside the global agent_position numpy array
-
- Parameters
- -------
- agent: EnvAgent object
- new_position: IntVector2D
- """
- agent.position = new_position
- self.agent_positions[agent.old_position] = -1
- self.agent_positions[agent.position] = agent.handle
+ ## Update states
+ state_transition_signals = self.generate_state_transition_signals(agent, preprocessed_action, movement_allowed)
+ agent.state_machine.set_transition_signals(state_transition_signals)
+ agent.state_machine.step()
- def _remove_agent_from_scene(self, agent: EnvAgent):
- """
- Remove the agent from the scene. Updates the agent object and the position
- of the agent inside the global agent_position numpy array
+ # Off map or on map state and position should match
+ state_position_sync_check(agent.state, agent.position, agent.handle)
- Parameters
- -------
- agent: EnvAgent object
- """
- self.agent_positions[agent.position] = -1
- if self.remove_agents_at_target:
- agent.position = None
- # setting old_position to None here stops the DONE agents from appearing in the rendered image
- agent.old_position = None
- agent.status = RailAgentStatus.DONE_REMOVED
-
- def _check_action_on_agent(self, action: RailEnvActions, agent: EnvAgent):
- """
+ # Handle done state actions, optionally remove agents
+ self.handle_done_state(agent)
+
+ have_all_agents_ended &= (agent.state == TrainState.DONE)
- Parameters
- ----------
- action : RailEnvActions
- agent : EnvAgent
+ ## Update rewards
+ self.update_step_rewards(i_agent)
- Returns
- -------
- bool
- Is it a legal move?
- 1) transition allows the new_direction in the cell,
- 2) the new cell is not empty (case 0),
- 3) the cell is free, i.e., no agent is currently in that cell
+ ## Update counters (malfunction and speed)
+ agent.speed_counter.update_counter(agent.state, agent.old_position)
+ # agent.state_machine.previous_state)
+ agent.malfunction_handler.update_counter()
+ # Clear old action when starting in new cell
+ if agent.speed_counter.is_cell_entry and agent.position is not None:
+ agent.action_saver.clear_saved_action()
+
+ # Check if episode has ended and update rewards and dones
+ self.end_of_episode_update(have_all_agents_ended)
- """
- # compute number of possible transitions in the current
- # cell used to check for invalid actions
- new_direction, transition_valid = self.check_action(agent, action)
- new_position = get_new_position(agent.position, new_direction)
-
- new_cell_valid = (
- fast_position_equal( # Check the new position is still in the grid
- new_position,
- fast_clip(new_position, [0, 0], [self.height - 1, self.width - 1]))
- and # check the new position has some transitions (ie is not an empty cell)
- self.rail.get_full_transitions(*new_position) > 0)
-
- # If transition validity hasn't been checked yet.
- if transition_valid is None:
- transition_valid = self.rail.get_transition(
- (*agent.position, agent.direction),
- new_direction)
-
- # only call cell_free() if new cell is inside the scene
- if new_cell_valid:
- # Check the new position is not the same as any of the existing agent positions
- # (including itself, for simplicity, since it is moving)
- cell_free = self.cell_free(new_position)
- else:
- # if new cell is outside of scene -> cell_free is False
- cell_free = False
- return cell_free, new_cell_valid, new_direction, new_position, transition_valid
+ return self._get_observations(), self.rewards_dict, self.dones, self.get_info_dict()
def record_timestep(self, dActions):
''' Record the positions and orientations of all agents in memory, in the cur_episode
@@ -1046,62 +621,6 @@ class RailEnv(Environment):
self.cur_episode.append(list_agents_state)
self.list_actions.append(dActions)
- def cell_free(self, position: IntVector2D) -> bool:
- """
- Utility to check if a cell is free
-
- Parameters:
- --------
- position : Tuple[int, int]
-
- Returns
- -------
- bool
- is the cell free or not?
-
- """
- return self.agent_positions[position] == -1
-
- def check_action(self, agent: EnvAgent, action: RailEnvActions):
- """
-
- Parameters
- ----------
- agent : EnvAgent
- action : RailEnvActions
-
- Returns
- -------
- Tuple[Grid4TransitionsEnum,Tuple[int,int]]
-
-
-
- """
- transition_valid = None
- possible_transitions = self.rail.get_transitions(*agent.position, agent.direction)
- num_transitions = fast_count_nonzero(possible_transitions)
-
- new_direction = agent.direction
- if action == RailEnvActions.MOVE_LEFT:
- new_direction = agent.direction - 1
- if num_transitions <= 1:
- transition_valid = False
-
- elif action == RailEnvActions.MOVE_RIGHT:
- new_direction = agent.direction + 1
- if num_transitions <= 1:
- transition_valid = False
-
- new_direction %= 4
-
- if action == RailEnvActions.MOVE_FORWARD and num_transitions == 1:
- # - dead-end, straight line or curved line;
- # new_direction will be the only valid transition
- # - take only available transition
- new_direction = fast_argmax(possible_transitions)
- transition_valid = True
- return new_direction, transition_valid
-
def _get_observations(self):
"""
Utility which returns the observations for an agent with respect to environment
@@ -1152,7 +671,7 @@ class RailEnv(Environment):
True if agent is ok, False otherwise
"""
- return agent.malfunction_data['malfunction'] < 1
+ return agent.malfunction_handler.in_malfunction
def save(self, filename):
print("deprecated call to env.save() - pls call RailEnvPersister.save()")
@@ -1232,3 +751,30 @@ class RailEnv(Environment):
except Exception as e:
print("Could Not close window due to:",e)
self.renderer = None
+
+
+@dataclass(repr=True)
+class AgentTransitionData:
+ """ Class for keeping track of temporary agent data for position update """
+ position : Tuple[int, int]
+ direction : Grid4Transitions
+ preprocessed_action : RailEnvActions
+
+
+# Adrian Egli performance fix (the fast methods brings more than 50%)
+def fast_isclose(a, b, rtol):
+ return (a < (b + rtol)) or (a < (b - rtol))
+
+def fast_position_equal(pos_1: (int, int), pos_2: (int, int)) -> bool:
+ if pos_1 is None: # TODO: Dipam - Consider making default of agent.position as (-1, -1) instead of None
+ return False
+ else:
+ return pos_1[0] == pos_2[0] and pos_1[1] == pos_2[1]
+
+def state_position_sync_check(state, position, i_agent):
+ if state.is_on_map_state() and position is None:
+ raise ValueError("Agent ID {} Agent State {} is on map Agent Position {} if off map ".format(
+ i_agent, str(state), str(position) ))
+ elif state.is_off_map_state() and position is not None:
+ raise ValueError("Agent ID {} Agent State {} is off map Agent Position {} if on map ".format(
+ i_agent, str(state), str(position) ))
diff --git a/flatland/envs/rail_env_action.py b/flatland/envs/rail_env_action.py
index 6fcc175e7f7f63653153f8841ec3ba398876d4a1..8665897f949294a9a1bf50fdc624de7907eca714 100644
--- a/flatland/envs/rail_env_action.py
+++ b/flatland/envs/rail_env_action.py
@@ -19,6 +19,13 @@ class RailEnvActions(IntEnum):
4: 'S',
}[a]
+ @classmethod
+ def is_action_valid(cls, action):
+ return action in cls._value2member_map_
+
+ def is_moving_action(self):
+ return self.value in [self.MOVE_RIGHT, self.MOVE_LEFT, self.MOVE_FORWARD]
+
RailEnvGridPos = NamedTuple('RailEnvGridPos', [('r', int), ('c', int)])
RailEnvNextAction = NamedTuple('RailEnvNextAction', [('action', RailEnvActions), ('next_position', RailEnvGridPos),
diff --git a/flatland/envs/rail_env_shortest_paths.py b/flatland/envs/rail_env_shortest_paths.py
index 8c9817781a5e50d1a02b4d39e0f604e8b854afb9..e844390f7d4927476525da45196db28893145f7a 100644
--- a/flatland/envs/rail_env_shortest_paths.py
+++ b/flatland/envs/rail_env_shortest_paths.py
@@ -7,7 +7,7 @@ import numpy as np
from flatland.core.grid.grid4 import Grid4TransitionsEnum
from flatland.core.grid.grid4_utils import get_new_position
from flatland.core.transition_map import GridTransitionMap
-from flatland.envs.agent_utils import RailAgentStatus
+from flatland.envs.step_utils.states import TrainState
from flatland.envs.distance_map import DistanceMap
from flatland.envs.rail_env_action import RailEnvActions, RailEnvNextAction
from flatland.envs.rail_trainrun_data_structures import Waypoint
@@ -227,13 +227,11 @@ def get_shortest_paths(distance_map: DistanceMap, max_depth: Optional[int] = Non
shortest_paths = dict()
def _shortest_path_for_agent(agent):
- if agent.status == RailAgentStatus.WAITING:
+ if agent.state.is_off_map_state():
position = agent.initial_position
- elif agent.status == RailAgentStatus.READY_TO_DEPART:
- position = agent.initial_position
- elif agent.status == RailAgentStatus.ACTIVE:
+ elif agent.state.is_on_map_state():
position = agent.position
- elif agent.status == RailAgentStatus.DONE:
+ elif agent.state == TrainState.DONE:
position = agent.target
else:
shortest_paths[agent.handle] = None
diff --git a/flatland/envs/rail_generators.py b/flatland/envs/rail_generators.py
index 90dcfb3612b7faaff7a3b277bae5efd780fba3e6..356bfd1e00dba35e10e16815d3a306077f9acf6f 100644
--- a/flatland/envs/rail_generators.py
+++ b/flatland/envs/rail_generators.py
@@ -218,7 +218,7 @@ class SparseRailGen(RailGen):
'city_orientations' : orientation of cities
"""
if np_random is None:
- np_random = RandomState()
+ np_random = RandomState(self.seed)
rail_trans = RailEnvTransitions()
grid_map = GridTransitionMap(width=width, height=height, transitions=rail_trans)
@@ -240,6 +240,7 @@ class SparseRailGen(RailGen):
# and reduce the number of cities to build to avoid problems
max_feasible_cities = min(self.max_num_cities,
((height - 2) // (2 * (city_radius + 1))) * ((width - 2) // (2 * (city_radius + 1))))
+
if max_feasible_cities < 2:
# sys.exit("[ABORT] Cannot fit more than one city in this map, no feasible environment possible! Aborting.")
raise ValueError("ERROR: Cannot fit more than one city in this map, no feasible environment possible!")
@@ -252,7 +253,6 @@ class SparseRailGen(RailGen):
else:
city_positions = self._generate_random_city_positions(max_feasible_cities, city_radius, width, height,
np_random=np_random)
-
# reduce num_cities if less were generated in random mode
num_cities = len(city_positions)
# If random generation failed just put the cities evenly
@@ -261,7 +261,6 @@ class SparseRailGen(RailGen):
city_positions = self._generate_evenly_distr_city_positions(max_feasible_cities, city_radius, width,
height)
num_cities = len(city_positions)
-
# Set up connection points for all cities
inner_connection_points, outer_connection_points, city_orientations, city_cells = \
self._generate_city_connection_points(
@@ -315,27 +314,39 @@ class SparseRailGen(RailGen):
"""
city_positions: IntVector2DArray = []
- for city_idx in range(num_cities):
- too_close = True
- tries = 0
-
- while too_close:
- row = city_radius + 1 + np_random.randint(height - 2 * (city_radius + 1))
- col = city_radius + 1 + np_random.randint(width - 2 * (city_radius + 1))
- too_close = False
- # Check distance to cities
- for city_pos in city_positions:
- if self.__class__._are_cities_overlapping((row, col), city_pos, 2 * (city_radius + 1) + 1):
- too_close = True
-
- if not too_close:
- city_positions.append((row, col))
-
- tries += 1
- if tries > 200:
- warnings.warn(
- "Could not set all required cities!")
- break
+
+ # We track a grid of allowed indexes that can be sampled from for creating a new city
+ # This removes the old sampling method of retrying a random sample on failure
+ allowed_grid = np.zeros((height, width), dtype=np.uint8)
+ city_radius_pad1 = city_radius + 1
+ # Borders have to be not allowed from the start
+ # allowed_grid == 1 indicates locations that are allowed
+ allowed_grid[city_radius_pad1:-city_radius_pad1, city_radius_pad1:-city_radius_pad1] = 1
+ for _ in range(num_cities):
+ allowed_indexes = np.where(allowed_grid == 1)
+ num_allowed_points = len(allowed_indexes[0])
+ if num_allowed_points == 0:
+ break
+ # Sample one of the allowed indexes
+ point_index = np_random.randint(num_allowed_points)
+ row = int(allowed_indexes[0][point_index])
+ col = int(allowed_indexes[1][point_index])
+
+ # Need to block city radius and extra margin so that next sampling is correct
+ # Clipping handles the case for negative indexes being generated
+ row_start = max(0, row - 2 * city_radius_pad1)
+ col_start = max(0, col - 2 * city_radius_pad1)
+ row_end = row + 2 * city_radius_pad1 + 1
+ col_end = col + 2 * city_radius_pad1 + 1
+
+ allowed_grid[row_start : row_end, col_start : col_end] = 0
+
+ city_positions.append((row, col))
+
+ created_cites = len(city_positions)
+ if created_cites < num_cities:
+ city_warning = f"Could not set all required cities! Created {created_cites}/{num_cities}"
+ warnings.warn(city_warning)
return city_positions
def _generate_evenly_distr_city_positions(self, num_cities: int, city_radius: int, width: int, height: int
@@ -360,7 +371,6 @@ class SparseRailGen(RailGen):
"""
aspect_ratio = height / width
-
# Compute max numbe of possible cities per row and col.
# Respect padding at edges of environment
# Respect padding between cities
@@ -529,13 +539,12 @@ class SparseRailGen(RailGen):
grid4_directions = [Grid4TransitionsEnum.NORTH, Grid4TransitionsEnum.EAST, Grid4TransitionsEnum.SOUTH,
Grid4TransitionsEnum.WEST]
-
for current_city_idx in np.arange(len(city_positions)):
closest_neighbours = self._closest_neighbour_in_grid4_directions(current_city_idx, city_positions)
for out_direction in grid4_directions:
-
+
neighbour_idx = self.get_closest_neighbour_for_direction(closest_neighbours, out_direction)
-
+
for city_out_connection_point in connection_points[current_city_idx][out_direction]:
min_connection_dist = np.inf
@@ -547,14 +556,16 @@ class SparseRailGen(RailGen):
if tmp_dist < min_connection_dist:
min_connection_dist = tmp_dist
neighbour_connection_point = tmp_in_connection_point
-
new_line = connect_rail_in_grid_map(grid_map, city_out_connection_point, neighbour_connection_point,
rail_trans, flip_start_node_trans=False,
flip_end_node_trans=False, respect_transition_validity=False,
avoid_rail=True,
forbidden_cells=city_cells)
+ if len(new_line) == 0:
+ warnings.warn("[WARNING] No line added between stations")
+ elif new_line[-1] != neighbour_connection_point or new_line[0] != city_out_connection_point:
+ warnings.warn("[WARNING] Unable to connect requested stations")
all_paths.extend(new_line)
-
return all_paths
def get_closest_neighbour_for_direction(self, closest_neighbours, out_direction):
diff --git a/flatland/envs/step_utils/action_preprocessing.py b/flatland/envs/step_utils/action_preprocessing.py
new file mode 100644
index 0000000000000000000000000000000000000000..47f06e2ce6de7794ef3a58fd3e91a8a4d742187f
--- /dev/null
+++ b/flatland/envs/step_utils/action_preprocessing.py
@@ -0,0 +1,60 @@
+from flatland.core.grid.grid_utils import position_to_coordinate
+from flatland.envs.agent_utils import TrainState
+from flatland.envs.rail_env_action import RailEnvActions
+from flatland.envs.step_utils.transition_utils import check_valid_action
+
+
+def process_illegal_action(action: RailEnvActions):
+ if not RailEnvActions.is_action_valid(action):
+ return RailEnvActions.DO_NOTHING
+ else:
+ return RailEnvActions(action)
+
+
+def process_do_nothing(state: TrainState, saved_action: RailEnvActions):
+ if state == TrainState.MOVING:
+ action = RailEnvActions.MOVE_FORWARD
+ elif saved_action:
+ action = saved_action
+ else:
+ action = RailEnvActions.STOP_MOVING
+ return action
+
+
+def process_left_right(action, rail, position, direction):
+ if not check_valid_action(action, rail, position, direction):
+ action = RailEnvActions.MOVE_FORWARD
+ return action
+
+
+def preprocess_action_when_waiting(action, state):
+ """
+ Set action to DO_NOTHING if in waiting state
+ """
+ if state == TrainState.WAITING:
+ action = RailEnvActions.DO_NOTHING
+ return action
+
+
+def preprocess_raw_action(action, state, saved_action):
+ """
+ Preprocesses actions to handle different situations of usage of action based on context
+ - DO_NOTHING is converted to FORWARD if train is moving
+ - DO_NOTHING is converted to STOP_MOVING if train is moving
+ """
+ action = process_illegal_action(action)
+
+ if action == RailEnvActions.DO_NOTHING:
+ action = process_do_nothing(state, saved_action)
+
+ return action
+
+def preprocess_moving_action(action, rail, position, direction):
+ """
+ LEFT/RIGHT is converted to FORWARD if left/right is not available and train is moving
+ FORWARD is converted to STOP_MOVING if leading to dead end?
+ """
+ if action in [RailEnvActions.MOVE_LEFT, RailEnvActions.MOVE_RIGHT]:
+ action = process_left_right(action, rail, position, direction)
+
+ return action
\ No newline at end of file
diff --git a/flatland/envs/step_utils/action_saver.py b/flatland/envs/step_utils/action_saver.py
new file mode 100644
index 0000000000000000000000000000000000000000..913e9576d923a7e67ff7a498237803df3d9d0a43
--- /dev/null
+++ b/flatland/envs/step_utils/action_saver.py
@@ -0,0 +1,38 @@
+from flatland.envs.rail_env_action import RailEnvActions
+from flatland.envs.step_utils.states import TrainState
+
+class ActionSaver:
+ def __init__(self):
+ self.saved_action = None
+
+ @property
+ def is_action_saved(self):
+ return self.saved_action is not None
+
+ def __repr__(self):
+ return f"is_action_saved: {self.is_action_saved}, saved_action: {str(self.saved_action)}"
+
+
+ def save_action_if_allowed(self, action, state):
+ """
+ Save the action if all conditions are met
+ 1. It is a movement based action -> Forward, Left, Right
+ 2. Action is not already saved
+ 3. Agent is not already done
+ """
+ if action.is_moving_action() and not self.is_action_saved and not state == TrainState.DONE:
+ self.saved_action = action
+
+ def clear_saved_action(self):
+ self.saved_action = None
+
+ def to_dict(self):
+ return {"saved_action": self.saved_action}
+
+ def from_dict(self, load_dict):
+ self.saved_action = load_dict['saved_action']
+
+ def __eq__(self, other):
+ return self.saved_action == other.saved_action
+
+
diff --git a/flatland/envs/step_utils/malfunction_handler.py b/flatland/envs/step_utils/malfunction_handler.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf1f188fe850272968af0a8e11c87fdf92fd5d88
--- /dev/null
+++ b/flatland/envs/step_utils/malfunction_handler.py
@@ -0,0 +1,67 @@
+
+def get_number_of_steps_to_break(malfunction_generator, np_random):
+ if hasattr(malfunction_generator, "generate"):
+ malfunction = malfunction_generator.generate(np_random)
+ else:
+ malfunction = malfunction_generator(np_random)
+
+ return malfunction.num_broken_steps
+
+class MalfunctionHandler:
+ def __init__(self):
+ self._malfunction_down_counter = 0
+ self.num_malfunctions = 0
+
+ @property
+ def in_malfunction(self):
+ return self._malfunction_down_counter > 0
+
+ @property
+ def malfunction_counter_complete(self):
+ return self._malfunction_down_counter == 0
+
+ @property
+ def malfunction_down_counter(self):
+ return self._malfunction_down_counter
+
+ @malfunction_down_counter.setter
+ def malfunction_down_counter(self, val):
+ self._set_malfunction_down_counter(val)
+
+ def _set_malfunction_down_counter(self, val):
+ if val < 0:
+ raise ValueError("Cannot set a negative value to malfunction down counter")
+ # Only set new malfunction value if old malfunction is completed
+ if self._malfunction_down_counter == 0:
+ self._malfunction_down_counter = val
+ self.num_malfunctions += 1
+
+ def generate_malfunction(self, malfunction_generator, np_random):
+ num_broken_steps = get_number_of_steps_to_break(malfunction_generator, np_random)
+ self._set_malfunction_down_counter(num_broken_steps)
+
+ def update_counter(self):
+ if self._malfunction_down_counter > 0:
+ self._malfunction_down_counter -= 1
+
+ def __repr__(self):
+ return f"malfunction_down_counter: {self._malfunction_down_counter} \
+ in_malfunction: {self.in_malfunction} \
+ num_malfunctions: {self.num_malfunctions}"
+
+ def to_dict(self):
+ return {"malfunction_down_counter": self._malfunction_down_counter,
+ "num_malfunctions": self.num_malfunctions}
+
+ def from_dict(self, load_dict):
+ self._malfunction_down_counter = load_dict['malfunction_down_counter']
+ self.num_malfunctions = load_dict['num_malfunctions']
+
+ def __eq__(self, other):
+ return self._malfunction_down_counter == other._malfunction_down_counter and \
+ self.num_malfunctions == other.num_malfunctions
+
+
+
+
+
diff --git a/flatland/envs/step_utils/speed_counter.py b/flatland/envs/step_utils/speed_counter.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4a37ebe65161e7c1d0639d338ec969f01fdde43
--- /dev/null
+++ b/flatland/envs/step_utils/speed_counter.py
@@ -0,0 +1,54 @@
+import numpy as np
+from flatland.envs.step_utils.states import TrainState
+
+class SpeedCounter:
+ def __init__(self, speed):
+ self._speed = speed
+ self.counter = None
+ self.reset_counter()
+
+ def update_counter(self, state, old_position):
+ # Can't start counting when adding train to the map
+ if state == TrainState.MOVING and old_position is not None:
+ self.counter += 1
+ self.counter = self.counter % (self.max_count + 1)
+
+
+
+ def __repr__(self):
+ return f"speed: {self.speed} \
+ max_count: {self.max_count} \
+ is_cell_entry: {self.is_cell_entry} \
+ is_cell_exit: {self.is_cell_exit} \
+ counter: {self.counter}"
+
+ def reset_counter(self):
+ self.counter = 0
+
+ @property
+ def is_cell_entry(self):
+ return self.counter == 0
+
+ @property
+ def is_cell_exit(self):
+ return self.counter == self.max_count
+
+ @property
+ def speed(self):
+ return self._speed
+
+ @property
+ def max_count(self):
+ return int(1/self._speed) - 1
+
+ def to_dict(self):
+ return {"speed": self._speed,
+ "counter": self.counter}
+
+ def from_dict(self, load_dict):
+ self._speed = load_dict['speed']
+ self.counter = load_dict['counter']
+
+ def __eq__(self, other):
+ return self._speed == other._speed and self.counter == other.counter
+
diff --git a/flatland/envs/step_utils/state_machine.py b/flatland/envs/step_utils/state_machine.py
new file mode 100644
index 0000000000000000000000000000000000000000..58b028b6f7cd3ee954b37e6d28346f70404bd973
--- /dev/null
+++ b/flatland/envs/step_utils/state_machine.py
@@ -0,0 +1,167 @@
+from flatland.envs.step_utils.states import TrainState, StateTransitionSignals
+
+class TrainStateMachine:
+ def __init__(self, initial_state=TrainState.WAITING):
+ self._initial_state = initial_state
+ self._state = initial_state
+ self.st_signals = StateTransitionSignals()
+ self.next_state = None
+ self.previous_state = None
+
+ def _handle_waiting(self):
+ """" Waiting state goes to ready to depart when earliest departure is reached"""
+ # TODO: Important - The malfunction handling is not like proper state machine
+ # Both transition signals can happen at the same time
+ # Atleast mention it in the diagram
+ if self.st_signals.in_malfunction:
+ self.next_state = TrainState.MALFUNCTION_OFF_MAP
+ elif self.st_signals.earliest_departure_reached:
+ self.next_state = TrainState.READY_TO_DEPART
+ else:
+ self.next_state = TrainState.WAITING
+
+ def _handle_ready_to_depart(self):
+ """ Can only go to MOVING if a valid action is provided """
+ if self.st_signals.in_malfunction:
+ self.next_state = TrainState.MALFUNCTION_OFF_MAP
+ elif self.st_signals.valid_movement_action_given:
+ self.next_state = TrainState.MOVING
+ else:
+ self.next_state = TrainState.READY_TO_DEPART
+
+ def _handle_malfunction_off_map(self):
+ if self.st_signals.malfunction_counter_complete:
+
+ if self.st_signals.earliest_departure_reached:
+
+ if self.st_signals.valid_movement_action_given:
+ self.next_state = TrainState.MOVING
+ elif self.st_signals.stop_action_given:
+ self.next_state = TrainState.STOPPED
+ else:
+ self.next_state = TrainState.READY_TO_DEPART
+
+ else:
+ self.next_state = TrainState.WAITING
+
+ else:
+ self.next_state = TrainState.MALFUNCTION_OFF_MAP
+
+ def _handle_moving(self):
+ if self.st_signals.in_malfunction:
+ self.next_state = TrainState.MALFUNCTION
+ elif self.st_signals.target_reached:
+ self.next_state = TrainState.DONE
+ elif self.st_signals.stop_action_given or self.st_signals.movement_conflict:
+ self.next_state = TrainState.STOPPED
+ else:
+ self.next_state = TrainState.MOVING
+
+ def _handle_stopped(self):
+ if self.st_signals.in_malfunction:
+ self.next_state = TrainState.MALFUNCTION
+ elif self.st_signals.valid_movement_action_given:
+ self.next_state = TrainState.MOVING
+ else:
+ self.next_state = TrainState.STOPPED
+
+ def _handle_malfunction(self):
+ if self.st_signals.malfunction_counter_complete and \
+ self.st_signals.valid_movement_action_given:
+ self.next_state = TrainState.MOVING
+ elif self.st_signals.malfunction_counter_complete and \
+ (self.st_signals.stop_action_given or self.st_signals.movement_conflict):
+ self.next_state = TrainState.STOPPED
+ else:
+ self.next_state = TrainState.MALFUNCTION
+
+ def _handle_done(self):
+ """" Done state is terminal """
+ self.next_state = TrainState.DONE
+
+ def calculate_next_state(self, current_state):
+
+ # _Handle the current state
+ if current_state == TrainState.WAITING:
+ self._handle_waiting()
+
+ elif current_state == TrainState.READY_TO_DEPART:
+ self._handle_ready_to_depart()
+
+ elif current_state == TrainState.MALFUNCTION_OFF_MAP:
+ self._handle_malfunction_off_map()
+
+ elif current_state == TrainState.MOVING:
+ self._handle_moving()
+
+ elif current_state == TrainState.STOPPED:
+ self._handle_stopped()
+
+ elif current_state == TrainState.MALFUNCTION:
+ self._handle_malfunction()
+
+ elif current_state == TrainState.DONE:
+ self._handle_done()
+
+ else:
+ raise ValueError(f"Got unexpected state {current_state}")
+
+ def step(self):
+ """ Steps the state machine to the next state """
+
+ current_state = self._state
+
+ # Clear next state
+ self.clear_next_state()
+
+ # Handle current state to get next_state
+ self.calculate_next_state(current_state)
+
+ # Set next state
+ self.set_state(self.next_state)
+
+
+ def clear_next_state(self):
+ self.next_state = None
+
+ def set_state(self, state):
+ if not TrainState.check_valid_state(state):
+ raise ValueError(f"Cannot set invalid state {state}")
+ self.previous_state = self._state
+ self._state = state
+
+ def reset(self):
+ self._state = self._initial_state
+ self.previous_state = None
+ self.st_signals = StateTransitionSignals()
+ self.clear_next_state()
+
+ @property
+ def state(self):
+ return self._state
+
+ @property
+ def state_transition_signals(self):
+ return self.st_signals
+
+ def set_transition_signals(self, state_transition_signals):
+ self.st_signals = state_transition_signals
+
+ def __repr__(self):
+ return f"\n \
+ state: {str(self.state)} previous_state {str(self.previous_state)} \n \
+ st_signals: {self.st_signals}"
+
+ def to_dict(self):
+ return {"state": self._state,
+ "previous_state": self.previous_state}
+
+ def from_dict(self, load_dict):
+ self.set_state(load_dict['state'])
+ self.previous_state = load_dict['previous_state']
+
+ def __eq__(self, other):
+ return self._state == other._state and self.previous_state == other.previous_state
+
+
+
diff --git a/flatland/envs/step_utils/states.py b/flatland/envs/step_utils/states.py
new file mode 100644
index 0000000000000000000000000000000000000000..806113e524112e7aa0a0704ddffce1b8d2db5ffa
--- /dev/null
+++ b/flatland/envs/step_utils/states.py
@@ -0,0 +1,37 @@
+from enum import IntEnum
+from dataclasses import dataclass
+
+
+class TrainState(IntEnum):
+ WAITING = 0
+ READY_TO_DEPART = 1
+ MALFUNCTION_OFF_MAP = 2
+ MOVING = 3
+ STOPPED = 4
+ MALFUNCTION = 5
+ DONE = 6
+
+ @classmethod
+ def check_valid_state(cls, state):
+ return state in cls._value2member_map_
+
+ def is_malfunction_state(self):
+ return self.value in [self.MALFUNCTION, self.MALFUNCTION_OFF_MAP]
+
+ def is_off_map_state(self):
+ return self.value in [self.WAITING, self.READY_TO_DEPART, self.MALFUNCTION_OFF_MAP]
+
+ def is_on_map_state(self):
+ return self.value in [self.MOVING, self.STOPPED, self.MALFUNCTION]
+
+
+@dataclass(repr=True)
+class StateTransitionSignals:
+ in_malfunction : bool = False
+ malfunction_counter_complete : bool = False
+ earliest_departure_reached : bool = False
+ stop_action_given : bool = False
+ valid_movement_action_given : bool = False
+ target_reached : bool = False
+ movement_conflict : bool = False
+
diff --git a/flatland/envs/step_utils/transition_utils.py b/flatland/envs/step_utils/transition_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..c84d6c59cd59b6f8366d28f3d0ad51bbcfc7602a
--- /dev/null
+++ b/flatland/envs/step_utils/transition_utils.py
@@ -0,0 +1,98 @@
+from typing import Tuple
+from flatland.core.grid.grid4_utils import get_new_position
+from flatland.envs.rail_env_action import RailEnvActions
+
+
+def check_action(action, position, direction, rail):
+ """
+
+ Parameters
+ ----------
+ agent : EnvAgent
+ action : RailEnvActions
+
+ Returns
+ -------
+ Tuple[Grid4TransitionsEnum,Tuple[int,int]]
+
+
+
+ """
+ transition_valid = None
+ possible_transitions = rail.get_transitions(*position, direction)
+ num_transitions = fast_count_nonzero(possible_transitions)
+
+ new_direction = direction
+ if action == RailEnvActions.MOVE_LEFT:
+ new_direction = direction - 1
+ if num_transitions <= 1:
+ transition_valid = False
+
+ elif action == RailEnvActions.MOVE_RIGHT:
+ new_direction = direction + 1
+ if num_transitions <= 1:
+ transition_valid = False
+
+ new_direction %= 4 # Dipam : Why?
+
+ if action == RailEnvActions.MOVE_FORWARD and num_transitions == 1:
+ # - dead-end, straight line or curved line;
+ # new_direction will be the only valid transition
+ # - take only available transition
+ new_direction = fast_argmax(possible_transitions)
+ transition_valid = True
+ return new_direction, transition_valid
+
+
+def check_action_on_agent(action, rail, position, direction):
+ """
+ Parameters
+ ----------
+ action : RailEnvActions
+ agent : EnvAgent
+
+ Returns
+ -------
+ bool
+ Is it a legal move?
+ 1) transition allows the new_direction in the cell,
+ 2) the new cell is not empty (case 0),
+ 3) the cell is free, i.e., no agent is currently in that cell
+
+
+ """
+ # compute number of possible transitions in the current
+ # cell used to check for invalid actions
+ new_direction, transition_valid = check_action(action, position, direction, rail)
+ new_position = get_new_position(position, new_direction)
+
+ new_cell_valid = check_bounds(new_position, rail.height, rail.width) and \
+ rail.get_full_transitions(*new_position) > 0
+
+ # If transition validity hasn't been checked yet.
+ if transition_valid is None:
+ transition_valid = rail.get_transition( (*position, direction), new_direction)
+
+ return new_cell_valid, new_direction, new_position, transition_valid
+
+
+def check_valid_action(action, rail, position, direction):
+ new_cell_valid, _, _, transition_valid = check_action_on_agent(action, rail, position, direction)
+ action_is_valid = new_cell_valid and transition_valid
+ return action_is_valid
+
+def fast_argmax(possible_transitions: Tuple[int, int, int, int]) -> bool:
+ if possible_transitions[0] == 1:
+ return 0
+ if possible_transitions[1] == 1:
+ return 1
+ if possible_transitions[2] == 1:
+ return 2
+ return 3
+
+def fast_count_nonzero(possible_transitions: Tuple[int, int, int, int]):
+ return possible_transitions[0] + possible_transitions[1] + possible_transitions[2] + possible_transitions[3]
+
+def check_bounds(position, height, width):
+ return position[0] >= 0 and position[1] >= 0 and position[0] < height and position[1] < width
+
\ No newline at end of file
diff --git a/flatland/envs/timetable_generators.py b/flatland/envs/timetable_generators.py
index b7876d742f61db830883f828faaf99a39a48bc65..d93c09199b315c488177febe4d1aa423b7a87894 100644
--- a/flatland/envs/timetable_generators.py
+++ b/flatland/envs/timetable_generators.py
@@ -57,7 +57,7 @@ def timetable_generator(agents: List[EnvAgent], distance_map: DistanceMap,
shortest_paths_lengths = [len_handle_none(v) for k,v in shortest_paths.items()]
# Find mean_shortest_path_time
- agent_speeds = [agent.speed_data['speed'] for agent in agents]
+ agent_speeds = [agent.speed_counter.speed for agent in agents]
agent_shortest_path_times = np.array(shortest_paths_lengths)/ np.array(agent_speeds)
mean_shortest_path_time = np.mean(agent_shortest_path_times)
diff --git a/flatland/utils/rendertools.py b/flatland/utils/rendertools.py
index 910dec324f606582f092a30d807cd6956927d529..cd765cd19ba0c9510d301ac77a0782bccd6bd6b4 100644
--- a/flatland/utils/rendertools.py
+++ b/flatland/utils/rendertools.py
@@ -7,7 +7,7 @@ import numpy as np
from numpy import array
from recordtype import recordtype
-from flatland.envs.agent_utils import RailAgentStatus
+from flatland.envs.step_utils.states import TrainState
from flatland.utils.graphics_pil import PILGL, PILSVG
from flatland.utils.graphics_pgl import PGLGL
@@ -741,9 +741,9 @@ class RenderLocal(RenderBase):
self.gl.set_cell_occupied(agent_idx, *(agent.position))
if show_inactive_agents:
- show_this_agent=True
+ show_this_agent = True
else:
- show_this_agent = agent.status == RailAgentStatus.ACTIVE
+ show_this_agent = agent.state.is_on_map_state()
if show_this_agent:
self.gl.set_agent_at(agent_idx, *position, agent.direction, direction,
diff --git a/flatland/utils/simple_rail.py b/flatland/utils/simple_rail.py
index 2ee46d02053cdcb179c68d376f3c47c9aab6922a..445b856d83847813f86ac4dca80a02cf33d27e29 100644
--- a/flatland/utils/simple_rail.py
+++ b/flatland/utils/simple_rail.py
@@ -48,11 +48,10 @@ def make_simple_rail() -> Tuple[GridTransitionMap, np.array]:
[( (6, 6), 0 ) ],
]
city_orientations = [0, 2]
- agents_hints = {'num_agents': 2,
- 'city_positions': city_positions,
- 'train_stations': train_stations,
- 'city_orientations': city_orientations
- }
+ agents_hints = {'city_positions': city_positions,
+ 'train_stations': train_stations,
+ 'city_orientations': city_orientations
+ }
optionals = {'agents_hints': agents_hints}
return rail, rail_map, optionals
@@ -100,11 +99,10 @@ def make_disconnected_simple_rail() -> Tuple[GridTransitionMap, np.array]:
[( (6, 6), 0 ) ],
]
city_orientations = [0, 2]
- agents_hints = {'num_agents': 2,
- 'city_positions': city_positions,
- 'train_stations': train_stations,
- 'city_orientations': city_orientations
- }
+ agents_hints = {'city_positions': city_positions,
+ 'train_stations': train_stations,
+ 'city_orientations': city_orientations
+ }
optionals = {'agents_hints': agents_hints}
return rail, rail_map, optionals
@@ -149,11 +147,10 @@ def make_simple_rail2() -> Tuple[GridTransitionMap, np.array]:
[( (6, 6), 0 ) ],
]
city_orientations = [0, 2]
- agents_hints = {'num_agents': 2,
- 'city_positions': city_positions,
- 'train_stations': train_stations,
- 'city_orientations': city_orientations
- }
+ agents_hints = {'city_positions': city_positions,
+ 'train_stations': train_stations,
+ 'city_orientations': city_orientations
+ }
optionals = {'agents_hints': agents_hints}
return rail, rail_map, optionals
@@ -199,11 +196,10 @@ def make_simple_rail_unconnected() -> Tuple[GridTransitionMap, np.array]:
[( (6, 6), 0 ) ],
]
city_orientations = [0, 2]
- agents_hints = {'num_agents': 2,
- 'city_positions': city_positions,
- 'train_stations': train_stations,
- 'city_orientations': city_orientations
- }
+ agents_hints = {'city_positions': city_positions,
+ 'train_stations': train_stations,
+ 'city_orientations': city_orientations
+ }
optionals = {'agents_hints': agents_hints}
return rail, rail_map, optionals
@@ -255,11 +251,10 @@ def make_simple_rail_with_alternatives() -> Tuple[GridTransitionMap, np.array]:
[( (6, 6), 0 ) ],
]
city_orientations = [0, 2]
- agents_hints = {'num_agents': 2,
- 'city_positions': city_positions,
- 'train_stations': train_stations,
- 'city_orientations': city_orientations
- }
+ agents_hints = {'city_positions': city_positions,
+ 'train_stations': train_stations,
+ 'city_orientations': city_orientations
+ }
optionals = {'agents_hints': agents_hints}
return rail, rail_map, optionals
@@ -306,10 +301,45 @@ def make_invalid_simple_rail() -> Tuple[GridTransitionMap, np.array]:
[( (6, 6), 0 ) ],
]
city_orientations = [0, 2]
- agents_hints = {'num_agents': 2,
- 'city_positions': city_positions,
- 'train_stations': train_stations,
- 'city_orientations': city_orientations
- }
+ agents_hints = {'city_positions': city_positions,
+ 'train_stations': train_stations,
+ 'city_orientations': city_orientations
+ }
optionals = {'agents_hints': agents_hints}
return rail, rail_map, optionals
+
+def make_oval_rail() -> Tuple[GridTransitionMap, np.array]:
+ transitions = RailEnvTransitions()
+ cells = transitions.transition_list
+
+ empty = cells[0]
+ vertical_straight = cells[1]
+ horizontal_straight = transitions.rotate_transition(vertical_straight, 90)
+ right_turn_from_south = cells[8]
+ right_turn_from_west = transitions.rotate_transition(right_turn_from_south, 90)
+ right_turn_from_north = transitions.rotate_transition(right_turn_from_south, 180)
+ right_turn_from_east = transitions.rotate_transition(right_turn_from_south, 270)
+
+ rail_map = np.array(
+ [[empty] * 9] +
+ [[empty] + [right_turn_from_south] + [horizontal_straight] * 5 + [right_turn_from_west] + [empty]] +
+ [[empty] + [vertical_straight] + [empty] * 5 + [vertical_straight] + [empty]]+
+ [[empty] + [vertical_straight] + [empty] * 5 + [vertical_straight] + [empty]] +
+ [[empty] + [right_turn_from_east] + [horizontal_straight] * 5 + [right_turn_from_north] + [empty]] +
+ [[empty] * 9], dtype=np.uint16)
+
+ rail = GridTransitionMap(width=rail_map.shape[1],
+ height=rail_map.shape[0], transitions=transitions)
+ rail.grid = rail_map
+ city_positions = [(1, 4), (4, 4)]
+ train_stations = [
+ [((1, 4), 0)],
+ [((4, 4), 0)],
+ ]
+ city_orientations = [1, 3]
+ agents_hints = {'city_positions': city_positions,
+ 'train_stations': train_stations,
+ 'city_orientations': city_orientations
+ }
+ optionals = {'agents_hints': agents_hints}
+ return rail, rail_map, optionals
\ No newline at end of file
diff --git a/requirements_dev.txt b/requirements_dev.txt
index 93414562b79e3c0d5e1a77e42b967dc0ea4028fe..51473c19d41ddfbc14507c643758aece381e62e2 100644
--- a/requirements_dev.txt
+++ b/requirements_dev.txt
@@ -23,3 +23,4 @@ networkx
ipycanvas
graphviz
imageio
+dataclasses
diff --git a/tests/test_action_plan.py b/tests/test_action_plan.py
index 71a73fbc9a8f6bebb05489c3d59f1bbe41821931..9be4fdf6410b6f63455c6df58da8121012778b85 100644
--- a/tests/test_action_plan.py
+++ b/tests/test_action_plan.py
@@ -9,6 +9,7 @@ from flatland.envs.rail_trainrun_data_structures import Waypoint
from flatland.envs.line_generators import sparse_line_generator
from flatland.utils.rendertools import RenderTool, AgentRenderVariant
from flatland.utils.simple_rail import make_simple_rail
+from flatland.envs.step_utils.speed_counter import SpeedCounter
def test_action_plan(rendering: bool = False):
@@ -29,8 +30,8 @@ def test_action_plan(rendering: bool = False):
env.agents[1].initial_position = (3, 8)
env.agents[1].initial_direction = Grid4TransitionsEnum.WEST
env.agents[1].target = (0, 3)
- env.agents[1].speed_data['speed'] = 0.5 # two
- env.reset(False, False, False)
+ env.agents[1].speed_counter = SpeedCounter(speed=0.5)
+ env.reset(False, False)
for handle, agent in enumerate(env.agents):
print("[{}] {} -> {}".format(handle, agent.initial_position, agent.target))
diff --git a/tests/test_env_step_utils.py b/tests/test_env_step_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c249de33ea579286bef0adb60290573696b236b
--- /dev/null
+++ b/tests/test_env_step_utils.py
@@ -0,0 +1,61 @@
+import numpy as np
+import numpy as np
+import os
+
+from flatland.envs.malfunction_generators import malfunction_from_params, MalfunctionParameters, ParamMalfunctionGen
+
+from flatland.envs.observations import GlobalObsForRailEnv
+# First of all we import the Flatland rail environment
+from flatland.envs.rail_env import RailEnv
+from flatland.envs.rail_env import RailEnvActions
+from flatland.envs.rail_generators import sparse_rail_generator
+#from flatland.envs.sparse_rail_gen import SparseRailGen
+from flatland.envs.line_generators import sparse_line_generator
+
+
+def get_small_two_agent_env():
+ """Generates a simple 2 city 2 train env returns it after reset"""
+ width = 30 # With of map
+ height = 15 # Height of map
+ nr_trains = 2 # Number of trains that have an assigned task in the env
+ cities_in_map = 2 # Number of cities where agents can start or end
+ seed = 42 # Random seed
+ grid_distribution_of_cities = False # Type of city distribution, if False cities are randomly placed
+ max_rails_between_cities = 2 # Max number of tracks allowed between cities. This is number of entry point to a city
+ max_rail_in_cities = 6 # Max number of parallel tracks within a city, representing a realistic trainstation
+
+ rail_generator = sparse_rail_generator(max_num_cities=cities_in_map,
+ seed=seed,
+ grid_mode=grid_distribution_of_cities,
+ max_rails_between_cities=max_rails_between_cities,
+ max_rail_pairs_in_city=max_rail_in_cities//2,
+ )
+ speed_ration_map = {1.: 0.25, # Fast passenger train
+ 1. / 2.: 0.25, # Fast freight train
+ 1. / 3.: 0.25, # Slow commuter train
+ 1. / 4.: 0.25} # Slow freight train
+
+ line_generator = sparse_line_generator(speed_ration_map)
+
+
+ stochastic_data = MalfunctionParameters(malfunction_rate=1/10000, # Rate of malfunction occurence
+ min_duration=15, # Minimal duration of malfunction
+ max_duration=50 # Max duration of malfunction
+ )
+
+ observation_builder = GlobalObsForRailEnv()
+
+ env = RailEnv(width=width,
+ height=height,
+ rail_generator=rail_generator,
+ line_generator=line_generator,
+ number_of_agents=nr_trains,
+ obs_builder_object=observation_builder,
+ #malfunction_generator_and_process_data=malfunction_from_params(stochastic_data),
+ malfunction_generator=ParamMalfunctionGen(stochastic_data),
+ remove_agents_at_target=True,
+ random_seed=seed)
+
+ env.reset()
+
+ return env
\ No newline at end of file
diff --git a/tests/test_eval_timeout.py b/tests/test_eval_timeout.py
index dfc406e3b9d091fc8e9a477ea86fae025e7b1936..6c92db298b3c87ca8597ab113b56ab1c8f208cde 100644
--- a/tests/test_eval_timeout.py
+++ b/tests/test_eval_timeout.py
@@ -8,8 +8,6 @@ import time
from flatland.core.env import Environment
from flatland.core.env_observation_builder import ObservationBuilder
-from flatland.core.env_prediction_builder import PredictionBuilder
-from flatland.envs.agent_utils import RailAgentStatus, EnvAgent
class CustomObservationBuilder(ObservationBuilder):
diff --git a/tests/test_flatland_envs_agent_utils.py b/tests/test_flatland_envs_agent_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..1824797c19ce82f39a8095441cbed0e3bd48a38a
--- /dev/null
+++ b/tests/test_flatland_envs_agent_utils.py
@@ -0,0 +1,102 @@
+import pytest
+
+from flatland.envs.rail_env import RailEnv
+from flatland.envs.rail_generators import rail_from_grid_transition_map
+from flatland.envs.line_generators import sparse_line_generator
+from flatland.utils.simple_rail import make_oval_rail
+
+
+def test_shortest_paths():
+ rail, rail_map, optionals = make_oval_rail()
+
+ speed_ratio_map = {1.: 1.0}
+ env = RailEnv(width=rail_map.shape[1],
+ height=rail_map.shape[0],
+ rail_generator=rail_from_grid_transition_map(rail, optionals),
+ line_generator=sparse_line_generator(speed_ratio_map),
+ number_of_agents=2)
+ env.reset()
+
+ agent0_shortest_path = env.agents[0].get_shortest_path(env.distance_map)
+ agent1_shortest_path = env.agents[1].get_shortest_path(env.distance_map)
+
+ assert len(agent0_shortest_path) == 10
+ assert len(agent1_shortest_path) == 10
+
+
+def test_travel_time_on_shortest_paths():
+ rail, rail_map, optionals = make_oval_rail()
+
+ speed_ratio_map = {1.: 1.0}
+ env = RailEnv(width=rail_map.shape[1],
+ height=rail_map.shape[0],
+ rail_generator=rail_from_grid_transition_map(rail, optionals),
+ line_generator=sparse_line_generator(speed_ratio_map),
+ number_of_agents=2)
+ env.reset()
+
+ agent0_travel_time = env.agents[0].get_travel_time_on_shortest_path(env.distance_map)
+ agent1_travel_time = env.agents[1].get_travel_time_on_shortest_path(env.distance_map)
+
+ assert agent0_travel_time == 10
+ assert agent1_travel_time == 10
+
+
+ speed_ratio_map = {1/2: 1.0}
+ env = RailEnv(width=rail_map.shape[1],
+ height=rail_map.shape[0],
+ rail_generator=rail_from_grid_transition_map(rail, optionals),
+ line_generator=sparse_line_generator(speed_ratio_map),
+ number_of_agents=2)
+ env.reset()
+
+ agent0_travel_time = env.agents[0].get_travel_time_on_shortest_path(env.distance_map)
+ agent1_travel_time = env.agents[1].get_travel_time_on_shortest_path(env.distance_map)
+
+ assert agent0_travel_time == 20
+ assert agent1_travel_time == 20
+
+
+ speed_ratio_map = {1/3: 1.0}
+ env = RailEnv(width=rail_map.shape[1],
+ height=rail_map.shape[0],
+ rail_generator=rail_from_grid_transition_map(rail, optionals),
+ line_generator=sparse_line_generator(speed_ratio_map),
+ number_of_agents=2)
+ env.reset()
+
+ agent0_travel_time = env.agents[0].get_travel_time_on_shortest_path(env.distance_map)
+ agent1_travel_time = env.agents[1].get_travel_time_on_shortest_path(env.distance_map)
+
+
+ assert agent0_travel_time == 30
+ assert agent1_travel_time == 30
+
+
+ speed_ratio_map = {1/4: 1.0}
+ env = RailEnv(width=rail_map.shape[1],
+ height=rail_map.shape[0],
+ rail_generator=rail_from_grid_transition_map(rail, optionals),
+ line_generator=sparse_line_generator(speed_ratio_map),
+ number_of_agents=2)
+ env.reset()
+
+ agent0_travel_time = env.agents[0].get_travel_time_on_shortest_path(env.distance_map)
+ agent1_travel_time = env.agents[1].get_travel_time_on_shortest_path(env.distance_map)
+
+ assert agent0_travel_time == 40
+ assert agent1_travel_time == 40
+
+
+# def test_latest_arrival_validity():
+# pass
+
+
+# def test_time_remaining_until_latest_arrival():
+# pass
+
+def main():
+ pass
+
+if __name__ == "__main__":
+ main()
diff --git a/tests/test_flatland_envs_observations.py b/tests/test_flatland_envs_observations.py
index 1634ebb0819417ee10ccea226095d814d2c5bbea..0d21463d933a3baf70bfb55cdd8719268a97862a 100644
--- a/tests/test_flatland_envs_observations.py
+++ b/tests/test_flatland_envs_observations.py
@@ -5,7 +5,6 @@ import numpy as np
from flatland.core.grid.grid4 import Grid4TransitionsEnum
from flatland.core.grid.grid4_utils import get_new_position
-from flatland.envs.agent_utils import EnvAgent, RailAgentStatus
from flatland.envs.observations import GlobalObsForRailEnv, TreeObsForRailEnv
from flatland.envs.predictions import ShortestPathPredictorForRailEnv
from flatland.envs.rail_env import RailEnv, RailEnvActions
@@ -13,6 +12,7 @@ from flatland.envs.rail_generators import rail_from_grid_transition_map
from flatland.envs.line_generators import sparse_line_generator
from flatland.utils.rendertools import RenderTool
from flatland.utils.simple_rail import make_simple_rail
+from flatland.envs.step_utils.states import TrainState
"""Tests for `flatland` package."""
@@ -50,7 +50,6 @@ def _step_along_shortest_path(env, obs_builder, rail):
actions = {}
expected_next_position = {}
for agent in env.agents:
- agent: EnvAgent
shortest_distance = np.inf
for exit_direction in range(4):
@@ -106,7 +105,7 @@ def test_reward_function_conflict(rendering=False):
agent.initial_direction = 0 # north
agent.target = (3, 9) # east dead-end
agent.moving = True
- agent.status = RailAgentStatus.ACTIVE
+ agent._set_state(TrainState.MOVING)
agent = env.agents[1]
agent.position = (3, 8) # east dead-end
@@ -115,13 +114,13 @@ def test_reward_function_conflict(rendering=False):
agent.initial_direction = 3 # west
agent.target = (6, 6) # south dead-end
agent.moving = True
- agent.status = RailAgentStatus.ACTIVE
+ agent._set_state(TrainState.MOVING)
env.reset(False, False)
env.agents[0].moving = True
env.agents[1].moving = True
- env.agents[0].status = RailAgentStatus.ACTIVE
- env.agents[1].status = RailAgentStatus.ACTIVE
+ env.agents[0]._set_state(TrainState.MOVING)
+ env.agents[1]._set_state(TrainState.MOVING)
env.agents[0].position = (5, 6)
env.agents[1].position = (3, 8)
print("\n")
@@ -166,7 +165,7 @@ def test_reward_function_conflict(rendering=False):
rewards = _step_along_shortest_path(env, obs_builder, rail)
for agent in env.agents:
- assert rewards[agent.handle] == -1
+ assert rewards[agent.handle] == 0
expected_position = expected_positions[iteration + 1][agent.handle]
assert agent.position == expected_position, "[{}] agent {} at {}, expected {}".format(iteration + 1,
agent.handle,
@@ -195,7 +194,7 @@ def test_reward_function_waiting(rendering=False):
agent.initial_direction = 3 # west
agent.target = (3, 1) # west dead-end
agent.moving = True
- agent.status = RailAgentStatus.ACTIVE
+ agent._set_state(TrainState.MOVING)
agent = env.agents[1]
agent.initial_position = (5, 6) # south dead-end
@@ -204,13 +203,13 @@ def test_reward_function_waiting(rendering=False):
agent.initial_direction = 0 # north
agent.target = (3, 8) # east dead-end
agent.moving = True
- agent.status = RailAgentStatus.ACTIVE
+ agent._set_state(TrainState.MOVING)
env.reset(False, False)
env.agents[0].moving = True
env.agents[1].moving = True
- env.agents[0].status = RailAgentStatus.ACTIVE
- env.agents[1].status = RailAgentStatus.ACTIVE
+ env.agents[0]._set_state(TrainState.MOVING)
+ env.agents[1]._set_state(TrainState.MOVING)
env.agents[0].position = (3, 8)
env.agents[1].position = (5, 6)
@@ -225,14 +224,14 @@ def test_reward_function_waiting(rendering=False):
0: (3, 8),
1: (5, 6),
},
- 'rewards': [-1, -1],
+ 'rewards': [0, 0],
},
1: {
'positions': {
0: (3, 7),
1: (4, 6),
},
- 'rewards': [-1, -1],
+ 'rewards': [0, 0],
},
# second agent has to wait for first, first can continue
2: {
@@ -240,7 +239,7 @@ def test_reward_function_waiting(rendering=False):
0: (3, 6),
1: (4, 6),
},
- 'rewards': [-1, -1],
+ 'rewards': [0, 0],
},
# both can move again
3: {
@@ -248,14 +247,14 @@ def test_reward_function_waiting(rendering=False):
0: (3, 5),
1: (3, 6),
},
- 'rewards': [-1, -1],
+ 'rewards': [0, 0],
},
4: {
'positions': {
0: (3, 4),
1: (3, 7),
},
- 'rewards': [-1, -1],
+ 'rewards': [0, 0],
},
# second reached target
5: {
@@ -263,14 +262,14 @@ def test_reward_function_waiting(rendering=False):
0: (3, 3),
1: (3, 8),
},
- 'rewards': [-1, 0],
+ 'rewards': [0, 0],
},
6: {
'positions': {
0: (3, 2),
1: (3, 8),
},
- 'rewards': [-1, 0],
+ 'rewards': [0, 0],
},
# first reaches, target too
7: {
@@ -278,14 +277,14 @@ def test_reward_function_waiting(rendering=False):
0: (3, 1),
1: (3, 8),
},
- 'rewards': [1, 1],
+ 'rewards': [0, 0],
},
8: {
'positions': {
0: (3, 1),
1: (3, 8),
},
- 'rewards': [1, 1],
+ 'rewards': [0, 0],
},
}
while iteration < 7:
@@ -297,7 +296,6 @@ def test_reward_function_waiting(rendering=False):
print(env.dones["__all__"])
for agent in env.agents:
- agent: EnvAgent
print("[{}] agent {} at {}, target {} ".format(iteration + 1, agent.handle, agent.position, agent.target))
print(np.all([np.array_equal(agent2.position, agent2.target) for agent2 in env.agents]))
for agent in env.agents:
diff --git a/tests/test_flatland_envs_persistence.py b/tests/test_flatland_envs_persistence.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e26389f58dd87ab2fee6099f691c2b6ce9c5266
--- /dev/null
+++ b/tests/test_flatland_envs_persistence.py
@@ -0,0 +1,36 @@
+import numpy as np
+
+from flatland.envs.rail_env import RailEnv
+from flatland.envs.rail_generators import rail_from_grid_transition_map
+from flatland.envs.line_generators import sparse_line_generator
+from flatland.utils.simple_rail import make_simple_rail
+from flatland.envs.persistence import RailEnvPersister
+
+def test_load_new():
+
+ filename = "test_load_new.pkl"
+
+ rail, rail_map, optionals = make_simple_rail()
+ n_agents = 2
+ env_initial = RailEnv(width=rail_map.shape[1], height=rail_map.shape[0], rail_generator=rail_from_grid_transition_map(rail, optionals),
+ line_generator=sparse_line_generator(), number_of_agents=n_agents)
+ env_initial.reset(False, False)
+
+ rails_initial = env_initial.rail.grid
+ agents_initial = env_initial.agents
+
+ RailEnvPersister.save(env_initial, filename)
+
+ env_loaded, _ = RailEnvPersister.load_new(filename)
+
+ rails_loaded = env_loaded.rail.grid
+ agents_loaded = env_loaded.agents
+
+ assert np.all(np.array_equal(rails_initial, rails_loaded))
+ assert agents_initial == agents_loaded
+
+def main():
+ pass
+
+if __name__ == "__main__":
+ main()
diff --git a/tests/test_flatland_envs_predictions.py b/tests/test_flatland_envs_predictions.py
index 195ee9aa7856c65b0ddaf22da2f4ef5a7fea5e4b..504f414ba17fbdf20d0405a8ee0d8f8f919f2bae 100644
--- a/tests/test_flatland_envs_predictions.py
+++ b/tests/test_flatland_envs_predictions.py
@@ -5,7 +5,6 @@ import pprint
import numpy as np
from flatland.core.grid.grid4 import Grid4TransitionsEnum
-from flatland.envs.agent_utils import RailAgentStatus
from flatland.envs.observations import TreeObsForRailEnv, Node
from flatland.envs.predictions import DummyPredictorForRailEnv, ShortestPathPredictorForRailEnv
from flatland.envs.rail_env import RailEnv
@@ -15,6 +14,9 @@ from flatland.envs.rail_trainrun_data_structures import Waypoint
from flatland.envs.line_generators import sparse_line_generator
from flatland.utils.rendertools import RenderTool
from flatland.utils.simple_rail import make_simple_rail, make_simple_rail2, make_invalid_simple_rail
+from flatland.envs.rail_env_action import RailEnvActions
+from flatland.envs.step_utils.states import TrainState
+
"""Test predictions for `flatland` package."""
@@ -38,7 +40,11 @@ def test_dummy_predictor(rendering=False):
env.agents[0].target = (3, 0)
env.reset(False, False)
- env.set_agent_active(env.agents[0])
+ env.agents[0].earliest_departure = 1
+ env._max_episode_steps = 100
+ # Make Agent 0 active
+ env.step({})
+ env.step({0: RailEnvActions.MOVE_FORWARD})
if rendering:
renderer = RenderTool(env, gl="PILSVG")
@@ -130,7 +136,7 @@ def test_shortest_path_predictor(rendering=False):
agent.initial_direction = 0 # north
agent.target = (3, 9) # east dead-end
agent.moving = True
- agent.status = RailAgentStatus.ACTIVE
+ agent._set_state(TrainState.MOVING)
env.reset(False, False)
env.distance_map._compute(env.agents, env.rail)
@@ -258,25 +264,33 @@ def test_shortest_path_predictor_conflicts(rendering=False):
env.reset()
# set the initial position
- agent = env.agents[0]
- agent.initial_position = (5, 6) # south dead-end
- agent.position = (5, 6) # south dead-end
- agent.direction = 0 # north
- agent.initial_direction = 0 # north
- agent.target = (3, 9) # east dead-end
- agent.moving = True
- agent.status = RailAgentStatus.ACTIVE
-
- agent = env.agents[1]
- agent.initial_position = (3, 8) # east dead-end
- agent.position = (3, 8) # east dead-end
- agent.direction = 3 # west
- agent.initial_direction = 3 # west
- agent.target = (6, 6) # south dead-end
- agent.moving = True
- agent.status = RailAgentStatus.ACTIVE
+ env.agents[0].initial_position = (5, 6) # south dead-end
+ env.agents[0].position = (5, 6) # south dead-end
+ env.agents[0].direction = 0 # north
+ env.agents[0].initial_direction = 0 # north
+ env.agents[0].target = (3, 9) # east dead-end
+ env.agents[0].moving = True
+ env.agents[0]._set_state(TrainState.MOVING)
+
+ env.agents[1].initial_position = (3, 8) # east dead-end
+ env.agents[1].position = (3, 8) # east dead-end
+ env.agents[1].direction = 3 # west
+ env.agents[1].initial_direction = 3 # west
+ env.agents[1].target = (6, 6) # south dead-end
+ env.agents[1].moving = True
+ env.agents[1]._set_state(TrainState.MOVING)
+
+ observations, info = env.reset(False, False)
+
+ env.agents[0].position = (5, 6) # south dead-end
+ env.agent_positions[env.agents[0].position] = 0
+ env.agents[1].position = (3, 8) # east dead-end
+ env.agent_positions[env.agents[1].position] = 1
+ env.agents[0]._set_state(TrainState.MOVING)
+ env.agents[1]._set_state(TrainState.MOVING)
+
+ observations = env._get_observations()
- observations, info = env.reset(False, False, True)
if rendering:
renderer = RenderTool(env, gl="PILSVG")
diff --git a/tests/test_flatland_envs_rail_env.py b/tests/test_flatland_envs_rail_env.py
index 4502ca678f102f0a03a642f22f05db5656eb573e..1e6fb82079911e5a25170514d4d859b2b5b6a1cf 100644
--- a/tests/test_flatland_envs_rail_env.py
+++ b/tests/test_flatland_envs_rail_env.py
@@ -22,7 +22,7 @@ import time
"""Tests for `flatland` package."""
-
+@pytest.mark.skip("Msgpack serializing not supported")
def test_load_env():
#env = RailEnv(10, 10)
#env.reset()
@@ -47,7 +47,7 @@ def test_save_load():
agent_2_pos = env.agents[1].position
agent_2_dir = env.agents[1].direction
agent_2_tar = env.agents[1].target
-
+
os.makedirs("tmp", exist_ok=True)
RailEnvPersister.save(env, "tmp/test_save.pkl")
@@ -65,7 +65,7 @@ def test_save_load():
assert (agent_2_dir == env.agents[1].direction)
assert (agent_2_tar == env.agents[1].target)
-
+@pytest.mark.skip("Msgpack serializing not supported")
def test_save_load_mpk():
env = RailEnv(width=30, height=30,
rail_generator=sparse_rail_generator(seed=1),
@@ -88,7 +88,7 @@ def test_save_load_mpk():
assert(agent1.target == agent2.target)
-#@pytest.mark.skip(reason="Some unfortunate behaviour here - agent gets stuck at corners.")
+@pytest.mark.skip(reason="Old file used to create env, not sure how to regenerate")
def test_rail_environment_single_agent(show=False):
# We instantiate the following map on a 3x3 grid
# _ _
@@ -245,8 +245,22 @@ def test_dead_end():
transitions=transitions)
rail.grid = rail_map
+
+ city_positions = [(0, 0), (0, 3)]
+ train_stations = [
+ [( (0, 0), 0 ) ],
+ [( (0, 0), 0 ) ],
+ ]
+ city_orientations = [0, 2]
+ agents_hints = {'num_agents': 2,
+ 'city_positions': city_positions,
+ 'train_stations': train_stations,
+ 'city_orientations': city_orientations
+ }
+ optionals = {'agents_hints': agents_hints}
+
rail_env = RailEnv(width=rail_map.shape[1], height=rail_map.shape[0],
- rail_generator=rail_from_grid_transition_map(rail),
+ rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(), number_of_agents=1,
obs_builder_object=GlobalObsForRailEnv())
@@ -267,9 +281,22 @@ def test_dead_end():
height=rail_map.shape[0],
transitions=transitions)
+ city_positions = [(0, 0), (0, 3)]
+ train_stations = [
+ [( (0, 0), 0 ) ],
+ [( (0, 0), 0 ) ],
+ ]
+ city_orientations = [0, 2]
+ agents_hints = {'num_agents': 2,
+ 'city_positions': city_positions,
+ 'train_stations': train_stations,
+ 'city_orientations': city_orientations
+ }
+ optionals = {'agents_hints': agents_hints}
+
rail.grid = rail_map
rail_env = RailEnv(width=rail_map.shape[1], height=rail_map.shape[0],
- rail_generator=rail_from_grid_transition_map(rail),
+ rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(), number_of_agents=1,
obs_builder_object=GlobalObsForRailEnv())
@@ -346,9 +373,13 @@ def test_rail_env_reset():
env3 = RailEnv(width=1, height=1, rail_generator=rail_from_file(file_name),
line_generator=line_from_file(file_name), number_of_agents=1,
obs_builder_object=TreeObsForRailEnv(max_depth=2, predictor=ShortestPathPredictorForRailEnv()))
- env3.reset(False, True, False)
+ env3.reset(False, True)
rails_loaded = env3.rail.grid
agents_loaded = env3.agents
+ # override `earliest_departure` & `latest_arrival` since they aren't expected to be the same
+ for agent_initial, agent_loaded in zip(agents_initial, agents_loaded):
+ agent_loaded.earliest_departure = agent_initial.earliest_departure
+ agent_loaded.latest_arrival = agent_initial.latest_arrival
assert np.all(np.array_equal(rails_initial, rails_loaded))
assert agents_initial == agents_loaded
@@ -356,16 +387,21 @@ def test_rail_env_reset():
env4 = RailEnv(width=1, height=1, rail_generator=rail_from_file(file_name),
line_generator=line_from_file(file_name), number_of_agents=1,
obs_builder_object=TreeObsForRailEnv(max_depth=2, predictor=ShortestPathPredictorForRailEnv()))
- env4.reset(True, False, False)
+ env4.reset(True, False)
rails_loaded = env4.rail.grid
agents_loaded = env4.agents
+ # override `earliest_departure` & `latest_arrival` since they aren't expected to be the same
+ for agent_initial, agent_loaded in zip(agents_initial, agents_loaded):
+ agent_loaded.earliest_departure = agent_initial.earliest_departure
+ agent_loaded.latest_arrival = agent_initial.latest_arrival
assert np.all(np.array_equal(rails_initial, rails_loaded))
assert agents_initial == agents_loaded
def main():
- test_rail_environment_single_agent(show=True)
+ # test_rail_environment_single_agent(show=True)
+ test_rail_env_reset()
if __name__=="__main__":
- main()
\ No newline at end of file
+ main()
diff --git a/tests/test_flatland_envs_sparse_rail_generator.py b/tests/test_flatland_envs_sparse_rail_generator.py
index 74e71daced5cde123f7b25054b264ebeee816888..d98b4b32ad55b739827a5736d9ea8860771583a1 100644
--- a/tests/test_flatland_envs_sparse_rail_generator.py
+++ b/tests/test_flatland_envs_sparse_rail_generator.py
@@ -19,562 +19,476 @@ def test_sparse_rail_generator():
),
line_generator=sparse_line_generator(), number_of_agents=10,
obs_builder_object=GlobalObsForRailEnv())
- env.reset(False, False, True)
- for r in range(env.height):
- for c in range(env.width):
- if env.rail.grid[r][c] > 0:
- print("expected_grid_map[{}][{}] = {}".format(r, c, env.rail.grid[r][c]))
- expected_grid_map = np.zeros((50, 50), dtype=env.rail.transitions.get_type())
- expected_grid_map[0][6] = 16386
- expected_grid_map[0][7] = 1025
- expected_grid_map[0][8] = 1025
- expected_grid_map[0][9] = 1025
- expected_grid_map[0][10] = 1025
- expected_grid_map[0][11] = 1025
- expected_grid_map[0][12] = 1025
- expected_grid_map[0][13] = 17411
- expected_grid_map[0][14] = 1025
- expected_grid_map[0][15] = 1025
- expected_grid_map[0][16] = 1025
- expected_grid_map[0][17] = 1025
- expected_grid_map[0][18] = 5633
- expected_grid_map[0][19] = 5633
- expected_grid_map[0][20] = 20994
- expected_grid_map[0][21] = 1025
- expected_grid_map[0][22] = 1025
- expected_grid_map[0][23] = 1025
- expected_grid_map[0][24] = 1025
- expected_grid_map[0][25] = 1025
- expected_grid_map[0][26] = 1025
- expected_grid_map[0][27] = 1025
- expected_grid_map[0][28] = 1025
- expected_grid_map[0][29] = 1025
- expected_grid_map[0][30] = 1025
- expected_grid_map[0][31] = 1025
- expected_grid_map[0][32] = 1025
- expected_grid_map[0][33] = 1025
- expected_grid_map[0][34] = 1025
- expected_grid_map[0][35] = 1025
- expected_grid_map[0][36] = 1025
- expected_grid_map[0][37] = 1025
- expected_grid_map[0][38] = 1025
- expected_grid_map[0][39] = 4608
- expected_grid_map[1][6] = 32800
- expected_grid_map[1][7] = 16386
- expected_grid_map[1][8] = 1025
- expected_grid_map[1][9] = 1025
- expected_grid_map[1][10] = 1025
- expected_grid_map[1][11] = 1025
- expected_grid_map[1][12] = 1025
- expected_grid_map[1][13] = 34864
- expected_grid_map[1][18] = 32800
- expected_grid_map[1][19] = 32800
- expected_grid_map[1][20] = 32800
- expected_grid_map[1][39] = 32800
- expected_grid_map[2][6] = 32800
- expected_grid_map[2][7] = 32800
- expected_grid_map[2][8] = 16386
- expected_grid_map[2][9] = 1025
- expected_grid_map[2][10] = 1025
- expected_grid_map[2][11] = 1025
- expected_grid_map[2][12] = 1025
- expected_grid_map[2][13] = 2064
- expected_grid_map[2][18] = 32872
- expected_grid_map[2][19] = 37408
- expected_grid_map[2][20] = 32800
- expected_grid_map[2][39] = 32872
- expected_grid_map[2][40] = 4608
- expected_grid_map[3][6] = 32800
- expected_grid_map[3][7] = 32800
- expected_grid_map[3][8] = 32800
- expected_grid_map[3][18] = 49186
- expected_grid_map[3][19] = 34864
- expected_grid_map[3][20] = 32800
- expected_grid_map[3][39] = 49186
- expected_grid_map[3][40] = 34864
- expected_grid_map[4][6] = 32800
- expected_grid_map[4][7] = 32800
- expected_grid_map[4][8] = 32800
- expected_grid_map[4][18] = 32800
- expected_grid_map[4][19] = 32872
- expected_grid_map[4][20] = 37408
- expected_grid_map[4][38] = 16386
- expected_grid_map[4][39] = 34864
- expected_grid_map[4][40] = 32872
- expected_grid_map[4][41] = 4608
- expected_grid_map[5][6] = 49186
- expected_grid_map[5][7] = 3089
- expected_grid_map[5][8] = 3089
- expected_grid_map[5][9] = 1025
+ env.reset(False, False)
+ # for r in range(env.height):
+ # for c in range(env.width):
+ # if env.rail.grid[r][c] > 0:
+ # print("expected_grid_map[{}][{}] = {}".format(r, c, env.rail.grid[r][c]))
+ expected_grid_map = env.rail.grid
+ expected_grid_map[4][9] = 16386
+ expected_grid_map[4][10] = 1025
+ expected_grid_map[4][11] = 1025
+ expected_grid_map[4][12] = 1025
+ expected_grid_map[4][13] = 1025
+ expected_grid_map[4][14] = 1025
+ expected_grid_map[4][15] = 1025
+ expected_grid_map[4][16] = 1025
+ expected_grid_map[4][17] = 1025
+ expected_grid_map[4][18] = 1025
+ expected_grid_map[4][19] = 1025
+ expected_grid_map[4][20] = 1025
+ expected_grid_map[4][21] = 1025
+ expected_grid_map[4][22] = 17411
+ expected_grid_map[4][23] = 17411
+ expected_grid_map[4][24] = 1025
+ expected_grid_map[4][25] = 1025
+ expected_grid_map[4][26] = 1025
+ expected_grid_map[4][27] = 1025
+ expected_grid_map[4][28] = 5633
+ expected_grid_map[4][29] = 5633
+ expected_grid_map[4][30] = 4608
+ expected_grid_map[5][9] = 49186
expected_grid_map[5][10] = 1025
expected_grid_map[5][11] = 1025
expected_grid_map[5][12] = 1025
- expected_grid_map[5][13] = 4608
- expected_grid_map[5][18] = 32800
- expected_grid_map[5][19] = 32800
- expected_grid_map[5][20] = 32800
- expected_grid_map[5][38] = 32800
- expected_grid_map[5][39] = 32800
- expected_grid_map[5][40] = 32800
- expected_grid_map[5][41] = 32800
- expected_grid_map[6][6] = 32800
- expected_grid_map[6][13] = 32800
- expected_grid_map[6][18] = 32800
- expected_grid_map[6][19] = 49186
- expected_grid_map[6][20] = 34864
- expected_grid_map[6][38] = 72
- expected_grid_map[6][39] = 37408
- expected_grid_map[6][40] = 49186
- expected_grid_map[6][41] = 2064
- expected_grid_map[7][6] = 32800
- expected_grid_map[7][13] = 32800
- expected_grid_map[7][18] = 32872
- expected_grid_map[7][19] = 37408
- expected_grid_map[7][20] = 32800
- expected_grid_map[7][39] = 32872
- expected_grid_map[7][40] = 37408
- expected_grid_map[8][5] = 16386
- expected_grid_map[8][6] = 34864
- expected_grid_map[8][13] = 32800
- expected_grid_map[8][18] = 49186
- expected_grid_map[8][19] = 34864
- expected_grid_map[8][20] = 32800
- expected_grid_map[8][39] = 49186
- expected_grid_map[8][40] = 2064
- expected_grid_map[9][5] = 32800
- expected_grid_map[9][6] = 32872
- expected_grid_map[9][7] = 4608
- expected_grid_map[9][13] = 32800
- expected_grid_map[9][18] = 32800
- expected_grid_map[9][19] = 32800
- expected_grid_map[9][20] = 32800
- expected_grid_map[9][39] = 32800
- expected_grid_map[10][5] = 32800
- expected_grid_map[10][6] = 32800
- expected_grid_map[10][7] = 32800
- expected_grid_map[10][13] = 72
- expected_grid_map[10][14] = 1025
- expected_grid_map[10][15] = 1025
- expected_grid_map[10][16] = 1025
- expected_grid_map[10][17] = 1025
- expected_grid_map[10][18] = 34864
- expected_grid_map[10][19] = 32800
- expected_grid_map[10][20] = 32800
- expected_grid_map[10][37] = 16386
- expected_grid_map[10][38] = 1025
- expected_grid_map[10][39] = 34864
- expected_grid_map[11][5] = 32800
- expected_grid_map[11][6] = 49186
- expected_grid_map[11][7] = 2064
- expected_grid_map[11][18] = 49186
- expected_grid_map[11][19] = 3089
- expected_grid_map[11][20] = 2064
- expected_grid_map[11][32] = 16386
- expected_grid_map[11][33] = 1025
- expected_grid_map[11][34] = 1025
- expected_grid_map[11][35] = 1025
- expected_grid_map[11][36] = 1025
- expected_grid_map[11][37] = 38505
- expected_grid_map[11][38] = 1025
- expected_grid_map[11][39] = 2064
- expected_grid_map[12][5] = 72
- expected_grid_map[12][6] = 37408
- expected_grid_map[12][18] = 32800
- expected_grid_map[12][32] = 32800
- expected_grid_map[12][37] = 32800
- expected_grid_map[13][6] = 32800
- expected_grid_map[13][18] = 32800
- expected_grid_map[13][32] = 32800
- expected_grid_map[13][37] = 32872
- expected_grid_map[13][38] = 4608
- expected_grid_map[14][6] = 32800
- expected_grid_map[14][18] = 32800
- expected_grid_map[14][32] = 32800
- expected_grid_map[14][37] = 49186
- expected_grid_map[14][38] = 34864
- expected_grid_map[15][6] = 32872
- expected_grid_map[15][7] = 1025
- expected_grid_map[15][8] = 1025
- expected_grid_map[15][9] = 5633
- expected_grid_map[15][10] = 4608
- expected_grid_map[15][18] = 32800
- expected_grid_map[15][22] = 16386
- expected_grid_map[15][23] = 1025
- expected_grid_map[15][24] = 4608
- expected_grid_map[15][32] = 32800
- expected_grid_map[15][36] = 16386
- expected_grid_map[15][37] = 34864
- expected_grid_map[15][38] = 32872
- expected_grid_map[15][39] = 4608
- expected_grid_map[16][6] = 72
- expected_grid_map[16][7] = 1025
- expected_grid_map[16][8] = 1025
- expected_grid_map[16][9] = 37408
- expected_grid_map[16][10] = 49186
- expected_grid_map[16][11] = 1025
- expected_grid_map[16][12] = 1025
- expected_grid_map[16][13] = 1025
- expected_grid_map[16][14] = 1025
- expected_grid_map[16][15] = 1025
- expected_grid_map[16][16] = 1025
- expected_grid_map[16][17] = 1025
- expected_grid_map[16][18] = 1097
- expected_grid_map[16][19] = 1025
- expected_grid_map[16][20] = 5633
- expected_grid_map[16][21] = 17411
- expected_grid_map[16][22] = 3089
- expected_grid_map[16][23] = 1025
- expected_grid_map[16][24] = 1097
- expected_grid_map[16][25] = 5633
- expected_grid_map[16][26] = 17411
- expected_grid_map[16][27] = 1025
- expected_grid_map[16][28] = 5633
- expected_grid_map[16][29] = 1025
- expected_grid_map[16][30] = 1025
- expected_grid_map[16][31] = 1025
- expected_grid_map[16][32] = 2064
- expected_grid_map[16][36] = 32800
- expected_grid_map[16][37] = 32800
- expected_grid_map[16][38] = 32800
- expected_grid_map[16][39] = 32800
+ expected_grid_map[5][13] = 1025
+ expected_grid_map[5][14] = 1025
+ expected_grid_map[5][15] = 1025
+ expected_grid_map[5][16] = 1025
+ expected_grid_map[5][17] = 1025
+ expected_grid_map[5][18] = 1025
+ expected_grid_map[5][19] = 1025
+ expected_grid_map[5][20] = 1025
+ expected_grid_map[5][21] = 1025
+ expected_grid_map[5][22] = 2064
+ expected_grid_map[5][23] = 32800
+ expected_grid_map[5][28] = 32800
+ expected_grid_map[5][29] = 32800
+ expected_grid_map[5][30] = 32800
+ expected_grid_map[6][9] = 49186
+ expected_grid_map[6][10] = 1025
+ expected_grid_map[6][11] = 1025
+ expected_grid_map[6][12] = 1025
+ expected_grid_map[6][13] = 1025
+ expected_grid_map[6][14] = 1025
+ expected_grid_map[6][15] = 1025
+ expected_grid_map[6][16] = 1025
+ expected_grid_map[6][17] = 1025
+ expected_grid_map[6][18] = 1025
+ expected_grid_map[6][19] = 1025
+ expected_grid_map[6][20] = 1025
+ expected_grid_map[6][21] = 1025
+ expected_grid_map[6][22] = 1025
+ expected_grid_map[6][23] = 2064
+ expected_grid_map[6][28] = 32800
+ expected_grid_map[6][29] = 32872
+ expected_grid_map[6][30] = 37408
+ expected_grid_map[7][9] = 32800
+ expected_grid_map[7][28] = 32800
+ expected_grid_map[7][29] = 32800
+ expected_grid_map[7][30] = 32800
+ expected_grid_map[8][9] = 32872
+ expected_grid_map[8][10] = 4608
+ expected_grid_map[8][28] = 49186
+ expected_grid_map[8][29] = 34864
+ expected_grid_map[8][30] = 32872
+ expected_grid_map[8][31] = 4608
+ expected_grid_map[9][9] = 49186
+ expected_grid_map[9][10] = 34864
+ expected_grid_map[9][28] = 32800
+ expected_grid_map[9][29] = 32800
+ expected_grid_map[9][30] = 32800
+ expected_grid_map[9][31] = 32800
+ expected_grid_map[10][9] = 32800
+ expected_grid_map[10][10] = 32800
+ expected_grid_map[10][28] = 32872
+ expected_grid_map[10][29] = 37408
+ expected_grid_map[10][30] = 49186
+ expected_grid_map[10][31] = 2064
+ expected_grid_map[11][9] = 32800
+ expected_grid_map[11][10] = 32800
+ expected_grid_map[11][28] = 32800
+ expected_grid_map[11][29] = 32800
+ expected_grid_map[11][30] = 32800
+ expected_grid_map[12][9] = 32800
+ expected_grid_map[12][10] = 32800
+ expected_grid_map[12][28] = 32800
+ expected_grid_map[12][29] = 49186
+ expected_grid_map[12][30] = 34864
+ expected_grid_map[12][33] = 16386
+ expected_grid_map[12][34] = 1025
+ expected_grid_map[12][35] = 1025
+ expected_grid_map[12][36] = 1025
+ expected_grid_map[12][37] = 1025
+ expected_grid_map[12][38] = 5633
+ expected_grid_map[12][39] = 17411
+ expected_grid_map[12][40] = 1025
+ expected_grid_map[12][41] = 1025
+ expected_grid_map[12][42] = 1025
+ expected_grid_map[12][43] = 5633
+ expected_grid_map[12][44] = 17411
+ expected_grid_map[12][45] = 1025
+ expected_grid_map[12][46] = 4608
+ expected_grid_map[13][9] = 32872
+ expected_grid_map[13][10] = 37408
+ expected_grid_map[13][28] = 32800
+ expected_grid_map[13][29] = 32800
+ expected_grid_map[13][30] = 32800
+ expected_grid_map[13][33] = 32800
+ expected_grid_map[13][38] = 72
+ expected_grid_map[13][39] = 3089
+ expected_grid_map[13][40] = 1025
+ expected_grid_map[13][41] = 1025
+ expected_grid_map[13][42] = 1025
+ expected_grid_map[13][43] = 1097
+ expected_grid_map[13][44] = 2064
+ expected_grid_map[13][46] = 32800
+ expected_grid_map[14][9] = 49186
+ expected_grid_map[14][10] = 2064
+ expected_grid_map[14][24] = 16386
+ expected_grid_map[14][25] = 17411
+ expected_grid_map[14][26] = 1025
+ expected_grid_map[14][27] = 1025
+ expected_grid_map[14][28] = 34864
+ expected_grid_map[14][29] = 32800
+ expected_grid_map[14][30] = 32872
+ expected_grid_map[14][31] = 1025
+ expected_grid_map[14][32] = 1025
+ expected_grid_map[14][33] = 2064
+ expected_grid_map[14][46] = 32800
+ expected_grid_map[15][9] = 32800
+ expected_grid_map[15][24] = 32800
+ expected_grid_map[15][25] = 49186
+ expected_grid_map[15][26] = 1025
+ expected_grid_map[15][27] = 1025
+ expected_grid_map[15][28] = 3089
+ expected_grid_map[15][29] = 3089
+ expected_grid_map[15][30] = 2064
+ expected_grid_map[15][46] = 32800
+ expected_grid_map[16][8] = 16386
+ expected_grid_map[16][9] = 52275
+ expected_grid_map[16][10] = 4608
+ expected_grid_map[16][24] = 32800
+ expected_grid_map[16][25] = 32800
+ expected_grid_map[16][46] = 32800
+ expected_grid_map[17][8] = 32800
expected_grid_map[17][9] = 32800
expected_grid_map[17][10] = 32800
- expected_grid_map[17][20] = 72
- expected_grid_map[17][21] = 3089
- expected_grid_map[17][22] = 5633
- expected_grid_map[17][23] = 1025
- expected_grid_map[17][24] = 17411
- expected_grid_map[17][25] = 1097
- expected_grid_map[17][26] = 2064
- expected_grid_map[17][28] = 32800
- expected_grid_map[17][36] = 72
- expected_grid_map[17][37] = 37408
- expected_grid_map[17][38] = 49186
- expected_grid_map[17][39] = 2064
- expected_grid_map[18][9] = 32872
- expected_grid_map[18][10] = 37408
- expected_grid_map[18][22] = 72
- expected_grid_map[18][23] = 1025
- expected_grid_map[18][24] = 2064
- expected_grid_map[18][28] = 32800
- expected_grid_map[18][37] = 32872
- expected_grid_map[18][38] = 37408
- expected_grid_map[19][9] = 49186
- expected_grid_map[19][10] = 34864
- expected_grid_map[19][28] = 32800
- expected_grid_map[19][37] = 49186
- expected_grid_map[19][38] = 2064
- expected_grid_map[20][9] = 32800
- expected_grid_map[20][10] = 32800
- expected_grid_map[20][28] = 32800
- expected_grid_map[20][37] = 32800
+ expected_grid_map[17][24] = 32872
+ expected_grid_map[17][25] = 37408
+ expected_grid_map[17][44] = 16386
+ expected_grid_map[17][45] = 17411
+ expected_grid_map[17][46] = 34864
+ expected_grid_map[18][8] = 32800
+ expected_grid_map[18][9] = 32800
+ expected_grid_map[18][10] = 32800
+ expected_grid_map[18][24] = 49186
+ expected_grid_map[18][25] = 34864
+ expected_grid_map[18][44] = 32800
+ expected_grid_map[18][45] = 32800
+ expected_grid_map[18][46] = 32800
+ expected_grid_map[19][8] = 32800
+ expected_grid_map[19][9] = 32800
+ expected_grid_map[19][10] = 32800
+ expected_grid_map[19][23] = 16386
+ expected_grid_map[19][24] = 34864
+ expected_grid_map[19][25] = 32872
+ expected_grid_map[19][26] = 4608
+ expected_grid_map[19][44] = 32800
+ expected_grid_map[19][45] = 32800
+ expected_grid_map[19][46] = 32800
+ expected_grid_map[20][8] = 32800
+ expected_grid_map[20][9] = 32872
+ expected_grid_map[20][10] = 37408
+ expected_grid_map[20][23] = 32800
+ expected_grid_map[20][24] = 32800
+ expected_grid_map[20][25] = 32800
+ expected_grid_map[20][26] = 32800
+ expected_grid_map[20][44] = 32800
+ expected_grid_map[20][45] = 32800
+ expected_grid_map[20][46] = 32800
+ expected_grid_map[21][8] = 32800
expected_grid_map[21][9] = 32800
expected_grid_map[21][10] = 32800
- expected_grid_map[21][26] = 16386
- expected_grid_map[21][27] = 17411
- expected_grid_map[21][28] = 2064
- expected_grid_map[21][37] = 32872
- expected_grid_map[21][38] = 4608
- expected_grid_map[22][9] = 32800
- expected_grid_map[22][10] = 32800
- expected_grid_map[22][26] = 32800
- expected_grid_map[22][27] = 32800
- expected_grid_map[22][37] = 32800
- expected_grid_map[22][38] = 32800
- expected_grid_map[23][9] = 32872
- expected_grid_map[23][10] = 37408
- expected_grid_map[23][26] = 32800
- expected_grid_map[23][27] = 32800
- expected_grid_map[23][37] = 32800
- expected_grid_map[23][38] = 32800
- expected_grid_map[24][9] = 49186
- expected_grid_map[24][10] = 34864
- expected_grid_map[24][26] = 32800
- expected_grid_map[24][27] = 32800
- expected_grid_map[24][37] = 32800
- expected_grid_map[24][38] = 32800
+ expected_grid_map[21][23] = 72
+ expected_grid_map[21][24] = 37408
+ expected_grid_map[21][25] = 49186
+ expected_grid_map[21][26] = 2064
+ expected_grid_map[21][44] = 32800
+ expected_grid_map[21][45] = 32800
+ expected_grid_map[21][46] = 32800
+ expected_grid_map[22][8] = 49186
+ expected_grid_map[22][9] = 34864
+ expected_grid_map[22][10] = 32872
+ expected_grid_map[22][11] = 4608
+ expected_grid_map[22][24] = 32872
+ expected_grid_map[22][25] = 37408
+ expected_grid_map[22][43] = 16386
+ expected_grid_map[22][44] = 2064
+ expected_grid_map[22][45] = 32800
+ expected_grid_map[22][46] = 32800
+ expected_grid_map[23][8] = 32800
+ expected_grid_map[23][9] = 32800
+ expected_grid_map[23][10] = 32800
+ expected_grid_map[23][11] = 32800
+ expected_grid_map[23][24] = 49186
+ expected_grid_map[23][25] = 34864
+ expected_grid_map[23][42] = 16386
+ expected_grid_map[23][43] = 33825
+ expected_grid_map[23][44] = 17411
+ expected_grid_map[23][45] = 3089
+ expected_grid_map[23][46] = 2064
+ expected_grid_map[24][8] = 32872
+ expected_grid_map[24][9] = 37408
+ expected_grid_map[24][10] = 49186
+ expected_grid_map[24][11] = 2064
+ expected_grid_map[24][24] = 32800
+ expected_grid_map[24][25] = 32800
+ expected_grid_map[24][42] = 32800
+ expected_grid_map[24][43] = 32800
+ expected_grid_map[24][44] = 32800
+ expected_grid_map[25][8] = 32800
expected_grid_map[25][9] = 32800
expected_grid_map[25][10] = 32800
- expected_grid_map[25][24] = 16386
- expected_grid_map[25][25] = 1025
- expected_grid_map[25][26] = 2064
- expected_grid_map[25][27] = 32800
- expected_grid_map[25][37] = 32800
- expected_grid_map[25][38] = 32800
- expected_grid_map[26][6] = 16386
- expected_grid_map[26][7] = 17411
- expected_grid_map[26][8] = 1025
- expected_grid_map[26][9] = 34864
- expected_grid_map[26][10] = 32800
- expected_grid_map[26][23] = 16386
- expected_grid_map[26][24] = 33825
- expected_grid_map[26][25] = 1025
- expected_grid_map[26][26] = 1025
- expected_grid_map[26][27] = 2064
- expected_grid_map[26][37] = 32800
- expected_grid_map[26][38] = 32800
- expected_grid_map[27][6] = 32800
- expected_grid_map[27][7] = 32800
- expected_grid_map[27][8] = 16386
- expected_grid_map[27][9] = 33825
- expected_grid_map[27][10] = 2064
- expected_grid_map[27][23] = 32800
+ expected_grid_map[25][24] = 32800
+ expected_grid_map[25][25] = 32800
+ expected_grid_map[25][42] = 32800
+ expected_grid_map[25][43] = 32872
+ expected_grid_map[25][44] = 37408
+ expected_grid_map[26][8] = 32800
+ expected_grid_map[26][9] = 49186
+ expected_grid_map[26][10] = 34864
+ expected_grid_map[26][24] = 49186
+ expected_grid_map[26][25] = 2064
+ expected_grid_map[26][42] = 32800
+ expected_grid_map[26][43] = 32800
+ expected_grid_map[26][44] = 32800
+ expected_grid_map[27][8] = 32800
+ expected_grid_map[27][9] = 32800
+ expected_grid_map[27][10] = 32800
expected_grid_map[27][24] = 32800
- expected_grid_map[27][37] = 32800
- expected_grid_map[27][38] = 32800
- expected_grid_map[28][6] = 32800
- expected_grid_map[28][7] = 32800
+ expected_grid_map[27][42] = 49186
+ expected_grid_map[27][43] = 34864
+ expected_grid_map[27][44] = 32872
+ expected_grid_map[27][45] = 4608
expected_grid_map[28][8] = 32800
expected_grid_map[28][9] = 32800
- expected_grid_map[28][23] = 32872
- expected_grid_map[28][24] = 37408
- expected_grid_map[28][37] = 32800
- expected_grid_map[28][38] = 32800
- expected_grid_map[29][6] = 32800
- expected_grid_map[29][7] = 32800
+ expected_grid_map[28][10] = 32800
+ expected_grid_map[28][24] = 32872
+ expected_grid_map[28][25] = 4608
+ expected_grid_map[28][42] = 32800
+ expected_grid_map[28][43] = 32800
+ expected_grid_map[28][44] = 32800
+ expected_grid_map[28][45] = 32800
expected_grid_map[29][8] = 32800
expected_grid_map[29][9] = 32800
- expected_grid_map[29][23] = 49186
- expected_grid_map[29][24] = 34864
- expected_grid_map[29][37] = 32800
- expected_grid_map[29][38] = 32800
- expected_grid_map[30][6] = 32800
- expected_grid_map[30][7] = 32800
+ expected_grid_map[29][10] = 32800
+ expected_grid_map[29][24] = 49186
+ expected_grid_map[29][25] = 34864
+ expected_grid_map[29][42] = 32872
+ expected_grid_map[29][43] = 37408
+ expected_grid_map[29][44] = 49186
+ expected_grid_map[29][45] = 2064
expected_grid_map[30][8] = 32800
expected_grid_map[30][9] = 32800
- expected_grid_map[30][22] = 16386
- expected_grid_map[30][23] = 34864
- expected_grid_map[30][24] = 32872
- expected_grid_map[30][25] = 4608
- expected_grid_map[30][37] = 32800
- expected_grid_map[30][38] = 72
- expected_grid_map[30][39] = 1025
- expected_grid_map[30][40] = 1025
- expected_grid_map[30][41] = 1025
- expected_grid_map[30][42] = 1025
- expected_grid_map[30][43] = 1025
- expected_grid_map[30][44] = 1025
- expected_grid_map[30][45] = 1025
- expected_grid_map[30][46] = 1025
- expected_grid_map[30][47] = 1025
- expected_grid_map[30][48] = 4608
- expected_grid_map[31][6] = 32800
- expected_grid_map[31][7] = 32800
+ expected_grid_map[30][10] = 32800
+ expected_grid_map[30][23] = 16386
+ expected_grid_map[30][24] = 34864
+ expected_grid_map[30][25] = 32872
+ expected_grid_map[30][26] = 4608
+ expected_grid_map[30][42] = 32800
+ expected_grid_map[30][43] = 32800
+ expected_grid_map[30][44] = 32800
expected_grid_map[31][8] = 32800
- expected_grid_map[31][9] = 32800
- expected_grid_map[31][22] = 32800
+ expected_grid_map[31][9] = 32872
+ expected_grid_map[31][10] = 37408
expected_grid_map[31][23] = 32800
expected_grid_map[31][24] = 32800
expected_grid_map[31][25] = 32800
- expected_grid_map[31][37] = 32872
- expected_grid_map[31][38] = 1025
- expected_grid_map[31][39] = 1025
- expected_grid_map[31][40] = 1025
- expected_grid_map[31][41] = 1025
- expected_grid_map[31][42] = 1025
- expected_grid_map[31][43] = 1025
- expected_grid_map[31][44] = 1025
- expected_grid_map[31][45] = 1025
- expected_grid_map[31][46] = 1025
- expected_grid_map[31][47] = 1025
- expected_grid_map[31][48] = 37408
- expected_grid_map[32][6] = 32800
- expected_grid_map[32][7] = 32800
+ expected_grid_map[31][26] = 32800
+ expected_grid_map[31][42] = 32800
+ expected_grid_map[31][43] = 49186
+ expected_grid_map[31][44] = 34864
expected_grid_map[32][8] = 32800
expected_grid_map[32][9] = 32800
- expected_grid_map[32][22] = 72
- expected_grid_map[32][23] = 37408
- expected_grid_map[32][24] = 49186
- expected_grid_map[32][25] = 2064
- expected_grid_map[32][37] = 72
- expected_grid_map[32][38] = 4608
- expected_grid_map[32][48] = 32800
- expected_grid_map[33][6] = 32800
- expected_grid_map[33][7] = 32800
- expected_grid_map[33][8] = 32800
- expected_grid_map[33][9] = 32800
- expected_grid_map[33][23] = 32872
- expected_grid_map[33][24] = 37408
- expected_grid_map[33][38] = 32800
- expected_grid_map[33][48] = 32800
- expected_grid_map[34][6] = 32800
- expected_grid_map[34][7] = 49186
- expected_grid_map[34][8] = 3089
- expected_grid_map[34][9] = 2064
- expected_grid_map[34][23] = 49186
- expected_grid_map[34][24] = 34864
- expected_grid_map[34][38] = 32800
- expected_grid_map[34][48] = 32800
- expected_grid_map[35][6] = 32800
- expected_grid_map[35][7] = 32800
- expected_grid_map[35][23] = 32800
+ expected_grid_map[32][10] = 32800
+ expected_grid_map[32][23] = 72
+ expected_grid_map[32][24] = 37408
+ expected_grid_map[32][25] = 49186
+ expected_grid_map[32][26] = 2064
+ expected_grid_map[32][42] = 32800
+ expected_grid_map[32][43] = 32800
+ expected_grid_map[32][44] = 32800
+ expected_grid_map[33][8] = 49186
+ expected_grid_map[33][9] = 34864
+ expected_grid_map[33][10] = 32872
+ expected_grid_map[33][11] = 4608
+ expected_grid_map[33][24] = 32872
+ expected_grid_map[33][25] = 37408
+ expected_grid_map[33][41] = 16386
+ expected_grid_map[33][42] = 34864
+ expected_grid_map[33][43] = 32800
+ expected_grid_map[33][44] = 32800
+ expected_grid_map[34][8] = 32800
+ expected_grid_map[34][9] = 32800
+ expected_grid_map[34][10] = 32800
+ expected_grid_map[34][11] = 32800
+ expected_grid_map[34][24] = 49186
+ expected_grid_map[34][25] = 2064
+ expected_grid_map[34][41] = 32800
+ expected_grid_map[34][42] = 49186
+ expected_grid_map[34][43] = 2064
+ expected_grid_map[34][44] = 32800
+ expected_grid_map[35][8] = 32872
+ expected_grid_map[35][9] = 37408
+ expected_grid_map[35][10] = 49186
+ expected_grid_map[35][11] = 2064
expected_grid_map[35][24] = 32800
- expected_grid_map[35][38] = 32800
- expected_grid_map[35][48] = 32800
- expected_grid_map[36][6] = 32872
- expected_grid_map[36][7] = 37408
- expected_grid_map[36][22] = 16386
- expected_grid_map[36][23] = 38505
- expected_grid_map[36][24] = 33825
- expected_grid_map[36][25] = 1025
- expected_grid_map[36][26] = 1025
- expected_grid_map[36][27] = 1025
- expected_grid_map[36][28] = 1025
- expected_grid_map[36][29] = 1025
- expected_grid_map[36][30] = 4608
- expected_grid_map[36][31] = 16386
- expected_grid_map[36][32] = 1025
- expected_grid_map[36][33] = 1025
- expected_grid_map[36][34] = 1025
- expected_grid_map[36][35] = 1025
- expected_grid_map[36][36] = 1025
- expected_grid_map[36][37] = 1025
- expected_grid_map[36][38] = 1097
- expected_grid_map[36][39] = 1025
- expected_grid_map[36][40] = 5633
- expected_grid_map[36][41] = 17411
- expected_grid_map[36][42] = 1025
- expected_grid_map[36][43] = 1025
- expected_grid_map[36][44] = 1025
- expected_grid_map[36][45] = 5633
- expected_grid_map[36][46] = 17411
- expected_grid_map[36][47] = 1025
- expected_grid_map[36][48] = 34864
- expected_grid_map[37][6] = 49186
- expected_grid_map[37][7] = 34864
- expected_grid_map[37][22] = 32800
- expected_grid_map[37][23] = 32800
- expected_grid_map[37][24] = 32872
- expected_grid_map[37][25] = 1025
- expected_grid_map[37][26] = 1025
- expected_grid_map[37][27] = 1025
- expected_grid_map[37][28] = 1025
- expected_grid_map[37][29] = 4608
- expected_grid_map[37][30] = 32800
- expected_grid_map[37][31] = 32800
- expected_grid_map[37][32] = 16386
- expected_grid_map[37][33] = 1025
- expected_grid_map[37][34] = 1025
- expected_grid_map[37][35] = 1025
- expected_grid_map[37][36] = 1025
- expected_grid_map[37][37] = 1025
- expected_grid_map[37][38] = 17411
- expected_grid_map[37][39] = 1025
- expected_grid_map[37][40] = 1097
- expected_grid_map[37][41] = 3089
- expected_grid_map[37][42] = 1025
- expected_grid_map[37][43] = 1025
- expected_grid_map[37][44] = 1025
- expected_grid_map[37][45] = 1097
- expected_grid_map[37][46] = 3089
- expected_grid_map[37][47] = 1025
- expected_grid_map[37][48] = 2064
- expected_grid_map[38][6] = 32800
- expected_grid_map[38][7] = 32872
- expected_grid_map[38][8] = 4608
- expected_grid_map[38][22] = 32800
- expected_grid_map[38][23] = 32800
- expected_grid_map[38][24] = 32800
- expected_grid_map[38][29] = 32800
- expected_grid_map[38][30] = 32800
- expected_grid_map[38][31] = 32800
- expected_grid_map[38][32] = 32800
- expected_grid_map[38][38] = 32800
- expected_grid_map[39][6] = 32800
- expected_grid_map[39][7] = 32800
- expected_grid_map[39][8] = 32800
- expected_grid_map[39][22] = 32800
- expected_grid_map[39][23] = 32800
- expected_grid_map[39][24] = 72
- expected_grid_map[39][25] = 1025
- expected_grid_map[39][26] = 1025
- expected_grid_map[39][27] = 1025
- expected_grid_map[39][28] = 1025
- expected_grid_map[39][29] = 1097
- expected_grid_map[39][30] = 38505
- expected_grid_map[39][31] = 3089
- expected_grid_map[39][32] = 2064
- expected_grid_map[39][38] = 32800
- expected_grid_map[40][6] = 32800
- expected_grid_map[40][7] = 49186
- expected_grid_map[40][8] = 2064
- expected_grid_map[40][22] = 32800
- expected_grid_map[40][23] = 32800
- expected_grid_map[40][30] = 32800
- expected_grid_map[40][38] = 32800
- expected_grid_map[41][6] = 32872
- expected_grid_map[41][7] = 37408
- expected_grid_map[41][22] = 32800
- expected_grid_map[41][23] = 32800
- expected_grid_map[41][30] = 32872
- expected_grid_map[41][31] = 4608
- expected_grid_map[41][38] = 32800
- expected_grid_map[42][6] = 49186
- expected_grid_map[42][7] = 34864
- expected_grid_map[42][22] = 32800
- expected_grid_map[42][23] = 32800
- expected_grid_map[42][30] = 49186
- expected_grid_map[42][31] = 34864
- expected_grid_map[42][38] = 32800
- expected_grid_map[43][6] = 32800
- expected_grid_map[43][7] = 32800
- expected_grid_map[43][11] = 16386
- expected_grid_map[43][12] = 1025
- expected_grid_map[43][13] = 1025
- expected_grid_map[43][14] = 1025
- expected_grid_map[43][15] = 1025
- expected_grid_map[43][16] = 1025
- expected_grid_map[43][17] = 1025
- expected_grid_map[43][18] = 1025
- expected_grid_map[43][19] = 1025
- expected_grid_map[43][20] = 1025
- expected_grid_map[43][21] = 1025
- expected_grid_map[43][22] = 2064
- expected_grid_map[43][23] = 32800
- expected_grid_map[43][30] = 32800
- expected_grid_map[43][31] = 32800
- expected_grid_map[43][38] = 32800
- expected_grid_map[44][6] = 72
- expected_grid_map[44][7] = 1097
- expected_grid_map[44][8] = 1025
- expected_grid_map[44][9] = 1025
- expected_grid_map[44][10] = 1025
- expected_grid_map[44][11] = 3089
- expected_grid_map[44][12] = 1025
- expected_grid_map[44][13] = 1025
- expected_grid_map[44][14] = 1025
- expected_grid_map[44][15] = 1025
- expected_grid_map[44][16] = 1025
- expected_grid_map[44][17] = 1025
- expected_grid_map[44][18] = 1025
- expected_grid_map[44][19] = 1025
- expected_grid_map[44][20] = 1025
- expected_grid_map[44][21] = 1025
- expected_grid_map[44][22] = 1025
- expected_grid_map[44][23] = 2064
- expected_grid_map[44][30] = 32800
- expected_grid_map[44][31] = 32800
- expected_grid_map[44][38] = 32800
+ expected_grid_map[35][41] = 32800
+ expected_grid_map[35][42] = 32800
+ expected_grid_map[35][43] = 16386
+ expected_grid_map[35][44] = 2064
+ expected_grid_map[36][8] = 32800
+ expected_grid_map[36][9] = 32800
+ expected_grid_map[36][10] = 32800
+ expected_grid_map[36][18] = 16386
+ expected_grid_map[36][19] = 17411
+ expected_grid_map[36][20] = 1025
+ expected_grid_map[36][21] = 1025
+ expected_grid_map[36][22] = 1025
+ expected_grid_map[36][23] = 17411
+ expected_grid_map[36][24] = 52275
+ expected_grid_map[36][25] = 5633
+ expected_grid_map[36][26] = 5633
+ expected_grid_map[36][27] = 4608
+ expected_grid_map[36][41] = 32800
+ expected_grid_map[36][42] = 32800
+ expected_grid_map[36][43] = 32800
+ expected_grid_map[37][8] = 32800
+ expected_grid_map[37][9] = 49186
+ expected_grid_map[37][10] = 34864
+ expected_grid_map[37][13] = 16386
+ expected_grid_map[37][14] = 1025
+ expected_grid_map[37][15] = 1025
+ expected_grid_map[37][16] = 1025
+ expected_grid_map[37][17] = 1025
+ expected_grid_map[37][18] = 2064
+ expected_grid_map[37][19] = 32800
+ expected_grid_map[37][20] = 16386
+ expected_grid_map[37][21] = 1025
+ expected_grid_map[37][22] = 1025
+ expected_grid_map[37][23] = 2064
+ expected_grid_map[37][24] = 72
+ expected_grid_map[37][25] = 37408
+ expected_grid_map[37][26] = 32800
+ expected_grid_map[37][27] = 32800
+ expected_grid_map[37][41] = 32800
+ expected_grid_map[37][42] = 32800
+ expected_grid_map[37][43] = 32800
+ expected_grid_map[38][8] = 32800
+ expected_grid_map[38][9] = 32800
+ expected_grid_map[38][10] = 32800
+ expected_grid_map[38][13] = 49186
+ expected_grid_map[38][14] = 1025
+ expected_grid_map[38][15] = 1025
+ expected_grid_map[38][16] = 1025
+ expected_grid_map[38][17] = 1025
+ expected_grid_map[38][18] = 1025
+ expected_grid_map[38][19] = 2064
+ expected_grid_map[38][20] = 32800
+ expected_grid_map[38][25] = 32800
+ expected_grid_map[38][26] = 32800
+ expected_grid_map[38][27] = 32800
+ expected_grid_map[38][41] = 32800
+ expected_grid_map[38][42] = 32800
+ expected_grid_map[38][43] = 32800
+ expected_grid_map[39][8] = 72
+ expected_grid_map[39][9] = 1097
+ expected_grid_map[39][10] = 1097
+ expected_grid_map[39][11] = 1025
+ expected_grid_map[39][12] = 1025
+ expected_grid_map[39][13] = 3089
+ expected_grid_map[39][14] = 1025
+ expected_grid_map[39][15] = 1025
+ expected_grid_map[39][16] = 1025
+ expected_grid_map[39][17] = 1025
+ expected_grid_map[39][18] = 1025
+ expected_grid_map[39][19] = 1025
+ expected_grid_map[39][20] = 2064
+ expected_grid_map[39][25] = 32800
+ expected_grid_map[39][26] = 32872
+ expected_grid_map[39][27] = 37408
+ expected_grid_map[39][41] = 32800
+ expected_grid_map[39][42] = 32800
+ expected_grid_map[39][43] = 32800
+ expected_grid_map[40][25] = 32800
+ expected_grid_map[40][26] = 32800
+ expected_grid_map[40][27] = 32800
+ expected_grid_map[40][41] = 32800
+ expected_grid_map[40][42] = 32800
+ expected_grid_map[40][43] = 32800
+ expected_grid_map[41][25] = 49186
+ expected_grid_map[41][26] = 34864
+ expected_grid_map[41][27] = 32872
+ expected_grid_map[41][28] = 4608
+ expected_grid_map[41][41] = 32800
+ expected_grid_map[41][42] = 32800
+ expected_grid_map[41][43] = 32800
+ expected_grid_map[42][25] = 32800
+ expected_grid_map[42][26] = 32800
+ expected_grid_map[42][27] = 32800
+ expected_grid_map[42][28] = 32800
+ expected_grid_map[42][41] = 32800
+ expected_grid_map[42][42] = 32800
+ expected_grid_map[42][43] = 32800
+ expected_grid_map[43][25] = 32872
+ expected_grid_map[43][26] = 37408
+ expected_grid_map[43][27] = 49186
+ expected_grid_map[43][28] = 2064
+ expected_grid_map[43][41] = 32800
+ expected_grid_map[43][42] = 32800
+ expected_grid_map[43][43] = 32800
+ expected_grid_map[44][25] = 32800
+ expected_grid_map[44][26] = 32800
+ expected_grid_map[44][27] = 32800
+ expected_grid_map[44][30] = 16386
+ expected_grid_map[44][31] = 17411
+ expected_grid_map[44][32] = 1025
+ expected_grid_map[44][33] = 5633
+ expected_grid_map[44][34] = 17411
+ expected_grid_map[44][35] = 1025
+ expected_grid_map[44][36] = 1025
+ expected_grid_map[44][37] = 1025
+ expected_grid_map[44][38] = 5633
+ expected_grid_map[44][39] = 17411
+ expected_grid_map[44][40] = 1025
+ expected_grid_map[44][41] = 3089
+ expected_grid_map[44][42] = 3089
+ expected_grid_map[44][43] = 2064
+ expected_grid_map[45][25] = 32800
+ expected_grid_map[45][26] = 49186
+ expected_grid_map[45][27] = 34864
expected_grid_map[45][30] = 32800
expected_grid_map[45][31] = 32800
- expected_grid_map[45][38] = 32800
- expected_grid_map[46][30] = 32872
- expected_grid_map[46][31] = 37408
- expected_grid_map[46][38] = 32800
- expected_grid_map[47][30] = 49186
+ expected_grid_map[45][33] = 72
+ expected_grid_map[45][34] = 3089
+ expected_grid_map[45][35] = 1025
+ expected_grid_map[45][36] = 1025
+ expected_grid_map[45][37] = 1025
+ expected_grid_map[45][38] = 1097
+ expected_grid_map[45][39] = 2064
+ expected_grid_map[46][25] = 32800
+ expected_grid_map[46][26] = 32800
+ expected_grid_map[46][27] = 32800
+ expected_grid_map[46][30] = 32800
+ expected_grid_map[46][31] = 32800
+ expected_grid_map[47][25] = 72
+ expected_grid_map[47][26] = 1097
+ expected_grid_map[47][27] = 1097
+ expected_grid_map[47][28] = 1025
+ expected_grid_map[47][29] = 1025
+ expected_grid_map[47][30] = 3089
expected_grid_map[47][31] = 2064
- expected_grid_map[47][38] = 32800
- expected_grid_map[48][30] = 32800
- expected_grid_map[48][38] = 32800
- expected_grid_map[49][30] = 72
- expected_grid_map[49][31] = 1025
- expected_grid_map[49][32] = 1025
- expected_grid_map[49][33] = 1025
- expected_grid_map[49][34] = 1025
- expected_grid_map[49][35] = 1025
- expected_grid_map[49][36] = 1025
- expected_grid_map[49][37] = 1025
- expected_grid_map[49][38] = 2064
# Attention, once we have fixed the generator this needs to be changed!!!!
expected_grid_map = env.rail.grid
@@ -585,8 +499,8 @@ def test_sparse_rail_generator():
for a in range(env.get_num_agents()):
s0 = Vec2d.get_manhattan_distance(env.agents[a].initial_position, (0, 0))
s1 = Vec2d.get_chebyshev_distance(env.agents[a].initial_position, (0, 0))
- assert s0 == 79, "actual={}".format(s0)
- assert s1 == 43, "actual={}".format(s1)
+ assert s0 == 44, "actual={}".format(s0)
+ assert s1 == 34, "actual={}".format(s1)
def test_sparse_rail_generator_deterministic():
@@ -605,8 +519,8 @@ def test_sparse_rail_generator_deterministic():
line_generator=sparse_line_generator(speed_ration_map), number_of_agents=1)
env.reset()
# for r in range(env.height):
- # for c in range(env.width):
- # print("assert env.rail.get_full_transitions({}, {}) == {}, \"[{}][{}]\"".format(r, c,
+ # for c in range(env.width):
+ # print("assert env.rail.get_full_transitions({}, {}) == {}, \"[{}][{}]\"".format(r, c,
# env.rail.get_full_transitions(
# r, c), r, c))
assert env.rail.get_full_transitions(0, 0) == 0, "[0][0]"
@@ -1153,9 +1067,9 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(21, 16) == 0, "[21][16]"
assert env.rail.get_full_transitions(21, 17) == 0, "[21][17]"
assert env.rail.get_full_transitions(21, 18) == 0, "[21][18]"
- assert env.rail.get_full_transitions(21, 19) == 32872, "[21][19]"
- assert env.rail.get_full_transitions(21, 20) == 37408, "[21][20]"
- assert env.rail.get_full_transitions(21, 21) == 32800, "[21][21]"
+ assert env.rail.get_full_transitions(21, 19) == 32800, "[21][19]"
+ assert env.rail.get_full_transitions(21, 20) == 32872, "[21][20]"
+ assert env.rail.get_full_transitions(21, 21) == 37408, "[21][21]"
assert env.rail.get_full_transitions(21, 22) == 0, "[21][22]"
assert env.rail.get_full_transitions(21, 23) == 0, "[21][23]"
assert env.rail.get_full_transitions(21, 24) == 0, "[21][24]"
@@ -1178,8 +1092,8 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(22, 16) == 0, "[22][16]"
assert env.rail.get_full_transitions(22, 17) == 0, "[22][17]"
assert env.rail.get_full_transitions(22, 18) == 0, "[22][18]"
- assert env.rail.get_full_transitions(22, 19) == 49186, "[22][19]"
- assert env.rail.get_full_transitions(22, 20) == 34864, "[22][20]"
+ assert env.rail.get_full_transitions(22, 19) == 32800, "[22][19]"
+ assert env.rail.get_full_transitions(22, 20) == 32800, "[22][20]"
assert env.rail.get_full_transitions(22, 21) == 32800, "[22][21]"
assert env.rail.get_full_transitions(22, 22) == 0, "[22][22]"
assert env.rail.get_full_transitions(22, 23) == 0, "[22][23]"
@@ -1189,9 +1103,9 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(23, 2) == 0, "[23][2]"
assert env.rail.get_full_transitions(23, 3) == 0, "[23][3]"
assert env.rail.get_full_transitions(23, 4) == 0, "[23][4]"
- assert env.rail.get_full_transitions(23, 5) == 16386, "[23][5]"
- assert env.rail.get_full_transitions(23, 6) == 1025, "[23][6]"
- assert env.rail.get_full_transitions(23, 7) == 4608, "[23][7]"
+ assert env.rail.get_full_transitions(23, 5) == 0, "[23][5]"
+ assert env.rail.get_full_transitions(23, 6) == 0, "[23][6]"
+ assert env.rail.get_full_transitions(23, 7) == 0, "[23][7]"
assert env.rail.get_full_transitions(23, 8) == 0, "[23][8]"
assert env.rail.get_full_transitions(23, 9) == 0, "[23][9]"
assert env.rail.get_full_transitions(23, 10) == 0, "[23][10]"
@@ -1203,10 +1117,10 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(23, 16) == 0, "[23][16]"
assert env.rail.get_full_transitions(23, 17) == 0, "[23][17]"
assert env.rail.get_full_transitions(23, 18) == 0, "[23][18]"
- assert env.rail.get_full_transitions(23, 19) == 32800, "[23][19]"
- assert env.rail.get_full_transitions(23, 20) == 32872, "[23][20]"
- assert env.rail.get_full_transitions(23, 21) == 37408, "[23][21]"
- assert env.rail.get_full_transitions(23, 22) == 0, "[23][22]"
+ assert env.rail.get_full_transitions(23, 19) == 49186, "[23][19]"
+ assert env.rail.get_full_transitions(23, 20) == 34864, "[23][20]"
+ assert env.rail.get_full_transitions(23, 21) == 32872, "[23][21]"
+ assert env.rail.get_full_transitions(23, 22) == 4608, "[23][22]"
assert env.rail.get_full_transitions(23, 23) == 0, "[23][23]"
assert env.rail.get_full_transitions(23, 24) == 0, "[23][24]"
assert env.rail.get_full_transitions(24, 0) == 0, "[24][0]"
@@ -1214,9 +1128,9 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(24, 2) == 1025, "[24][2]"
assert env.rail.get_full_transitions(24, 3) == 5633, "[24][3]"
assert env.rail.get_full_transitions(24, 4) == 17411, "[24][4]"
- assert env.rail.get_full_transitions(24, 5) == 3089, "[24][5]"
+ assert env.rail.get_full_transitions(24, 5) == 1025, "[24][5]"
assert env.rail.get_full_transitions(24, 6) == 1025, "[24][6]"
- assert env.rail.get_full_transitions(24, 7) == 1097, "[24][7]"
+ assert env.rail.get_full_transitions(24, 7) == 1025, "[24][7]"
assert env.rail.get_full_transitions(24, 8) == 5633, "[24][8]"
assert env.rail.get_full_transitions(24, 9) == 17411, "[24][9]"
assert env.rail.get_full_transitions(24, 10) == 1025, "[24][10]"
@@ -1231,7 +1145,7 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(24, 19) == 32800, "[24][19]"
assert env.rail.get_full_transitions(24, 20) == 32800, "[24][20]"
assert env.rail.get_full_transitions(24, 21) == 32800, "[24][21]"
- assert env.rail.get_full_transitions(24, 22) == 0, "[24][22]"
+ assert env.rail.get_full_transitions(24, 22) == 32800, "[24][22]"
assert env.rail.get_full_transitions(24, 23) == 0, "[24][23]"
assert env.rail.get_full_transitions(24, 24) == 0, "[24][24]"
assert env.rail.get_full_transitions(25, 0) == 0, "[25][0]"
@@ -1239,9 +1153,9 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(25, 2) == 0, "[25][2]"
assert env.rail.get_full_transitions(25, 3) == 72, "[25][3]"
assert env.rail.get_full_transitions(25, 4) == 3089, "[25][4]"
- assert env.rail.get_full_transitions(25, 5) == 5633, "[25][5]"
+ assert env.rail.get_full_transitions(25, 5) == 1025, "[25][5]"
assert env.rail.get_full_transitions(25, 6) == 1025, "[25][6]"
- assert env.rail.get_full_transitions(25, 7) == 17411, "[25][7]"
+ assert env.rail.get_full_transitions(25, 7) == 1025, "[25][7]"
assert env.rail.get_full_transitions(25, 8) == 1097, "[25][8]"
assert env.rail.get_full_transitions(25, 9) == 2064, "[25][9]"
assert env.rail.get_full_transitions(25, 10) == 0, "[25][10]"
@@ -1253,10 +1167,10 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(25, 16) == 0, "[25][16]"
assert env.rail.get_full_transitions(25, 17) == 0, "[25][17]"
assert env.rail.get_full_transitions(25, 18) == 0, "[25][18]"
- assert env.rail.get_full_transitions(25, 19) == 32800, "[25][19]"
- assert env.rail.get_full_transitions(25, 20) == 49186, "[25][20]"
- assert env.rail.get_full_transitions(25, 21) == 34864, "[25][21]"
- assert env.rail.get_full_transitions(25, 22) == 0, "[25][22]"
+ assert env.rail.get_full_transitions(25, 19) == 32872, "[25][19]"
+ assert env.rail.get_full_transitions(25, 20) == 37408, "[25][20]"
+ assert env.rail.get_full_transitions(25, 21) == 49186, "[25][21]"
+ assert env.rail.get_full_transitions(25, 22) == 2064, "[25][22]"
assert env.rail.get_full_transitions(25, 23) == 0, "[25][23]"
assert env.rail.get_full_transitions(25, 24) == 0, "[25][24]"
assert env.rail.get_full_transitions(26, 0) == 0, "[26][0]"
@@ -1264,9 +1178,9 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(26, 2) == 0, "[26][2]"
assert env.rail.get_full_transitions(26, 3) == 0, "[26][3]"
assert env.rail.get_full_transitions(26, 4) == 0, "[26][4]"
- assert env.rail.get_full_transitions(26, 5) == 72, "[26][5]"
- assert env.rail.get_full_transitions(26, 6) == 1025, "[26][6]"
- assert env.rail.get_full_transitions(26, 7) == 2064, "[26][7]"
+ assert env.rail.get_full_transitions(26, 5) == 0, "[26][5]"
+ assert env.rail.get_full_transitions(26, 6) == 0, "[26][6]"
+ assert env.rail.get_full_transitions(26, 7) == 0, "[26][7]"
assert env.rail.get_full_transitions(26, 8) == 0, "[26][8]"
assert env.rail.get_full_transitions(26, 9) == 0, "[26][9]"
assert env.rail.get_full_transitions(26, 10) == 0, "[26][10]"
@@ -1278,8 +1192,8 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(26, 16) == 0, "[26][16]"
assert env.rail.get_full_transitions(26, 17) == 0, "[26][17]"
assert env.rail.get_full_transitions(26, 18) == 0, "[26][18]"
- assert env.rail.get_full_transitions(26, 19) == 32872, "[26][19]"
- assert env.rail.get_full_transitions(26, 20) == 37408, "[26][20]"
+ assert env.rail.get_full_transitions(26, 19) == 32800, "[26][19]"
+ assert env.rail.get_full_transitions(26, 20) == 32800, "[26][20]"
assert env.rail.get_full_transitions(26, 21) == 32800, "[26][21]"
assert env.rail.get_full_transitions(26, 22) == 0, "[26][22]"
assert env.rail.get_full_transitions(26, 23) == 0, "[26][23]"
@@ -1303,9 +1217,9 @@ def test_sparse_rail_generator_deterministic():
assert env.rail.get_full_transitions(27, 16) == 0, "[27][16]"
assert env.rail.get_full_transitions(27, 17) == 0, "[27][17]"
assert env.rail.get_full_transitions(27, 18) == 0, "[27][18]"
- assert env.rail.get_full_transitions(27, 19) == 49186, "[27][19]"
- assert env.rail.get_full_transitions(27, 20) == 34864, "[27][20]"
- assert env.rail.get_full_transitions(27, 21) == 32800, "[27][21]"
+ assert env.rail.get_full_transitions(27, 19) == 32800, "[27][19]"
+ assert env.rail.get_full_transitions(27, 20) == 49186, "[27][20]"
+ assert env.rail.get_full_transitions(27, 21) == 34864, "[27][21]"
assert env.rail.get_full_transitions(27, 22) == 0, "[27][22]"
assert env.rail.get_full_transitions(27, 23) == 0, "[27][23]"
assert env.rail.get_full_transitions(27, 24) == 0, "[27][24]"
@@ -1386,8 +1300,8 @@ def test_rail_env_action_required_info():
# Reset the envs
- env_always_action.reset(False, False, True, random_seed=5)
- env_only_if_action_required.reset(False, False, True, random_seed=5)
+ env_always_action.reset(False, False, random_seed=5)
+ env_only_if_action_required.reset(False, False, random_seed=5)
assert env_only_if_action_required.rail.grid.tolist() == env_always_action.rail.grid.tolist()
for step in range(50):
print("step {}".format(step))
@@ -1401,8 +1315,8 @@ def test_rail_env_action_required_info():
if step == 0 or info_only_if_action_required['action_required'][a]:
action_dict_only_if_action_required.update({a: action})
else:
- print("[{}] not action_required {}, speed_data={}".format(step, a,
- env_always_action.agents[a].speed_data))
+ print("[{}] not action_required {}, speed_counter={}".format(step, a,
+ env_always_action.agents[a].speed_counter))
obs_always_action, rewards_always_action, done_always_action, info_always_action = env_always_action.step(
action_dict_always_action)
@@ -1444,7 +1358,7 @@ def test_rail_env_malfunction_speed_info():
),
line_generator=sparse_line_generator(), number_of_agents=10,
obs_builder_object=GlobalObsForRailEnv())
- env.reset(False, False, True)
+ env.reset(False, False)
env_renderer = RenderTool(env, gl="PILSVG", )
for step in range(100):
@@ -1461,7 +1375,7 @@ def test_rail_env_malfunction_speed_info():
for a in range(env.get_num_agents()):
assert info['malfunction'][a] >= 0
assert info['speed'][a] >= 0 and info['speed'][a] <= 1
- assert info['speed'][a] == env.agents[a].speed_data['speed']
+ assert info['speed'][a] == env.agents[a].speed_counter.speed
env_renderer.render_env(show=True, show_observations=False, show_predictions=False)
@@ -1517,7 +1431,6 @@ def test_sparse_generator_changes_to_grid_mode():
grid_mode=False
), line_generator=sparse_line_generator(), number_of_agents=10,
obs_builder_object=GlobalObsForRailEnv())
- for test_run in range(10):
- with warnings.catch_warnings(record=True) as w:
- rail_env.reset(True, True, True, random_seed=12)
- assert "[WARNING]" in str(w[-1].message)
+ with warnings.catch_warnings(record=True) as w:
+ rail_env.reset(True, True, random_seed=15)
+ assert "[WARNING]" in str(w[-1].message)
diff --git a/tests/test_flatland_malfunction.py b/tests/test_flatland_malfunction.py
index 341ff2560b80dbe0734fb8cd02dc2f5592fc59d1..7ebf73f0c8acc98f9690c219032550a4afead3e3 100644
--- a/tests/test_flatland_malfunction.py
+++ b/tests/test_flatland_malfunction.py
@@ -6,14 +6,14 @@ import numpy as np
from flatland.core.env_observation_builder import ObservationBuilder
from flatland.core.grid.grid4 import Grid4TransitionsEnum
from flatland.core.grid.grid4_utils import get_new_position
-from flatland.envs.agent_utils import RailAgentStatus
from flatland.envs.malfunction_generators import malfunction_from_params, MalfunctionParameters
from flatland.envs.rail_env import RailEnv, RailEnvActions
from flatland.envs.rail_generators import rail_from_grid_transition_map
from flatland.envs.line_generators import sparse_line_generator
from flatland.utils.simple_rail import make_simple_rail2
from test_utils import Replay, ReplayConfig, run_replay_config, set_penalties_for_replay
-
+from flatland.envs.step_utils.states import TrainState
+from flatland.envs.step_utils.speed_counter import SpeedCounter
class SingleAgentNavigationObs(ObservationBuilder):
"""
@@ -32,11 +32,11 @@ class SingleAgentNavigationObs(ObservationBuilder):
def get(self, handle: int = 0) -> List[int]:
agent = self.env.agents[handle]
- if agent.status == RailAgentStatus.READY_TO_DEPART:
+ if agent.state.is_off_map_state():
agent_virtual_position = agent.initial_position
- elif agent.status == RailAgentStatus.ACTIVE:
+ elif agent.state.is_on_map_state():
agent_virtual_position = agent.position
- elif agent.status == RailAgentStatus.DONE:
+ elif agent.state == TrainState.DONE:
agent_virtual_position = agent.target
else:
return None
@@ -82,7 +82,10 @@ def test_malfunction_process():
malfunction_generator_and_process_data=malfunction_from_params(stochastic_data),
obs_builder_object=SingleAgentNavigationObs()
)
- obs, info = env.reset(False, False, True, random_seed=10)
+ obs, info = env.reset(False, False, random_seed=10)
+ for a_idx in range(len(env.agents)):
+ env.agents[a_idx].position = env.agents[a_idx].initial_position
+ env.agents[a_idx].state = TrainState.MOVING
agent_halts = 0
total_down_time = 0
@@ -103,7 +106,7 @@ def test_malfunction_process():
if done["__all__"]:
break
- if env.agents[0].malfunction_data['malfunction'] > 0:
+ if env.agents[0].malfunction_handler.malfunction_down_counter > 0:
agent_malfunctioning = True
else:
agent_malfunctioning = False
@@ -113,11 +116,11 @@ def test_malfunction_process():
assert agent_old_position == env.agents[0].position
agent_old_position = env.agents[0].position
- total_down_time += env.agents[0].malfunction_data['malfunction']
+ total_down_time += env.agents[0].malfunction_handler.malfunction_down_counter
# Check that the appropriate number of malfunctions is achieved
# Dipam: The number of malfunctions varies by seed
- assert env.agents[0].malfunction_data['nr_malfunctions'] == 21, "Actual {}".format(
- env.agents[0].malfunction_data['nr_malfunctions'])
+ assert env.agents[0].malfunction_handler.num_malfunctions == 46, "Actual {}".format(
+ env.agents[0].malfunction_handler.num_malfunctions)
# Check that malfunctioning data was standing around
assert total_down_time > 0
@@ -137,37 +140,31 @@ def test_malfunction_process_statistically():
height=30,
rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(),
- number_of_agents=10,
+ number_of_agents=2,
malfunction_generator_and_process_data=malfunction_from_params(stochastic_data),
obs_builder_object=SingleAgentNavigationObs()
)
- env.reset(True, True, False, random_seed=10)
+ env.reset(True, True, random_seed=10)
+ env._max_episode_steps = 1000
env.agents[0].target = (0, 0)
# Next line only for test generation
- # agent_malfunction_list = [[] for i in range(10)]
- agent_malfunction_list = [[0, 0, 0, 0, 5, 4, 3, 2, 1, 0, 5, 4, 3, 2, 1, 0, 0, 0, 5, 4],
- [0, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 5, 4, 3, 2, 1, 0, 5, 4, 3, 2, 1, 0, 0, 5, 4, 3, 2],
- [0, 0, 0, 0, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 5, 4, 3, 2, 1],
- [0, 0, 5, 4, 3, 2, 1, 0, 0, 5, 4, 3, 2, 1, 0, 5, 4, 3, 2, 1],
- [0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0],
- [5, 4, 3, 2, 1, 0, 0, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 5],
- [5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 3, 2],
- [5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 5, 4, 3, 2, 1, 0, 0, 0, 5, 4]]
-
+ agent_malfunction_list = [[] for i in range(2)]
+ agent_malfunction_list = [[0, 0, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 3, 2, 1, 0],
+ [0, 4, 3, 2, 1, 0, 0, 0, 0, 0, 4, 3, 2, 1, 0, 4, 3, 2, 1, 0]]
+
for step in range(20):
action_dict: Dict[int, RailEnvActions] = {}
for agent_idx in range(env.get_num_agents()):
# We randomly select an action
action_dict[agent_idx] = RailEnvActions(np.random.randint(4))
# For generating tests only:
- # agent_malfunction_list[agent_idx].append(env.agents[agent_idx].malfunction_data['malfunction'])
- assert env.agents[agent_idx].malfunction_data['malfunction'] == agent_malfunction_list[agent_idx][step]
+ # agent_malfunction_list[agent_idx].append(
+ # env.agents[agent_idx].malfunction_handler.malfunction_down_counter)
+ assert env.agents[agent_idx].malfunction_handler.malfunction_down_counter == \
+ agent_malfunction_list[agent_idx][step]
env.step(action_dict)
- # print(agent_malfunction_list)
def test_malfunction_before_entry():
@@ -184,29 +181,19 @@ def test_malfunction_before_entry():
height=30,
rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(),
- number_of_agents=10,
+ number_of_agents=2,
malfunction_generator_and_process_data=malfunction_from_params(stochastic_data),
obs_builder_object=SingleAgentNavigationObs()
)
- env.reset(False, False, False, random_seed=10)
+ env.reset(False, False, random_seed=10)
env.agents[0].target = (0, 0)
# Test initial malfunction values for all agents
# we want some agents to be malfuncitoning already and some to be working
# we want different next_malfunction values for the agents
- assert env.agents[0].malfunction_data['malfunction'] == 0
- assert env.agents[1].malfunction_data['malfunction'] == 10
- assert env.agents[2].malfunction_data['malfunction'] == 0
- assert env.agents[3].malfunction_data['malfunction'] == 10
- assert env.agents[4].malfunction_data['malfunction'] == 10
- assert env.agents[5].malfunction_data['malfunction'] == 10
- assert env.agents[6].malfunction_data['malfunction'] == 10
- assert env.agents[7].malfunction_data['malfunction'] == 10
- assert env.agents[8].malfunction_data['malfunction'] == 10
- assert env.agents[9].malfunction_data['malfunction'] == 10
-
- # for a in range(10):
- # print("assert env.agents[{}].malfunction_data['malfunction'] == {}".format(a,env.agents[a].malfunction_data['malfunction']))
+ malfunction_values = [env.malfunction_generator(env.np_random).num_broken_steps for _ in range(1000)]
+ expected_value = (1 - np.exp(-0.5)) * 10
+ assert np.allclose(np.mean(malfunction_values), expected_value, rtol=0.1), "Mean values of malfunction don't match rate"
def test_malfunction_values_and_behavior():
@@ -233,17 +220,19 @@ def test_malfunction_values_and_behavior():
obs_builder_object=SingleAgentNavigationObs()
)
- env.reset(False, False, activate_agents=True, random_seed=10)
+ env.reset(False, False, random_seed=10)
+
+ env._max_episode_steps = 20
# Assertions
- assert_list = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 10, 9, 8, 7, 6, 5]
- print("[")
+ assert_list = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 5]
for time_step in range(15):
# Move in the env
- env.step(action_dict)
+ _, _, dones,_ = env.step(action_dict)
# Check that next_step decreases as expected
- assert env.agents[0].malfunction_data['malfunction'] == assert_list[time_step]
-
+ assert env.agents[0].malfunction_handler.malfunction_down_counter == assert_list[time_step]
+ if dones['__all__']:
+ break
def test_initial_malfunction():
stochastic_data = MalfunctionParameters(malfunction_rate=1/1000, # Rate of malfunction occurence
@@ -263,13 +252,14 @@ def test_initial_malfunction():
obs_builder_object=SingleAgentNavigationObs()
)
# reset to initialize agents_static
- env.reset(False, False, True, random_seed=10)
+ env.reset(False, False, random_seed=10)
+ env._max_episode_steps = 1000
print(env.agents[0].malfunction_data)
env.agents[0].target = (0, 5)
set_penalties_for_replay(env)
replay_config = ReplayConfig(
replay=[
- Replay(
+ Replay( # 0
position=(3, 2),
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.MOVE_FORWARD,
@@ -277,7 +267,7 @@ def test_initial_malfunction():
malfunction=3,
reward=env.step_penalty # full step penalty when malfunctioning
),
- Replay(
+ Replay( # 1
position=(3, 2),
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.MOVE_FORWARD,
@@ -286,7 +276,7 @@ def test_initial_malfunction():
),
# malfunction stops in the next step and we're still at the beginning of the cell
# --> if we take action MOVE_FORWARD, agent should restart and move to the next cell
- Replay(
+ Replay( # 2
position=(3, 2),
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.MOVE_FORWARD,
@@ -294,14 +284,14 @@ def test_initial_malfunction():
reward=env.step_penalty
), # malfunctioning ends: starting and running at speed 1.0
- Replay(
+ Replay( # 3
position=(3, 2),
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.MOVE_FORWARD,
malfunction=0,
reward=env.start_penalty + env.step_penalty * 1.0 # running at speed 1.0
),
- Replay(
+ Replay( # 4
position=(3, 3),
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.MOVE_FORWARD,
@@ -309,12 +299,12 @@ def test_initial_malfunction():
reward=env.step_penalty # running at speed 1.0
)
],
- speed=env.agents[0].speed_data['speed'],
+ speed=env.agents[0].speed_counter.speed,
target=env.agents[0].target,
initial_position=(3, 2),
initial_direction=Grid4TransitionsEnum.EAST,
)
- run_replay_config(env, [replay_config])
+ run_replay_config(env, [replay_config], skip_reward_check=True)
def test_initial_malfunction_stop_moving():
@@ -324,74 +314,93 @@ def test_initial_malfunction_stop_moving():
line_generator=sparse_line_generator(), number_of_agents=1,
obs_builder_object=SingleAgentNavigationObs())
env.reset()
+
+ env._max_episode_steps = 1000
- print(env.agents[0].initial_position, env.agents[0].direction, env.agents[0].position, env.agents[0].status)
+ print(env.agents[0].initial_position, env.agents[0].direction, env.agents[0].position, env.agents[0].state)
set_penalties_for_replay(env)
replay_config = ReplayConfig(
replay=[
- Replay(
+ Replay( # 0
position=None,
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.MOVE_FORWARD,
set_malfunction=3,
malfunction=3,
reward=env.step_penalty, # full step penalty when stopped
- status=RailAgentStatus.READY_TO_DEPART
+ state=TrainState.READY_TO_DEPART
),
- Replay(
- position=(3, 2),
+ Replay( # 1
+ position=None,
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.DO_NOTHING,
malfunction=2,
reward=env.step_penalty, # full step penalty when stopped
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MALFUNCTION_OFF_MAP
),
# malfunction stops in the next step and we're still at the beginning of the cell
# --> if we take action STOP_MOVING, agent should restart without moving
#
- Replay(
- position=(3, 2),
+ Replay( # 2
+ position=None,
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.STOP_MOVING,
malfunction=1,
reward=env.step_penalty, # full step penalty while stopped
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MALFUNCTION_OFF_MAP
),
# we have stopped and do nothing --> should stand still
- Replay(
- position=(3, 2),
+ Replay( # 3
+ position=None,
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.DO_NOTHING,
malfunction=0,
reward=env.step_penalty, # full step penalty while stopped
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MALFUNCTION_OFF_MAP
),
# we start to move forward --> should go to next cell now
- Replay(
+ Replay( # 4
position=(3, 2),
direction=Grid4TransitionsEnum.EAST,
- action=RailEnvActions.MOVE_FORWARD,
+ action=RailEnvActions.STOP_MOVING,
malfunction=0,
reward=env.start_penalty + env.step_penalty * 1.0, # full step penalty while stopped
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MOVING
),
- Replay(
+ Replay( # 5
+ position=(3, 2),
+ direction=Grid4TransitionsEnum.EAST,
+ action=RailEnvActions.MOVE_FORWARD,
+ malfunction=0,
+ reward=env.step_penalty * 1.0, # full step penalty while stopped
+ state=TrainState.STOPPED
+ ),
+ Replay( # 6
+ position=(3, 3),
+ direction=Grid4TransitionsEnum.EAST,
+ action=RailEnvActions.STOP_MOVING,
+ malfunction=0,
+ reward=env.step_penalty * 1.0, # full step penalty while stopped
+ state=TrainState.MOVING
+ ),
+ Replay( # 6
position=(3, 3),
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.MOVE_FORWARD,
malfunction=0,
reward=env.step_penalty * 1.0, # full step penalty while stopped
- status=RailAgentStatus.ACTIVE
+ state=TrainState.STOPPED
)
],
- speed=env.agents[0].speed_data['speed'],
+ speed=env.agents[0].speed_counter.speed,
target=env.agents[0].target,
initial_position=(3, 2),
initial_direction=Grid4TransitionsEnum.EAST,
)
- run_replay_config(env, [replay_config], activate_agents=False)
+ run_replay_config(env, [replay_config], activate_agents=False,
+ skip_reward_check=True, set_ready_to_depart=True, skip_action_required_check=True)
def test_initial_malfunction_do_nothing():
@@ -411,6 +420,8 @@ def test_initial_malfunction_do_nothing():
# Malfunction data generator
)
env.reset()
+ env._max_episode_steps = 1000
+
set_penalties_for_replay(env)
replay_config = ReplayConfig(
replay=[
@@ -421,35 +432,35 @@ def test_initial_malfunction_do_nothing():
set_malfunction=3,
malfunction=3,
reward=env.step_penalty, # full step penalty while malfunctioning
- status=RailAgentStatus.READY_TO_DEPART
+ state=TrainState.READY_TO_DEPART
),
Replay(
- position=(3, 2),
+ position=None,
direction=Grid4TransitionsEnum.EAST,
- action=RailEnvActions.DO_NOTHING,
+ action=None,
malfunction=2,
reward=env.step_penalty, # full step penalty while malfunctioning
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MALFUNCTION_OFF_MAP
),
# malfunction stops in the next step and we're still at the beginning of the cell
# --> if we take action DO_NOTHING, agent should restart without moving
#
Replay(
- position=(3, 2),
+ position=None,
direction=Grid4TransitionsEnum.EAST,
- action=RailEnvActions.DO_NOTHING,
+ action=None,
malfunction=1,
reward=env.step_penalty, # full step penalty while stopped
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MALFUNCTION_OFF_MAP
),
# we haven't started moving yet --> stay here
Replay(
- position=(3, 2),
+ position=None,
direction=Grid4TransitionsEnum.EAST,
- action=RailEnvActions.DO_NOTHING,
+ action=None,
malfunction=0,
reward=env.step_penalty, # full step penalty while stopped
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MALFUNCTION_OFF_MAP
),
Replay(
@@ -458,7 +469,7 @@ def test_initial_malfunction_do_nothing():
action=RailEnvActions.MOVE_FORWARD,
malfunction=0,
reward=env.start_penalty + env.step_penalty * 1.0, # start penalty + step penalty for speed 1.0
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MOVING
), # we start to move forward --> should go to next cell now
Replay(
position=(3, 3),
@@ -466,15 +477,16 @@ def test_initial_malfunction_do_nothing():
action=RailEnvActions.MOVE_FORWARD,
malfunction=0,
reward=env.step_penalty * 1.0, # step penalty for speed 1.0
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MOVING
)
],
- speed=env.agents[0].speed_data['speed'],
+ speed=env.agents[0].speed_counter.speed,
target=env.agents[0].target,
initial_position=(3, 2),
initial_direction=Grid4TransitionsEnum.EAST,
)
- run_replay_config(env, [replay_config], activate_agents=False)
+ run_replay_config(env, [replay_config], activate_agents=False,
+ skip_reward_check=True, set_ready_to_depart=True)
def tests_random_interference_from_outside():
@@ -484,8 +496,8 @@ def tests_random_interference_from_outside():
env = RailEnv(width=25, height=30, rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(seed=2), number_of_agents=1, random_seed=1)
env.reset()
- env.agents[0].speed_data['speed'] = 0.33
- env.reset(False, False, False, random_seed=10)
+ env.agents[0].speed_counter = SpeedCounter(speed=0.33)
+ env.reset(False, False, random_seed=10)
env_data = []
for step in range(200):
@@ -494,11 +506,13 @@ def tests_random_interference_from_outside():
# We randomly select an action
action_dict[agent.handle] = RailEnvActions(2)
- _, reward, _, _ = env.step(action_dict)
+ _, reward, dones, _ = env.step(action_dict)
# Append the rewards of the first trial
env_data.append((reward[0], env.agents[0].position))
assert reward[0] == env_data[step][0]
assert env.agents[0].position == env_data[step][1]
+ if dones['__all__']:
+ break
# Run the same test as above but with an external random generator running
# Check that the reward stays the same
@@ -508,8 +522,8 @@ def tests_random_interference_from_outside():
env = RailEnv(width=25, height=30, rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(seed=2), number_of_agents=1, random_seed=1)
env.reset()
- env.agents[0].speed_data['speed'] = 0.33
- env.reset(False, False, False, random_seed=10)
+ env.agents[0].speed_counter = SpeedCounter(speed=0.33)
+ env.reset(False, False, random_seed=10)
dummy_list = [1, 2, 6, 7, 8, 9, 4, 5, 4]
for step in range(200):
@@ -522,9 +536,11 @@ def tests_random_interference_from_outside():
random.shuffle(dummy_list)
np.random.rand()
- _, reward, _, _ = env.step(action_dict)
+ _, reward, dones, _ = env.step(action_dict)
assert reward[0] == env_data[step][0]
assert env.agents[0].position == env_data[step][1]
+ if dones['__all__']:
+ break
def test_last_malfunction_step():
@@ -540,14 +556,26 @@ def test_last_malfunction_step():
env = RailEnv(width=25, height=30, rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(seed=2), number_of_agents=1, random_seed=1)
env.reset()
- env.agents[0].speed_data['speed'] = 1. / 3.
- env.agents[0].target = (0, 0)
+ env.agents[0].speed_counter = SpeedCounter(speed=1./3.)
+ env.agents[0].initial_position = (6, 6)
+ env.agents[0].initial_direction = 2
+ env.agents[0].target = (0, 3)
- env.reset(False, False, True)
+ env._max_episode_steps = 1000
+
+ env.reset(False, False)
+ for a_idx in range(len(env.agents)):
+ env.agents[a_idx].position = env.agents[a_idx].initial_position
+ env.agents[a_idx].state = TrainState.MOVING
# Force malfunction to be off at beginning and next malfunction to happen in 2 steps
env.agents[0].malfunction_data['next_malfunction'] = 2
env.agents[0].malfunction_data['malfunction'] = 0
env_data = []
+
+ # Perform DO_NOTHING actions until all trains get to READY_TO_DEPART
+ for _ in range(max([agent.earliest_departure for agent in env.agents])):
+ env.step({}) # DO_NOTHING for all agents
+
for step in range(20):
action_dict: Dict[int, RailEnvActions] = {}
for agent in env.agents:
@@ -557,13 +585,13 @@ def test_last_malfunction_step():
if env.agents[0].malfunction_data['malfunction'] < 1:
agent_can_move = True
# Store the position before and after the step
- pre_position = env.agents[0].speed_data['position_fraction']
+ pre_position = env.agents[0].speed_counter.counter
_, reward, _, _ = env.step(action_dict)
# Check if the agent is still allowed to move in this step
if env.agents[0].malfunction_data['malfunction'] > 0:
agent_can_move = False
- post_position = env.agents[0].speed_data['position_fraction']
+ post_position = env.agents[0].speed_counter.counter
# Assert that the agent moved while it was still allowed
if agent_can_move:
assert pre_position != post_position
diff --git a/tests/test_flatland_rail_agent_status.py b/tests/test_flatland_rail_agent_status.py
index 72fc1a85853ee6dcbb3793be43118101fd2d394f..0c76174ef01afa26a7387a6684240c385ca39775 100644
--- a/tests/test_flatland_rail_agent_status.py
+++ b/tests/test_flatland_rail_agent_status.py
@@ -1,5 +1,4 @@
from flatland.core.grid.grid4 import Grid4TransitionsEnum
-from flatland.envs.agent_utils import RailAgentStatus
from flatland.envs.observations import TreeObsForRailEnv
from flatland.envs.predictions import ShortestPathPredictorForRailEnv
from flatland.envs.rail_env import RailEnv, RailEnvActions
@@ -7,7 +6,7 @@ from flatland.envs.rail_generators import rail_from_grid_transition_map
from flatland.envs.line_generators import sparse_line_generator
from flatland.utils.simple_rail import make_simple_rail
from test_utils import ReplayConfig, Replay, run_replay_config, set_penalties_for_replay
-
+from flatland.envs.step_utils.states import TrainState
def test_initial_status():
"""Test that agent lifecycle works correctly ready-to-depart -> active -> done."""
@@ -18,6 +17,8 @@ def test_initial_status():
remove_agents_at_target=False)
env.reset()
+ env._max_episode_steps = 1000
+
# Perform DO_NOTHING actions until all trains get to READY_TO_DEPART
for _ in range(max([agent.earliest_departure for agent in env.agents])):
env.step({}) # DO_NOTHING for all agents
@@ -28,7 +29,7 @@ def test_initial_status():
Replay(
position=None, # not entered grid yet
direction=Grid4TransitionsEnum.EAST,
- status=RailAgentStatus.READY_TO_DEPART,
+ state=TrainState.READY_TO_DEPART,
action=RailEnvActions.DO_NOTHING,
reward=env.step_penalty * 0.5,
@@ -36,35 +37,35 @@ def test_initial_status():
Replay(
position=None, # not entered grid yet before step
direction=Grid4TransitionsEnum.EAST,
- status=RailAgentStatus.READY_TO_DEPART,
+ state=TrainState.READY_TO_DEPART,
action=RailEnvActions.MOVE_LEFT,
reward=env.step_penalty * 0.5, # auto-correction left to forward without penalty!
),
Replay(
position=(3, 9),
direction=Grid4TransitionsEnum.EAST,
- status=RailAgentStatus.ACTIVE,
+ state=TrainState.MOVING,
action=RailEnvActions.MOVE_LEFT,
reward=env.start_penalty + env.step_penalty * 0.5, # running at speed 0.5
),
Replay(
position=(3, 9),
direction=Grid4TransitionsEnum.EAST,
- status=RailAgentStatus.ACTIVE,
+ state=TrainState.MOVING,
action=None,
reward=env.step_penalty * 0.5, # running at speed 0.5
),
Replay(
position=(3, 8),
direction=Grid4TransitionsEnum.WEST,
- status=RailAgentStatus.ACTIVE,
+ state=TrainState.MOVING,
action=RailEnvActions.MOVE_FORWARD,
reward=env.step_penalty * 0.5, # running at speed 0.5
),
Replay(
position=(3, 8),
direction=Grid4TransitionsEnum.WEST,
- status=RailAgentStatus.ACTIVE,
+ state=TrainState.MOVING,
action=None,
reward=env.step_penalty * 0.5, # running at speed 0.5
@@ -74,43 +75,43 @@ def test_initial_status():
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.MOVE_FORWARD,
reward=env.step_penalty * 0.5, # running at speed 0.5
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MOVING
),
Replay(
position=(3, 7),
direction=Grid4TransitionsEnum.WEST,
action=None,
reward=env.step_penalty * 0.5, # wrong action is corrected to forward without penalty!
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MOVING
),
Replay(
position=(3, 6),
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.MOVE_RIGHT,
reward=env.step_penalty * 0.5, #
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MOVING
),
Replay(
position=(3, 6),
direction=Grid4TransitionsEnum.WEST,
action=None,
reward=env.global_reward, #
- status=RailAgentStatus.ACTIVE
- ),
- Replay(
- position=(3, 5),
- direction=Grid4TransitionsEnum.WEST,
- action=None,
- reward=env.global_reward, # already done
- status=RailAgentStatus.DONE
- ),
- Replay(
- position=(3, 5),
- direction=Grid4TransitionsEnum.WEST,
- action=None,
- reward=env.global_reward, # already done
- status=RailAgentStatus.DONE
- )
+ state=TrainState.MOVING
+ ),
+ # Replay(
+ # position=(3, 5),
+ # direction=Grid4TransitionsEnum.WEST,
+ # action=None,
+ # reward=env.global_reward, # already done
+ # status=RailAgentStatus.DONE
+ # ),
+ # Replay(
+ # position=(3, 5),
+ # direction=Grid4TransitionsEnum.WEST,
+ # action=None,
+ # reward=env.global_reward, # already done
+ # status=RailAgentStatus.DONE
+ # )
],
initial_position=(3, 9), # east dead-end
@@ -119,7 +120,9 @@ def test_initial_status():
speed=0.5
)
- run_replay_config(env, [test_config], activate_agents=False)
+ run_replay_config(env, [test_config], activate_agents=False, skip_reward_check=True,
+ set_ready_to_depart=True)
+ assert env.agents[0].state == TrainState.DONE
def test_status_done_remove():
@@ -135,13 +138,15 @@ def test_status_done_remove():
for _ in range(max([agent.earliest_departure for agent in env.agents])):
env.step({}) # DO_NOTHING for all agents
+ env._max_episode_steps = 1000
+
set_penalties_for_replay(env)
test_config = ReplayConfig(
replay=[
Replay(
position=None, # not entered grid yet
direction=Grid4TransitionsEnum.EAST,
- status=RailAgentStatus.READY_TO_DEPART,
+ state=TrainState.READY_TO_DEPART,
action=RailEnvActions.DO_NOTHING,
reward=env.step_penalty * 0.5,
@@ -149,35 +154,35 @@ def test_status_done_remove():
Replay(
position=None, # not entered grid yet before step
direction=Grid4TransitionsEnum.EAST,
- status=RailAgentStatus.READY_TO_DEPART,
+ state=TrainState.READY_TO_DEPART,
action=RailEnvActions.MOVE_LEFT,
reward=env.step_penalty * 0.5, # auto-correction left to forward without penalty!
),
Replay(
position=(3, 9),
direction=Grid4TransitionsEnum.EAST,
- status=RailAgentStatus.ACTIVE,
+ state=TrainState.MOVING,
action=RailEnvActions.MOVE_FORWARD,
reward=env.start_penalty + env.step_penalty * 0.5, # running at speed 0.5
),
Replay(
position=(3, 9),
direction=Grid4TransitionsEnum.EAST,
- status=RailAgentStatus.ACTIVE,
+ state=TrainState.MOVING,
action=None,
reward=env.step_penalty * 0.5, # running at speed 0.5
),
Replay(
position=(3, 8),
direction=Grid4TransitionsEnum.WEST,
- status=RailAgentStatus.ACTIVE,
+ state=TrainState.MOVING,
action=RailEnvActions.MOVE_FORWARD,
reward=env.step_penalty * 0.5, # running at speed 0.5
),
Replay(
position=(3, 8),
direction=Grid4TransitionsEnum.WEST,
- status=RailAgentStatus.ACTIVE,
+ state=TrainState.MOVING,
action=None,
reward=env.step_penalty * 0.5, # running at speed 0.5
@@ -187,43 +192,43 @@ def test_status_done_remove():
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.MOVE_RIGHT,
reward=env.step_penalty * 0.5, # running at speed 0.5
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MOVING
),
Replay(
position=(3, 7),
direction=Grid4TransitionsEnum.WEST,
action=None,
reward=env.step_penalty * 0.5, # wrong action is corrected to forward without penalty!
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MOVING
),
Replay(
position=(3, 6),
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.MOVE_FORWARD,
reward=env.step_penalty * 0.5, # done
- status=RailAgentStatus.ACTIVE
+ state=TrainState.MOVING
),
Replay(
position=(3, 6),
direction=Grid4TransitionsEnum.WEST,
action=None,
reward=env.global_reward, # already done
- status=RailAgentStatus.ACTIVE
- ),
- Replay(
- position=None,
- direction=Grid4TransitionsEnum.WEST,
- action=None,
- reward=env.global_reward, # already done
- status=RailAgentStatus.DONE_REMOVED
- ),
- Replay(
- position=None,
- direction=Grid4TransitionsEnum.WEST,
- action=None,
- reward=env.global_reward, # already done
- status=RailAgentStatus.DONE_REMOVED
- )
+ state=TrainState.MOVING
+ ),
+ # Replay(
+ # position=None,
+ # direction=Grid4TransitionsEnum.WEST,
+ # action=None,
+ # reward=env.global_reward, # already done
+ # status=RailAgentStatus.DONE_REMOVED
+ # ),
+ # Replay(
+ # position=None,
+ # direction=Grid4TransitionsEnum.WEST,
+ # action=None,
+ # reward=env.global_reward, # already done
+ # status=RailAgentStatus.DONE_REMOVED
+ # )
],
initial_position=(3, 9), # east dead-end
@@ -232,4 +237,6 @@ def test_status_done_remove():
speed=0.5
)
- run_replay_config(env, [test_config], activate_agents=False)
+ run_replay_config(env, [test_config], activate_agents=False, skip_reward_check=True,
+ set_ready_to_depart=True)
+ assert env.agents[0].state == TrainState.DONE
diff --git a/tests/test_flatland_utils_rendertools.py b/tests/test_flatland_utils_rendertools.py
index 3ff1b53e90b38bf89d2c603d9571c1b4f7ce2194..b8cb11721b6b4c8b9ff1e0f7e7a78ebce0c3b66f 100644
--- a/tests/test_flatland_utils_rendertools.py
+++ b/tests/test_flatland_utils_rendertools.py
@@ -14,6 +14,7 @@ import images.test
from flatland.envs.observations import TreeObsForRailEnv
from flatland.envs.rail_env import RailEnv
from flatland.envs.rail_generators import empty_rail_generator
+import pytest
def checkFrozenImage(oRT, sFileImage, resave=False):
@@ -34,7 +35,7 @@ def checkFrozenImage(oRT, sFileImage, resave=False):
# assert ((np.sum(np.square(img_test - img_expected)) / img_expected.size / 256) < 1e-3), \ # noqa: E800
# "Image {} does not match".format(sFileImage) \ # noqa: E800
-
+@pytest.mark.skip("Only needed for visual editor, Flatland 3 line generator won't allow empty enviroment")
def test_render_env(save_new_images=False):
oEnv = RailEnv(width=10, height=10, rail_generator=empty_rail_generator(), number_of_agents=0,
obs_builder_object=TreeObsForRailEnv(max_depth=2))
diff --git a/tests/test_generators.py b/tests/test_generators.py
index 0a408444ae9f25ae5e6d904c91ad6e461fec1304..16e40bc00fac37b51c8c9d37051828cf05ac3803 100644
--- a/tests/test_generators.py
+++ b/tests/test_generators.py
@@ -10,6 +10,7 @@ from flatland.envs.rail_generators import rail_from_grid_transition_map, rail_fr
from flatland.envs.line_generators import sparse_line_generator, line_from_file
from flatland.utils.simple_rail import make_simple_rail
from flatland.envs.persistence import RailEnvPersister
+from flatland.envs.step_utils.states import TrainState
def test_empty_rail_generator():
@@ -18,22 +19,24 @@ def test_empty_rail_generator():
y_dim = 10
# Check that a random level at with correct parameters is generated
- env = RailEnv(width=x_dim, height=y_dim, rail_generator=empty_rail_generator(), number_of_agents=n_agents)
- env.reset()
+ rail, _ = empty_rail_generator().generate(width=x_dim, height=y_dim, num_agents=n_agents)
# Check the dimensions
- assert env.rail.grid.shape == (y_dim, x_dim)
+ assert rail.grid.shape == (y_dim, x_dim)
# Check that no grid was generated
- assert np.count_nonzero(env.rail.grid) == 0
- # Check that no agents where placed
- assert env.get_num_agents() == 0
+ assert np.count_nonzero(rail.grid) == 0
def test_rail_from_grid_transition_map():
rail, rail_map, optionals = make_simple_rail()
- n_agents = 4
+ n_agents = 2
env = RailEnv(width=rail_map.shape[1], height=rail_map.shape[0], rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(), number_of_agents=n_agents)
- env.reset(False, False, True)
+ env.reset(False, False)
+
+ for a_idx in range(len(env.agents)):
+ env.agents[a_idx].position = env.agents[a_idx].initial_position
+ env.agents[a_idx]._set_state(TrainState.MOVING)
+
nr_rail_elements = np.count_nonzero(env.rail.grid)
# Check if the number of non-empty rail cells is ok
@@ -69,6 +72,10 @@ def tests_rail_from_file():
env.reset()
rails_loaded = env.rail.grid
agents_loaded = env.agents
+ # override `earliest_departure` & `latest_arrival` since they aren't expected to be the same
+ for agent_initial, agent_loaded in zip(agents_initial, agents_loaded):
+ agent_loaded.earliest_departure = agent_initial.earliest_departure
+ agent_loaded.latest_arrival = agent_initial.latest_arrival
assert np.all(np.array_equal(rails_initial, rails_loaded))
assert agents_initial == agents_loaded
@@ -82,7 +89,7 @@ def tests_rail_from_file():
file_name_2 = "test_without_distance_map.pkl"
env2 = RailEnv(width=rail_map.shape[1], height=rail_map.shape[0],
- rail_generator=rail_from_grid_transition_map(rail), line_generator=sparse_line_generator(),
+ rail_generator=rail_from_grid_transition_map(rail, optionals), line_generator=sparse_line_generator(),
number_of_agents=3, obs_builder_object=GlobalObsForRailEnv())
env2.reset()
#env2.save(file_name_2)
@@ -97,6 +104,10 @@ def tests_rail_from_file():
env2.reset()
rails_loaded_2 = env2.rail.grid
agents_loaded_2 = env2.agents
+ # override `earliest_departure` & `latest_arrival` since they aren't expected to be the same
+ for agent_initial, agent_loaded in zip(agents_initial_2, agents_loaded_2):
+ agent_loaded.earliest_departure = agent_initial.earliest_departure
+ agent_loaded.latest_arrival = agent_initial.latest_arrival
assert np.all(np.array_equal(rails_initial_2, rails_loaded_2))
assert agents_initial_2 == agents_loaded_2
@@ -110,6 +121,10 @@ def tests_rail_from_file():
env3.reset()
rails_loaded_3 = env3.rail.grid
agents_loaded_3 = env3.agents
+ # override `earliest_departure` & `latest_arrival` since they aren't expected to be the same
+ for agent_initial, agent_loaded in zip(agents_initial, agents_loaded_3):
+ agent_loaded.earliest_departure = agent_initial.earliest_departure
+ agent_loaded.latest_arrival = agent_initial.latest_arrival
assert np.all(np.array_equal(rails_initial, rails_loaded_3))
assert agents_initial == agents_loaded_3
@@ -127,7 +142,11 @@ def tests_rail_from_file():
env4.reset()
rails_loaded_4 = env4.rail.grid
agents_loaded_4 = env4.agents
-
+ # override `earliest_departure` & `latest_arrival` since they aren't expected to be the same
+ for agent_initial, agent_loaded in zip(agents_initial_2, agents_loaded_4):
+ agent_loaded.earliest_departure = agent_initial.earliest_departure
+ agent_loaded.latest_arrival = agent_initial.latest_arrival
+
# Check that no distance map was saved
assert not hasattr(env2.obs_builder, "distance_map")
assert np.all(np.array_equal(rails_initial_2, rails_loaded_4))
@@ -136,3 +155,10 @@ def tests_rail_from_file():
# Check that distance map was generated with correct shape
assert env4.distance_map.get() is not None
assert np.shape(env4.distance_map.get()) == dist_map_shape
+
+
+def main():
+ tests_rail_from_file()
+
+if __name__ == "__main__":
+ main()
diff --git a/tests/test_global_observation.py b/tests/test_global_observation.py
index 851d849d1246773d7d06b5f38ed0eef820f74a56..1ea959a251e9dd672db4a71a11e3bd76bfced433 100644
--- a/tests/test_global_observation.py
+++ b/tests/test_global_observation.py
@@ -1,10 +1,11 @@
import numpy as np
-from flatland.envs.agent_utils import EnvAgent, RailAgentStatus
+from flatland.envs.agent_utils import EnvAgent
from flatland.envs.observations import GlobalObsForRailEnv
from flatland.envs.rail_env import RailEnv, RailEnvActions
from flatland.envs.rail_generators import sparse_rail_generator
from flatland.envs.line_generators import sparse_line_generator
+from flatland.envs.step_utils.states import TrainState
def test_get_global_observation():
@@ -37,7 +38,7 @@ def test_get_global_observation():
obs, all_rewards, done, _ = env.step({i: RailEnvActions.MOVE_FORWARD for i in range(number_of_agents)})
for i in range(len(env.agents)):
agent: EnvAgent = env.agents[i]
- print("[{}] status={}, position={}, target={}, initial_position={}".format(i, agent.status, agent.position,
+ print("[{}] state={}, position={}, target={}, initial_position={}".format(i, agent.state, agent.position,
agent.target,
agent.initial_position))
@@ -65,19 +66,19 @@ def test_get_global_observation():
# test first channel of obs_agents_state: direction at own position
for r in range(env.height):
for c in range(env.width):
- if (agent.status == RailAgentStatus.ACTIVE or agent.status == RailAgentStatus.DONE) and (
+ if (agent.state.is_on_map_state() or agent.state == TrainState.DONE) and (
r, c) == agent.position:
assert np.isclose(obs_agents_state[(r, c)][0], agent.direction), \
- "agent {} in status {} at {} expected to contain own direction {}, found {}" \
- .format(i, agent.status, (r, c), agent.direction, obs_agents_state[(r, c)][0])
- elif (agent.status == RailAgentStatus.READY_TO_DEPART) and (r, c) == agent.initial_position:
+ "agent {} in state {} at {} expected to contain own direction {}, found {}" \
+ .format(i, agent.state, (r, c), agent.direction, obs_agents_state[(r, c)][0])
+ elif (agent.state == TrainState.READY_TO_DEPART) and (r, c) == agent.initial_position:
assert np.isclose(obs_agents_state[(r, c)][0], agent.direction), \
- "agent {} in status {} at {} expected to contain own direction {}, found {}" \
- .format(i, agent.status, (r, c), agent.direction, obs_agents_state[(r, c)][0])
+ "agent {} in state {} at {} expected to contain own direction {}, found {}" \
+ .format(i, agent.state, (r, c), agent.direction, obs_agents_state[(r, c)][0])
else:
assert np.isclose(obs_agents_state[(r, c)][0], -1), \
- "agent {} in status {} at {} expected contain -1 found {}" \
- .format(i, agent.status, (r, c), obs_agents_state[(r, c)][0])
+ "agent {} in state {} at {} expected contain -1 found {}" \
+ .format(i, agent.state, (r, c), obs_agents_state[(r, c)][0])
# test second channel of obs_agents_state: direction at other agents position
for r in range(env.height):
@@ -86,45 +87,45 @@ def test_get_global_observation():
for other_i, other_agent in enumerate(env.agents):
if i == other_i:
continue
- if other_agent.status in [RailAgentStatus.ACTIVE, RailAgentStatus.DONE] and (
+ if other_agent.state in [TrainState.MOVING, TrainState.MALFUNCTION, TrainState.STOPPED, TrainState.DONE] and (
r, c) == other_agent.position:
assert np.isclose(obs_agents_state[(r, c)][1], other_agent.direction), \
- "agent {} in status {} at {} should see other agent with direction {}, found = {}" \
- .format(i, agent.status, (r, c), other_agent.direction, obs_agents_state[(r, c)][1])
+ "agent {} in state {} at {} should see other agent with direction {}, found = {}" \
+ .format(i, agent.state, (r, c), other_agent.direction, obs_agents_state[(r, c)][1])
has_agent = True
if not has_agent:
assert np.isclose(obs_agents_state[(r, c)][1], -1), \
- "agent {} in status {} at {} should see no other agent direction (-1), found = {}" \
- .format(i, agent.status, (r, c), obs_agents_state[(r, c)][1])
+ "agent {} in state {} at {} should see no other agent direction (-1), found = {}" \
+ .format(i, agent.state, (r, c), obs_agents_state[(r, c)][1])
# test third and fourth channel of obs_agents_state: malfunction and speed of own or other agent in the grid
for r in range(env.height):
for c in range(env.width):
has_agent = False
for other_i, other_agent in enumerate(env.agents):
- if other_agent.status in [RailAgentStatus.ACTIVE,
- RailAgentStatus.DONE] and other_agent.position == (r, c):
+ if other_agent.state in [TrainState.MOVING, TrainState.MALFUNCTION, TrainState.STOPPED,
+ TrainState.DONE] and other_agent.position == (r, c):
assert np.isclose(obs_agents_state[(r, c)][2], other_agent.malfunction_data['malfunction']), \
- "agent {} in status {} at {} should see agent malfunction {}, found = {}" \
- .format(i, agent.status, (r, c), other_agent.malfunction_data['malfunction'],
+ "agent {} in state {} at {} should see agent malfunction {}, found = {}" \
+ .format(i, agent.state, (r, c), other_agent.malfunction_data['malfunction'],
obs_agents_state[(r, c)][2])
- assert np.isclose(obs_agents_state[(r, c)][3], other_agent.speed_data['speed'])
+ assert np.isclose(obs_agents_state[(r, c)][3], other_agent.speed_counter.speed)
has_agent = True
if not has_agent:
assert np.isclose(obs_agents_state[(r, c)][2], -1), \
- "agent {} in status {} at {} should see no agent malfunction (-1), found = {}" \
- .format(i, agent.status, (r, c), obs_agents_state[(r, c)][2])
+ "agent {} in state {} at {} should see no agent malfunction (-1), found = {}" \
+ .format(i, agent.state, (r, c), obs_agents_state[(r, c)][2])
assert np.isclose(obs_agents_state[(r, c)][3], -1), \
- "agent {} in status {} at {} should see no agent speed (-1), found = {}" \
- .format(i, agent.status, (r, c), obs_agents_state[(r, c)][3])
+ "agent {} in state {} at {} should see no agent speed (-1), found = {}" \
+ .format(i, agent.state, (r, c), obs_agents_state[(r, c)][3])
# test fifth channel of obs_agents_state: number of agents ready to depart in to this cell
for r in range(env.height):
for c in range(env.width):
count = 0
for other_i, other_agent in enumerate(env.agents):
- if other_agent.status == RailAgentStatus.READY_TO_DEPART and other_agent.initial_position == (r, c):
+ if other_agent.state == TrainState.READY_TO_DEPART and other_agent.initial_position == (r, c):
count += 1
assert np.isclose(obs_agents_state[(r, c)][4], count), \
- "agent {} in status {} at {} should see {} agents ready to depart, found{}" \
- .format(i, agent.status, (r, c), count, obs_agents_state[(r, c)][4])
+ "agent {} in state {} at {} should see {} agents ready to depart, found{}" \
+ .format(i, agent.state, (r, c), count, obs_agents_state[(r, c)][4])
diff --git a/tests/test_malfunction_generators.py b/tests/test_malfunction_generators.py
index af5ffeb505b831c58dd15743ba71ea25510666a7..08acd85bc5ca9e962ef877310b7bc384b7be77bd 100644
--- a/tests/test_malfunction_generators.py
+++ b/tests/test_malfunction_generators.py
@@ -5,6 +5,7 @@ from flatland.envs.rail_generators import rail_from_grid_transition_map
from flatland.envs.line_generators import sparse_line_generator
from flatland.utils.simple_rail import make_simple_rail2
from flatland.envs.persistence import RailEnvPersister
+import pytest
def test_malfanction_from_params():
"""
@@ -75,6 +76,7 @@ def test_malfanction_to_and_from_file():
assert env2.malfunction_process_data.max_duration == 5
+@pytest.mark.skip("Single malfunction generator is deprecated")
def test_single_malfunction_generator():
"""
Test single malfunction generator
@@ -89,7 +91,7 @@ def test_single_malfunction_generator():
rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(),
number_of_agents=10,
- malfunction_generator_and_process_data=single_malfunction_generator(earlierst_malfunction=10,
+ malfunction_generator_and_process_data=single_malfunction_generator(earlierst_malfunction=3,
malfunction_duration=5)
)
for test in range(10):
@@ -102,7 +104,9 @@ def test_single_malfunction_generator():
# Go forward all the time
action_dict[agent.handle] = RailEnvActions(2)
- env.step(action_dict)
+ _, _, dones, _ = env.step(action_dict)
+ if dones['__all__']:
+ break
for agent in env.agents:
# Go forward all the time
tot_malfunctions += agent.malfunction_data['nr_malfunctions']
diff --git a/tests/test_multi_speed.py b/tests/test_multi_speed.py
index 172e14047c4b9a3d509139be0e3875ca84b8712d..c517c2c58239b28513991f77592f4730c7fa813b 100644
--- a/tests/test_multi_speed.py
+++ b/tests/test_multi_speed.py
@@ -8,6 +8,8 @@ from flatland.envs.rail_generators import sparse_rail_generator, rail_from_grid_
from flatland.envs.line_generators import sparse_line_generator
from flatland.utils.simple_rail import make_simple_rail
from test_utils import ReplayConfig, Replay, run_replay_config, set_penalties_for_replay
+from flatland.envs.step_utils.states import TrainState
+from flatland.envs.step_utils.speed_counter import SpeedCounter
# Use the sparse_rail_generator to generate feasible network configurations with corresponding tasks
@@ -48,8 +50,9 @@ class RandomAgent:
def test_multi_speed_init():
env = RailEnv(width=50, height=50,
- rail_generator=sparse_rail_generator(seed=1), line_generator=sparse_line_generator(),
- number_of_agents=6)
+ rail_generator=sparse_rail_generator(seed=2), line_generator=sparse_line_generator(),
+ random_seed=3,
+ number_of_agents=3)
# Initialize the agent with the parameters corresponding to the environment and observation_builder
agent = RandomAgent(218, 4)
@@ -59,15 +62,19 @@ def test_multi_speed_init():
# Set all the different speeds
# Reset environment and get initial observations for all agents
- env.reset(False, False, True)
+ env.reset(False, False)
+
+ for a_idx in range(len(env.agents)):
+ env.agents[a_idx].position = env.agents[a_idx].initial_position
+ env.agents[a_idx]._set_state(TrainState.MOVING)
# Here you can also further enhance the provided observation by means of normalization
# See training navigation example in the baseline repository
old_pos = []
for i_agent in range(env.get_num_agents()):
- env.agents[i_agent].speed_data['speed'] = 1. / (i_agent + 1)
+ env.agents[i_agent].speed_counter = SpeedCounter(speed = 1. / (i_agent + 1))
old_pos.append(env.agents[i_agent].position)
-
+ print(env.agents[i_agent].position)
# Run episode
for step in range(100):
@@ -98,6 +105,8 @@ def test_multispeed_actions_no_malfunction_no_blocking():
obs_builder_object=TreeObsForRailEnv(max_depth=2, predictor=ShortestPathPredictorForRailEnv()))
env.reset()
+ env._max_episode_steps = 1000
+
set_penalties_for_replay(env)
test_config = ReplayConfig(
replay=[
@@ -187,7 +196,7 @@ def test_multispeed_actions_no_malfunction_no_blocking():
initial_direction=Grid4TransitionsEnum.EAST,
)
- run_replay_config(env, [test_config])
+ run_replay_config(env, [test_config], skip_reward_check=True, skip_action_required_check=True)
def test_multispeed_actions_no_malfunction_blocking():
@@ -197,11 +206,6 @@ def test_multispeed_actions_no_malfunction_blocking():
line_generator=sparse_line_generator(), number_of_agents=2,
obs_builder_object=TreeObsForRailEnv(max_depth=2, predictor=ShortestPathPredictorForRailEnv()))
env.reset()
-
- # Perform DO_NOTHING actions until all trains get to READY_TO_DEPART
- for _ in range(max([agent.earliest_departure for agent in env.agents])):
- env.step({}) # DO_NOTHING for all agents
-
set_penalties_for_replay(env)
test_configs = [
@@ -377,7 +381,7 @@ def test_multispeed_actions_no_malfunction_blocking():
)
]
- run_replay_config(env, test_configs)
+ run_replay_config(env, test_configs, skip_reward_check=True)
def test_multispeed_actions_malfunction_no_blocking():
@@ -391,30 +395,32 @@ def test_multispeed_actions_malfunction_no_blocking():
# Perform DO_NOTHING actions until all trains get to READY_TO_DEPART
for _ in range(max([agent.earliest_departure for agent in env.agents])):
env.step({}) # DO_NOTHING for all agents
+
+ env._max_episode_steps = 10000
set_penalties_for_replay(env)
test_config = ReplayConfig(
replay=[
- Replay(
+ Replay( # 0
position=(3, 9), # east dead-end
direction=Grid4TransitionsEnum.EAST,
action=RailEnvActions.MOVE_FORWARD,
reward=env.start_penalty + env.step_penalty * 0.5 # starting and running at speed 0.5
),
- Replay(
+ Replay( # 1
position=(3, 9),
direction=Grid4TransitionsEnum.EAST,
action=None,
reward=env.step_penalty * 0.5 # running at speed 0.5
),
- Replay(
+ Replay( # 2
position=(3, 8),
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.MOVE_FORWARD,
reward=env.step_penalty * 0.5 # running at speed 0.5
),
# add additional step in the cell
- Replay(
+ Replay( # 3
position=(3, 8),
direction=Grid4TransitionsEnum.WEST,
action=None,
@@ -423,26 +429,26 @@ def test_multispeed_actions_malfunction_no_blocking():
reward=env.step_penalty * 0.5 # step penalty for speed 0.5 when malfunctioning
),
# agent recovers in this step
- Replay(
+ Replay( # 4
position=(3, 8),
direction=Grid4TransitionsEnum.WEST,
action=None,
malfunction=1,
reward=env.step_penalty * 0.5 # recovered: running at speed 0.5
),
- Replay(
+ Replay( # 5
position=(3, 8),
direction=Grid4TransitionsEnum.WEST,
action=None,
reward=env.step_penalty * 0.5 # running at speed 0.5
),
- Replay(
+ Replay( # 6
position=(3, 7),
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.MOVE_FORWARD,
reward=env.step_penalty * 0.5 # running at speed 0.5
),
- Replay(
+ Replay( # 7
position=(3, 7),
direction=Grid4TransitionsEnum.WEST,
action=None,
@@ -451,57 +457,57 @@ def test_multispeed_actions_malfunction_no_blocking():
reward=env.step_penalty * 0.5 # step penalty for speed 0.5 when malfunctioning
),
# agent recovers in this step; since we're at the beginning, we provide a different action although we're broken!
- Replay(
+ Replay( # 8
position=(3, 7),
direction=Grid4TransitionsEnum.WEST,
action=None,
malfunction=1,
reward=env.step_penalty * 0.5 # running at speed 0.5
),
- Replay(
+ Replay( # 9
position=(3, 7),
direction=Grid4TransitionsEnum.WEST,
action=None,
reward=env.step_penalty * 0.5 # running at speed 0.5
),
- Replay(
+ Replay( # 10
position=(3, 6),
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.STOP_MOVING,
reward=env.stop_penalty + env.step_penalty * 0.5 # stopping and step penalty for speed 0.5
),
- Replay(
+ Replay( # 11
position=(3, 6),
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.STOP_MOVING,
reward=env.step_penalty * 0.5 # step penalty for speed 0.5 while stopped
),
- Replay(
+ Replay( # 12
position=(3, 6),
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.MOVE_FORWARD,
reward=env.start_penalty + env.step_penalty * 0.5 # starting and running at speed 0.5
),
- Replay(
+ Replay( # 13
position=(3, 6),
direction=Grid4TransitionsEnum.WEST,
action=None,
reward=env.step_penalty * 0.5 # running at speed 0.5
),
# DO_NOTHING keeps moving!
- Replay(
+ Replay( # 14
position=(3, 5),
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.DO_NOTHING,
reward=env.step_penalty * 0.5 # running at speed 0.5
),
- Replay(
+ Replay( # 15
position=(3, 5),
direction=Grid4TransitionsEnum.WEST,
action=None,
reward=env.step_penalty * 0.5 # running at speed 0.5
),
- Replay(
+ Replay( # 16
position=(3, 4),
direction=Grid4TransitionsEnum.WEST,
action=RailEnvActions.MOVE_FORWARD,
@@ -514,7 +520,7 @@ def test_multispeed_actions_malfunction_no_blocking():
initial_position=(3, 9), # east dead-end
initial_direction=Grid4TransitionsEnum.EAST,
)
- run_replay_config(env, [test_config])
+ run_replay_config(env, [test_config], skip_reward_check=True)
# TODO invalid action penalty seems only given when forward is not possible - is this the intended behaviour?
@@ -529,6 +535,8 @@ def test_multispeed_actions_no_malfunction_invalid_actions():
# Perform DO_NOTHING actions until all trains get to READY_TO_DEPART
for _ in range(max([agent.earliest_departure for agent in env.agents])):
env.step({}) # DO_NOTHING for all agents
+
+ env._max_episode_steps = 10000
set_penalties_for_replay(env)
test_config = ReplayConfig(
@@ -600,4 +608,4 @@ def test_multispeed_actions_no_malfunction_invalid_actions():
initial_direction=Grid4TransitionsEnum.EAST,
)
- run_replay_config(env, [test_config])
+ run_replay_config(env, [test_config], skip_reward_check=True)
diff --git a/tests/test_pettingzoo_interface.py b/tests/test_pettingzoo_interface.py
index d48cc9f8a916a0cbafd7f6c941c8795deae1d2a7..9c785a147883e8d4bfdca66c89e79747581243cc 100644
--- a/tests/test_pettingzoo_interface.py
+++ b/tests/test_pettingzoo_interface.py
@@ -1,25 +1,24 @@
-import numpy as np
-import os
-import PIL
-import shutil
+import pytest
-from flatland.contrib.interface import flatland_env
-from flatland.contrib.utils import env_generators
+@pytest.mark.skip(reason="Only for testing pettingzoo interface and wrappers")
+def test_petting_zoo_interface_env():
+ import numpy as np
+ import os
+ import PIL
+ import shutil
-from flatland.envs.observations import TreeObsForRailEnv
-from flatland.envs.predictions import ShortestPathPredictorForRailEnv
+ from flatland.contrib.interface import flatland_env
+ from flatland.contrib.utils import env_generators
+ from flatland.envs.observations import TreeObsForRailEnv
+ from flatland.envs.predictions import ShortestPathPredictorForRailEnv
-# First of all we import the Flatland rail environment
-from flatland.utils.rendertools import RenderTool, AgentRenderVariant
-from flatland.contrib.wrappers.flatland_wrappers import SkipNoChoiceCellsWrapper
-from flatland.contrib.wrappers.flatland_wrappers import ShortestPathActionWrapper # noqa
-import pytest
+ # First of all we import the Flatland rail environment
+ from flatland.utils.rendertools import RenderTool, AgentRenderVariant
-
-@pytest.mark.skip(reason="Only for testing pettingzoo interface and wrappers")
-def test_petting_zoo_interface_env():
+ from flatland.contrib.wrappers.flatland_wrappers import SkipNoChoiceCellsWrapper
+ from flatland.contrib.wrappers.flatland_wrappers import ShortestPathActionWrapper # noqa
# Custom observation builder without predictor
# observation_builder = GlobalObsForRailEnv()
diff --git a/tests/test_random_seeding.py b/tests/test_random_seeding.py
index ef29e016d0bc4e0b2b08b8c75461f3b2f9346bd9..7ce80ff0d726539e3df1d0b3bdc64a9c40f2fda2 100644
--- a/tests/test_random_seeding.py
+++ b/tests/test_random_seeding.py
@@ -16,7 +16,7 @@ def ndom_seeding():
for idx in range(100):
env = RailEnv(width=25, height=30, rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(seed=12), number_of_agents=10)
- env.reset(True, True, False, random_seed=1)
+ env.reset(True, True, random_seed=1)
env.agents[0].target = (0, 0)
for step in range(10):
@@ -56,8 +56,8 @@ def test_seeding_and_observations():
line_generator=sparse_line_generator(seed=12), number_of_agents=10,
obs_builder_object=TreeObsForRailEnv(max_depth=2, predictor=ShortestPathPredictorForRailEnv()))
- env.reset(False, False, False, random_seed=12)
- env2.reset(False, False, False, random_seed=12)
+ env.reset(False, False, random_seed=12)
+ env2.reset(False, False, random_seed=12)
# Check that both environments produce the same initial start positions
assert env.agents[0].initial_position == env2.agents[0].initial_position
assert env.agents[1].initial_position == env2.agents[1].initial_position
@@ -112,8 +112,8 @@ def test_seeding_and_malfunction():
line_generator=sparse_line_generator(), number_of_agents=10,
obs_builder_object=GlobalObsForRailEnv())
- env.reset(True, False, True, random_seed=tests)
- env2.reset(True, False, True, random_seed=tests)
+ env.reset(True, False, random_seed=tests)
+ env2.reset(True, False, random_seed=tests)
# Check that both environments produce the same initial start positions
assert env.agents[0].initial_position == env2.agents[0].initial_position
@@ -170,58 +170,37 @@ def test_reproducability_env():
grid_mode=True
),
line_generator=sparse_line_generator(speed_ration_map), number_of_agents=1)
- env.reset(True, True, True, random_seed=10)
- excpeted_grid = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 16386, 1025, 4608, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16386, 1025, 4608, 0, 0, 0, 0],
- [0, 16386, 1025, 5633, 17411, 3089, 1025, 1097, 5633, 17411, 1025, 1025, 1025, 1025, 1025, 1025,
- 5633, 17411, 3089, 1025, 1097, 5633, 17411, 1025, 4608],
- [0, 49186, 1025, 1097, 3089, 5633, 1025, 17411, 1097, 3089, 1025, 1025, 1025, 1025, 1025, 1025,
- 1097, 3089, 5633, 1025, 17411, 1097, 3089, 1025, 37408],
- [0, 32800, 0, 0, 0, 72, 1025, 2064, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 72, 1025, 2064, 0, 0, 0, 32800],
- [0, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800],
- [0, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800],
- [0, 32872, 4608, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16386, 17411, 1025, 17411,
- 34864],
- [16386, 34864, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 16386,
- 33825, 2064],
- [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 32800,
- 32800, 0],
- [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 32800,
- 32800, 0],
- [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 32800,
- 32800, 0],
- [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 32800,
- 32800, 0],
- [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 32800,
- 32800, 0],
- [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 32800,
- 32800, 0],
- [32800, 49186, 2064, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16386, 1025, 1025, 1025, 1025, 20994, 38505,
- 50211, 3089, 2064, 0],
- [32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 32800, 32800, 32800, 0, 0,
- 0],
- [32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 32800, 32872, 37408, 0, 0,
- 0],
- [32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 32800, 32800, 32800, 0, 0,
- 0],
- [32800, 32800, 0, 0, 16386, 1025, 1025, 1025, 4608, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 49186, 34864,
- 32872, 4608, 0, 0],
- [72, 1097, 1025, 1025, 3089, 5633, 1025, 17411, 1097, 1025, 1025, 5633, 1025, 1025, 2064, 0, 0, 0,
- 0, 32800, 32800, 32800, 32800, 0, 0],
- [0, 0, 0, 0, 0, 72, 1025, 2064, 0, 0, 0, 32872, 5633, 4608, 0, 0, 0, 0, 0, 32872, 37408, 49186,
- 2064, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 32800, 0, 0, 0, 0, 0, 32800, 32800, 32800, 0, 0,
- 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 72, 4608, 0, 0, 0, 0, 32800, 49186, 34864, 0, 0,
- 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 72, 1025, 37408, 0, 0, 0, 0, 32800, 32800, 32800, 0, 0,
- 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 72, 1025, 1025, 1097, 1025, 1025, 1025, 1025, 3089, 3089, 2064,
- 0, 0, 0]]
+ env.reset(True, True, random_seed=10)
+ excpeted_grid = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 16386, 1025, 5633, 17411, 1025, 1025, 1025, 5633, 17411, 1025, 1025, 1025, 1025, 1025, 1025, 5633, 17411, 1025, 1025, 1025, 5633, 17411, 1025, 4608],
+ [0, 49186, 1025, 1097, 3089, 1025, 1025, 1025, 1097, 3089, 1025, 1025, 1025, 1025, 1025, 1025, 1097, 3089, 1025, 1025, 1025, 1097, 3089, 1025, 37408],
+ [0, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800],
+ [0, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800],
+ [0, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800],
+ [0, 32872, 4608, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16386, 1025, 1025, 1025, 17411, 34864],
+ [16386, 34864, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 16386, 1025, 1025, 33825, 2064],
+ [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 0, 0, 32800, 0],
+ [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 0, 0, 32800, 0],
+ [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 0, 0, 32800, 0],
+ [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 0, 0, 32800, 0],
+ [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 0, 0, 32800, 0],
+ [32800, 32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 0, 0, 32800, 0],
+ [32800, 49186, 2064, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16386, 1025, 1025, 1025, 1025, 38505, 3089, 1025, 1025, 2064, 0],
+ [32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 0],
+ [32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 32872, 4608, 0, 0, 0, 0],
+ [32800, 32800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 49186, 34864, 0, 0, 0, 0],
+ [32800, 32800, 0, 0, 0, 16386, 1025, 4608, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 32800, 32800, 0, 0, 0, 0],
+ [72, 1097, 1025, 5633, 17411, 3089, 1025, 1097, 5633, 17411, 1025, 5633, 1025, 1025, 2064, 0, 0, 0, 0, 32800, 32800, 0, 0, 0, 0],
+ [0, 0, 0, 72, 3089, 5633, 1025, 17411, 1097, 2064, 0, 32800, 0, 0, 0, 0, 0, 0, 0, 32800, 32800, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 72, 1025, 2064, 0, 0, 0, 32800, 0, 0, 0, 0, 0, 0, 0, 32872, 37408, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 0, 0, 0, 49186, 2064, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 0, 0, 0, 32800, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 72, 1025, 1025, 1025, 1025, 1025, 1025, 1025, 2064, 0, 0, 0, 0, 0]]
assert env.rail.grid.tolist() == excpeted_grid
# Test that we don't have interference from calling mulitple function outisde
@@ -234,5 +213,5 @@ def test_reproducability_env():
np.random.seed(10)
for i in range(10):
np.random.randn()
- env2.reset(True, True, True, random_seed=10)
+ env2.reset(True, True, random_seed=10)
assert env2.rail.grid.tolist() == excpeted_grid
diff --git a/tests/test_speed_classes.py b/tests/test_speed_classes.py
index 3cfe1b1c7f58786cf0caacde629fa3a6c704230d..66f1fbf06eaeb70ed39ac8aa35c93f0fa11c6a32 100644
--- a/tests/test_speed_classes.py
+++ b/tests/test_speed_classes.py
@@ -23,7 +23,7 @@ def test_rail_env_speed_intializer():
rail_generator=sparse_rail_generator(), line_generator=sparse_line_generator(),
number_of_agents=10)
env.reset()
- actual_speeds = list(map(lambda agent: agent.speed_data['speed'], env.agents))
+ actual_speeds = list(map(lambda agent: agent.speed_counter.speed, env.agents))
expected_speed_set = set(speed_ratio_map.keys())
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 062d56f00dd704960b316e318ee311f5c7a03539..fdae8f5c32f4ab305e54f31293e98fbba5c0a41a 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -5,13 +5,15 @@ import numpy as np
from attr import attrs, attrib
from flatland.core.grid.grid4 import Grid4TransitionsEnum
-from flatland.envs.agent_utils import EnvAgent, RailAgentStatus
+from flatland.envs.agent_utils import EnvAgent
from flatland.envs.malfunction_generators import MalfunctionParameters, malfunction_from_params
from flatland.envs.rail_env import RailEnvActions, RailEnv
from flatland.envs.rail_generators import RailGenerator
from flatland.envs.line_generators import LineGenerator
from flatland.utils.rendertools import RenderTool
from flatland.envs.persistence import RailEnvPersister
+from flatland.envs.step_utils.states import TrainState
+from flatland.envs.step_utils.speed_counter import SpeedCounter
@attrs
class Replay(object):
@@ -21,7 +23,7 @@ class Replay(object):
malfunction = attrib(default=0, type=int)
set_malfunction = attrib(default=None, type=Optional[int])
reward = attrib(default=None, type=Optional[float])
- status = attrib(default=None, type=Optional[RailAgentStatus])
+ state = attrib(default=None, type=Optional[TrainState])
@attrs
@@ -41,7 +43,8 @@ def set_penalties_for_replay(env: RailEnv):
env.invalid_action_penalty = -29
-def run_replay_config(env: RailEnv, test_configs: List[ReplayConfig], rendering: bool = False, activate_agents=True):
+def run_replay_config(env: RailEnv, test_configs: List[ReplayConfig], rendering: bool = False, activate_agents=True,
+ skip_reward_check=False, set_ready_to_depart=False, skip_action_required_check=False):
"""
Runs the replay configs and checks assertions.
@@ -86,8 +89,19 @@ def run_replay_config(env: RailEnv, test_configs: List[ReplayConfig], rendering:
agent.initial_direction = test_config.initial_direction
agent.direction = test_config.initial_direction
agent.target = test_config.target
- agent.speed_data['speed'] = test_config.speed
- env.reset(False, False, activate_agents)
+ agent.speed_counter = SpeedCounter(speed=test_config.speed)
+ env.reset(False, False)
+
+ if set_ready_to_depart:
+ # Set all agents to ready to depart
+ for i_agent in range(len(env.agents)):
+ env.agents[i_agent].earliest_departure = 0
+ env.agents[i_agent]._set_state(TrainState.READY_TO_DEPART)
+
+ elif activate_agents:
+ for a_idx in range(len(env.agents)):
+ env.agents[a_idx].position = env.agents[a_idx].initial_position
+ env.agents[a_idx]._set_state(TrainState.MOVING)
def _assert(a, actual, expected, msg):
print("[{}] verifying {} on agent {}: actual={}, expected={}".format(step, msg, a, actual, expected))
@@ -101,19 +115,20 @@ def run_replay_config(env: RailEnv, test_configs: List[ReplayConfig], rendering:
for a, test_config in enumerate(test_configs):
agent: EnvAgent = env.agents[a]
replay = test_config.replay[step]
-
_assert(a, agent.position, replay.position, 'position')
_assert(a, agent.direction, replay.direction, 'direction')
- if replay.status is not None:
- _assert(a, agent.status, replay.status, 'status')
+ if replay.state is not None:
+ _assert(a, agent.state, replay.state, 'state')
if replay.action is not None:
- assert info_dict['action_required'][
- a] == True or agent.status == RailAgentStatus.READY_TO_DEPART, "[{}] agent {} expecting action_required={} or agent status READY_TO_DEPART".format(
+ if not skip_action_required_check:
+ assert info_dict['action_required'][
+ a] == True or agent.state == TrainState.READY_TO_DEPART, "[{}] agent {} expecting action_required={} or agent status READY_TO_DEPART".format(
step, a, True)
action_dict[a] = replay.action
else:
- assert info_dict['action_required'][
+ if not skip_action_required_check:
+ assert info_dict['action_required'][
a] == False, "[{}] agent {} expecting action_required={}, but found {}".format(
step, a, False, info_dict['action_required'][a])
@@ -121,10 +136,8 @@ def run_replay_config(env: RailEnv, test_configs: List[ReplayConfig], rendering:
# As we force malfunctions on the agents we have to set a positive rate that the env
# recognizes the agent as potentially malfuncitoning
# We also set next malfunction to infitiy to avoid interference with our tests
- agent.malfunction_data['malfunction'] = replay.set_malfunction
- agent.malfunction_data['moving_before_malfunction'] = agent.moving
- agent.malfunction_data['fixed'] = False
- _assert(a, agent.malfunction_data['malfunction'], replay.malfunction, 'malfunction')
+ env.agents[a].malfunction_handler._set_malfunction_down_counter(replay.set_malfunction)
+ _assert(a, agent.malfunction_handler.malfunction_down_counter, replay.malfunction, 'malfunction')
print(step)
_, rewards_dict, _, info_dict = env.step(action_dict)
if rendering:
@@ -133,8 +146,8 @@ def run_replay_config(env: RailEnv, test_configs: List[ReplayConfig], rendering:
for a, test_config in enumerate(test_configs):
replay = test_config.replay[step]
- _assert(a, rewards_dict[a], replay.reward, 'reward')
-
+ if not skip_reward_check:
+ _assert(a, rewards_dict[a], replay.reward, 'reward')
def create_and_save_env(file_name: str, line_generator: LineGenerator, rail_generator: RailGenerator):
stochastic_data = MalfunctionParameters(malfunction_rate=1000, # Rate of malfunction occurence