def rebuild_db(self):
self.write()
def bad_asset_dialog():
dialog = QMessageBox(self.dialog)
dialog.setWindowTitle("No Starbound Assets")
dialog.setText("No Starbound assets could be found.")
dialog.setInformativeText(
"The Starbound folder option might be set wrong.")
dialog.setIcon(QMessageBox.Critical)
dialog.exec()
try:
rebuild = build_assets_db(self.dialog)
except FileNotFoundError:
rebuild = False
assets_db_file = Config().read("assets_db")
starbound_folder = Config().read("starbound_folder")
self.db = Assets(assets_db_file, starbound_folder)
total = str(self.db.total_indexed())
if not rebuild or total == 0:
bad_asset_dialog()
else:
dialog = QMessageBox(self.dialog)
dialog.setWindowTitle("Finished Indexing")
dialog.setText("Finished indexing Starbound assets.")
dialog.setInformativeText("Found %s assets." % total)
dialog.setIcon(QMessageBox.Information)
dialog.exec()
self.ui.total_indexed.setText(total + " indexed")
def syncinfo(self, name):
obj = self.salt.remote_execution_module(tgt=name,
fun='saltutil.sync_all')
print('obj--------------------------------------------------')
print(obj)
print('开始资产收集')
Asset = Assets(name=name)
Asset.initialize()
Asset.data_inject()
def __init__(self, parent):
self.dialog = QDialog(parent)
self.ui = qt_mods.Ui_Dialog()
self.ui.setupUi(self.dialog)
starbound_folder = Config().read("starbound_folder")
self.assets = Assets(Config().read("assets_db"), starbound_folder)
mods = self.assets.get_mods()
self.ui.mods_total.setText(str(len(mods)) + " total")
for mod in mods:
self.ui.mods_list.addItem(mod)
self.ui.export_button.clicked.connect(self.export_list)
def __init__(self, parent, known_blueprints, new_blueprints):
"""Blueprint library management dialog."""
self.dialog = QDialog(parent)
self.ui = qt_blueprints.Ui_Dialog()
self.ui.setupUi(self.dialog)
assets_db_file = Config().read("assets_db")
starbound_folder = Config().read("starbound_folder")
self.assets = Assets(assets_db_file, starbound_folder)
self.blueprints = self.assets.blueprints()
self.known_blueprints = known_blueprints
self.new_blueprints = new_blueprints
# populate known list
self.ui.known_blueprints.clear()
for blueprint in self.known_blueprints:
if blueprint is not None:
self.ui.known_blueprints.addItem(BlueprintItem(blueprint))
self.ui.known_blueprints.sortItems(0)
# populate initial available list
self.ui.available_blueprints.clear()
for blueprint in self.blueprints.get_all_blueprints():
self.ui.available_blueprints.addItem(blueprint[6])
# populate category combobox
for cat in self.blueprints.get_categories():
self.ui.category.addItem(cat)
if len(self.new_blueprints) == 0:
self.ui.clear_new_button.setEnabled(False)
self.ui.add_button.clicked.connect(self.add_blueprint)
self.ui.remove_button.clicked.connect(self.remove_blueprint)
self.ui.filter.textChanged.connect(self.update_available_list)
self.ui.category.currentTextChanged.connect(self.update_available_list)
self.ui.available_blueprints.itemSelectionChanged.connect(
self.update_blueprint_info)
self.ui.clear_new_button.clicked.connect(self.clear_new_blueprints)
self.ui.available_blueprints.setCurrentRow(0)
self.ui.filter.setFocus()
self.update_blueprint_info()
def build_assets_db(parent):
assets_db_file = Config().read("assets_db")
starbound_folder = Config().read("starbound_folder")
assets_db = Assets(assets_db_file, starbound_folder)
def bad_asset_dialog():
dialog = QMessageBox(parent)
dialog.setWindowTitle("No Assets Found")
dialog.setText("Unable to index Starbound assets.")
dialog.setInformativeText(
"Check that the Starbound folder was set correctly.")
dialog.setIcon(QMessageBox.Critical)
dialog.exec()
assets_db.db.close()
assets_db.init_db()
asset_files = assets_db.find_assets()
total = 0
progress = QProgressDialog("Indexing Starbound assets...", "Abort", 0,
len(asset_files), parent)
progress.setWindowTitle("Indexing...")
progress.setWindowModality(QtCore.Qt.ApplicationModal)
progress.forceShow()
progress.setValue(total)
for i in assets_db.create_index():
total += 1
progress.setValue(total)
if progress.wasCanceled():
assets_db.db.close()
return False
progress.hide()
if total == 0:
bad_asset_dialog()
return False
else:
Config().set("pak_hash", make_pak_hash())
return True
def __init__(self, parent):
self.dialog = QDialog(parent)
self.ui = qt_options.Ui_Dialog()
self.ui.setupUi(self.dialog)
assets_db_file = Config().read("assets_db")
starbound_folder = Config().read("starbound_folder")
self.db = Assets(assets_db_file, starbound_folder)
self.config = Config()
self.current_folder = self.config.read("starbound_folder")
# read the current config and prefill everything
self.ui.starbound_folder.setText(self.config.read("starbound_folder"))
self.ui.total_indexed.setText(
str(self.db.total_indexed()) + " indexed")
self.ui.update_checkbox.setChecked(
self.config.read("check_updates") == "yes")
self.ui.starbound_folder_button.clicked.connect(self.open_starbound)
self.ui.rebuild_button.clicked.connect(self.rebuild_db)
self.ui.update_checkbox.toggled.connect(self.write_update_check)
def __init__(self, parent, just_browse=False, category="<all>"):
"""Dialog for viewing/searching indexed items and returning selection."""
self.dialog = QDialog(parent)
self.ui = qt_itembrowser.Ui_Dialog()
self.ui.setupUi(self.dialog)
assets_db_file = Config().read("assets_db")
starbound_folder = Config().read("starbound_folder")
self.assets = Assets(assets_db_file, starbound_folder)
self.remember_category = category
if just_browse:
self.ui.buttonBox.setStandardButtons(QDialogButtonBox.Close)
self.item_browse_select = None
self.items = self.assets.items()
# populate category combobox
for cat in self.items.get_categories():
self.ui.category.addItem(cat[0])
self.ui.category.setCurrentText(self.remember_category)
# populate initial items list
self.ui.items.clear()
self.update_item_list()
self.update_item_view()
self.ui.items.itemSelectionChanged.connect(self.update_item_view)
if not just_browse:
self.ui.items.itemDoubleClicked.connect(self.dialog.accept)
self.ui.filter.textChanged.connect(self.update_item_list)
self.ui.category.currentTextChanged.connect(self.update_item_list)
self.ui.items.setCurrentRow(0)
self.ui.filter.setFocus()
def __init__(self):
# check for new Starcheat version online in seperate thread
update_result = [None]
update_thread = Thread(target=update_check_worker,
args=[update_result],
daemon=True)
update_thread.start()
if platform.system() == "Darwin":
QApplication.setAttribute(QtCore.Qt.AA_DontShowIconsInMenus)
"""Display the main Starcheat window."""
self.app = QApplication(sys.argv)
self.window = StarcheatMainWindow(self)
self.ui = qt_mainwindow.Ui_MainWindow()
self.ui.setupUi(self.window)
logging.info("Main window init")
self.players = None
self.filename = None
self.item_browser = None
# remember the last selected item browser category
self.remember_browser = "<all>"
self.options_dialog = None
self.preview_armor = True
self.preview_bg = "#ffffff"
# connect action menu
self.ui.actionSave.triggered.connect(self.save)
self.ui.actionReload.triggered.connect(self.reload)
self.ui.actionOpen.triggered.connect(self.open_file)
self.ui.actionQuit.triggered.connect(self.app.closeAllWindows)
self.ui.actionOptions.triggered.connect(self.new_options_dialog)
self.ui.actionItemBrowser.triggered.connect(self.new_item_browser)
self.ui.actionAbout.triggered.connect(self.new_about_dialog)
self.ui.actionMods.triggered.connect(self.new_mods_dialog)
self.ui.actionImageBrowser.triggered.connect(
self.new_image_browser_dialog)
self.ui.actionExportPlayerBinary.triggered.connect(self.export_save)
self.ui.actionExportPlayerJSON.triggered.connect(self.export_json)
self.ui.actionImportPlayerBinary.triggered.connect(self.import_save)
self.ui.actionImportPlayerJSON.triggered.connect(self.import_json)
# set up bag tables
bags = ("head", "chest", "legs", "back", "main_bag", "object_bag",
"tile_bag", "reagent_bag", "food_bag", "essentials", "mouse")
for bag in bags:
logging.debug("Setting up %s bag", bag)
self.bag_setup(getattr(self.ui, bag), bag)
self.preview_setup()
# signals
self.ui.blueprints_button.clicked.connect(self.new_blueprint_edit)
self.ui.appearance_button.clicked.connect(self.new_appearance_dialog)
self.ui.techs_button.clicked.connect(self.new_techs_dialog)
self.ui.quests_button.clicked.connect(self.new_quests_dialog)
self.ui.ship_button.clicked.connect(self.new_ship_dialog)
self.ui.name.textChanged.connect(self.set_name)
self.ui.male.clicked.connect(self.set_gender)
self.ui.female.clicked.connect(self.set_gender)
self.ui.pixels.valueChanged.connect(self.set_pixels)
self.ui.health.valueChanged.connect(
lambda: self.set_stat_slider("health"))
self.ui.energy.valueChanged.connect(
lambda: self.set_stat_slider("energy"))
self.ui.health_button.clicked.connect(lambda: self.max_stat("health"))
self.ui.energy_button.clicked.connect(lambda: self.max_stat("energy"))
self.ui.copy_uuid_button.clicked.connect(self.copy_uuid)
self.window.setWindowModified(False)
logging.debug("Showing main window")
self.window.show()
# launch first setup if we need to
if not new_setup_dialog(self.window):
logging.error("Config/index creation failed")
return
logging.info("Starbound folder: %s", Config().read("starbound_folder"))
logging.info("Checking assets hash")
if not check_index_valid(self.window):
logging.error("Index creation failed")
return
logging.info("Loading assets database")
self.assets = Assets(Config().read("assets_db"),
Config().read("starbound_folder"))
self.items = self.assets.items()
# populate species combobox
for species in self.assets.species().get_species_list():
self.ui.race.addItem(species)
self.ui.race.currentTextChanged.connect(self.update_species)
# populate game mode combobox
for mode in sorted(self.assets.player().mode_types.values()):
self.ui.game_mode.addItem(mode)
self.ui.game_mode.currentTextChanged.connect(self.set_game_mode)
# launch open file dialog
self.player = None
logging.debug("Open file dialog")
open_player = self.open_file()
# we *need* at least an initial save file
if not open_player:
logging.warning("No player file selected")
return
self.ui.name.setFocus()
# block for update check result (should be ready now)
update_thread.join()
if update_result[0]:
update_check_dialog(self.window, update_result[0])
sys.exit(self.app.exec_())
