def generate_problem(self, problem_range):
min_blocks = self.get_value("min_blocks")
max_blocks = self.get_value("max_blocks")
assert min_blocks >= BlocksworldDomainGenerator.MIN_BLOCKS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
blocks = random.randint(min_blocks, max_blocks)
properties = {
"min_blocks": min_blocks,
"max_blocks": max_blocks,
"blocks": blocks,
"bin_params": ["blocks"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -n %u" % (BlocksworldDomainGenerator.GENERATOR_BIN,
blocks)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_n = self.get_value("min_n")
max_n = self.get_value("max_n")
assert min_n >= NPuzzleDomainGenerator.MIN_N
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
n = random.randint(min_n, max_n)
properties = {
"min_n": min_n,
"max_n": max_n,
"n": n,
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -n %u" % (
NPuzzleDomainGenerator.GENERATOR_BIN,
n)
unused_completed_process = subprocess.run(
gen_cmd, shell=True, stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_size = self.get_value("min_size")
max_size = self.get_value("max_size")
min_g_percent = self.get_value("min_g_percent")
max_g_percent = self.get_value("max_g_percent")
min_hole_percent = self.get_value("min_hole_percent")
max_hole_percent = self.get_value("max_hole_percent")
assert min_size >= VisitAllDomainGenerator.MIN_SIZE
assert min_g_percent >= 0 and max_g_percent <= 100
assert min_hole_percent >= 0 and max_hole_percent <= 100
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
size = random.randint(min_size, max_size)
goal_percent = random.randint(min_g_percent, max_g_percent)
goals = int((size * size * goal_percent) / 100)
goals = max(VisitAllDomainGenerator.MIN_GOALS, goals)
hole_percent = random.randint(min_hole_percent, max_hole_percent)
holes = int((((size * size) - goals - 1) * hole_percent) / 100)
seed = random.randint(1, VisitAllDomainGenerator.MAX_SEED)
properties = {
"min_size": min_size,
"max_size": max_size,
"min_g_percent": min_g_percent,
"max_g_percent": max_g_percent,
"min_hole_percent": min_hole_percent,
"max_hole_percent": max_hole_percent,
"size": size,
"goals": goals,
"holes": holes,
"seed": seed,
"bin_params": ["size"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -n %u -r %.2f -u %u -s %u" % (
VisitAllDomainGenerator.GENERATOR_BIN, size,
goal_percent / 100.0, holes, seed)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def write(self, solution_filepath):
file_handle = open(solution_filepath, "w")
file.write_properties(file_handle, self._properties, ";")
for grounded_action in self._action_list:
file_handle.write("%s\n" % (grounded_action))
file_handle.close()
def generate_problem(self, problem_range):
min_size = self.get_value("min_size")
max_size = self.get_value("max_size")
min_balls = self.get_value("min_balls")
max_balls = self.get_value("max_balls")
min_walls = self.get_value("min_walls")
max_walls = self.get_value("max_walls")
assert min_size >= SokobanDomainGenerator.MIN_SIZE
assert min_balls >= SokobanDomainGenerator.MIN_BALLS
assert min_walls >= SokobanDomainGenerator.MIN_WALLS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
size = random.randint(min_size, max_size)
balls = random.randint(min_balls, max_balls)
walls = random.randint(min_walls, max_walls)
properties = {
"size": size,
"min_size": min_size,
"max_size": max_size,
"min_balls": min_balls,
"max_balls": max_balls,
"min_walls": min_walls,
"max_walls": max_walls,
"size": size,
"balls": balls,
"walls": walls,
"bin_params": ["size"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -n %u -b %u -w %u" % (
SokobanDomainGenerator.GENERATOR_BIN, size, balls, walls)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_spanners = self.get_value("min_spanners")
max_spanners = self.get_value("max_spanners")
min_nuts = self.get_value("min_nuts")
max_nuts = self.get_value("max_nuts")
min_locations = self.get_value("min_locations")
max_locations = self.get_value("max_locations")
assert min_spanners >= SpannerDomainGenerator.MIN_SPANNERS
assert min_nuts >= SpannerDomainGenerator.MIN_NUTS
assert min_locations >= SpannerDomainGenerator.MIN_LOCATIONS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
spanners = random.randint(min_spanners, max_spanners)
nuts = min(spanners, random.randint(min_nuts, max_nuts))
locations = random.randint(min_locations, max_locations)
properties = {
"min_spanners": min_spanners,
"max_spanners": max_spanners,
"min_nuts": min_nuts,
"max_nuts": max_nuts,
"min_locations": min_locations,
"max_locations": max_locations,
"spanners": spanners,
"nuts": nuts,
"locations": locations,
"bin_params": ["spanners", "nuts", "locations"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s %u %u %u" % (SpannerDomainGenerator.GENERATOR_BIN,
spanners, nuts, locations)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_robots = self.get_value("min_robots")
max_robots = self.get_value("max_robots")
min_rooms = self.get_value("min_rooms")
max_rooms = self.get_value("max_rooms")
min_balls = self.get_value("min_balls")
max_balls = self.get_value("max_balls")
assert min_robots >= GrippersDomainGenerator.MIN_ROBOTS
assert min_rooms >= GrippersDomainGenerator.MIN_ROOMS
assert min_balls >= GrippersDomainGenerator.MIN_BALLS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
robots = random.randint(min_robots, max_robots)
rooms = random.randint(min_rooms, max_rooms)
balls = random.randint(min_balls, max_balls)
properties = {
"min_robots": min_robots,
"max_robots": max_robots,
"min_rooms": min_rooms,
"max_rooms": max_rooms,
"min_balls": min_balls,
"max_balls": max_balls,
"robots": robots,
"rooms": rooms,
"balls": balls,
"bin_params": ["robots", "rooms", "balls"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -n %u -r %u -o %u" % (
GrippersDomainGenerator.GENERATOR_BIN, robots, rooms, balls)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_cocktails = self.get_value("min_cocktails")
max_cocktails = self.get_value("max_cocktails")
min_ingredients = self.get_value("min_ingredients")
max_ingredients = self.get_value("max_ingredients")
min_shots = self.get_value("min_shots")
max_shots = self.get_value("max_shots")
assert min_cocktails >= BarmanDomainGenerator.MIN_COCKTAILS
assert min_ingredients >= BarmanDomainGenerator.MIN_INGREDIENTS
assert min_shots >= BarmanDomainGenerator.MIN_SHOTS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
cocktails = random.randint(min_cocktails, max_cocktails)
ingredients = random.randint(min_ingredients, max_ingredients)
shots = random.randint(min_shots, max_shots)
properties = {
"min_cocktails": min_cocktails,
"max_cocktails": max_cocktails,
"min_ingredients": min_ingredients,
"max_ingredients": max_ingredients,
"min_shots": min_shots,
"max_shots": max_shots,
"cocktails": cocktails,
"ingredients": ingredients,
"shots": shots,
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s %u %u %u" % (BarmanDomainGenerator.GENERATOR_BIN,
cocktails, ingredients, shots)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_rows = self.get_value("min_rows")
max_rows = self.get_value("max_rows")
min_columns = self.get_value("min_columns")
max_columns = self.get_value("max_columns")
assert min_rows >= GoldminerDomainGenerator.MIN_ROWS
assert min_columns >= GoldminerDomainGenerator.MIN_COLUMNS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
rows = random.randint(min_rows, max_rows)
columns = random.randint(min_columns, max_columns)
seed = random.randint(1, GoldminerDomainGenerator.MAX_SEED)
properties = {
"min_rows": min_rows,
"max_rows": max_rows,
"min_columns": min_columns,
"max_columns": max_columns,
"rows": rows,
"columns": columns,
"seed": seed,
"bin_params": ["rows", "columns"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -r %u -c %u -s %u" % (
GoldminerDomainGenerator.GENERATOR_BIN,
rows,
columns,
seed)
unused_completed_process = subprocess.run(
gen_cmd, shell=True, stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_locations = self.get_value("min_locations")
max_locations = self.get_value("max_locations")
min_cars = self.get_value("min_cars")
max_cars = self.get_value("max_cars")
assert min_locations >= FerryDomainGenerator.MIN_LOCATIONS
assert min_cars >= FerryDomainGenerator.MIN_CARS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
locations = random.randint(min_locations, max_locations)
cars = random.randint(min_cars, max_cars)
seed = random.randint(1, FerryDomainGenerator.MAX_SEED)
properties = {
"min_locations": min_locations,
"max_locations": max_locations,
"min_cars": min_cars,
"max_cars": max_cars,
"locations": locations,
"cars": cars,
"seed": seed,
"bin_params": ["locations", "cars"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -l %u -c %u -s %u" % (
FerryDomainGenerator.GENERATOR_BIN, locations, cars, seed)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_floors = self.get_value("min_floors")
max_floors = self.get_value("max_floors")
min_passengers = self.get_value("min_passengers")
max_passengers = self.get_value("max_passengers")
assert min_floors >= MiconicDomainGenerator.MIN_FLOORS
assert min_passengers >= MiconicDomainGenerator.MIN_PASSENGERS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
floors = random.randint(min_floors, max_floors)
passengers = random.randint(min_passengers, max_passengers)
properties = {
"min_floors": min_floors,
"max_floors": max_floors,
"min_passengers": min_passengers,
"max_passengers": max_passengers,
"floors": floors,
"passengers": passengers,
"bin_params": ["floors", "passengers"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -f %u -p %u" % (MiconicDomainGenerator.GENERATOR_BIN,
floors,
passengers)
unused_completed_process = subprocess.run(
gen_cmd, shell=True, stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_curbs = self.get_value("min_curbs")
max_curbs = self.get_value("max_curbs")
assert min_curbs >= ParkingDomainGenerator.MIN_CURBS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
curbs = random.randint(min_curbs, max_curbs)
max_cars = 2 * curbs - 2
cars = random.randint(ParkingDomainGenerator._MIN_CARS, max_cars)
properties = {
"min_curbs": min_curbs,
"max_curbs": max_curbs,
"min_cars": 1,
"max_cars": max_cars,
"curbs": curbs,
"cars": cars,
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s %u %u" % (ParkingDomainGenerator.GENERATOR_BIN,
curbs, cars)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_children = self.get_value("min_children")
max_children = self.get_value("max_children")
min_trays = self.get_value("min_trays")
max_trays = self.get_value("max_trays")
min_gluten_ratio = self.get_value("min_gluten_ratio")
max_gluten_ratio = self.get_value("max_gluten_ratio")
min_sandwich_ratio = self.get_value("min_sandwich_ratio")
max_sandwich_ratio = self.get_value("max_sandwich_ratio")
assert min_children >= ChildsnackDomainGenerator.MIN_CHILDREN
assert min_trays >= ChildsnackDomainGenerator.MIN_TRAYS
assert min_sandwich_ratio >= \
ChildsnackDomainGenerator.MIN_SANDWICH_RATIO
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
seed = random.randint(0, ChildsnackDomainGenerator.MAX_SEED)
children = random.randint(min_children, max_children)
trays = random.randint(min_trays, max_trays)
gluten_ratio = random.uniform(min_gluten_ratio, max_gluten_ratio)
gluten_ratio = round_no(gluten_ratio, prec=2, base=0.25)
sandwich_ratio = random.uniform(min_sandwich_ratio,
max_sandwich_ratio)
properties = {
"min_children": min_children,
"max_children": max_children,
"min_trays": min_trays,
"max_trays": max_trays,
"min_gluten_ratio": min_gluten_ratio,
"max_gluten_ratio": max_gluten_ratio,
"min_sandwich_ratio": min_sandwich_ratio,
"max_sandwich_ratio": max_sandwich_ratio,
"seed": seed,
"children": children,
"trays": trays,
"gluten_ratio": "%.1f" % (gluten_ratio),
"sandwich_ratio": "%.1f" % (sandwich_ratio),
"bin_params": ["children", "trays"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
# Use %.1f to force the 2nd endpoint of the ratio values (the max).
# example: %.1f(1.9xxx...) = 2.0
gen_cmd = "%s %s %u %u %u %.1f %.1f" % (
ChildsnackDomainGenerator.GENERATOR_BIN,
ChildsnackDomainGenerator.PROBLEM_TYPE, seed, children, trays,
gluten_ratio, sandwich_ratio)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
locations = self.get_value("locations")
last_location = locations - 1
min_crates = self.get_value("min_crates")
max_crates = self.get_value("max_crates")
assert min_crates >= DeliveryDomainGenerator.MIN_CRATES
for problem_no in problem_range:
crates = random.randint(min_crates, max_crates)
assert crates > 0
# Generate a list of start locations and destinations.
source_list = []
destination_list = []
for _ in range(crates):
source_list.append(random.randint(0, last_location))
destination_list.append(random.randint(0, last_location))
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
properties = {
"locations": locations,
"min_crates": min_crates,
"max_crates": max_crates,
"crates": crates,
"bin_params": ["crates"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
file_handle.write("""(define (problem delivery-%uc-%ul)
""" % (crates, locations))
file_handle.write(""" (:domain %s)
""" % (DeliveryDomainGenerator._DOMAIN_NAME))
file_handle.write(""" (:objects truck0%s)
""" % ("".join([" crate%u" % (i) for i in range(crates)])))
file_handle.write(""" (:init (truck truck0) (atl%u truck0)%s)
""" % (random.randint(0, last_location), "".join([
" (crate crate%u) (atl%u crate%u)" % (i, source_list[i], i)
for i in range(crates)
])))
file_handle.write(""" (:goal (and%s))
""" % ("".join([
" (atl%u crate%u)" % (destination_list[i], i)
for i in range(crates)
])))
file_handle.write(")")
file_handle.close()
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_satellites = self.get_value("min_satellites")
max_satellites = self.get_value("max_satellites")
min_instruments = self.get_value("min_instruments")
max_instruments = self.get_value("max_instruments")
min_modes = self.get_value("min_modes")
max_modes = self.get_value("max_modes")
min_targets = self.get_value("min_targets")
max_targets = self.get_value("max_targets")
min_observations = self.get_value("min_observations")
max_observations = self.get_value("max_observations")
assert min_satellites >= SatelliteDomainGenerator.MIN_SATELLITES
assert min_instruments >= SatelliteDomainGenerator.MIN_INSTRUMENTS
assert min_modes >= SatelliteDomainGenerator.MIN_MODES
assert min_targets >= SatelliteDomainGenerator.MIN_TARGETS
assert min_observations >= SatelliteDomainGenerator.MIN_OBSERVATIONS
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
satellites = random.randint(min_satellites, max_satellites)
instruments = random.randint(min_instruments, max_instruments)
modes = random.randint(min_modes, max_modes)
targets = random.randint(min_targets, max_targets)
observations = random.randint(min_observations, max_observations)
seed = random.randint(1, SatelliteDomainGenerator.MAX_SEED)
properties = {
"min_satellites":
min_satellites,
"max_satellites":
max_satellites,
"min_instruments":
min_instruments,
"max_instruments":
max_instruments,
"min_modes":
min_modes,
"max_modes":
max_modes,
"min_targets":
min_targets,
"max_targets":
max_targets,
"min_observations":
min_observations,
"max_observations":
max_observations,
"satellites":
satellites,
"instruments":
instruments,
"modes":
modes,
"targets":
targets,
"observations":
observations,
"seed":
seed,
"bin_params": [
"satellites", "instruments", "modes", "targets",
"observations"
]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s %s %u %u %u %u %u" % (
SatelliteDomainGenerator.GENERATOR_BIN, seed, satellites,
instruments, modes, targets, observations)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_x = self.get_value("min_x")
max_x = self.get_value("max_x")
min_y = self.get_value("min_y")
max_y = self.get_value("max_y")
min_types = self.get_value("min_types")
max_types = self.get_value("max_types")
min_keys = self.get_value("min_keys")
max_keys = self.get_value("max_keys")
min_locks = self.get_value("min_locks")
max_locks = self.get_value("max_locks")
min_prob = self.get_value("min_prob")
max_prob = self.get_value("max_prob")
assert min_x >= GridDomainGenerator.MIN_X
assert min_y >= GridDomainGenerator.MIN_Y
assert min_types >= GridDomainGenerator.MIN_TYPES
assert min_keys >= GridDomainGenerator.MIN_KEYS
assert min_locks >= GridDomainGenerator.MIN_LOCKS
assert min_prob >= GridDomainGenerator.MIN_PROBABILITY
assert max_prob <= GridDomainGenerator.MAX_PROBABILITY
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
x = random.randint(min_x, max_x)
y = random.randint(min_y, max_y)
types = random.randint(min_types, max_types)
keys = random.randint(min_keys, max_keys)
locks = random.randint(min_locks, max_locks)
probability = random.randint(min_prob, max_prob)
# Legal values for keys and locks.
keys = min((x * y) - 2, keys)
locks = min(keys, locks)
locks = max(1, locks)
properties = {
"min_x": min_x,
"max_x": max_x,
"min_y": min_y,
"max_y": max_y,
"min_types": min_types,
"max_types": max_types,
"min_keys": min_keys,
"max_keys": max_keys,
"min_locks": min_locks,
"max_locks": max_locks,
"min_prob": min_prob,
"max_prob": max_prob,
"x": x,
"y": y,
"types": types,
"keys": keys,
"locks": locks,
"probability": probability,
"bin_params": ["x", "y", "keys", "locks"],
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -x %u -y %u -t %u -k %u -l %u -p %u" % (
GridDomainGenerator.GENERATOR_BIN, x, y, types, keys, locks,
probability)
unused_completed_process = subprocess.run(gen_cmd,
shell=True,
stdout=file_handle)
# Just return an empty list.
return []
def generate_problem(self, problem_range):
min_depots = self.get_value("min_depots")
max_depots = self.get_value("max_depots")
min_distributors = self.get_value("min_distributors")
max_distributors = self.get_value("max_distributors")
min_trucks = self.get_value("min_trucks")
max_trucks = self.get_value("max_trucks")
min_pallets = self.get_value("min_pallets")
max_pallets = self.get_value("max_pallets")
min_hoists = self.get_value("min_hoists")
max_hoists = self.get_value("max_hoists")
min_crates = self.get_value("min_crates")
max_crates = self.get_value("max_crates")
assert min_depots >= DepotsDomainGenerator.MIN_DEPOTS
assert min_distributors >= DepotsDomainGenerator.MIN_DISTRIBUTORS
assert min_trucks >= DepotsDomainGenerator.MIN_TRUCKS
assert min_pallets >= DepotsDomainGenerator.MIN_PALLETS
assert min_hoists >= DepotsDomainGenerator.MIN_HOISTS
assert min_crates >= DepotsDomainGenerator.MIN_CRATES
for problem_no in problem_range:
problem_file = "problem_%u.problem.pddl" % (problem_no)
file_handle = open("%s/%s" % (self._base_dir, problem_file), "w")
depots = random.randint(min_depots, max_depots)
distributors = random.randint(min_distributors, max_distributors)
trucks = random.randint(min_trucks, max_trucks)
pallets = random.randint(min_pallets, max_pallets)
hoists = random.randint(min_hoists, max_hoists)
crates = random.randint(min_crates, max_crates)
seed = random.randint(1, DepotsDomainGenerator.MAX_SEED)
properties = {
"min_depots": min_depots,
"max_depots": max_depots,
"min_distributors": min_distributors,
"max_distributors": max_distributors,
"min_trucks": min_trucks,
"max_trucks": max_trucks,
"min_pallets": min_pallets,
"max_pallets": max_pallets,
"min_hoists": min_hoists,
"max_hoists": max_hoists,
"min_crates": min_crates,
"max_crates": max_crates,
"depots": depots,
"distributors": distributors,
"trucks": trucks,
"pallets": pallets,
"hoists": hoists,
"crates": crates,
"seed": seed,
"bin_params": ["depots", "trucks"]
}
file.write_properties(file_handle, properties,
constants.PDDL_COMMENT_PREFIX)
gen_cmd = "%s -e %u -i %u -t %u -p %u -h %u -c %u -s %u" % (
DepotsDomainGenerator.GENERATOR_BIN,
depots,
distributors,
trucks,
pallets,
hoists,
crates,
seed)
unused_completed_process = subprocess.run(
gen_cmd, shell=True, stdout=file_handle)
# Just return an empty list.
return []
