def __init__(self):
super().__init__()
self.register_signal("COMPLETE")
self.register_signal("FADEOUT")
self.star_lower_bound = config.get("split_final_star",
"star_lower_bound")
self.star_upper_bound = config.get("split_final_star",
"star_upper_bound")
def __init__(self, ):
super().__init__()
self.register_signal("FOUND")
self.register_signal("FADEOUT")
self.portal_lower_bound = config.get("split_ddd_enter",
"portal_lower_bound")
self.portal_upper_bound = config.get("split_ddd_enter",
"portal_upper_bound")
def __init__(self, ):
super().__init__()
self.register_signal("ENTERED")
self.register_signal("FADEOUT")
self.bowser_lower_bound = config.get("split_final_star",
"stage_lower_bound")
self.bowser_upper_bound = config.get("split_final_star",
"stage_upper_bound")
def __init__(self):
super().__init__()
self.register_signal("FADEOUT")
self.register_signal("COMPLETE")
self._star_skip_enabled = config.get("general", "mid_run_start_enabled")
self._prev_prediction = -1
self._jump_predictions = 0
self._restart_split_delay = 1.2012 + (config.get("advanced", "file_select_frame_offset") / 29.97)
def __init__(self, ):
super().__init__()
self.register_signal("ENTERED")
self.register_signal("FADEOUT")
self.lower_bound = np.array(config.get("split_ddd_enter",
"hat_lower_bound"),
dtype="uint8")
self.upper_bound = np.array(config.get("split_ddd_enter",
"hat_upper_bound"),
dtype="uint8")
def __init__(self):
super().__init__()
self.register_signal("SPAWNED")
self.register_signal("FADEOUT")
self._iteration_value = {0: 1, 1: 4, 2: 1}
self._looping_iteration = 0
self.star_lower_bound = config.get("split_final_star",
"star_lower_bound")
self.star_upper_bound = config.get("split_final_star",
"star_upper_bound")
def __init__(self):
super().__init__()
self.register_signal("FADEOUT")
self.register_signal("START")
self._star_skip_enabled = config.get("general", "mid_run_start_enabled")
self._prev_prediction = -1
self._jump_predictions = 0
def initialize(self):
# Configure window
self.setWindowTitle(self.title)
if config.get("general", "on_top"):
self.setWindowFlags(QtCore.Qt.FramelessWindowHint
| QtCore.Qt.WindowStaysOnTopHint)
else:
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setFixedSize(self.width, self.height)
# Configure Central Widget
self.central_widget.setObjectName("central_widget")
self.central_widget.setStyleSheet(
r"QWidget#central_widget{background-image: url(" +
resource_path(constants.BACKGROUND_PATH) +
"); background-attachment: fixed;}")
self.setCentralWidget(self.central_widget)
# Configure Other Widgets
self.close_btn.move(340, 8)
self.minimize_btn.move(320, 8)
self.star_btn.move(250, 68)
self.star_count.setFixedWidth(150)
self.star_count.move(197, 115)
self.star_count.setFont(self.start_count_font)
self.star_count.star_count = "-"
self.star_count.split_star = "-"
self.start_btn.move(206, 200)
self.start_btn.setFont(self.button_font)
self.start_btn.setTextColour(QtGui.QColor(225, 227, 230))
self.start_btn.add_state("start", self.start_pixmap, "Start")
self.start_btn.add_state("stop", self.stop_pixmap, "Stop")
self.start_btn.add_state("init", self.init_pixmap, "Initializing..")
self.start_btn.set_state("start")
self.split_list.setFont(self.button_font)
self.split_list.setFixedSize(183, self.height)
self.split_list.move(0, 0)
self.open_route()
# Connections
self.close_btn.clicked.connect(self.close)
self.minimize_btn.clicked.connect(self.showMinimized)
self.start_btn.clicked.connect(self.start_clicked)
self.star_btn.clicked.connect(self._reset)
self.dialogs["route_editor"].route_updated.connect(
self._on_route_update)
self.dialogs["settings_dialog"].applied.connect(self.settings_updated)
self.dialogs["capture_editor"].applied.connect(self._reset)
self.dialogs["update_dialog"].ignore_btn.clicked.connect(
lambda: self.ignore_update.emit())
self.dialogs["update_dialog"].update_btn.clicked.connect(
lambda: self.install_update.emit())
def run(self):
self._running = True
reset_occurred = False
frame = 0
generated_frames = []
while self._running:
c_time = time.time()
try:
self._game_capture.capture()
except:
self.error.emit("Unable to capture " +
config.get("game", "process_name"))
self.stop()
break
reset_region = self._game_capture.get_region(RESET_REGION)
fadeout_region = self._game_capture.get_region(FADEOUT_REGION)
if is_black(fadeout_region, 0.1, 0.97):
reset_occurred = True
if reset_occurred:
if not is_black(fadeout_region,
config.get("thresholds", "black_threshold"),
0.99):
frame += 1
if frame <= self.CAPTURE_COUNT:
generated_frames.append(reset_region)
else:
self._running = False
try:
time.sleep((1 / 29.97) - (time.time() - c_time))
except ValueError:
pass
for i, frame in enumerate(generated_frames):
cv2.imwrite(
ResetGeneratorDialog.TEMPLATE_DIR + "generated_temp_" +
str(i + 1) + ".jpg", frame)
self.generated.emit()
def open_route(self):
self._reset()
if config.get("route", "path") == "":
return
#try:
route = route_loader.load(config.get("route", "path"))
# except KeyError:
# self.display_error_message("Key Error", "Route Error")
# return False
if not route:
self.display_error_message("Could not load route", "Route Error")
self._load_route_dir()
config.set_key("route", "path", "")
config.save_config()
return False
error = route_loader.validate_route(route)
if error:
self.display_error_message(error, "Route Error")
return False
self.route = route
self.split_list.clear()
self.star_count.star_count = route.initial_star
self.star_count.split_star = route.splits[0].star_count
for split in route.splits:
split_icon_path = split.icon_path
if split_icon_path:
split_icon_path = rel_to_abs(split_icon_path)
icon = QtGui.QPixmap(split_icon_path)
else:
icon = None
self.split_list.add_split(split.title, icon)
self.split_list.repaint()
return True
def _is_reset(self, region, template):
match = cv2.minMaxLoc(cv2.matchTemplate(region,
template,
cv2.TM_SQDIFF_NORMED))[0]
if match < config.get("thresholds", "reset_threshold"):
return True
else:
return False
def show(self):
# Load game_region from preferences
game_region = config.get('game', 'game_region')
self.game_region_selector.resize(game_region[2], game_region[3])
self.game_region_selector.setPos(game_region[0], game_region[1])
self.game_region_panel.update_text(*[str(v) for v in game_region])
self._refresh_process_list()
p_name = config.get("game", "process_name")
for i in range(len(self._process_list)):
if self._process_list[i][0].name() == p_name:
self.process_combo.setCurrentIndex(i)
self.refresh_graphics_scene()
config.create_rollback()
super().show()
def _save_open_route(self, file_path):
prev_route = config.get("route", "path")
config.set_key("route", "path", file_path)
config.save_config()
success = self.open_route()
if success:
return
else:
config.set_key("route", "path", prev_route)
config.save_config()
self.open_route()
def _reset(self):
if not config.get("general", "srl_mode"):
if as64core.current_time - as64core.last_split < self._undo_threshold:
as64core.undo()
as64core.reset()
if as64core.start_on_reset:
as64core.split()
as64core.enable_fade_count(False)
as64core.enable_xcam_count(False)
as64core.set_in_game(False)
as64core.star_count = as64core.route.initial_star
def __init__(self):
super().__init__()
self.register_signal("RESET")
self.register_signal("COMPLETE")
self._fps = config.get("advanced", "fadeout_process_frame_rate")
self._reset_threshold = config.get("thresholds", "reset_threshold")
self._black_threshold = config.get("thresholds", "black_threshold")
self._undo_threshold = config.get("thresholds", "undo_threshold")
_, _, reset_width, reset_height = as64core.get_region_rect(as64core.RESET_REGION)
self._reset_template = cv2.resize(cv2.imread(resource_path(config.get("advanced", "reset_frame_one"))),
(reset_width, reset_height), interpolation=cv2.INTER_AREA)
self._reset_template_2 = cv2.resize(cv2.imread(resource_path(config.get("advanced", "reset_frame_two"))),
(reset_width, reset_height), interpolation=cv2.INTER_AREA)
def __init__(self):
super().__init__()
self._running = False
self._game_capture = GameCapture(config.get("game", "process_name"),
config.get("game", "game_region"),
GAME_JP)
def contextMenuEvent(self, event):
context_menu = QtWidgets.QMenu(self)
route_menu = QtWidgets.QMenu("Open Route")
route_actions = {}
category_menus = {}
# SRL MODE Action
srl_action = QtWidgets.QAction("SRL Mode", self, checkable=True)
context_menu.addAction(srl_action)
srl_action.setChecked(config.get("general", "srl_mode"))
context_menu.addSeparator()
for category in sorted(
self._routes,
key=lambda text:
[int(c) if c.isdigit() else c for c in re.split(r'(\d+)', text)]):
if len(self._routes[category]) == 1 or category == "":
for route in self._routes[category]:
route_menu.addAction(route[0])
route_actions[route[0]] = partial(self._save_open_route,
route[1])
else:
category_menus[category] = QtWidgets.QMenu(str(category))
route_menu.addMenu(category_menus[category])
for route in self._routes[category]:
category_menus[category].addAction(route[0])
route_actions[route[0]] = partial(self._save_open_route,
route[1])
route_menu.addSeparator()
file_action = route_menu.addAction("From File")
# Actions
edit_route = context_menu.addAction("Edit Route")
context_menu.addMenu(route_menu)
context_menu.addSeparator()
cords_action = context_menu.addAction("Edit Coordinates")
context_menu.addSeparator()
advanced_action = context_menu.addAction("Settings")
context_menu.addSeparator()
reset_gen_action = context_menu.addAction("Generate Reset Templates")
context_menu.addSeparator()
output_action = context_menu.addAction("Show Output")
context_menu.addSeparator()
on_top_action = QtWidgets.QAction("Always On Top",
self,
checkable=True)
context_menu.addAction(on_top_action)
on_top_action.setChecked(config.get("general", "on_top"))
context_menu.addSeparator()
about_action = context_menu.addAction("About")
update_action = context_menu.addAction("Check for Updates..")
context_menu.addSeparator()
exit_action = context_menu.addAction("Exit")
action = context_menu.exec_(self.mapToGlobal(event.pos()))
# Connections
if action == srl_action:
checked = srl_action.isChecked()
config.set_key("general", "srl_mode", checked)
config.save_config()
elif action == edit_route:
self.dialogs["route_editor"].show()
elif action == file_action:
self.open_route_browser()
elif action == cords_action:
self.dialogs["capture_editor"].show()
try:
self.dialogs["output_dialog"].close()
except AttributeError:
pass
elif action == advanced_action:
self.dialogs["settings_dialog"].show()
elif action == reset_gen_action:
self.dialogs["reset_dialog"].show()
elif action == output_action:
self.dialogs["output_dialog"].show()
elif action == on_top_action:
checked = on_top_action.isChecked()
config.set_key("general", "on_top", checked)
config.save_config()
self.set_always_on_top(config.get("general", "on_top"))
elif action == about_action:
self.dialogs["about_dialog"].show()
elif action == update_action:
self.check_update.emit()
elif action == exit_action:
self.close()
else:
try:
route_actions[action.text()]()
except (KeyError, AttributeError):
pass
def execute(self):
if as64core.fade_status in (as64core.FADEOUT_COMPLETE, as64core.FADEOUT_PARTIAL):
return self.signals["FADEOUT"]
else:
if as64core.split_index() > 0:
prev_split_star = as64core.route.splits[as64core.split_index()-1].star_count
else:
prev_split_star = as64core.route.initial_star
if as64core.prediction_info.prediction == as64core.star_count and as64core.prediction_info.probability > config.get("thresholds", "probability_threshold"):
as64core.enable_fade_count(True)
as64core.enable_xcam_count(True)
return self.signals["START"]
elif self._star_skip_enabled and prev_split_star <= as64core.prediction_info.prediction <= as64core.current_split().star_count and as64core.prediction_info.probability > config.get("thresholds", "probability_threshold"):
if as64core.prediction_info.prediction == self._prev_prediction:
self._jump_predictions += 1
else:
self._jump_predictions = 0
if self._jump_predictions >= 4:
as64core.enable_fade_count(True)
as64core.enable_xcam_count(True)
as64core.set_star_count(as64core.prediction_info.prediction)
self._jump_predictions = 0
self._prev_prediction = -1
return self.signals["START"]
self._prev_prediction = as64core.prediction_info.prediction
return self.signals["LOOP"]
def __init__(self,):
super().__init__()
self.register_signal("RESET")
self._restart_split_delay = config.get("advanced", "restart_split_delay")
def on_transition(self):
as64core.fps = config.get("advanced", "star_process_frame_rate")
as64core.enable_predictions(True)
as64core.enable_xcam_count(True)
super().on_transition()
def execute(self):
region = as64core.get_region(as64core.FADEOUT_REGION)
if as64core.fade_status in (as64core.FADEOUT_COMPLETE, as64core.FADEOUT_PARTIAL):
return self.signals["FADEOUT"]
else:
if as64core.split_index() > 0:
prev_split_star = as64core.route.splits[as64core.split_index() - 1].star_count
else:
prev_split_star = as64core.route.initial_star
if as64core.prediction_info.prediction == as64core.star_count and as64core.prediction_info.probability > config.get(
"thresholds", "probability_threshold"):
as64core.enable_fade_count(True)
as64core.enable_xcam_count(True)
as64core.set_in_game(True)
return self.signals["COMPLETE"]
elif self._star_skip_enabled and prev_split_star <= as64core.prediction_info.prediction <= as64core.current_split().star_count and as64core.prediction_info.probability > config.get(
"thresholds", "probability_threshold"):
if as64core.prediction_info.prediction == self._prev_prediction:
self._jump_predictions += 1
else:
self._jump_predictions = 0
if self._jump_predictions >= 4:
as64core.enable_fade_count(True)
as64core.enable_xcam_count(True)
as64core.set_star_count(as64core.prediction_info.prediction)
self._jump_predictions = 0
self._prev_prediction = -1
as64core.set_in_game(True)
return self.signals["COMPLETE"]
self._prev_prediction = as64core.prediction_info.prediction
if as64core.fadein_count == 2:
region_int = region.astype(int)
region_int_b, region_int_g, region_int_r = region_int.transpose(2, 0, 1)
mask = (np.abs(region_int_r - region_int_g) > 25)
region[mask] = [0, 0, 0]
if np.any(region == [0, 0, 0]):
try:
time.sleep(self._restart_split_delay)
except ValueError:
pass
as64core.fadein_count = 0
as64core.fadeout_count = 0
as64core.split()
as64core.set_in_game(True)
return self.signals["COMPLETE"]
return self.signals["LOOP"]
def settings_updated(self):
self.set_always_on_top(config.get("general", "on_top"))
self._reset()
