diff options
Diffstat (limited to 'archived/projt-launcher/launcher/BaseInstance.h')
| -rw-r--r-- | archived/projt-launcher/launcher/BaseInstance.h | 427 |
1 files changed, 427 insertions, 0 deletions
diff --git a/archived/projt-launcher/launcher/BaseInstance.h b/archived/projt-launcher/launcher/BaseInstance.h new file mode 100644 index 0000000000..e413e0162d --- /dev/null +++ b/archived/projt-launcher/launcher/BaseInstance.h @@ -0,0 +1,427 @@ +// SPDX-License-Identifier: GPL-3.0-only +// SPDX-FileCopyrightText: 2026 Project Tick +// SPDX-FileContributor: Project Tick Team +/* + * ProjT Launcher - Minecraft Launcher + * Copyright (C) 2026 Project Tick + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +/* === Upstream License Block (Do Not Modify) ============================== + * + * Prism Launcher - Minecraft Launcher + * Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net> + * Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org> + * Copyright (C) 2023 TheKodeToad <TheKodeToad@proton.me> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * This file incorporates work covered by the following copyright and + * permission notice: + * + * Copyright 2013-2021 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + ======================================================================== */ + +#pragma once +#include <cassert> + +#include <QDataStream> +#include <QDateTime> +#include <QList> +#include <QMenu> +#include <QObject> +#include <QProcess> +#include <QSet> +#include "QObjectPtr.h" + +#include "settings/SettingsObject.h" + +#include "BaseVersionList.h" +#include "MessageLevel.h" +#include "minecraft/auth/MinecraftAccount.hpp" +#include "settings/INIFile.h" + +#include "net/Mode.h" + +#include "RuntimeContext.h" +#include "minecraft/launch/MinecraftTarget.hpp" + +class QDir; +class Task; +class InstanceWindow; +class LaunchController; + +namespace projt::launch +{ + class LaunchPipeline; +} +class BaseInstance; + +// pointer for lazy people +using InstancePtr = std::shared_ptr<BaseInstance>; + +/// Shortcut saving target representations +enum class ShortcutTarget +{ + Desktop, + Applications, + Other +}; + +/// Shortcut data representation +struct ShortcutData +{ + QString name; + QString filePath; + ShortcutTarget target = ShortcutTarget::Other; + + bool operator==(const ShortcutData& other) const + { + return name == other.name && filePath == other.filePath && target == other.target; + } +}; + +/// Console settings +int getConsoleMaxLines(SettingsObjectPtr settings); +bool shouldStopOnConsoleOverflow(SettingsObjectPtr settings); + +/*! + * \brief Base class for instances. + * This class implements many functions that are common between instances and + * provides a standard interface for all instances. + * + * To create a new instance type, create a new class inheriting from this class + * and implement the pure virtual functions. + */ +class BaseInstance : public QObject, public std::enable_shared_from_this<BaseInstance> +{ + Q_OBJECT + protected: + /// no-touchy! + BaseInstance(SettingsObjectPtr globalSettings, SettingsObjectPtr settings, const QString& rootDir); + + public: /* types */ + enum class Status + { + Present, + Gone // either nuked or invalidated + }; + + public: + /// virtual destructor to make sure the destruction is COMPLETE + virtual ~BaseInstance() + {} + + virtual void saveNow() = 0; + + /*** + * the instance has been invalidated - it is no longer tracked by the launcher for some reason, + * but it has not necessarily been deleted. + * + * Happens when the instance folder changes to some other location, or the instance is removed by external means. + */ + void invalidate(); + + /// The instance's ID. The ID SHALL be determined by LAUNCHER internally. The ID IS guaranteed to + /// be unique. + virtual QString id() const; + + void setMinecraftRunning(bool running); + void setRunning(bool running); + bool isRunning() const; + int64_t totalTimePlayed() const; + int64_t lastTimePlayed() const; + void resetTimePlayed(); + + /// get the type of this instance + QString instanceType() const; + + /// Path to the instance's root directory. + QString instanceRoot() const; + + /// Path to the instance's game root directory. + virtual QString gameRoot() const + { + return instanceRoot(); + } + + /// Path to the instance's mods directory. + virtual QString modsRoot() const = 0; + + QString name() const; + void setName(QString val); + + /// Sync name and rename instance dir accordingly; returns true if successful + bool syncInstanceDirName(const QString& newRoot) const; + + /// Register a created shortcut + void registerShortcut(const ShortcutData& data); + QList<ShortcutData> shortcuts() const; + void setShortcuts(const QList<ShortcutData>& shortcuts); + + /// Value used for instance window titles + QString windowTitle() const; + + QString iconKey() const; + void setIconKey(QString val); + + QString notes() const; + void setNotes(QString val); + + QString getPreLaunchCommand(); + QString getPostExitCommand(); + QString getWrapperCommand(); + + bool isManagedPack() const; + QString getManagedPackType() const; + QString getManagedPackID() const; + QString getManagedPackName() const; + QString getManagedPackVersionID() const; + QString getManagedPackVersionName() const; + void setManagedPack(const QString& type, + const QString& id, + const QString& name, + const QString& versionId, + const QString& version); + void copyManagedPack(BaseInstance& other); + + /// Traits. Normally inside the version, depends on instance implementation. + virtual QSet<QString> traits() const = 0; + + /** + * Gets the time that the instance was last launched. + * Stored in milliseconds since epoch. + */ + qint64 lastLaunch() const; + /// Sets the last launched time to 'val' milliseconds since epoch + void setLastLaunch(qint64 val = QDateTime::currentMSecsSinceEpoch()); + + /*! + * \brief Gets this instance's settings object. + * This settings object stores instance-specific settings. + * + * Note that this method is not const. + * It may call loadSpecificSettings() to ensure those are loaded. + * + * \return A pointer to this instance's settings object. + */ + virtual SettingsObjectPtr settings(); + + /*! + * \brief Loads settings specific to an instance type if they're not already loaded. + */ + virtual void loadSpecificSettings() = 0; + + /// returns a valid update task + virtual QList<Task::Ptr> createUpdateTask() = 0; + + /// returns a valid launcher (pipeline container) + virtual shared_qobject_ptr<projt::launch::LaunchPipeline> createLaunchPipeline( + AuthSessionPtr account, + MinecraftTarget::Ptr targetToJoin) = 0; + + /// returns the current launch pipeline (if any) + shared_qobject_ptr<projt::launch::LaunchPipeline> getLaunchPipeline(); + + /*! + * Create envrironment variables for running the instance + */ + virtual QProcessEnvironment createEnvironment() = 0; + virtual QProcessEnvironment createLaunchEnvironment() = 0; + + /*! + * Returns the root folder to use for looking up log files + */ + virtual QStringList getLogFileSearchPaths() = 0; + + virtual QString getStatusbarDescription() = 0; + + /// Returns the path to the instance's config directory (e.g., .minecraft/config). + /// This is on BaseInstance because all instance types need config storage, + /// even if the actual path differs per implementation. + virtual QString instanceConfigFolder() const = 0; + + /// get variables this instance exports + virtual QMap<QString, QString> getVariables() = 0; + + virtual QString typeName() const = 0; + + virtual void updateRuntimeContext(); + RuntimeContext runtimeContext() const + { + return m_runtimeContext; + } + + bool hasVersionBroken() const + { + return m_hasBrokenVersion; + } + void setVersionBroken(bool value) + { + if (m_hasBrokenVersion != value) + { + m_hasBrokenVersion = value; + emit propertiesChanged(this); + } + } + + bool hasUpdateAvailable() const + { + return m_hasUpdate; + } + void setUpdateAvailable(bool value) + { + if (m_hasUpdate != value) + { + m_hasUpdate = value; + emit propertiesChanged(this); + } + } + + bool hasCrashed() const + { + return m_crashed; + } + void setCrashed(bool value) + { + if (m_crashed != value) + { + m_crashed = value; + emit propertiesChanged(this); + } + } + + virtual bool canLaunch() const; + virtual bool canEdit() const = 0; + virtual bool canExport() const = 0; + + bool reloadSettings(); + + /** + * 'print' a verbose description of the instance into a QStringList + */ + virtual QStringList verboseDescription(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin) = 0; + + Status currentStatus() const; + + QStringList getLinkedInstances() const; + void setLinkedInstances(const QStringList& list); + void addLinkedInstanceId(const QString& id); + bool removeLinkedInstanceId(const QString& id); + bool isLinkedToInstanceId(const QString& id) const; + + // Instance window and controller management + InstanceWindow* getInstanceWindow() const + { + return m_instanceWindow; + } + void setInstanceWindow(InstanceWindow* window) + { + m_instanceWindow = window; + } + + shared_qobject_ptr<LaunchController> getLaunchController() const + { + return m_launchController; + } + void setLaunchController(shared_qobject_ptr<LaunchController> controller) + { + m_launchController = controller; + } + + bool isLegacy(); + + protected: + void changeStatus(Status newStatus); + + SettingsObjectPtr globalSettings() const + { + return m_global_settings.lock(); + } + + bool isSpecificSettingsLoaded() const + { + return m_specific_settings_loaded; + } + void setSpecificSettingsLoaded(bool loaded) + { + m_specific_settings_loaded = loaded; + } + + signals: + /*! + * \brief Signal emitted when properties relevant to the instance view change + */ + void propertiesChanged(BaseInstance* inst); + + void launchPipelineChanged(shared_qobject_ptr<projt::launch::LaunchPipeline>); + + void runningStatusChanged(bool running); + + void profilerChanged(); + + void statusChanged(Status from, Status to); + + protected slots: + void iconUpdated(QString key); + + protected: /* data */ + QString m_rootDir; + SettingsObjectPtr m_settings; + // InstanceFlags m_flags; + bool m_isRunning = false; + shared_qobject_ptr<projt::launch::LaunchPipeline> m_launchProcess; + QDateTime m_timeStarted; + RuntimeContext m_runtimeContext; + + private: /* data */ + Status m_status = Status::Present; + bool m_crashed = false; + bool m_hasUpdate = false; + bool m_hasBrokenVersion = false; + + SettingsObjectWeakPtr m_global_settings; + bool m_specific_settings_loaded = false; + + // Instance-specific UI state (moved from Application) + InstanceWindow* m_instanceWindow = nullptr; + shared_qobject_ptr<LaunchController> m_launchController; +}; + +Q_DECLARE_METATYPE(shared_qobject_ptr<BaseInstance>) +// Q_DECLARE_METATYPE(BaseInstance::InstanceFlag) +// Q_DECLARE_OPERATORS_FOR_FLAGS(BaseInstance::InstanceFlags) |