AutoSplit64plusLinux/AutoSplit64.py at master · SmolAlli/AutoSplit64plusLinux · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
import sys
import os
from threading import Thread
import logging
from PyQt6 import QtCore, QtWidgets, QtGui
from as64gui.app import App
import as64core
from as64core.processing import register_process, insert_global_hook, insert_global_processor_hook, ProcessorGenerator
from as64core.route_loader import load
from as64processes.standard import *
from as64processes.xcam import *
from as64processes.ddd import *
from as64processes.final import *

class AutoSplit64(QtCore.QObject):
    error = QtCore.pyqtSignal(str)
    update_found = QtCore.pyqtSignal(dict)

    def __init__(self, parent=None):
        super().__init__(parent=parent)

        # Initialize GUI
        self.app = App()

        # Connections
        self.app.start.connect(lambda: Thread(target=self.start).start())
        self.app.stop.connect(self.stop)
        self.app.destroyed.connect(lambda: self.stop())
        self.error.connect(self.app.display_error_message)

    def start(self):
        as64core.init()


        if not os.path.exists(resource_path(config.get("advanced", "reset_frame_one"))) or not os.path.exists(resource_path(config.get("advanced", "reset_frame_two"))):
            self.on_error("Reset template files are missing!\n\nPlease generate reset templates first.")
            return

        register_process("WAIT", ProcessWait())
        register_process("RUN_START", ProcessRunStart())
        register_process("RUN_START_UP_RTA", ProcessRunStartUpSegment())
        register_process("STAR_COUNT", ProcessStarCount())
        register_process("FADEIN", ProcessFadein())
        register_process("FADEOUT", ProcessFadeout())
        register_process("FADEOUT_NO_STAR", ProcessFadeoutNoStar())
        register_process("FADEOUT_RESET_ONLY", ProcessFadeoutResetOnly())
        register_process("POST_FADEOUT", ProcessPostFadeout())
        register_process("FLASH_CHECK", ProcessFlashCheck())
        register_process("RESET", ProcessReset())
        register_process("DUMMY", ProcessDummy())

        register_process("XCAM", ProcessXCam())
        register_process("XCAM_UP_RTA", ProcessXCamStartUpSegment())

        register_process("FILE_SELECT_SPLIT", ProcessFileSelectSplit())

        register_process("FIND_DDD_PORTAL", ProcessFindDDDPortal())
        register_process("DDD_SPLIT", ProcessDDDEntry())  # TODO: RENAME ProcessDDDEntry to ProcessDDDSplit
        register_process("DDD_SPLIT_X", ProcessDDDEntryX())  # TODO: RENAME ProcessDDDEntryX to ProcessDDDSplitX

        register_process("FINAL_DETECT_ENTRY", ProcessFinalStageEntry())  # TODO: RENAME
        register_process("FINAL_DETECT_SPAWN", ProcessFinalStarSpawn())  # TODO: RENAME
        register_process("FINAL_STAR_SPLIT", ProcessFinalStarGrab())  # TODO: RENAME to FINAL_STAR_SPLIT

        try:
            timing = load(config.get("route", "path")).timing
        except AttributeError:
            timing = None

        if timing == as64core.TIMING_UP_RTA:
            insert_global_hook("RESET", ProcessResetNoStart())
            as64core.start_on_reset = False
            initial_processor = ProcessorGenerator.generate("logic/up_rta/initial_up_rta.processor")
        elif timing == as64core.TIMING_FILE_SELECT:
            insert_global_hook("RESET", ProcessResetNoStart())
            as64core.start_on_reset = False
            initial_processor = ProcessorGenerator.generate("logic/file_select/initial_file_select_start.processor")
        else:
            initial_processor = ProcessorGenerator.generate("logic/standard/initial.processor")

        standard_processor = ProcessorGenerator.generate("logic/standard/star_fade.processor")
        fade_only_processor = ProcessorGenerator.generate("logic/standard/fade_only.processor")
        xcam_processor = ProcessorGenerator.generate("logic/standard/xcam_split.processor")
        ddd_processor = ProcessorGenerator.generate("logic/ddd/ddd.processor")
        mips_x_processor = ProcessorGenerator.generate("logic/ddd/mips_x.processor")
        final_processor = ProcessorGenerator.generate("logic/final/final.processor")

        as64core.register_split_processor(as64core.SPLIT_INITIAL, initial_processor)
        as64core.register_split_processor(as64core.SPLIT_NORMAL, standard_processor)
        as64core.register_split_processor(as64core.SPLIT_FADE_ONLY, fade_only_processor)
        as64core.register_split_processor(as64core.SPLIT_MIPS, ddd_processor)
        as64core.register_split_processor(as64core.SPLIT_MIPS_X, mips_x_processor)
        as64core.register_split_processor(as64core.SPLIT_FINAL, final_processor)
        as64core.register_split_processor(as64core.SPLIT_XCAM, xcam_processor)

        as64core.set_update_listener(self.on_update)
        as64core.set_error_listener(self.on_error)
        as64core.set_start_listener(self.on_start)

        as64core.start()

    def stop(self):
        as64core.stop()

    def on_start(self):
        self.app.set_started(True)

    def on_update(self, index, star_count, split_star):
        self.app.update_display(index, star_count, split_star)

    def on_error(self, error):
        self.error.emit(error)
        self.app.set_started(False)

    def exit(self):
        self.stop()
        self.app.close()


if __name__ == "__main__":
    # Create QT Application
    qt_app = QtWidgets.QApplication(sys.argv)

    # Configure QT Application Style
    qt_app.setStyle('Fusion')

    palette = QtGui.QPalette()
    palette.setColor(QtGui.QPalette.ColorRole.Window, QtGui.QColor(60, 63, 65))
    palette.setColor(QtGui.QPalette.ColorRole.WindowText, QtGui.QColor(200, 203, 207))
    palette.setColor(QtGui.QPalette.ColorRole.Link, QtGui.QColor(88, 157, 246))
    palette.setColor(QtGui.QPalette.ColorRole.Base, QtGui.QColor(23, 25, 27))
    palette.setColor(QtGui.QPalette.ColorRole.AlternateBase, QtGui.QColor(53, 55, 57))
    palette.setColor(QtGui.QPalette.ColorRole.ToolTipBase, QtGui.QColor(255, 255, 255))
    palette.setColor(QtGui.QPalette.ColorRole.ToolTipText, QtGui.QColor(255, 255, 255))
    palette.setColor(QtGui.QPalette.ColorRole.Text, QtGui.QColor(200, 203, 207))
    palette.setColor(QtGui.QPalette.ColorRole.Button, QtGui.QColor(53, 55, 57))
    palette.setColor(QtGui.QPalette.ColorRole.ButtonText, QtGui.QColor(200, 203, 207))
    palette.setColor(QtGui.QPalette.ColorRole.BrightText, QtGui.QColor(255, 0, 0))
    palette.setColor(QtGui.QPalette.ColorRole.Highlight, QtGui.QColor(75, 110, 175))
    palette.setColor(QtGui.QPalette.ColorRole.HighlightedText, QtGui.QColor(0, 0, 0))
    palette.setColor(QtGui.QPalette.ColorRole.Light, QtGui.QColor(105, 108, 112))
    palette.setColor(QtGui.QPalette.ColorRole.Dark, QtGui.QColor(12, 12, 12))

    qt_app.setPalette(palette)

    # Add font to database
    QtGui.QFontDatabase.addApplicationFont(resource_path("resources/gui/font/TCM_____.ttf"))

    logging.basicConfig(
        level=logging.WARNING,
        format='%(asctime)s:%(levelname)s:%(name)s:%(message)s',
        filename=".log",
        filemode='a'
    )

    # Create main application
    autosplit64 = AutoSplit64(qt_app)

    # Exit
    sys.exit(qt_app.exec())