def setup_failure_freeplay(setup_manager: SetupManager, message: str, color_key="red"): match_config = MatchConfig() match_config.game_mode = game_mode_types[0] match_config.game_map = "BeckwithPark" match_config.enable_rendering = True mutators = MutatorConfig() mutators.match_length = match_length_types[3] match_config.mutators = mutators match_config.player_configs = [] setup_manager.load_match_config(match_config) setup_manager.start_match() color = getattr(setup_manager.game_interface.renderer, color_key)() setup_manager.game_interface.renderer.begin_rendering() # setup_manager.game_interface.renderer.draw_rect_2d(20, 20, 800, 800, True, setup_manager.game_interface.renderer.black()) setup_manager.game_interface.renderer.draw_string_2d( 20, 200, 4, 4, message, color) setup_manager.game_interface.renderer.end_rendering()
def start_match(bot_list, match_settings): launcher_preference_map = load_launcher_settings() launcher_prefs = launcher_preferences_from_map(launcher_preference_map) # Show popup in GUI if rocket league is not started with -rlbot flag try: testSetupManager = SetupManager() temp, port = gateway_util.find_existing_process() if port is None: # RLBot.exe is not running, but Rocket League might be. That's a situation we can recover from, RLBot.exe # will be booted up using the ideal port later, so assume that port. port = gateway_util.IDEAL_RLBOT_PORT del temp # It's fine if rocket league is not running, this would just return false and we'd proceed. What we're checking # for is an exception thrown when rocket league IS running but without the necessary flags or a mismatched port. testSetupManager.is_rocket_league_running(port) except Exception as e: eel.noRLBotFlagPopup() print( f"Error starting match. This is probably due to Rocket League not being started under the -rlbot flag. {e}" ) else: eel.spawn(start_match_helper, bot_list, match_settings, launcher_prefs)
def setup_match(self): # TODO This should be replaced? arguments = docopt(__doc__) bot_directory = arguments['--bot-folder'] bundles = scan_directory_for_bot_configs(bot_directory) # Set up RLBot.cfg framework_config = create_bot_config_layout() config_location = os.path.join(os.path.dirname(__file__), 'rlbot.cfg') framework_config.parse_file(config_location, max_index=MAX_PLAYERS) match_config = parse_match_config(framework_config, config_location, {}, {}) looks_configs = { idx: bundle.get_looks_config() for idx, bundle in enumerate(bundles) } names = [bundle.name for bundle in bundles] player_config = match_config.player_configs[0] match_config.player_configs.clear() for i in range(max(len(bundles), self.min_bots)): copied = PlayerConfig() copied.bot = player_config.bot copied.name = player_config.name copied.rlbot_controlled = player_config.rlbot_controlled copied.config_path = player_config.config_path copied.team = player_config.team if i % 2 == 0 else not player_config.team if i < len(bundles): copied.name = names[i] # If you want to override bot appearances to get a certain visual effect, e.g. with # specific boost colors, this is a good place to do it. copied.loadout_config = load_bot_appearance( looks_configs[i], 0) match_config.player_configs.append(copied) manager = SetupManager() manager.load_match_config(match_config, {}) manager.connect_to_game( RocketLeagueLauncherPreference( RocketLeagueLauncherPreference.STEAM, False)) manager.start_match()
def __init__(self): match_config = MatchConfig() match_config.game_mode = 'Soccer' match_config.game_map = 'Mannfield_Night' match_config.existing_match_behavior = 'Continue And Spawn' match_config.mutators = MutatorConfig() match_config.mutators.match_length = 'Unlimited' # there needs to be at least one bot for the match to start bot_config = PlayerConfig() bot_config.name = "Dummy" bot_config.team = 0 bot_config.bot = True bot_config.rlbot_controlled = True match_config.player_configs = [bot_config] sm = SetupManager() sm.connect_to_game() sm.load_match_config(match_config) sm.start_match() self.game_interface: GameInterface = sm.game_interface
def start_match_helper(bot_list, match_settings): print(bot_list) print(match_settings) match_config = MatchConfig() match_config.game_mode = match_settings['game_mode'] match_config.game_map = match_settings['map'] match_config.skip_replays = match_settings['skip_replays'] match_config.instant_start = match_settings['instant_start'] match_config.enable_lockstep = match_settings['enable_lockstep'] match_config.enable_rendering = match_settings['enable_rendering'] match_config.enable_state_setting = match_settings['enable_state_setting'] match_config.auto_save_replay = match_settings['auto_save_replay'] match_config.existing_match_behavior = match_settings['match_behavior'] match_config.mutators = MutatorConfig() mutators = match_settings['mutators'] match_config.mutators.match_length = mutators['match_length'] match_config.mutators.max_score = mutators['max_score'] match_config.mutators.overtime = mutators['overtime'] match_config.mutators.series_length = mutators['series_length'] match_config.mutators.game_speed = mutators['game_speed'] match_config.mutators.ball_max_speed = mutators['ball_max_speed'] match_config.mutators.ball_type = mutators['ball_type'] match_config.mutators.ball_weight = mutators['ball_weight'] match_config.mutators.ball_size = mutators['ball_size'] match_config.mutators.ball_bounciness = mutators['ball_bounciness'] match_config.mutators.boost_amount = mutators['boost_amount'] match_config.mutators.rumble = mutators['rumble'] match_config.mutators.boost_strength = mutators['boost_strength'] match_config.mutators.gravity = mutators['gravity'] match_config.mutators.demolish = mutators['demolish'] match_config.mutators.respawn_time = mutators['respawn_time'] human_index_tracker = IncrementingInteger(0) match_config.player_configs = [create_player_config(bot, human_index_tracker) for bot in bot_list] match_config.script_configs = [create_script_config(script) for script in match_settings['scripts']] global sm if sm is not None: try: sm.shut_down() except Exception as e: print(e) sm = SetupManager() sm.early_start_seconds = 5 sm.connect_to_game() sm.load_match_config(match_config) sm.launch_early_start_bot_processes() sm.start_match() sm.launch_bot_processes()
def setup_match(manager: SetupManager): manager.shut_down(kill_all_pids=True, quiet=True) # Stop any running pids manager.load_config() manager.launch_early_start_bot_processes() manager.start_match() manager.launch_bot_processes()
def spawn_car_in_showroom(loadout_config: LoadoutConfig, team: int, showcase_type: str, map_name: str, launcher_prefs: RocketLeagueLauncherPreference): match_config = MatchConfig() match_config.game_mode = 'Soccer' match_config.game_map = map_name match_config.instant_start = True match_config.existing_match_behavior = 'Continue And Spawn' match_config.networking_role = NetworkingRole.none match_config.enable_state_setting = True match_config.skip_replays = True bot_config = PlayerConfig() bot_config.bot = True bot_config.rlbot_controlled = True bot_config.team = team bot_config.name = "Showroom" bot_config.loadout_config = loadout_config match_config.player_configs = [bot_config] match_config.mutators = MutatorConfig() match_config.mutators.boost_amount = 'Unlimited' match_config.mutators.match_length = 'Unlimited' global sm if sm is None: sm = SetupManager() sm.connect_to_game(launcher_preference=launcher_prefs) sm.load_match_config(match_config) sm.start_match() game_state = GameState( cars={0: CarState(physics=Physics( location=Vector3(0, 0, 20), velocity=Vector3(0, 0, 0), angular_velocity=Vector3(0, 0, 0), rotation=Rotator(0, 0, 0) ))}, ball=BallState(physics=Physics( location=Vector3(0, 0, -100), velocity=Vector3(0, 0, 0), angular_velocity=Vector3(0, 0, 0) )) ) player_input = PlayerInput() team_sign = -1 if team == 0 else 1 if showcase_type == "boost": player_input.boost = True player_input.steer = 1 game_state.cars[0].physics.location.y = -1140 game_state.cars[0].physics.velocity.x = 2300 game_state.cars[0].physics.angular_velocity.z = 3.5 elif showcase_type == "throttle": player_input.throttle = 1 player_input.steer = 0.56 game_state.cars[0].physics.location.y = -1140 game_state.cars[0].physics.velocity.x = 1410 game_state.cars[0].physics.angular_velocity.z = 1.5 elif showcase_type == "back-center-kickoff": game_state.cars[0].physics.location.y = 4608 * team_sign game_state.cars[0].physics.rotation.yaw = -0.5 * pi * team_sign elif showcase_type == "goal-explosion": game_state.cars[0].physics.location.y = -2000 * team_sign game_state.cars[0].physics.rotation.yaw = -0.5 * pi * team_sign game_state.cars[0].physics.velocity.y = -2300 * team_sign game_state.ball.physics.location = Vector3(0, -3500 * team_sign, 93) sm.game_interface.update_player_input(player_input, 0) sm.game_interface.set_game_state(game_state)
def main(): print("starting") manager = SetupManager() manager.startup() manager.load_config() manager.init_ball_prediction() manager.launch_bot_processes() manager.run() # Runs forever until interrupted
def run_exercises(setup_manager: SetupManager, exercises: Iterable[Exercise], seed: int, reload_agent: bool = True) -> Iterator[Result]: """ It is recommended to use setup_manager_context() to generate your setup_manager. """ game_interface = setup_manager.game_interface names = [exercise.get_name() for exercise in exercises] with training_status_renderer_context(names, game_interface.renderer) as ren: for i, exercise in enumerate(exercises): with safe_matchcomms_factory(setup_manager) as matchcomms_factory: def update_row(status: str, status_color_func): nonlocal i nonlocal exercise ren.update( i, Row(exercise.get_name(), status, status_color_func)) update_row('config', ren.renderman.white) # Only reload the match if the config has changed. new_match_config = exercise.get_match_config() if new_match_config != setup_manager.match_config: update_row('match', ren.renderman.white) _setup_match(new_match_config, setup_manager) update_row('bots', ren.renderman.white) _wait_until_bots_ready(setup_manager, new_match_config) if reload_agent: update_row('reload', ren.renderman.white) setup_manager.reload_all_agents(quiet=True) # Briefing update_row('brief', ren.renderman.white) try: exercise.set_matchcomms_factory(matchcomms_factory) early_result = exercise.on_briefing() except Exception as e: update_row('brief', ren.renderman.red) yield Result( exercise, seed, FailDueToExerciseException(e, traceback.format_exc())) continue if early_result is not None: if isinstance(early_result.grade, Pass): update_row('PASS', ren.renderman.green) else: update_row('FAIL', ren.renderman.red) yield early_result continue update_row('wait', ren.renderman.white) _wait_until_good_ticks(game_interface) update_row('setup', ren.renderman.white) error_result = _setup_exercise(game_interface, exercise, seed) if error_result is not None: update_row('setup', ren.renderman.red) yield error_result continue # Wait for the set_game_state() to propagate before we start running ex.on_tick() # TODO: wait until the game looks similar. update_row('sleep', ren.renderman.white) time.sleep(0.03) update_row('>>>>', ren.renderman.white) result = _grade_exercise(game_interface, exercise, seed) if isinstance(result.grade, Pass): update_row('PASS', ren.renderman.green) else: update_row('FAIL', ren.renderman.red) yield result
def main(gym=False): print(f"Starting Custom runner with gym:{gym}") check_python_version() manager = SetupManager(gym) manager.connect_to_game() manager.load_config() manager.launch_ball_prediction() manager.launch_quick_chat_manager() manager.launch_bot_processes() manager.start_match() return manager
def main(): print("starting") check_python_version() manager = SetupManager() manager.connect_to_game() manager.load_config() manager.launch_ball_prediction() manager.launch_quick_chat_manager() manager.launch_bot_processes() manager.start_match() manager.infinite_loop() # Runs forever until interrupted
def ensure_dll_is_injected(): manager = SetupManager() manager.connect_to_game()
def _wait_until_bots_ready(setup_manager: SetupManager, match_config: MatchConfig): logger = get_logger(DEFAULT_LOGGER) while not setup_manager.has_received_metadata_from_all_bots(): logger.debug('Waiting on all bots to post their metadata.') setup_manager.try_recieve_agent_metadata() time.sleep(0.1)
def setup_match(self): # Set up RLBot.cfg framework_config = create_bot_config_layout() config_location = os.path.join(os.path.dirname(__file__), 'rlbot.cfg') framework_config.parse_file(config_location, max_index=MAX_PLAYERS) match_config = parse_match_config(framework_config, config_location, {}, {}) match_config.game_map = self.choreo_obj.map_name # The three blocks of code below are basically identical. # TODO Make them into a function? # Gets appearance list from choreo. appearances = self.choreo_obj.get_appearances(self.min_bots) # Checks that it is the correct length. if len(appearances) != self.min_bots: print( '[RLBotChoreography]: Number of appearances does not match number of bots.' ) print('[RLBotChoreography]: Using default appearances.') appearances = ['default.cfg'] * self.min_bots # Gets teams list from choreo. teams = self.choreo_obj.get_teams(self.min_bots) # Checks that it is the correct length. if len(teams) != self.min_bots: print( '[RLBotChoreography]: Number of teams does not match number of bots.' ) print('[RLBotChoreography]: Putting all on blue.') teams = [0] * self.min_bots # Gets names list from choreo. names = self.choreo_obj.get_names(self.min_bots) # Checks that it is the correct length. if len(names) != self.min_bots: print( '[RLBotChoreography]: Number of names does not match number of bots.' ) print('[RLBotChoreography]: Using bot indices as names.') names = range(self.min_bots) # Loads appearances. looks_configs = { idx: create_looks_configurations().parse_file( os.path.abspath('./ChoreographyHive/appearances/' + file_name)) for idx, file_name in enumerate(appearances) } # rlbot.cfg specifies only one bot, # so we have to copy each and assign correct appearance. player_config = match_config.player_configs[0] match_config.player_configs.clear() for i in range(self.min_bots): copied = PlayerConfig() copied.name = names[i] copied.team = teams[i] copied.bot = player_config.bot copied.rlbot_controlled = player_config.rlbot_controlled copied.config_path = player_config.config_path copied.loadout_config = load_bot_appearance( looks_configs[i], copied.team) match_config.player_configs.append(copied) manager = SetupManager() manager.load_match_config(match_config, {}) manager.connect_to_game() manager.start_match()
def run_tests(my_queue: Queue): """Runs the tests.""" check_python_version() manager = SetupManager() has_started = False for config in TESTS: if len(TESTS[config]) == 0: continue # Start a match. directory = os.path.abspath(os.path.dirname(__file__)) config_location = os.path.join(directory, config, "match.cfg") manager.load_config(config_location=config_location) manager.connect_to_game() manager.launch_early_start_bot_processes() manager.start_match() manager.launch_bot_processes() if not has_started: # Let other thread know that game has been launched. my_queue.put(Message.READY) has_started = True # Load first test for this config. test_num = 0 my_queue.put((get_game_state( os.path.join(directory, config, TESTS[config][test_num])), None)) while not manager.quit_event.is_set(): manager.try_recieve_agent_metadata() # Move onto the next test. if keyboard.is_pressed(NEXT_KEY): test_num += 1 # If we have exceeded the number of tests in this config, # break and go to the next config. if len(TESTS[config]) <= test_num: break # Loads the next test. my_queue.put((get_game_state( os.path.join(directory, config, TESTS[config][test_num])), None)) # Prevent accidental multiple key presses. time.sleep(1) # Kill all bot processes. manager.shut_down(kill_all_pids=True) my_queue.put((None, Message.DONE)) print("Thread 1 closing.") exit()
def run_challenge(match_config: MatchConfig, challenge: dict, upgrades: dict) -> Tuple[bool, dict]: """Launch the game and keep track of the state""" setup_manager = SetupManager() setup_manager.early_start_seconds = 5 setup_manager.connect_to_game() setup_manager.load_match_config(match_config) setup_manager.launch_early_start_bot_processes() setup_manager.start_match() setup_manager.launch_bot_processes() game_results = None try: game_results = manage_game_state(challenge, upgrades, setup_manager) except: # no matter what happens we gotta continue traceback.print_exc() print("Something failed with the game. Will proceed with shutdown") # need to make failure apparent to user setup_failure_freeplay(setup_manager, "The game failed to continue") return False, {} setup_manager.shut_down() return game_results
def run_match(file_path): assert os.path.exists(file_path), f"Invalid path: {file_path}" _, ext = os.path.splitext(file_path) assert ext == ".cfg", f"Wrong file extension: '{ext}', expected '.cfg'" print(f"Using config at {file_path}") manager = SetupManager() manager.load_config(config_location=file_path) try: manager.connect_to_game() manager.launch_early_start_bot_processes() manager.start_match() manager.launch_bot_processes() except Exception: traceback.print_exc() finally: manager.shut_down(kill_all_pids=True)
def _setup_match(match_config: MatchConfig, manager: SetupManager): manager.shut_down(kill_all_pids=True, quiet=True) # To be safe. manager.load_match_config(match_config) manager.launch_early_start_bot_processes() manager.start_match() manager.launch_bot_processes()
def wait_for_all_bots(manager: SetupManager): while not manager.has_received_metadata_from_all_bots(): manager.try_recieve_agent_metadata() time.sleep(0.1)
def record_atba(): raw_config_parser = configparser.RawConfigParser() raw_config_parser.read(RLBOT_CONFIG_FILE) framework_config = create_bot_config_layout() framework_config.parse_file(raw_config_parser, max_index=10) manager = SetupManager() manager.connect_to_game() manager.load_config(framework_config=framework_config, config_location=RLBOT_CONFIG_FILE) manager.launch_ball_prediction() manager.launch_quick_chat_manager() manager.launch_bot_processes() manager.start_match() manager.infinite_loop() # Runs terminated by timeout in other thread.
def stop_match(manager: SetupManager): manager.shut_down(kill_all_pids=True, quiet=True)
def main(): print("starting") manager = SetupManager() manager.startup() manager.load_config() manager.launch_bot_processes() manager.run() # Runs forever until interrupted manager.shut_down()
def start_match_helper(bot_list, match_settings): print(bot_list) print(match_settings) match_config = MatchConfig() match_config.game_mode = match_settings['game_mode'] match_config.game_map = match_settings['map'] match_config.mutators = MutatorConfig() mutators = match_settings['mutators'] match_config.mutators.match_length = mutators['match_length'] match_config.mutators.max_score = mutators['max_score'] match_config.mutators.overtime = mutators['overtime'] match_config.mutators.series_length = mutators['series_length'] match_config.mutators.game_speed = mutators['game_speed'] match_config.mutators.ball_max_speed = mutators['ball_max_speed'] match_config.mutators.ball_type = mutators['ball_type'] match_config.mutators.ball_weight = mutators['ball_weight'] match_config.mutators.ball_size = mutators['ball_size'] match_config.mutators.ball_bounciness = mutators['ball_bounciness'] match_config.mutators.boost_amount = mutators['boost_amount'] match_config.mutators.rumble = mutators['rumble'] match_config.mutators.boost_strength = mutators['boost_strength'] match_config.mutators.gravity = mutators['gravity'] match_config.mutators.demolish = mutators['demolish'] match_config.mutators.respawn_time = mutators['respawn_time'] human_index_tracker = IncrementingInteger(0) match_config.player_configs = [ create_player_config(bot, human_index_tracker) for bot in bot_list ] global sm if sm is not None: try: sm.shut_down() except Exception as e: print(e) sm = SetupManager() sm.connect_to_game() sm.load_match_config(match_config) sm.launch_ball_prediction() sm.launch_quick_chat_manager() sm.launch_bot_processes() sm.start_match()
def _setup_match(match_config: MatchConfig, manager: SetupManager): manager.shut_down(kill_all_pids=True, quiet=True) # To be safe. manager.load_match_config(match_config) manager.launch_early_start_bot_processes() manager.start_match() manager.launch_bot_processes() time.sleep(.5) manager.try_recieve_agent_metadata() # Sometimes this launches bots!
def _setup_match(match_config: MatchConfig, manager: SetupManager): manager.shut_down(quiet=True) # To be safe. manager.load_match_config(match_config) manager.launch_quick_chat_manager() manager.launch_ball_prediction() manager.launch_bot_processes() manager.start_match()
class RLBotQTGui(QMainWindow, Ui_MainWindow): def __init__(self): """ Creates a new QT mainwindow with the GUI """ super().__init__() self.setupUi(self) self.overall_config = None self.index_manager = IndexManager(MAX_PLAYERS) self.agents = [] self.agent_presets = {} self.bot_names_to_agent_dict = {} self.loadout_presets = {} self.current_bot = None self.overall_config_timer = None self.setup_manager = None self.match_process = None self.overall_config = None self.overall_config_path = None self.launch_in_progress = False self.car_customisation = CarCustomisationDialog(self) self.agent_customisation = AgentCustomisationDialog(self) self.mutator_customisation = MutatorEditor(self) if os.path.isfile(DEFAULT_RLBOT_CONFIG_LOCATION): self.load_overall_config(DEFAULT_RLBOT_CONFIG_LOCATION) else: self.load_off_disk_overall_config() self.init_match_settings() self.update_match_settings() self.connect_functions() self.update_bot_type_combobox() def bot_item_drop_event(self, dropped_listwidget, event): """ Switches the team for the dropped agent to the other team :param dropped_listwidget: The listwidget belonging to the new team for the agent :param event: The QDropEvent containing the source :return: """ dragged_listwidget = event.source() if dragged_listwidget is dropped_listwidget: # drops in the same widget return self.current_bot.set_team(0 if dropped_listwidget == self.blue_listwidget else 1) self.update_teams_listwidgets() def fixed_indices(self): """ Agents in the GUI might not have following overall indices, thereby a file saved through the GUI would cause other bots to start than the GUI when ran :return: CustomConfig instance, copy of the overall config which has the indices sorted out """ config = self.overall_config.copy() used_indices = sorted(self.index_manager.numbers) not_used_indices = [e for e in range(MAX_PLAYERS) if e not in used_indices] order = used_indices + not_used_indices header = config[PARTICIPANT_CONFIGURATION_HEADER] for name, config_value in header.values.items(): old_values = list(config_value.value) for i in range(MAX_PLAYERS): config_value.set_value(old_values[order[i]], index=i) return config def run_button_pressed(self): if self.launch_in_progress: # Do nothing if we're already in the process of launching a configuration. # Attempting to run again when we're in this state can result in duplicate processes. # TODO: Add a mutex around this variable here for safety. return self.launch_in_progress = True if self.setup_manager is not None: self.setup_manager.shut_down(time_limit=5, kill_all_pids=False) # Leave any external processes alive, e.g. Java or C#, since it can # be useful to keep them around. The user can kill them with the # Kill Bots button instead. self.match_process = threading.Thread(target=self.start_match) self.match_process.start() def start_match(self): """ Starts a match with the current configuration :return: """ agent_configs_dict = {} loadout_configs_dict = {} for agent in self.agents: i, agent_config, loadout_config = agent.get_configs() agent_configs_dict[i] = agent_config loadout_configs_dict[i] = loadout_config agent_configs = {} loadout_configs = {} index = 0 for i in range(MAX_PLAYERS): if i in agent_configs_dict: agent_configs[index] = agent_configs_dict[i] loadout_configs[index] = loadout_configs_dict[i] index += 1 self.setup_manager = SetupManager() self.setup_manager.load_config(self.overall_config, self.overall_config_path, agent_configs, loadout_configs) self.setup_manager.connect_to_game() self.setup_manager.launch_ball_prediction() self.setup_manager.launch_quick_chat_manager() self.setup_manager.launch_bot_processes() self.setup_manager.start_match() self.launch_in_progress = False self.setup_manager.infinite_loop() def connect_functions(self): """ Connects all events to the functions which should be called :return: """ # Lambda is sometimes used to prevent passing the event parameter. self.cfg_load_pushbutton.clicked.connect(lambda: self.load_overall_config()) self.cfg_save_pushbutton.clicked.connect(lambda: self.save_overall_config()) self.blue_listwidget.itemSelectionChanged.connect(self.load_selected_bot) self.orange_listwidget.itemSelectionChanged.connect(self.load_selected_bot) self.blue_listwidget.dropEvent = lambda event: self.bot_item_drop_event(self.blue_listwidget, event) self.orange_listwidget.dropEvent = lambda event: self.bot_item_drop_event(self.orange_listwidget, event) self.blue_name_lineedit.editingFinished.connect(self.team_settings_edit_event) self.orange_name_lineedit.editingFinished.connect(self.team_settings_edit_event) self.blue_color_spinbox.valueChanged.connect(self.team_settings_edit_event) self.orange_color_spinbox.valueChanged.connect(self.team_settings_edit_event) self.blue_minus_toolbutton.clicked.connect(lambda e: self.remove_agent(self.current_bot)) self.orange_minus_toolbutton.clicked.connect(lambda e: self.remove_agent(self.current_bot)) self.blue_plus_toolbutton.clicked.connect(lambda e: self.add_agent_button(team_index=0)) self.orange_plus_toolbutton.clicked.connect(lambda e: self.add_agent_button(team_index=1)) for child in self.bot_config_groupbox.findChildren(QWidget): if isinstance(child, QLineEdit): child.editingFinished.connect(self.bot_config_edit_event) elif isinstance(child, QSlider): child.valueChanged.connect(self.bot_config_edit_event) elif isinstance(child, QRadioButton): child.toggled.connect(self.bot_config_edit_event) elif isinstance(child, QComboBox): child.currentTextChanged.connect(self.bot_config_edit_event) self.loadout_preset_toolbutton.clicked.connect(self.car_customisation.popup) self.agent_preset_toolbutton.clicked.connect(self.agent_customisation.popup) self.preset_load_toplevel_pushbutton.clicked.connect(self.load_preset_toplevel) for child in self.match_settings_groupbox.findChildren(QWidget): if isinstance(child, QComboBox): child.currentTextChanged.connect(self.match_settings_edit_event) elif isinstance(child, QCheckBox): child.toggled.connect(self.match_settings_edit_event) self.edit_mutators_pushbutton.clicked.connect(self.mutator_customisation.popup) self.kill_bots_pushbutton.clicked.connect(self.kill_bots) self.run_button.clicked.connect(self.run_button_pressed) def load_preset_toplevel(self): preset = self.agent_customisation.load_preset_cfg() if preset is None: return self.agent_preset_combobox.setCurrentText(preset.get_name()) loadout_preset = self.add_loadout_preset(preset.looks_path) self.car_customisation.update_presets_widgets() loadout_index = index_of_config_path_in_combobox(self.loadout_preset_combobox, loadout_preset.config_path) self.loadout_preset_combobox.setCurrentIndex(loadout_index) self.current_bot.set_loadout_preset(loadout_preset) def bot_config_edit_event(self, value=None): """ Handles the events called when editing a value regarding the bot configuration :param value: the new value to store in the config :return: """ sender = self.sender() if value is None: value = sender.text() agent = self.current_bot if sender is self.bot_type_combobox: self.update_bot_type_combobox() elif sender is self.blue_radiobutton and value: # 'and value' check to make sure that one got selected if agent.get_team() != 0: agent.set_team(0) self.update_teams_listwidgets() self.blue_listwidget.setCurrentItem(self.blue_listwidget.findItems( self.validate_name(agent.get_name(), agent), QtCore.Qt.MatchExactly)[0]) elif sender is self.orange_radiobutton and value: if agent.get_team() != 1: agent.set_team(1) self.update_teams_listwidgets() self.orange_listwidget.setCurrentItem(self.orange_listwidget.findItems( self.validate_name(agent.get_name(), agent), QtCore.Qt.MatchExactly)[0]) elif sender is self.ign_lineedit: if agent not in self.agents: return if not agent.get_team(): listwidget = self.blue_listwidget else: listwidget = self.orange_listwidget name = self.validate_name(value, agent) old_name = self.validate_name(agent.ingame_name, agent) row = listwidget.currentRow() del self.bot_names_to_agent_dict[old_name] agent.set_name(value) self.bot_names_to_agent_dict[name] = agent self.update_teams_listwidgets() listwidget.setCurrentRow(row) elif sender is self.loadout_preset_combobox: if self.bot_config_groupbox.isEnabled() and self.current_bot is not None: index = self.loadout_preset_combobox.currentIndex() preset = self.loadout_preset_combobox.itemData(index) self.current_bot.set_loadout_preset(preset) elif sender is self.agent_preset_combobox: if value and self.bot_config_groupbox.isEnabled() and self.current_bot is not None: preset = self.agent_preset_combobox.currentData() self.current_bot.set_agent_preset(preset) agent.set_name(agent.agent_preset.config.get(BOT_CONFIG_MODULE_HEADER, BOT_NAME_KEY)) self.ign_lineedit.setText(agent.ingame_name) if not agent.get_team(): listwidget = self.blue_listwidget else: listwidget = self.orange_listwidget row = listwidget.currentRow() self.update_teams_listwidgets() listwidget.setCurrentRow(row) loadout_index = index_of_config_path_in_combobox(self.loadout_preset_combobox, preset.looks_path) if loadout_index is not None: self.loadout_preset_combobox.setCurrentIndex(loadout_index) elif sender is self.bot_level_slider: agent.set_bot_skill(value / 100) if self.cfg_autosave_checkbutton.isChecked() and os.path.isfile(self.overall_config_path): self.save_overall_config(10) def update_bot_type_combobox(self): """ Handles selecting another bot type in the combobox, hides some frames and shows others depending on the setting Also saves the new type if there is a bot selected :return: """ bot_type = self.bot_type_combobox.currentText() if bot_type == 'RLBot': self.rlbot_frame.setHidden(False) self.extra_line.setHidden(False) self.psyonix_bot_frame.setHidden(True) self.appearance_frame.setHidden(False) self.label_3.setHidden(False) self.ign_lineedit.setHidden(False) elif bot_type == 'Psyonix': self.psyonix_bot_frame.setHidden(False) self.rlbot_frame.setHidden(True) self.extra_line.setHidden(False) self.appearance_frame.setHidden(False) self.label_3.setHidden(False) self.ign_lineedit.setHidden(False) elif bot_type == 'Human': self.psyonix_bot_frame.setHidden(True) self.rlbot_frame.setHidden(True) self.extra_line.setHidden(True) self.appearance_frame.setHidden(False) self.label_3.setHidden(True) self.ign_lineedit.setHidden(True) elif bot_type == 'Party Member Bot': self.rlbot_frame.setHidden(False) self.extra_line.setHidden(False) self.psyonix_bot_frame.setHidden(True) self.appearance_frame.setHidden(False) self.label_3.setHidden(True) self.ign_lineedit.setHidden(True) if self.bot_config_groupbox.isEnabled() and self.current_bot is not None: config_type = bot_type.lower().replace(" ", "_") self.current_bot.set_participant_type(config_type) def team_settings_edit_event(self, value=None): """ Handles the events when editing a value regarding the team settings :param value: the new value to store in the config :return: """ sender = self.sender() if value is None: value = sender.text() if sender is self.blue_name_lineedit: self.overall_config.set_value(TEAM_CONFIGURATION_HEADER, "Team Blue Name", value) elif sender is self.orange_name_lineedit: self.overall_config.set_value(TEAM_CONFIGURATION_HEADER, "Team Orange Name", value) elif sender is self.blue_color_spinbox: self.overall_config.set_value(TEAM_CONFIGURATION_HEADER, "Team Blue Color", value) elif sender is self.orange_color_spinbox: self.overall_config.set_value(TEAM_CONFIGURATION_HEADER, "Team Orange Color", value) if self.cfg_autosave_checkbutton.isChecked() and os.path.isfile(self.overall_config_path): self.save_overall_config(10) def update_team_settings(self): """ Sets all team settings widgets to the value in the overall config :return: """ self.blue_name_lineedit.setText(self.overall_config.get(TEAM_CONFIGURATION_HEADER, "Team Blue Name")) self.orange_name_lineedit.setText(self.overall_config.get(TEAM_CONFIGURATION_HEADER, "Team Orange Name")) self.blue_color_spinbox.setValue(self.overall_config.getint(TEAM_CONFIGURATION_HEADER, "Team Blue Color")) self.orange_color_spinbox.setValue(self.overall_config.getint(TEAM_CONFIGURATION_HEADER, "Team Orange Color")) def load_off_disk_overall_config(self): self.cfg_autosave_checkbutton.setChecked(False) self.cfg_autosave_checkbutton.setDisabled(True) if self.overall_config is None: self.overall_config = create_bot_config_layout() GUIAgent.overall_config = self.overall_config self.overall_config.init_indices(MAX_PLAYERS) self.overall_config_path = "" self.load_agents() # self.load_bot_directory(".") self.update_teams_listwidgets() if not self.overall_config_path: self.cfg_file_path_lineedit.setStyleSheet("border: 1px solid red;") self.cfg_file_path_lineedit.setText("Please load a configuration file") self.blue_plus_toolbutton.setEnabled(False) self.orange_plus_toolbutton.setEnabled(False) self.run_button.setEnabled(False) else: self.cfg_file_path_lineedit.setText(self.overall_config_path) self.update_team_settings() self.car_customisation.update_presets_widgets() self.agent_customisation.update_presets_widgets() self.mutator_customisation.update_comboboxes() def load_overall_config(self, config_path=None): """ Loads the overall config from the config path, or asks for a path if config_path is None :param config_path: the path to load the overall_config from, if None a path is requested :return: """ if self.overall_config is None: self.overall_config = create_bot_config_layout() GUIAgent.overall_config = self.overall_config if config_path is None: config_path = QFileDialog.getOpenFileName(self, "Load Overall Config", "", "Config Files (*.cfg)")[0] if not config_path: self.statusbar.showMessage("No file selected, not loading config", 5000) return if config_path is None or not os.path.isfile(config_path): return if pathlib.Path(config_path).suffix != '.cfg': self.popup_message("This file is not a config file!", "Invalid File Extension", QMessageBox.Warning) return raw_parser = configparser.RawConfigParser() raw_parser.read(config_path, encoding='utf8') for section in ['Match Configuration', 'Participant Configuration']: if not raw_parser.has_section(section): self.popup_message(f"Config file is missing the section {section}, not loading it!", "Invalid Config File", QMessageBox.Warning) return self.overall_config_path = config_path self.overall_config.parse_file(raw_parser, MAX_PLAYERS, config_directory=os.path.dirname(self.overall_config_path)) self.load_agents() # self.load_bot_directory(".") self.update_teams_listwidgets() self.cfg_file_path_lineedit.setText(self.overall_config_path) self.cfg_file_path_lineedit.setStyleSheet("") self.run_button.setEnabled(True) self.update_team_settings() self.car_customisation.update_presets_widgets() self.agent_customisation.update_presets_widgets() self.mutator_customisation.update_comboboxes() def save_overall_config(self, time_out=0): """ Schedules a save after given time_out :param time_out: The amount of seconds it should wait before saving :return: """ def save(): if not os.path.exists(self.overall_config_path): return self.overall_config_timer.setInterval(1000) if self.remaining_save_timer > 0: self.statusbar.showMessage("Saving Overall Config in " + str(self.remaining_save_timer) + " seconds") self.remaining_save_timer -= 1 else: self.clean_overall_config_loadouts() with open(self.overall_config_path, "w", encoding='utf8') as f: f.write(str(self.fixed_indices())) self.statusbar.showMessage("Saved Overall Config to " + self.overall_config_path, 5000) self.overall_config_timer.stop() if self.overall_config_timer is None: self.overall_config_timer = QTimer() self.overall_config_timer.timeout.connect(save) save_path = self.overall_config_path if save_path is None or not os.path.isfile(save_path): save_path = QFileDialog.getSaveFileName(self, "Save Overall Config", "", "Config Files (*.cfg)")[0] if not save_path: self.statusbar.showMessage("Unable to save the configuration without a path", 5000) return self.overall_config_path = save_path self.remaining_save_timer = time_out self.overall_config_timer.start(0) def clean_overall_config_loadouts(self): """ Set all unusued loadout paths to None. This makes sure agents don't have a custom loadout when new agents are added in the gui. """ for i in range(MAX_PLAYERS): if i not in self.index_manager.numbers: self.overall_config.set_value(PARTICIPANT_CONFIGURATION_HEADER, PARTICIPANT_LOADOUT_CONFIG_KEY, "None", i) def load_selected_bot(self): """ Loads all the values belonging to the new selected agent into the bot_config_groupbox :return: """ # prevent processing from itself (clearing the other one processes this) if not self.sender().selectedItems(): return blue = True if self.sender() is self.blue_listwidget else False if blue: # deselect the other listbox self.orange_listwidget.clearSelection() else: self.blue_listwidget.clearSelection() item_name = self.sender().selectedItems()[0].text() agent = self.bot_names_to_agent_dict[item_name] if agent is None: # something went wrong if agent is None return self.current_bot = agent self.bot_config_groupbox.setEnabled(True) # Make sure that you can edit the bot # enable [-] for right listwidget if blue: self.blue_minus_toolbutton.setDisabled(False) self.orange_minus_toolbutton.setDisabled(True) else: self.orange_minus_toolbutton.setDisabled(False) self.blue_minus_toolbutton.setDisabled(True) # load the bot parameters into the edit frame agent_type = agent.get_participant_type() known_types = ['human', 'psyonix', 'rlbot', 'party_member_bot'] assert agent_type in known_types, 'Bot has unknown type: %s' % agent_type self.bot_type_combobox.setCurrentIndex(known_types.index(agent_type)) if blue: self.blue_radiobutton.setChecked(True) else: self.orange_radiobutton.setChecked(True) self.ign_lineedit.setText(agent.ingame_name) loadout_index = index_of_config_path_in_combobox( self.loadout_preset_combobox, agent.get_loadout_preset().config_path) self.loadout_preset_combobox.setCurrentIndex(loadout_index or 0) self.agent_preset_combobox.blockSignals(True) self.agent_preset_combobox.setCurrentText(agent.get_agent_preset().get_name()) self.agent_preset_combobox.blockSignals(False) self.bot_level_slider.setValue(int(agent.get_bot_skill() * 100)) def update_teams_listwidgets(self): """ Clears all items from the listwidgets and then adds everything from the self.agents list again to the right team :return: """ self.bot_names_to_agent_dict.clear() self.blue_listwidget.clear() self.orange_listwidget.clear() for agent in self.agents: name = self.validate_name(agent.ingame_name, agent) if not agent.get_team(): self.blue_listwidget.addItem(name) else: self.orange_listwidget.addItem(name) self.bot_names_to_agent_dict[name] = agent self.enable_disable_on_bot_select_deselect() # if max bot count reached: disable + button if not self.index_manager.has_free_slots(): self.blue_plus_toolbutton.setDisabled(True) self.orange_plus_toolbutton.setDisabled(True) else: self.blue_plus_toolbutton.setDisabled(False) self.orange_plus_toolbutton.setDisabled(False) def enable_disable_on_bot_select_deselect(self): """ Disables the botconfig groupbox and minus buttons when no bot is selected :return: """ if not self.blue_listwidget.selectedItems() and not self.orange_listwidget.selectedItems(): self.bot_config_groupbox.setDisabled(True) self.blue_minus_toolbutton.setDisabled(True) self.orange_minus_toolbutton.setDisabled(True) else: self.bot_config_groupbox.setDisabled(False) def validate_name(self, name, agent): """ Finds the modification of name which is not yet in the list :param name: the (new) name for the agent :param agent: the agent instance to allow the same name as the previous one if necessary :return: the best modification of name not yet in a listwidget """ if name in self.bot_names_to_agent_dict and self.bot_names_to_agent_dict[name] is not agent: i = 0 while True: if name + " (" + str(i) + ")" in self.bot_names_to_agent_dict and \ self.bot_names_to_agent_dict[name + " (" + str(i) + ")"] is not agent: i += 1 else: value = name + " (" + str(i) + ")" return value else: return name def add_agent_button(self, team_index: int): """ The method to handle the [+] button press, adds an agent to the team :param team_index: the team to set for the new agent, 0 for blue and 1 for orange :return: """ agent = self.load_agent() if agent is None: return agent.set_team(team_index) self.car_customisation.update_presets_widgets() self.agent_customisation.update_presets_widgets() self.update_teams_listwidgets() if agent.get_team() == 0: self.blue_listwidget.setCurrentItem(self.blue_listwidget.findItems( self.validate_name(agent.get_name(), agent), QtCore.Qt.MatchExactly)[0]) else: self.orange_listwidget.setCurrentItem(self.orange_listwidget.findItems( self.validate_name(agent.get_name(), agent), QtCore.Qt.MatchExactly)[0]) def load_agents(self, config_file=None): """ Loads all agents for this team from the rlbot.cfg :param config_file: A config file that is similar to rlbot.cfg """ if config_file is not None: self.overall_config = config_file self.agents.clear() num_participants = get_num_players(self.overall_config) try: for i in range(num_participants): self.load_agent(i) except BaseException as e: raise ValueError(f"{str(e)}\nPlease check your config files! {self.overall_config_path}") def load_agent(self, overall_index: int=None): """ Loads all data for overall_index from the overall config and also loads both presets :param overall_index: the index of the targeted agent :return agent: an Agent (gui_agent) class with all loaded values """ if not self.index_manager.has_free_slots(): return None if overall_index is None: overall_index = self.index_manager.get_new_index() else: self.index_manager.use_index(overall_index) agent = self.add_agent(overall_index=overall_index) path_in_overall_config = agent.get_agent_config_path() if path_in_overall_config is None: # Fall back to the path of the first agent if there's nothing configured. path_in_overall_config = self.overall_config.getpath(PARTICIPANT_CONFIGURATION_HEADER, PARTICIPANT_CONFIG_KEY, 0) agent_preset = self.add_agent_preset(path_in_overall_config) agent.set_agent_preset(agent_preset) agent.set_name(agent_preset.config.get(BOT_CONFIG_MODULE_HEADER, BOT_NAME_KEY)) # Add the preset's loadout as a loadout own_loadout = self.add_loadout_preset(agent_preset.looks_path) # Agent has a loadout defined in overall config, load that if it is not None loadout_file_in_overall_config = self.overall_config.get(PARTICIPANT_CONFIGURATION_HEADER, PARTICIPANT_LOADOUT_CONFIG_KEY, overall_index) if loadout_file_in_overall_config is None or loadout_file_in_overall_config == "None": agent.set_loadout_preset(own_loadout) else: directory = get_python_root() file_path = loadout_file_in_overall_config loadout_file_in_overall_config = os.path.realpath(os.path.join(directory, file_path)) loadout_preset = self.add_loadout_preset(loadout_file_in_overall_config) agent.set_loadout_preset(loadout_preset) return agent def load_bot_config_bundle(self, config_bundle: BotConfigBundle): self.add_agent_preset(config_bundle.config_path) self.add_loadout_preset(config_bundle.looks_path) def load_bot_directory(self, directory): for bundle in scan_directory_for_bot_configs(directory): try: self.load_bot_config_bundle(bundle) except Exception as e: print(e) def add_agent(self, overall_index=None, team_index=None): """ Creates the agent using self.agent_class and adds it to the index manager. :param overall_index: The index of the bot in the config file if it already exists. :param team_index: The index of the team to place the agent in :return agent: an Agent (gui_agent) with either given index or a free one, returns None if there is no index given and all indices are occupied """ if overall_index is None: if not self.index_manager.has_free_slots(): return overall_index = self.index_manager.get_new_index() else: self.index_manager.use_index(overall_index) agent = GUIAgent(overall_index=overall_index) if team_index is not None: agent.set_team(team_index) self.agents.append(agent) self.overall_config.set_value(MATCH_CONFIGURATION_HEADER, PARTICIPANT_COUNT_KEY, len(self.agents)) return agent def remove_agent(self, agent: GUIAgent): """ Removes the given agent. :param agent: the agent to remove :return: """ self.index_manager.free_index(agent.overall_index) self.agents.remove(agent) self.update_teams_listwidgets() self.overall_config.set_value(MATCH_CONFIGURATION_HEADER, PARTICIPANT_COUNT_KEY, len(self.agents)) self.overall_config.set_value(PARTICIPANT_CONFIGURATION_HEADER, PARTICIPANT_LOADOUT_CONFIG_KEY, "None", agent.overall_index) if len(self.agents) == 0: return if agent.get_team() == 0: if self.blue_listwidget.count() != 0: self.blue_listwidget.setCurrentRow(self.blue_listwidget.count() - 1) else: self.orange_listwidget.setCurrentRow(self.orange_listwidget.count() - 1) else: if self.orange_listwidget.count() != 0: self.orange_listwidget.setCurrentRow(self.orange_listwidget.count() - 1) else: self.blue_listwidget.setCurrentRow(self.blue_listwidget.count() - 1) def add_loadout_preset(self, file_path: str): """ Loads a preset using file_path with all values from that path loaded :param file_path: the path to load the preset from, if invalid a default preset is returned :return preset: the loadout preset created """ if file_path is not None and os.path.isfile(file_path): name = pathlib.Path(file_path).stem else: name = "new preset" if file_path in self.loadout_presets: return self.loadout_presets[file_path] preset = LoadoutPreset(name, file_path) self.loadout_presets[preset.config_path] = preset return preset def add_agent_preset(self, file_path): """ Loads a preset using file_path with all values from that path loaded :param file_path: the path to load the preset from. We'll throw an exception if it's invalid. :return preset: the agent preset created """ if file_path is not None and os.path.isfile(file_path): name = pathlib.Path(file_path).stem else: raise FileNotFoundError(f"File path {file_path} is not found!") if name in self.agent_presets: if self.agent_presets[name].config_path == file_path: return self.agent_presets[name] else: i = 1 for preset_name in self.agent_presets: if name in preset_name: i += 1 name = f"{name} ({i})" preset = AgentPreset(name, file_path) self.agent_presets[preset.get_name()] = preset return preset def init_match_settings(self): """ Adds all items to the match settings comboboxes :return: """ self.mode_type_combobox.addItems(game_mode_types) self.map_type_combobox.addItems(map_types) def update_match_settings(self): """ Sets all match setting widgets to the values in the overall config :return: """ self.mode_type_combobox.setCurrentText(self.overall_config.get(MATCH_CONFIGURATION_HEADER, GAME_MODE)) self.map_type_combobox.setCurrentText(self.overall_config.get(MATCH_CONFIGURATION_HEADER, GAME_MAP)) self.skip_replays_checkbox.setChecked(self.overall_config.getboolean(MATCH_CONFIGURATION_HEADER, SKIP_REPLAYS)) self.instant_start_checkbox.setChecked( self.overall_config.getboolean(MATCH_CONFIGURATION_HEADER, INSTANT_START)) def match_settings_edit_event(self, value): """ Handles all edits to match settings and sets the config value to the new value :param value: the value to apply to the overall config :return: """ sender = self.sender() if sender is self.mode_type_combobox: self.overall_config.set_value(MATCH_CONFIGURATION_HEADER, GAME_MODE, value) elif sender is self.map_type_combobox: self.overall_config.set_value(MATCH_CONFIGURATION_HEADER, GAME_MAP, value) elif sender is self.skip_replays_checkbox: self.overall_config.set_value(MATCH_CONFIGURATION_HEADER, SKIP_REPLAYS, value) elif sender is self.instant_start_checkbox: self.overall_config.set_value(MATCH_CONFIGURATION_HEADER, INSTANT_START, value) elif sender is self.match_length_combobox: self.overall_config.set_value(MUTATOR_CONFIGURATION_HEADER, MUTATOR_MATCH_LENGTH, value) elif sender is self.boost_type_combobox: self.overall_config.set_value(MUTATOR_CONFIGURATION_HEADER, MUTATOR_BOOST_AMOUNT, value) if self.cfg_autosave_checkbutton.isChecked() and os.path.isfile(self.overall_config_path): self.save_overall_config(10) def popup_message(self, message: str, title: str, icon=QMessageBox.Warning): popup = QMessageBox(self) popup.setIcon(icon) popup.setWindowTitle(title) popup.setText(message) popup.setStandardButtons(QMessageBox.Ok) popup.exec_() def kill_bots(self): if self.setup_manager is not None: self.setup_manager.shut_down(time_limit=5, kill_all_pids=True) else: print("There gotta be some setup manager already") @staticmethod def main(): """ Start the GUI :return: """ app = QApplication(sys.argv) rlbot_icon = QtGui.QIcon(os.path.join(get_rlbot_directory(), 'img', 'rlbot_icon.png')) app.setWindowIcon(rlbot_icon) window = RLBotQTGui() window.show() app.exec_()
class PokebotTrainer(BaseScript): def __init__(self): super().__init__("Pokebot Trainer") self.action_broker = MyActionBroker(self) self.active_bots: List[ActiveBot] = [] self.available_bots: Dict[str, BotConfigBundle] = {b.name: b for b in self.get_bots()} self.available_bot_names: List[str] = list(self.available_bots.keys()) self.available_bot_names.sort() self.logger.info(f"Pokebot trainer has: {self.available_bots.keys()}") self.setup_manager = SetupManager() self.ready = False self.requested_relaunch: MatchConfig = None self.bots_pending_post_spawn_processing: List[ActiveBot] = [] def index_from_spawn_id(self, spawn_id): packet = self.game_tick_packet for n in range(0, packet.num_cars): packet_spawn_id = packet.game_cars[n].spawn_id if spawn_id == packet_spawn_id: return n return None def heartbeat_connection_attempts_to_twitch_broker(self, port): register_api_config = Configuration() register_api_config.host = f"http://127.0.0.1:{STANDARD_TWITCH_BROKER_PORT}" twitch_broker_register = RegisterApi(ApiClient(configuration=register_api_config)) while True: try: twitch_broker_register.register_action_server( ActionServerRegistration(base_url=f"http://127.0.0.1:{port}")) except MaxRetryError: self.logger.warning('Failed to register with twitch broker, will try again...') sleep(10) def get_bots(self): return scan_directory_for_bot_configs(BOT_DIRECTORY) def get_actions_currently_available(self) -> List[AvailableActions]: actions = [] for name in self.available_bot_names: blue_text = highlight_team_color(f"blue {name}", 0) actions.append(BotAction(description=f"Spawn {blue_text}", action_type=SPAWN, data={'name': name, 'team': 0})) for name in self.available_bot_names: orange_text = highlight_team_color(f"orange {name}", 1) actions.append(BotAction(description=f"Spawn {orange_text}", action_type=SPAWN, data={'name': name, 'team': 1})) return [AvailableActions(self.name, None, actions)] def process_choice(self, choice: BotAction): if not self.setup_manager.has_started: self.logger.error(f"Tried to {choice.description} before the setup manager was fully started!") return if choice.action_type == SPAWN: name = choice.data['name'] team = choice.data['team'] bundle = self.available_bots[name] names = set([ab.name for ab in self.active_bots if ab is not None]) unique_name = name[:31] count = 2 while unique_name in names: unique_name = f'{name[:27]} ({count})' # Truncate at 27 because we can have up to '(10)' appended count += 1 new_bot = ActiveBot(unique_name, team, randint(1, 2**31 - 1), self.game_tick_packet.game_info.seconds_elapsed, bundle) try: none_index = self.active_bots.index(None) self.active_bots[none_index] = new_bot except ValueError: self.active_bots.append(new_bot) self.bots_pending_post_spawn_processing.append(new_bot) self.set_pending_relaunch_config(self.active_bots) def set_pending_relaunch_config(self, active_bots: List[ActiveBot]): match_config = MatchConfig() match_config.player_configs = [player_config_from_active_bot(ab) for ab in active_bots] match_config.game_mode = 'Soccer' match_config.game_map = 'DFHStadium' match_config.existing_match_behavior = 'Continue And Spawn' match_config.mutators = MutatorConfig() self.requested_relaunch = match_config def execute_relaunch(self): match_config = self.requested_relaunch if match_config is None: return self.requested_relaunch = None self.setup_manager.load_match_config(match_config) self.setup_manager.start_match() self.setup_manager.launch_bot_processes(match_config=match_config) self.setup_manager.try_recieve_agent_metadata() self.logger.info("Done relaunching bots") if GIVE_BOOST: car_states = {} self.get_game_tick_packet() for bot in self.bots_pending_post_spawn_processing: index = self.index_from_spawn_id(bot.spawn_id) if index is not None: car_states[index] = CarState(boost_amount=100) self.set_game_state(GameState(cars=car_states)) self.bots_pending_post_spawn_processing.clear() def start(self): port = find_usable_port(9886) Thread(target=run_action_server, args=(port,), daemon=True).start() set_bot_action_broker(self.action_broker) Thread(target=self.heartbeat_connection_attempts_to_twitch_broker, args=(port,), daemon=True).start() self.setup_manager.connect_to_game() self.ready = True while True: self.get_game_tick_packet() self.setup_manager.try_recieve_agent_metadata() game_seconds = self.game_tick_packet.game_info.seconds_elapsed needs_relaunch = False next_bots: List[ActiveBot] = [] for b in self.active_bots: if b is not None and game_seconds > b.join_time + LIFESPAN: next_bots.append(None) needs_relaunch = True else: next_bots.append(b) if needs_relaunch: while len(next_bots) > 0 and next_bots[-1] is None: next_bots.pop() # Get rid of any trailing None values. self.active_bots = next_bots self.set_pending_relaunch_config(next_bots) self.execute_relaunch() sleep(0.1)
class TestSpawner: def __init__(self, python_file: Path, standalone_bot_config: StandaloneBotConfig, bundle: BotConfigBundle): self.python_file = python_file self.standalone_bot_config = standalone_bot_config self.bundle = bundle self.player_config: PlayerConfig = None self.setup_manager: SetupManager = None self.spawn_id = self.create_spawn_id() self.player_index = standalone_bot_config.player_index or 0 self.team = standalone_bot_config.team or 0 self.name = self.get_bot_name() def get_bot_name(self) -> str: if self.bundle is not None: return self.bundle.name if self.standalone_bot_config.name is not None: print( f'Spawning your bot with the name {self.standalone_bot_config.name} because no config path was provided!' ) return self.standalone_bot_config.name print( f'Spawning your bot with the name {self.python_file.name} because no config path was provided!' ) return self.python_file.name def create_spawn_id(self): """ We want a spawn id unique to the python file which will be stable across re-runs. """ hash = hashlib.sha1(str(self.python_file).encode('utf-8')) number_form = int(hash.hexdigest(), 16) return number_form % FLATBUFFER_MAX_INT def create_player_config(self, config_path: str) -> PlayerConfig: player_config = PlayerConfig() player_config.bot = True player_config.rlbot_controlled = True player_config.bot_skill = 1 player_config.human_index = 0 player_config.name = self.name player_config.team = 0 player_config.config_path = config_path player_config.spawn_id = self.spawn_id return player_config def build_match_config(self, player_config_path: str): if self.player_config is None: self.player_config = self.create_player_config(player_config_path) match_config = MatchConfig() match_config.player_configs = [self.player_config] match_config.game_mode = 'Soccer' match_config.game_map = 'DFHStadium' match_config.existing_match_behavior = 'Continue And Spawn' match_config.mutators = MutatorConfig() match_config.enable_state_setting = True match_config.enable_rendering = True return match_config def spawn_bot(self): config_path = None if self.bundle is not None: config_path = self.bundle.config_path match_config = self.build_match_config(config_path) if self.setup_manager is None: self.setup_manager = SetupManager() rlbot_gateway_process, _ = gateway_util.find_existing_process() if rlbot_gateway_process is None: # RLBot.exe is not running yet, we should use the Restart behavior. # That avoids a situation where dead cars start piling up when # RLBot.exe gets killed and re-launched over and over and lacks context # to clean up previous cars. match_config.existing_match_behavior = 'Restart' self.setup_manager.connect_to_game() self.setup_manager.load_match_config(match_config) self.setup_manager.start_match()
def ensure_dll_is_injected(): manager = SetupManager() manager.startup()