def start(self):
"""Runs once, sets up the hivemind and its agents."""
# Prints an activation message into the console.
# This let's you know that the process is up and running.
self.logger.info("Hello World!")
# Loads game interface.
self.game_interface.load_interface()
# This is how you access field info.
# First create the initialise the object...
field_info = FieldInfoPacket()
# Then update it.
self.game_interface.update_field_info_packet(field_info)
# Same goes for the packet, but that is
# also updated in the main loop every tick.
packet = GameTickPacket()
self.game_interface.update_live_data_packet(packet)
# Initialise drones list. Will be filled with Drone objects for every drone.
self.drones = []
# Runs the game loop where the hivemind will spend the rest of its time.
self.game_loop()
def __init__(self, agent_metadata_queue, quit_event, options):
super().__init__(agent_metadata_queue, quit_event, options)
# Sets up the logger. The string is the name of your hivemind.
# This is configured inside your config file under hivemind_name.
self.logger = get_logger(options['name'])
# Give a warning if exec_path was given.
if self.exec_path is not None:
self.logger.warning(
"An exec_path was given, but this is a PythonHivemind, and so it is ignored."
)
self.logger.warning(
" Try subclassing SubprocessHivemind if you want to use an executable."
)
# The game interface is how you get access to things
# like ball prediction, the game tick packet, or rendering.
self.game_interface = GameInterface(self.logger)
# drone_indices is a set of bot indices
# which requested this hivemind with the same key.
self.drone_indices = set()
self._field_info = FieldInfoPacket()
def __game_loop(self):
"""
The bot hivemind will stay in this loop for the whole game.
This is where the initialize_hive and get_outputs functions are called.
"""
# Creating ball prediction and field info objects to later update in wrapper methods.
self._ball_prediction = BallPrediction()
self._field_info = FieldInfoPacket()
self.game_interface.update_field_info_packet(self._field_info)
# Wrapper for renderer.
self.renderer: RenderingManager = self.game_interface.renderer
# Create packet object.
packet = GameTickPacket()
# Uses one of the drone indices as a key.
key = next(iter(self.drone_indices))
self.game_interface.fresh_live_data_packet(packet, 20, key)
# Initialization step for your hivemind.
self.initialize_hive(packet)
while not self.quit_event.is_set():
try:
# Updating the packet.
self.game_interface.fresh_live_data_packet(packet, 20, key)
# Get outputs from hivemind for each bot.
# Outputs are expected to be a Dict[int, PlayerInput]
outputs = self.get_outputs(packet)
if outputs is None:
self.logger.error("No outputs were returned.")
self.logger.error(
" Try putting `return {i: PlayerInput() for i in self.drone_indices}`"
)
self.logger.error(" in `get_outputs()` to troubleshoot.")
continue
if len(outputs) < len(self.drone_indices):
self.logger.error("Not enough outputs were given.")
elif len(outputs) > len(self.drone_indices):
self.logger.error("Too many outputs were given.")
# Send the drone inputs to the drones.
for index in outputs:
if index not in self.drone_indices:
self.logger.error(
"Tried to send output to bot index not in drone_indices."
)
continue
output = outputs[index]
self.game_interface.update_player_input(output, index)
except Exception:
traceback.print_exc()
class SkeletonAgentTest(SkeletonAgent):
field_info = FieldInfoPacket()
field_info.num_boosts = MAX_BOOSTS
field_info.num_goals = MAX_GOALS
"""A base class for all UnnamedAgent tests"""
def get_field_info(self):
return self.field_info
def game_loop(self):
"""The main game loop. This is where your hivemind code goes."""
# Setting up rate limiter.
rate_limit = rate_limiter.RateLimiter(120)
# Setting up data.
field_info = FieldInfoPacket()
self.game_interface.update_field_info_packet(field_info)
packet = GameTickPacket()
self.game_interface.update_live_data_packet(packet)
data.setup(self, packet, field_info, self.running_indices)
self.ball.predict = BallPrediction()
# https://github.com/RLBot/RLBotPythonExample/wiki/Ball-Path-Prediction
# MAIN LOOP:
while True:
# Updating the game packet from the game.
self.game_interface.update_live_data_packet(packet)
# Processing packet.
data.process(self, packet)
# Ball prediction.
self.game_interface.update_ball_prediction(self.ball.predict)
# Planning.
brain.plan(self)
# Rendering.
self.render_debug(self.game_interface.renderer)
# For each drone under the hivemind's control, do something.
for drone in self.drones:
# The controls are reset each frame.
drone.ctrl = PlayerInput(
) # Basically the same as SimpleControllerState().
# Role execution.
if drone.role is not None:
drone.role.execute(self, drone)
self.render_role(self.game_interface.renderer, drone)
# Send the controls to the bots.
self.game_interface.update_player_input(
drone.ctrl, drone.index)
# Rate limit sleep.
rate_limit.acquire()
def connect(self, game_interface: GameInterface, configs):
print("commentator connected!")
self.config_paths = configs
self.game_interface = game_interface
self.botReadouts = []
print(f"we were passed {len(configs)} bundles")
for i in range(len(configs)):
self.botReadouts.append(self.createAgentInfo(configs[i]))
self.touchTimer = 0
self.currentTime = 0
self.firstIter = True
self.overTime = False
self.shotDetection = True
self.shooter = None
self.currentZone = None
self.KOE = None
self.contactNames = rstring(["hits", "touches", "moves"])
self.dominantNames = rstring(["dominant", "commanding", "powerful"])
self.dangerously = rstring(
["alarmingly", "perilously", "precariously", "dangerously"])
self.RC_Intros = rstring([
"Here's a fun fact. ", "Check this out. ", "This is interesting. ",
"You might like this. "
])
self.ballHistory = []
self.lastTouches = []
self.RC_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
self.teams = []
self.zoneInfo = None
self.joinTimer = 0
self.packet = GameTickPacket()
self.f_packet = FieldInfoPacket()
self.ball_predictions = BallPrediction()
self.lastCommentTime = time.time()
self.finished = False
self.q = Queue(maxsize=200)
self.host = threading.Thread(target=host, args=(
self.q,
0,
))
self.host.start()
# for each in self.botReadouts:
# print(each)
# self.speak(each,10,10)
self.update()
def start(self):
"""Runs once, sets up the hivemind and its agents."""
# Prints an activation message into the console.
# This let's you know that the process is up and running.
self.logger.info("Hello World!")
# Loads game interface.
self.game_interface.load_interface()
# Wait a moment for all agents to have a chance to start up and send metadata.
self.logger.info("Snoozing for 3 seconds; give me a moment.")
time.sleep(3)
self.try_receive_agent_metadata()
# This is how you access field info.
# First create the initialise the object...
field_info = FieldInfoPacket()
# Then update it.
self.game_interface.update_field_info_packet(field_info)
# Same goes for the packet, but that is
# also updated in the main loop every tick.
packet = GameTickPacket()
self.game_interface.update_live_data_packet(packet)
# Ball prediction works the same. Check the main loop.
# Create a Ball object for the ball that holds its information.
self.ball = Ball()
# Create a Drone object for every drone that holds its information.
self.drones = []
for index in range(packet.num_cars):
if index in self.running_indices:
self.drones.append(Drone(index, packet.game_cars[index].team))
# Other attribute initialisation.
self.state = State.SETUP
self.pinch_target = None
# Runs the game loop where the hivemind will spend the rest of its time.
self.game_loop()
def game_loop(self):
"""The main game loop. This is where your hivemind code goes."""
# Setting up rate limiter.
rate_limit = rate_limiter.RateLimiter(120)
# Setting up data.
field_info = FieldInfoPacket()
self.game_interface.update_field_info_packet(field_info)
packet = GameTickPacket()
self.game_interface.update_live_data_packet(packet)
data.setup(self, packet, field_info, self.running_indices)
self.ball.predict = BallPrediction()
# MAIN LOOP:
while True:
# Updating the game packet from the game.
self.game_interface.update_live_data_packet(packet)
# Processing packet.
data.process(self, packet)
# Ball prediction.
self.game_interface.update_ball_prediction(self.ball.predict)
brain.think(self)
for drone in self.drones:
drone.ctrl = PlayerInput()
if drone.role is not None:
drone.role.execute(self, drone)
self.game_interface.update_player_input(
drone.ctrl, drone.index)
self.draw_debug()
# Rate limit sleep.
rate_limit.acquire()
def get_field_info(self) -> FieldInfoPacket:
field_info = FieldInfoPacket()
self.game_interface.update_field_info_packet(field_info)
return field_info