class WandererRoborobo(MultiAgentEnv):
action_space = Box(np.array([-1, -1], dtype=np.float32), np.array([1, 1], dtype=np.float32))
observation_space = Box(np.concatenate((np.repeat(0, 8), [-2, -15])), np.concatenate((np.repeat(1, 8), [2, 15])))
def __init__(self, nbrobs: int, max_moves: int):
super().__init__()
self.nbrobs = nbrobs
self.max_moves = max_moves
self.moves = 0
self.rob = None
self.wms = None
def __del__(self):
if self.rob:
self.rob.close()
def reset(self):
if self.rob is None:
self.rob = Pyroborobo('config/wanderer.properties', WorldObserver, "dummy", "dummy", "dummy",
{'gInitialNumberOfRobots': str(self.nbrobs)})
self.rob.start()
wo = self.rob.world_observer
wo.set_roborobo(self.rob)
self.wms = self.rob.world_models
else:
print('reset')
wo = self.rob.world_observer
wo.reset()
self.moves = 0
obs_dict = {'player'+str(i): self.get_obs(i) for i in range(self.nbrobs)}
return obs_dict
def get_obs(self, i):
return np.concatenate((self.wms[i].get_camera_sensors_dist(), [self.wms[i].translation, self.wms[i].rotation]))
def step(self, action_dict):
self.moves += 1
for i in range(self.nbrobs):
self.wms[i].translation = action_dict['player'+str(i)][0] * 2
self.wms[i].rotation = action_dict['player'+str(i)][1] * 15
stop = self.rob.update(1)
if stop:
sys.exit(0)
obs_dict = {'player'+str(i): self.get_obs(i) for i in range(self.nbrobs)}
punish = {i: (1 - obs_dict['player'+str(i)][2]) + (1 - obs_dict['player'+str(i)][3] + (1 - obs_dict['player'+str(i)][4])
+ (np.abs(obs_dict['player'+str(i)][9])/15))
for i in range(self.nbrobs)}
done = {'player'+str(i): self.moves > self.max_moves for i in range(self.nbrobs)}
done['__all__'] = all(done.values())
rewards = {'player'+str(i): self.wms[i].translation - 10*punish[i] for i in range(self.nbrobs)}
return obs_dict, rewards, done, {}
def render(self):
pass
def reset(self):
if self.rob is None:
self.rob = Pyroborobo('config/wanderer.properties', WorldObserver, "dummy", "dummy", "dummy",
{'gInitialNumberOfRobots': str(self.nbrobs)})
self.rob.start()
wo = self.rob.world_observer
wo.set_roborobo(self.rob)
self.wms = self.rob.world_models
else:
print('reset')
wo = self.rob.world_observer
wo.reset()
self.moves = 0
obs_dict = {'player'+str(i): self.get_obs(i) for i in range(self.nbrobs)}
return obs_dict
def __init__(self, id_, data):
CircleObject.__init__(self,
id_) # Do not forget to call super constructor
self.regrow_time = 100
self.cur_regrow = 0
self.triggered = False
self.rob = Pyroborobo.get() # Get pyroborobo singleton
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 __init__(self, world_model):
self.rot_speed = 0.5
# 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)
self.rob = Pyroborobo.get()
print("I'm a Python controller")
def __init__(self, id, data):
CircleObject.__init__(self, id) # Do not forget to call super constructor
self.regrow_time = data['regrowTimeMax']
self.cur_regrow = 0
self.triggered = False
self.gate_id = data['sendMessageTo']
self.rob = Pyroborobo.get() # Get pyroborobo singleton
def reset(self):
if self.rob is None:
self.rob = Pyroborobo('config/pynegociate.properties', None, None,
None, None,
{'gInitialNumberOfRobots': str(self.nbrobs)})
self.rob.start()
wo = self.rob.world_observer
self.wms = self.rob.world_models
else:
print('reset')
wo = self.rob.world_observer
wo.reset()
obs_dict = {
f'{i}-{self.curlife[i]}': self.wms[i].get_observations()['obs']
for i in range(self.nbrobs)
}
return obs_dict
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)
self.rob = Pyroborobo.get()
self.camera_max_range = 0
self.repulse_radius = 0
self.orientation_radius = 0
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 __init__(self, id_: int, data: dict):
CircleObject.__init__(self, id_)
self.rob = Pyroborobo.get()
print(data)
self.message = data.get("sendMessageTo", 0)
self.triggered = False
self.regrow_time = 0
self.regrow_time_max = data['regrowTimeMax']
def __init__(self, wm):
super().__init__(wm)
self.weights = None
self.received_weights = dict()
self.rob = Pyroborobo.get()
self.next_gen_every_it = 400
self.deactivated = False
self.next_gen_in_it = self.next_gen_every_it
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 __init__(self, world):
super().__init__(world)
self.rob = Pyroborobo.get()
self.global_fit = 0
self.pointCount = 0
self.reference_function = 0
self.next_id_obj = 8
self.nb_objects = 25
self.feuille = []
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():
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/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():
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 __init__(self, wm):
super().__init__(wm)
self.weights = None
self.received_weights = dict()
self.rob = Pyroborobo.get()
self.next_gen_every_it = 400
self.deactivated = False
self.next_gen_in_it = self.next_gen_every_it
self._cur_inputs = None # pre-allocate inputs to avoid too much copy
self.distances = None
self.distances = None
self.is_robots = None
self.is_walls = None
self.is_objects = None
self.robot_controllers = None
self.prev_dist = np.array([0])
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 step(self):
self.cur_it -= 1
if self.cur_it < 0:
x, y = self.position
new_x, new_y = x + 20, y
if Pyroborobo.get().iterations < 200:
try:
self.radius = 100
except RuntimeError:
print(
"[ERROR FOR THE EXAMPLE] Cannot work, object not unregistered first"
)
self.unregister()
success = self.set_coordinates(new_x, new_y)
if not success:
self.set_coordinates(self.default_x, self.default_y)
self.register()
self.cur_it = self.move_every
def __init__(self, id=-1, data={}):
super().__init__(id,data)
self.set_color(0, 255, 0)
self.type = 4
self.regrow_time = 50
self.cur_regrow = 0
self.data = data
self.x = 0
self.y = 0
self.new_x = 0
self.new_y = 0
self.take = True
#self.default_x = copy.copy(data["x"])
#self.default_y = copy.copy(data["y"])
self.rob = Pyroborobo.get() # Get pyroborobo singleton
self.dropped_in_nest = False
self.dropped = False
self.nbRobot = 0 # nombre de robot qui l'ont transporté jusqu'a présent
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)
def __init__(self, world):
super().__init__(world)
rob = Pyroborobo.get()
def __init__(self, wm):
super().__init__(wm)
self.arena_size = Pyroborobo.get().arena_size
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()
def __init__(self, wm):
super().__init__(wm)
self.writer = None
self.rob = Pyroborobo.get()
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"])
