551 lines
12 KiB
C++
551 lines
12 KiB
C++
/* Copyright 2013-2014 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.
|
|
*/
|
|
|
|
#include <QFile>
|
|
#include <QDir>
|
|
#include <QUuid>
|
|
#include <QJsonDocument>
|
|
#include <QJsonArray>
|
|
#include <pathutils.h>
|
|
|
|
#include "logic/minecraft/InstanceVersion.h"
|
|
#include "logic/minecraft/VersionBuilder.h"
|
|
#include "logic/OneSixInstance.h"
|
|
|
|
InstanceVersion::InstanceVersion(OneSixInstance *instance, QObject *parent)
|
|
: QAbstractListModel(parent), m_instance(instance)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void InstanceVersion::reload(const QStringList &external)
|
|
{
|
|
m_externalPatches = external;
|
|
beginResetModel();
|
|
VersionBuilder::build(this, m_instance, m_externalPatches);
|
|
reapply(true);
|
|
endResetModel();
|
|
}
|
|
|
|
void InstanceVersion::clear()
|
|
{
|
|
id.clear();
|
|
m_updateTimeString.clear();
|
|
m_updateTime = QDateTime();
|
|
m_releaseTimeString.clear();
|
|
m_releaseTime = QDateTime();
|
|
type.clear();
|
|
assets.clear();
|
|
processArguments.clear();
|
|
minecraftArguments.clear();
|
|
minimumLauncherVersion = 0xDEADBEAF;
|
|
mainClass.clear();
|
|
appletClass.clear();
|
|
libraries.clear();
|
|
tweakers.clear();
|
|
jarMods.clear();
|
|
traits.clear();
|
|
}
|
|
|
|
bool InstanceVersion::canRemove(const int index) const
|
|
{
|
|
return VersionPatches.at(index)->isMoveable();
|
|
}
|
|
|
|
bool InstanceVersion::preremove(VersionPatchPtr patch)
|
|
{
|
|
bool ok = true;
|
|
for(auto & jarmod: patch->getJarMods())
|
|
{
|
|
QString fullpath =PathCombine(m_instance->jarModsDir(), jarmod->name);
|
|
QFileInfo finfo (fullpath);
|
|
if(finfo.exists())
|
|
ok &= QFile::remove(fullpath);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool InstanceVersion::remove(const int index)
|
|
{
|
|
if (!canRemove(index))
|
|
return false;
|
|
if(!preremove(VersionPatches[index]))
|
|
{
|
|
return false;
|
|
}
|
|
auto toDelete = VersionPatches.at(index)->getPatchFilename();
|
|
if(!QFile::remove(toDelete))
|
|
return false;
|
|
beginRemoveRows(QModelIndex(), index, index);
|
|
VersionPatches.removeAt(index);
|
|
endRemoveRows();
|
|
reapply(true);
|
|
saveCurrentOrder();
|
|
return true;
|
|
}
|
|
|
|
bool InstanceVersion::remove(const QString id)
|
|
{
|
|
int i = 0;
|
|
for (auto patch : VersionPatches)
|
|
{
|
|
if (patch->getPatchID() == id)
|
|
{
|
|
return remove(i);
|
|
}
|
|
i++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
QString InstanceVersion::versionFileId(const int index) const
|
|
{
|
|
if (index < 0 || index >= VersionPatches.size())
|
|
{
|
|
return QString();
|
|
}
|
|
return VersionPatches.at(index)->getPatchID();
|
|
}
|
|
|
|
VersionPatchPtr InstanceVersion::versionPatch(const QString &id)
|
|
{
|
|
for (auto file : VersionPatches)
|
|
{
|
|
if (file->getPatchID() == id)
|
|
{
|
|
return file;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
VersionPatchPtr InstanceVersion::versionPatch(int index)
|
|
{
|
|
if(index < 0 || index >= VersionPatches.size())
|
|
return 0;
|
|
return VersionPatches[index];
|
|
}
|
|
|
|
|
|
bool InstanceVersion::hasJarMods()
|
|
{
|
|
return !jarMods.isEmpty();
|
|
}
|
|
|
|
bool InstanceVersion::hasFtbPack()
|
|
{
|
|
return versionPatch("org.multimc.ftb.pack.json") != nullptr;
|
|
}
|
|
|
|
bool InstanceVersion::removeFtbPack()
|
|
{
|
|
return remove("org.multimc.ftb.pack.json");
|
|
}
|
|
|
|
bool InstanceVersion::isVanilla()
|
|
{
|
|
QDir patches(PathCombine(m_instance->instanceRoot(), "patches/"));
|
|
for(auto patchptr: VersionPatches)
|
|
{
|
|
if(patchptr->isCustom())
|
|
return false;
|
|
}
|
|
if(QFile::exists(PathCombine(m_instance->instanceRoot(), "custom.json")))
|
|
return false;
|
|
if(QFile::exists(PathCombine(m_instance->instanceRoot(), "version.json")))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool InstanceVersion::revertToVanilla()
|
|
{
|
|
beginResetModel();
|
|
// remove custom.json, if present
|
|
QString customPath = PathCombine(m_instance->instanceRoot(), "custom.json");
|
|
if(QFile::exists(customPath))
|
|
{
|
|
if(!QFile::remove(customPath))
|
|
{
|
|
endResetModel();
|
|
return false;
|
|
}
|
|
}
|
|
// remove version.json, if present
|
|
QString versionPath = PathCombine(m_instance->instanceRoot(), "version.json");
|
|
if(QFile::exists(versionPath))
|
|
{
|
|
if(!QFile::remove(versionPath))
|
|
{
|
|
endResetModel();
|
|
return false;
|
|
}
|
|
}
|
|
// remove patches, if present
|
|
auto it = VersionPatches.begin();
|
|
while (it != VersionPatches.end())
|
|
{
|
|
if ((*it)->isMoveable())
|
|
{
|
|
if(!preremove(*it))
|
|
{
|
|
endResetModel();
|
|
saveCurrentOrder();
|
|
return false;
|
|
}
|
|
if(!QFile::remove((*it)->getPatchFilename()))
|
|
{
|
|
endResetModel();
|
|
saveCurrentOrder();
|
|
return false;
|
|
}
|
|
it = VersionPatches.erase(it);
|
|
}
|
|
else
|
|
it++;
|
|
}
|
|
reapply(true);
|
|
endResetModel();
|
|
saveCurrentOrder();
|
|
return true;
|
|
}
|
|
|
|
bool InstanceVersion::hasDeprecatedVersionFiles()
|
|
{
|
|
if(QFile::exists(PathCombine(m_instance->instanceRoot(), "custom.json")))
|
|
return true;
|
|
if(QFile::exists(PathCombine(m_instance->instanceRoot(), "version.json")))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool InstanceVersion::removeDeprecatedVersionFiles()
|
|
{
|
|
beginResetModel();
|
|
// remove custom.json, if present
|
|
QString customPath = PathCombine(m_instance->instanceRoot(), "custom.json");
|
|
if(QFile::exists(customPath))
|
|
{
|
|
if(!QFile::remove(customPath))
|
|
{
|
|
endResetModel();
|
|
return false;
|
|
}
|
|
}
|
|
// remove version.json, if present
|
|
QString versionPath = PathCombine(m_instance->instanceRoot(), "version.json");
|
|
if(QFile::exists(versionPath))
|
|
{
|
|
if(!QFile::remove(versionPath))
|
|
{
|
|
endResetModel();
|
|
return false;
|
|
}
|
|
}
|
|
endResetModel();
|
|
return true;
|
|
}
|
|
|
|
QList<std::shared_ptr<OneSixLibrary> > InstanceVersion::getActiveNormalLibs()
|
|
{
|
|
QList<std::shared_ptr<OneSixLibrary> > output;
|
|
for (auto lib : libraries)
|
|
{
|
|
if (lib->isActive() && !lib->isNative())
|
|
{
|
|
for (auto other : output)
|
|
{
|
|
if (other->rawName() == lib->rawName())
|
|
{
|
|
QLOG_WARN() << "Multiple libraries with name" << lib->rawName() << "in library list!";
|
|
continue;
|
|
}
|
|
}
|
|
output.append(lib);
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
QList<std::shared_ptr<OneSixLibrary> > InstanceVersion::getActiveNativeLibs()
|
|
{
|
|
QList<std::shared_ptr<OneSixLibrary> > output;
|
|
for (auto lib : libraries)
|
|
{
|
|
if (lib->isActive() && lib->isNative())
|
|
{
|
|
output.append(lib);
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
|
|
std::shared_ptr<InstanceVersion> InstanceVersion::fromJson(const QJsonObject &obj)
|
|
{
|
|
std::shared_ptr<InstanceVersion> version(new InstanceVersion(0));
|
|
try
|
|
{
|
|
VersionBuilder::readJsonAndApplyToVersion(version.get(), obj);
|
|
}
|
|
catch(MMCError & err)
|
|
{
|
|
return 0;
|
|
}
|
|
return version;
|
|
}
|
|
|
|
QVariant InstanceVersion::data(const QModelIndex &index, int role) const
|
|
{
|
|
if (!index.isValid())
|
|
return QVariant();
|
|
|
|
int row = index.row();
|
|
int column = index.column();
|
|
|
|
if (row < 0 || row >= VersionPatches.size())
|
|
return QVariant();
|
|
|
|
if (role == Qt::DisplayRole)
|
|
{
|
|
switch (column)
|
|
{
|
|
case 0:
|
|
return VersionPatches.at(row)->getPatchName();
|
|
case 1:
|
|
return VersionPatches.at(row)->getPatchVersion();
|
|
default:
|
|
return QVariant();
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
QVariant InstanceVersion::headerData(int section, Qt::Orientation orientation, int role) const
|
|
{
|
|
if (orientation == Qt::Horizontal)
|
|
{
|
|
if (role == Qt::DisplayRole)
|
|
{
|
|
switch (section)
|
|
{
|
|
case 0:
|
|
return tr("Name");
|
|
case 1:
|
|
return tr("Version");
|
|
default:
|
|
return QVariant();
|
|
}
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
Qt::ItemFlags InstanceVersion::flags(const QModelIndex &index) const
|
|
{
|
|
if (!index.isValid())
|
|
return Qt::NoItemFlags;
|
|
return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
|
|
}
|
|
|
|
int InstanceVersion::rowCount(const QModelIndex &parent) const
|
|
{
|
|
return VersionPatches.size();
|
|
}
|
|
|
|
int InstanceVersion::columnCount(const QModelIndex &parent) const
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
void InstanceVersion::saveCurrentOrder() const
|
|
{
|
|
PatchOrder order;
|
|
for(auto item: VersionPatches)
|
|
{
|
|
if(!item->isMoveable())
|
|
continue;
|
|
order.append(item->getPatchID());
|
|
}
|
|
VersionBuilder::writeOverrideOrders(m_instance, order);
|
|
}
|
|
|
|
void InstanceVersion::move(const int index, const MoveDirection direction)
|
|
{
|
|
int theirIndex;
|
|
if (direction == MoveUp)
|
|
{
|
|
theirIndex = index - 1;
|
|
}
|
|
else
|
|
{
|
|
theirIndex = index + 1;
|
|
}
|
|
|
|
if (index < 0 || index >= VersionPatches.size())
|
|
return;
|
|
if (theirIndex >= rowCount())
|
|
theirIndex = rowCount() - 1;
|
|
if (theirIndex == -1)
|
|
theirIndex = rowCount() - 1;
|
|
if (index == theirIndex)
|
|
return;
|
|
int togap = theirIndex > index ? theirIndex + 1 : theirIndex;
|
|
|
|
auto from = versionPatch(index);
|
|
auto to = versionPatch(theirIndex);
|
|
|
|
if (!from || !to || !to->isMoveable() || !from->isMoveable())
|
|
{
|
|
return;
|
|
}
|
|
beginMoveRows(QModelIndex(), index, index, QModelIndex(), togap);
|
|
VersionPatches.swap(index, theirIndex);
|
|
endMoveRows();
|
|
saveCurrentOrder();
|
|
reapply();
|
|
}
|
|
void InstanceVersion::resetOrder()
|
|
{
|
|
QDir(m_instance->instanceRoot()).remove("order.json");
|
|
reload(m_externalPatches);
|
|
}
|
|
|
|
void InstanceVersion::reapply(const bool alreadyReseting)
|
|
{
|
|
clear();
|
|
for(auto file: VersionPatches)
|
|
{
|
|
file->applyTo(this);
|
|
}
|
|
finalize();
|
|
}
|
|
|
|
void InstanceVersion::finalize()
|
|
{
|
|
// HACK: deny april fools. my head hurts enough already.
|
|
QDate now = QDate::currentDate();
|
|
bool isAprilFools = now.month() == 4 && now.day() == 1;
|
|
if (assets.endsWith("_af") && !isAprilFools)
|
|
{
|
|
assets = assets.left(assets.length() - 3);
|
|
}
|
|
if (assets.isEmpty())
|
|
{
|
|
assets = "legacy";
|
|
}
|
|
auto finalizeArguments = [&]( QString & minecraftArguments, const QString & processArguments ) -> void
|
|
{
|
|
if (!minecraftArguments.isEmpty())
|
|
return;
|
|
QString toCompare = processArguments.toLower();
|
|
if (toCompare == "legacy")
|
|
{
|
|
minecraftArguments = " ${auth_player_name} ${auth_session}";
|
|
}
|
|
else if (toCompare == "username_session")
|
|
{
|
|
minecraftArguments = "--username ${auth_player_name} --session ${auth_session}";
|
|
}
|
|
else if (toCompare == "username_session_version")
|
|
{
|
|
minecraftArguments = "--username ${auth_player_name} "
|
|
"--session ${auth_session} "
|
|
"--version ${profile_name}";
|
|
}
|
|
};
|
|
finalizeArguments(vanillaMinecraftArguments, vanillaProcessArguments);
|
|
finalizeArguments(minecraftArguments, processArguments);
|
|
}
|
|
|
|
void InstanceVersion::installJarMods(QStringList selectedFiles)
|
|
{
|
|
for(auto filename: selectedFiles)
|
|
{
|
|
installJarModByFilename(filename);
|
|
}
|
|
}
|
|
|
|
void InstanceVersion::installJarModByFilename(QString filepath)
|
|
{
|
|
QString patchDir = PathCombine(m_instance->instanceRoot(), "patches");
|
|
if(!ensureFolderPathExists(patchDir))
|
|
{
|
|
// THROW...
|
|
return;
|
|
}
|
|
|
|
if (!ensureFolderPathExists(m_instance->jarModsDir()))
|
|
{
|
|
// THROW...
|
|
return;
|
|
}
|
|
|
|
QFileInfo sourceInfo(filepath);
|
|
auto uuid = QUuid::createUuid();
|
|
QString id = uuid.toString().remove('{').remove('}');
|
|
QString target_filename = id + ".jar";
|
|
QString target_id = "org.multimc.jarmod." + id;
|
|
QString target_name = sourceInfo.completeBaseName() + " (jar mod)";
|
|
QString finalPath = PathCombine(m_instance->jarModsDir(), target_filename);
|
|
|
|
QFileInfo targetInfo(finalPath);
|
|
if(targetInfo.exists())
|
|
{
|
|
// THROW
|
|
return;
|
|
}
|
|
|
|
if (!QFile::copy(sourceInfo.absoluteFilePath(),QFileInfo(finalPath).absoluteFilePath()))
|
|
{
|
|
// THROW
|
|
return;
|
|
}
|
|
|
|
auto f = std::make_shared<VersionFile>();
|
|
auto jarMod = std::make_shared<Jarmod>();
|
|
jarMod->name = target_filename;
|
|
f->jarMods.append(jarMod);
|
|
f->name = target_name;
|
|
f->fileId = target_id;
|
|
f->order = getFreeOrderNumber();
|
|
QString patchFileName = PathCombine(patchDir, target_id + ".json");
|
|
f->filename = patchFileName;
|
|
|
|
QFile file(patchFileName);
|
|
if (!file.open(QFile::WriteOnly))
|
|
{
|
|
QLOG_ERROR() << "Error opening" << file.fileName()
|
|
<< "for reading:" << file.errorString();
|
|
return;
|
|
// THROW
|
|
}
|
|
file.write(f->toJson(true).toJson());
|
|
file.close();
|
|
int index = VersionPatches.size();
|
|
beginInsertRows(QModelIndex(), index, index);
|
|
VersionPatches.append(f);
|
|
endInsertRows();
|
|
saveCurrentOrder();
|
|
}
|
|
|
|
int InstanceVersion::getFreeOrderNumber()
|
|
{
|
|
int largest = 100;
|
|
// yes, I do realize this is dumb. The order thing itself is dumb. and to be removed next.
|
|
for(auto thing: VersionPatches)
|
|
{
|
|
int order = thing->getOrder();
|
|
if(order > largest)
|
|
largest = order;
|
|
}
|
|
return largest + 1;
|
|
}
|