def main():
rob = Pyroborobo.create("config/boids.properties",
world_observer_class=CreateObjectWorldObserver,
override_conf_dict={"gInitialNumberOfRobots": "2"})
rob.start()
rob.update(1000)
rob.close()
def main():
rob = Pyroborobo.create("config/unique_meet.properties",
controller_class=CounterController,
world_observer_class=CounterWorldObserver,
override_conf_dict={"gInitialNumberOfRobots": 30})
rob.start()
rob.update(3000)
rob.close()
def main():
rob: Pyroborobo = Pyroborobo.create("config/ball.properties",
controller_class=HungryController,
object_class_dict={"ball": BallObject})
# Do not forget to set gMovableObjects in properties
rob.start()
print(rob.objects)
rob.update(10000)
rob.close()
def main():
rob = Pyroborobo.create("config/moving_objects.properties",
object_class_dict={
"slowmove": SlowMoveObject,
"uwall": UWallObject
})
rob.start()
rob.update(10000)
rob.close()
def main():
print(pyroborobo.__file__)
pyrob = Pyroborobo.create(
"config/boids.properties",
controller_class=TeleportingController,
override_conf_dict={"gInitialNumberOfRobots": "2"})
pyrob.start()
pyrob.update(1000)
pyrob.close()
def main():
rob = Pyroborobo.create("config/trap.properties",
controller_class=SimpleController,
object_class_dict={'gate': GateObject, 'switch': SwitchObject})
rob.start()
rob.update(1)
# test for screen shots
#screen = rob.get_screen()
#print(np.array(screen, copy=False))
rob.close()
def main():
global rob
rob = Pyroborobo.create(
"config/paintwars.properties",
controller_class=MyController,
world_observer_class=MyWorldObserver,
# world_model_class=PyWorldModel,
agent_observer_class=MyAgentObserver,
object_class_dict={},
override_conf_dict={"gDisplayMode":
simulation_mode} # defined in paintwars_config
)
rob.start()
print("# ___________________________ #")
print("# #")
print("# Welcome to Paint Wars #")
print("# ___________________________ #")
print("#")
print("#")
print("# Team RED :", get_name_red_team())
print("# Team BLUE:", get_name_blue_team())
print("#")
print("#")
rob.update(2001)
rob.close()
print("\n=-=-=-=-=-=-=-=-=\n= FINAL RESULTS =\n=-=-=-=-=-=-=-=-=\n")
#print(scores)
print("Team Red :", scores["Team Red"])
print("Team Blue :", scores["Team Blue"])
print("tiles left:", scores["nobody"])
print("")
s = ""
if scores["Team Red"] > scores["Team Blue"]:
s += "# Team RED won! Congratulations " + get_name_red_team() + " ! #"
elif scores["Team Red"] < scores["Team Blue"]:
s += "# Team BLUE won! Congratulations " + get_name_blue_team(
) + " ! #"
else:
s += "Draw! (no winner)"
print(len(s) * "#")
print(s)
print(len(s) * "#")
print("")
def main():
rob = Pyroborobo.create("config/talking_robots.properties",
controller_class=TalkingController,
object_class_dict={'_default': ResourceObject, 'select': SelectObject}
)
rob.start()
rob.update(1)
print("Hello, welcome to demo 1")
print("Press P to pause the simulation")
print("Click on a robot to know more info about him")
print("The orange object can only be activated by the robot #9")
print("have fun")
should_quit = rob.update(1000)
rob.close()
def main():
global rob
rob = Pyroborobo.create(
"config/pacman.properties",
controller_class=MyController,
world_observer_class=MyWorldObserver,
# world_model_class=PyWorldModel,
agent_observer_class=MyAgentObserver,
object_class_dict={'gate': GateObject, 'switch': SwitchObject, 'ball': BallObject}
#,override_conf_dict={"gNbOfInitialRobots": 30} # NOT IMPLEMENTED
)
rob.start()
rob.update(30000)
rob.close()
def main():
rob = Pyroborobo.create("config/medea.properties",
controller_class=MedeaController,
override_conf_dict={
"gVerbose": "True",
"gDisplayMode": "2"
})
rob.start()
for i in range(10):
print("start timer")
curtime = perf_counter()
should_quit = rob.update(1000)
print(perf_counter() - curtime)
if should_quit:
break
rob.close()
def main():
global rob
rob = Pyroborobo.create(
"config/paintwars.properties",
controller_class=MyController,
world_observer_class=MyWorldObserver,
# world_model_class=PyWorldModel,
agent_observer_class=MyAgentObserver,
object_class_dict={}
, override_conf_dict={"gInitialNumberOfRobots": number_of_robots, "gDisplayMode": simulation_mode}
)
rob.start()
rob.update(1000000)
rob.close()
def main():
nbgen = 10000
nbiterpergen = 400
rob: Pyroborobo = Pyroborobo.create(
"config/pywander_pyobj.properties",
controller_class=EvolController,
agent_observer_class=EvolObserver,
object_class_dict={'gate': GateObject, 'switch': SwitchObject}
)
rob.start()
for igen in range(nbgen):
print("*" * 10, igen, "*" * 10)
stop = rob.update(nbiterpergen)
if stop:
break
weights = get_weights(rob)
fitnesses = get_fitnesses(rob)
new_weights = fitprop(weights, fitnesses)
apply_weights(rob, new_weights)
reset_agent_observers(rob)
pass
def receive_writer(self, writer):
self.writer = writer
def step_post(self):
if self.writer:
writer.writerow({"it": self.rob.iterations,
"id": self.controller.id,
"x": self.controller.absolute_position[0],
"y": self.controller.absolute_position[1]})
if __name__ == "__main__":
import os
rob = Pyroborobo.create("config/pywander.properties",
controller_class=SimpleController,
agent_observer_class=LogAgentObserver,
override_conf_dict={"gBatchMode": True, "gDisplayMode": 2})
rob.start()
sdl_driver = os.getenv("SDL_VIDEODRIVER")
if sdl_driver != "dummy":
print("WARNING: You should set SDL_VIDEODRIVER=dummy to run me on a cluster")
print("SDL_VIDEODRIVER=dummy python simple_batchmode_example.py")
with open("logs/simple_pos_log.txt", "w") as f:
writer = DictWriter(f, ["it", "id", "x", "y"])
writer.writeheader()
for agobs in rob.agent_observers:
agobs.receive_writer(writer)
rob.update(1000)
# and now with a gzip file
with gzip.open("logs/simple_pos_log2.txt.gz", "wt") as f: # write a gzip file in text mode, see doc of gzip
writer = DictWriter(f, ["it", "id", "x", "y"])
from pyroborobo import DistAwareController, Pyroborobo
class MyCustomDistAwareController(DistAwareController):
def __init__(self, world_model):
# Obligatory call to super.__init__ to avoid segfault
DistAwareController.__init__(self, world_model)
print("Hello, I'm a custom DistAwareController")
self.rob = Pyroborobo.get()
def step(self):
self.set_translation(1)
self.set_rotation(0.01)
nbrob = len(self.rob.controllers)
next_id = (self.id + 1) % nbrob
dist = self.get_distance_to_robot(next_id)
print(f"I am {dist} pixel from {next_id}")
if __name__ == "__main__":
rob = Pyroborobo.create("config/pywander_12sensors.properties",
controller_class=MyCustomDistAwareController)
rob.start()
rob.update(1000)
rob.close()
def step(self): # step is called at each time step
self.set_translation(1) # Let's go forward
self.set_rotation(0)
# Now, our world_model object is a PyWorldModel, we can have access to camera_* properties
camera_dist = self.get_all_distances()
camera_rob_id = self.get_all_robot_ids()
if camera_dist[1] < 1: # if we see something on our right
if camera_rob_id[1] != -1: # and it's a robot
self.set_rotation(-self.rot_speed) # go hug it
else: # if it's an object
self.set_rotation(self.rot_speed) # turn left
elif camera_dist[2] < 1: # or in front of us
if camera_rob_id[2] != -1: # and it's a robot
self.set_rotation(0) # go hug it
else: # if object
self.set_rotation(self.rot_speed) # avoid it
elif camera_dist[3] < 1: # Otherwise, if we see something on our left
if camera_rob_id[3] != -1: # and it's a robot
self.set_rotation(self.rot_speed) # go hug the robot
else:
self.set_rotation(-self.rot_speed) # avoid it (turn right)
if __name__ == "__main__":
rob = Pyroborobo.create("config/simple.properties",
controller_class=GatherController)
rob.start()
rob.update(10000)
rob.close()
if np.random.random() < 0.001 * 0.0001:
self.hide()
self.relocate()
self.show()
def is_pushed(self, id_, speed):
super().is_pushed(id_, speed)
#print(f"I'm kicked by {id_}")
def inspect(self, prefix):
return f"[INSPECT] Ball #{self.id}\n"
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
if __name__ == "__main__":
rob = Pyroborobo.create(
"config/robot_40sensors.properties",
controller_class=BoidsController,
world_observer_class=MyWorldObserver,
#agent_observer_class=MyAgentObserver,
object_class_dict={},
override_conf_dict={
"gDisplayMode": simulation_mode_at_startup,
"gRobotDisplayFocus": True
})
rob.start()
rob.update(100000)
rob.close()
def main():
nbgen = 150
nbiterpergen = 3000
lambda_ = 20
nb_repet = 3
mu = 5
bestFit = 0
data = []
data2 = []
performance_list = []
performance_list_ded = []
performance_list2 = []
performance_list_ded2 = []
rob: Pyroborobo = Pyroborobo.create("config/test.properties",
controller_class=EvolController,
world_observer_class=WorldObserverEvol,
object_class_dict={
'uwall': UWallObject,
'switch': SwitchObject,
'feuille': Feuille
},
override_conf_dict={
"gBatchMode": True,
"gDisplayMode": 2,
"gInitialNumberOfRobots": lambda_
})
rob.start()
# un genome : une solution candidate , poids du réseau
all_genomes = init_from_file(rob, "HallOfFame_copie", lambda_)
debug = []
for igen in range(nbgen):
"""
if igen in gen_to_track:
rob.init_trajectory_monitor() """# log trajectory for all agents
print("*" * 10, igen, "*" * 10)
## Pour tester une solution candidate(les poids) il faudrait faire
## une moyenne sur plusieurs expériences et pas que sur une
s = ("génération:", igen)
debug.append(s)
performance_gen_ref = []
performance_gen_ded = []
i = 0
for genome in all_genomes:
i = i + 1
s2 = ("genome:", i)
#debug.append(s2)
# print("*" * 10,"genome:",i, "*" * 10)
# print("genome",genome)
performance_gen_ref_repet = []
performance_gen_ded_repet = []
for z in range(nb_repet):
apply_weight_clonal(rob, genome)
#print("weight:",get_weights(rob))
#tps1 = time.time()
stop = rob.update(nbiterpergen)
if stop:
break
# tps2 = time.time()
#print("temps test genome :",tps2 - tps1)
#fitness dediee de chaque agent/robot
fitnesses_ded_list = get_fitnesses_ded(rob)
#fitness dediee totale pour ce genome
fitness_ded_genome = np.sum(fitnesses_ded_list)
performance_gen_ded_repet.append(fitness_ded_genome)
performance_gen_ref_repet.append(get_reference_function(rob))
reset_world_observer(rob)
reset_agent_controllers(rob)
performance_gen_ded.append(np.mean(performance_gen_ded_repet))
performance_gen_ref.append(np.mean(performance_gen_ref_repet))
fitness_max = np.max(performance_gen_ded)
score_max = np.max(performance_gen_ref)
s = (igen, fitness_max)
s2 = (igen, score_max)
data.append(s)
data2.append(s2)
if bestFit < np.mean(performance_gen_ded):
bestFit = np.mean(performance_gen_ded)
performance_list_ded2.append(bestFit)
performance_list2.append(np.mean(performance_gen_ref))
performance_list_ded.append(performance_gen_ded)
performance_list.append(performance_gen_ref)
#on garde le meilleur genome en memoire
updateHoF(all_genomes, performance_gen_ref)
#ou utiliser fitprop ici ou tout algo de selection de type ES
#print("performance dédiée:",performance_gen_ded)
all_genomes = mu_comma_lambda_nextgen(all_genomes, performance_gen_ded,
mu, lambda_)
"""
if igen in gen_to_track:
rob.save_trajectory_image("all_agents for gen"+str(igen))"""
if (igen % 10 == 0):
plt.plot(np.arange(len(performance_list2)), performance_list2)
plt.xlabel("génération")
plt.ylabel("Score")
plt.title("graphe_evolution_score")
plt.savefig("graphe_de_performance_ref")
plt.figure()
plt.plot(np.arange(len(performance_list_ded2)),
performance_list_ded2)
plt.xlabel("génération")
plt.ylabel("Fitness")
plt.title("graphe_evolution_fitness")
plt.savefig("graphe_de_performance_ded")
plt.figure()
plt.plot(np.arange(len(performance_list2)), performance_list2)
plt.xlabel("génération")
plt.ylabel("Score")
plt.title("graphe_evolution_score")
plt.savefig("graphe_de_performance_ref")
plt.figure()
plt.plot(np.arange(len(performance_list_ded2)), performance_list_ded2)
plt.xlabel("génération")
plt.ylabel("Fitness")
plt.title("graphe_evolution_fitness")
plt.savefig("graphe_de_performance_ded")
plt.figure()
with open('score.csv', 'w+') as out:
csv_out = csv.writer(out)
for row in data2:
csv_out.writerow(row)
with open('fitness.csv', 'w+') as out:
csv_out = csv.writer(out)
for row in data:
csv_out.writerow(row)
class SimpleController(Controller):
def __init__(self, world_model):
# It is *mandatory* to call the super constructor before any other operation to link the python object to its C++ counterpart
Controller.__init__(self, world_model)
assert self.nb_sensors == 8, "SimpleController only works with 8 sensors"
print("I'm a Python controller")
def reset(self):
print("I'm initialised")
def step(self): # step is called at each time step
self.set_translation(1) # Let's go forward
self.set_rotation(0)
# Now, our world_model object is a PyWorldModel, we can have access to camera_* properties
if (self.get_distance_at(1) < 1 # if we see something on our left
or self.get_distance_at(2) < 1): # or in front of us
self.set_rotation(0.5) # turn right
elif self.get_distance_at(
3) < 1: # Otherwise, if we see something on our right
self.set_rotation(-0.5) # turn left
if __name__ == "__main__":
rob = Pyroborobo.create("config/pywander.properties",
controller_class=SimpleController)
rob.start()
rob.update(1000)
rob.close()
def main():
rob = Pyroborobo.create("config/medea.properties",
controller_class=MedeaController)
rob.start()
rob.update(10000)
rob.close()
self.set_translation(1) # Let's go forward
self.set_rotation(0)
# Now, our world_model object is a PyWorldModel, we can have access to camera_* properties
if (self.get_distance_at(1) < 1 # if we see something on our left
or self.get_distance_at(2) < 1): # or in front of us
self.set_rotation(0.5) # turn right
elif self.get_distance_at(
3) < 1: # Otherwise, if we see something on our right
self.set_rotation(-0.5) # turn left
if __name__ == "__main__":
import os
os.makedirs("logs/screenshot_example", exist_ok=True)
rob = Pyroborobo.create(
"config/simple.properties",
controller_class=SimpleController,
override_conf_dict={"gLogDirectoryname": "logs/screenshot_example"})
rob.start()
rob.update(100)
rob.save_screenshot("full_screenshot_for_iter_100")
rob.init_trajectory_monitor() # log trajectory for all agents
rob.update(100)
rob.save_trajectory_image("all_agents")
rob.init_trajectory_monitor(0) # log the trajectory for agent with id 0
rob.update(100)
rob.save_trajectory_image("agent_0")
# let's make a movie
def main():
global rob, arenaIndexSelector, invertStartingPosition, simulation_mode
print(f"Name of the script : {sys.argv[0]=}")
print(f"Arguments : {sys.argv[1:]=}")
if len(sys.argv) == 4:
print("## Using command-line parameters ##")
print("arena :", int(sys.argv[1]))
arenaIndexSelector = int(sys.argv[1])
print("invert position:", sys.argv[2])
invertStartingPosition = True if sys.argv[2] == "True" or sys.argv[
2] == "true" else False
print("simulation mode:", int(sys.argv[3]))
simulation_mode = int(sys.argv[3])
elif len(sys.argv) > 1:
print("Syntax :", sys.argv[0],
"arena_number invert_position simulation_mode")
print("Example:", sys.argv[0], "3 True 1")
exit(0)
rob = Pyroborobo.create(
"config/paintwars.properties",
controller_class=MyController,
world_observer_class=MyWorldObserver,
# world_model_class=PyWorldModel,
agent_observer_class=MyAgentObserver,
object_class_dict={},
override_conf_dict={"gDisplayMode":
simulation_mode} # defined in paintwars_config
)
rob.start()
print("# ___________________________ #")
print("# #")
print("# Welcome to Paint Wars #")
print("# ___________________________ #")
print("#")
print("#")
print("# Team RED vs. Team BLUE !")
print("#")
print("#")
rob.update(2001)
rob.close()
print("\n=-=-=-=-=-=-=-=-=\n= FINAL RESULTS =\n=-=-=-=-=-=-=-=-=\n")
#print(scores)
print("Team Red :", scores["Team Red"])
print("Team Blue :", scores["Team Blue"])
print("tiles left:", scores["nobody"])
print("")
s = ""
if scores["Team Red"] > scores["Team Blue"]:
s += "# Team RED won! Congratulations ! #"
winner = "Team Red"
elif scores["Team Red"] < scores["Team Blue"]:
s += "# Team BLUE won! Congratulations ! #"
winner = "Team Blue"
else:
s += "Draw! (no winner)"
winner = "no winner"
print(len(s) * "#")
print(s)
print(len(s) * "#")
print("")
summary = "arena=" + str(arenaIndexSelector) + " invert_position=" + str(
invertStartingPosition) + " winner=\"" + winner + "\""
if len(sys.argv) == 4:
print(summary)
self.cur_regrow = 0
def step(self):
if self.triggered:
self.cur_regrow -= 1
if self.cur_regrow <= 0 and self.can_register():
self.show()
self.register()
self.triggered = False
def open(self):
self.triggered = True
self.hide()
self.unregister()
self.cur_regrow = self.regrow_time
def inspect(self, prefix=""):
return "I'm a gate!"
if __name__ == "__main__":
rob = Pyroborobo.create("config/pywander_pyobj.properties",
controller_class=SimpleController,
object_class_dict={
'gate': GateObject,
'switch': SwitchObject
})
rob.start()
rob.update(3000)
rob.close()
super().__init__(-1)
self.set_color(0, 0, 255)
self.radius = 10
self.footprint_radius = 20
self.relocate()
self.show()
def step(self):
pass
def reset(self):
self.register()
def inspect(self, prefix):
return f"Working as always boys, #{self.id}"
if __name__ == "__main__":
rob = Pyroborobo.create("config/empty_arena.properties",
controller_class=SimpleController,
override_conf_dict={
"gInitialNumberOfRobots": 1,
"gNbOfPhysicalObjects": 1
})
rob.start()
for i in range(100):
quit = rob.update(100)
obj = rob.add_object(SimpleDisk())
if quit: break
rob.close()
if self.get_object_at(3) != -1 and not must_flee:
self.set_rotation(self.rotspeed) # turn left
else:
self.set_rotation(-self.rotspeed)
must_flee = True
def inspect(self, prefix):
output = ""
for i in range(self.nb_sensors):
output += f"""sensor {i}:
dist: {self.get_distance_at(i)}
id: {self.world_model.camera_objects_ids[i]}
nbobjs: {len(self.rob.objects)}
is_object: {self.get_object_at(i)}
is_robot: {self.get_robot_id_at(i)}
is_wall: {self.get_wall_at(i)}\n\n"""
return output
if __name__ == "__main__":
rob = Pyroborobo.create("config/pywander_pyobj_resource.properties",
controller_class=HungryController,
object_class_dict={
'_default': ResourceObject,
'gate': GateObject,
'switch': SwitchObject
})
rob.start()
rob.update(10000)
rob.close()
self.orientation = 1
print("I'm a Python controller")
def reset(self):
print("I'm initialised")
def step(self): # step is called at each time step
self.set_translation(1) # Let's go forward
if np.random.random(
) < 0.01: # Change orientation every 100 frames or so
self.orientation = -self.orientation
self.set_rotation(self.wander_rot_speed * self.orientation)
# Now, our world_model object is a PyWorldModel, we can have access to camera_* properties
camera_dist = self.get_all_distances()
if camera_dist[1] < 1: # if we see something on our right
self.set_rotation(self.rot_speed) # go avoid it
elif camera_dist[2] < 1: # or in front of us
self.set_rotation(self.rot_speed) # avoid it
elif camera_dist[3] < 1: # Otherwise, if we see something on our left
self.set_rotation(-self.rot_speed) # avoid it (turn right)
if __name__ == "__main__":
rob = Pyroborobo.create("config/simple.properties",
controller_class=RepulseController)
rob.start()
rob.update(10000)
rob.close()
camera_dist = self.get_all_distances()
camera_id = self.get_all_robot_ids()
camera_angle_rad = self.get_all_sensor_angles()
camera_angle = camera_angle_rad * 180 / np.pi
own_orientation = self.absolute_orientation
for i in np.argsort(
camera_dist): # get the index from the closest to the farthest
if camera_angle[i] < -270 or camera_angle[i] > 270:
continue
else:
dist = camera_dist[i]
if dist < self.repulse_radius:
if camera_angle[i] != 0:
self.set_rotation(-camera_angle_rad[i] / np.pi)
else:
self.set_rotation(1)
elif dist < self.orientation_radius and camera_id[i] != -1:
orient_angle = self.get_robot_relative_orientation_at(i)
self.set_rotation(orient_angle / np.pi)
elif dist < self.camera_max_range and camera_id[i] != -1:
self.set_rotation(camera_angle_rad[i] / np.pi)
break # stop
if __name__ == "__main__":
rob = Pyroborobo.create("config/boids.properties",
controller_class=BoidsController)
rob.start()
rob.update(100000)
rob.close()
for i in range(self.nb_sensors):
print(f"Sensor {i}:")
print(f"\tdist: {self.get_distance_at(i)}")
print(f"\tis object: {self.get_object_at(i) != -1}")
print(f"\tis_wall: {self.get_wall_at(i)}")
print(f"\tis robot: {self.get_robot_id_at(i) != -1}")
is_robot = self.get_robot_id_at(i) != -1
is_wall = self.get_wall_at(i)
if is_robot:
robid = self.get_robot_id_at(i)
print(f"\trobot id: {robid}")
print(
f"\trobot's controller: {self.get_robot_controller_at(i)}"
)
ctl = self.get_robot_controller_at(i)
print(
f"\tThis robot is at {ctl.absolute_position} with orientation {ctl.absolute_orientation}."
)
elif self.get_object_at(i) != -1: # then it's an object
print(
f"\tphysical object instance: {self.get_object_instance_at(i)}"
)
if __name__ == "__main__":
rob = Pyroborobo.create("config/simple.properties",
controller_class=TutorialController)
rob.start()
rob.update(10000)
rob.close()
1] > 1000 # id is a wall or a robot (id > 1000)
must_avoid_r = ids[3] == WALL_ID or ids[
3] > 1000 # id is a wall or a robot (id > 1000)
must_avoid_f = ids[2] == WALL_ID or ids[2] > 1000
if is_resource_l:
self.world_model.rotation = -10 + np.random.normal(0, 4)
if is_resource_r:
self.world_model.rotation = 10 + np.random.normal(0, 4)
# even if there are resources, avoid walls if too close (half dist)
if (dists[2] < maxdisthalf and must_avoid_f)\
or (dists[1] < maxdisthalf and must_avoid_l):
self.world_model.rotation = 10 + np.random.normal(0, 4)
if dists[3] < maxdisthalf and must_avoid_r:
self.world_model.rotation = -10 + np.random.normal(0, 4)
rob = Pyroborobo.create("config/wanderer.properties", None, WanderController,
PyWorldModel, None, {
"gate": GateObject,
"switch": SwitchObject
}, {})
if __name__ == "__main__":
rob.start()
nbgen = 1
for i in range(nbgen):
rob.update(10000)
print("over")
Pyroborobo.close()
