pollymc/logic/minecraft/VersionFinal.cpp

433 lines
8.8 KiB
C++
Raw Normal View History

/* Copyright 2013 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 <QDebug>
#include <QFile>
#include <QDir>
#include <pathutils.h>
2014-05-09 00:50:10 +05:30
#include "logic/minecraft/VersionFinal.h"
#include "logic/minecraft/VersionBuilder.h"
2014-05-09 00:50:10 +05:30
#include "logic/OneSixInstance.h"
2014-03-02 03:36:47 +05:30
VersionFinal::VersionFinal(OneSixInstance *instance, QObject *parent)
: QAbstractListModel(parent), m_instance(instance)
{
clear();
}
void VersionFinal::reload(const QStringList &external)
{
beginResetModel();
VersionBuilder::build(this, m_instance, external);
reapply(true);
endResetModel();
}
2014-03-02 03:36:47 +05:30
void VersionFinal::clear()
{
id.clear();
2014-05-10 05:23:32 +05:30
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();
}
2014-03-02 03:36:47 +05:30
bool VersionFinal::canRemove(const int index) const
{
2014-05-10 05:23:32 +05:30
return VersionPatches.at(index)->isMoveable();
}
2014-03-31 03:49:43 +05:30
2014-05-10 05:23:32 +05:30
bool VersionFinal::preremove(VersionPatchPtr patch)
2014-05-05 03:40:59 +05:30
{
bool ok = true;
2014-05-10 05:23:32 +05:30
for(auto & jarmod: patch->getJarMods())
2014-05-05 03:40:59 +05:30
{
QString fullpath =PathCombine(m_instance->jarModsDir(), jarmod->name);
QFileInfo finfo (fullpath);
if(finfo.exists())
2014-05-05 03:40:59 +05:30
ok &= QFile::remove(fullpath);
}
return ok;
}
bool VersionFinal::remove(const int index)
{
2014-05-05 03:40:59 +05:30
if (!canRemove(index))
return false;
2014-05-10 05:23:32 +05:30
if(!preremove(VersionPatches[index]))
{
2014-05-05 03:40:59 +05:30
return false;
}
2014-05-10 05:23:32 +05:30
if(!QFile::remove(VersionPatches.at(index)->getPatchFilename()))
2014-05-05 03:40:59 +05:30
return false;
beginResetModel();
2014-05-10 05:23:32 +05:30
VersionPatches.removeAt(index);
2014-05-05 03:40:59 +05:30
reapply(true);
endResetModel();
return true;
}
2014-03-31 03:49:43 +05:30
bool VersionFinal::remove(const QString id)
{
int i = 0;
2014-05-10 05:23:32 +05:30
for (auto patch : VersionPatches)
2014-03-31 03:49:43 +05:30
{
2014-05-10 05:23:32 +05:30
if (patch->getPatchID() == id)
2014-03-31 03:49:43 +05:30
{
return remove(i);
}
i++;
}
return false;
}
2014-03-02 03:36:47 +05:30
QString VersionFinal::versionFileId(const int index) const
{
2014-05-10 05:23:32 +05:30
if (index < 0 || index >= VersionPatches.size())
{
return QString();
}
2014-05-10 05:23:32 +05:30
return VersionPatches.at(index)->getPatchID();
}
2014-03-31 03:49:43 +05:30
2014-05-10 05:23:32 +05:30
VersionPatchPtr VersionFinal::versionPatch(const QString &id)
{
2014-05-10 05:23:32 +05:30
for (auto file : VersionPatches)
{
2014-05-10 05:23:32 +05:30
if (file->getPatchID() == id)
{
return file;
}
}
return 0;
}
2014-05-10 05:23:32 +05:30
VersionPatchPtr VersionFinal::versionPatch(int index)
{
if(index < 0 || index >= VersionPatches.size())
return 0;
return VersionPatches[index];
}
bool VersionFinal::hasJarMods()
{
return !jarMods.isEmpty();
}
2014-03-31 03:49:43 +05:30
bool VersionFinal::hasFtbPack()
{
return versionPatch("org.multimc.ftb.pack.json") != nullptr;
2014-03-31 03:49:43 +05:30
}
bool VersionFinal::removeFtbPack()
{
return remove("org.multimc.ftb.pack.json");
}
bool VersionFinal::isVanilla()
{
QDir patches(PathCombine(m_instance->instanceRoot(), "patches/"));
2014-05-10 05:23:32 +05:30
if(VersionPatches.size() > 1)
2014-05-05 03:40:59 +05:30
return false;
if(QFile::exists(PathCombine(m_instance->instanceRoot(), "custom.json")))
return false;
return true;
}
bool VersionFinal::revertToVanilla()
{
beginResetModel();
2014-05-10 05:23:32 +05:30
auto it = VersionPatches.begin();
while (it != VersionPatches.end())
{
2014-05-10 05:23:32 +05:30
if ((*it)->isMoveable())
{
2014-05-05 03:40:59 +05:30
if(!preremove(*it))
{
endResetModel();
return false;
}
2014-05-10 05:23:32 +05:30
if(!QFile::remove((*it)->getPatchFilename()))
2014-05-05 03:40:59 +05:30
{
endResetModel();
return false;
}
2014-05-10 05:23:32 +05:30
it = VersionPatches.erase(it);
}
else
it++;
}
reapply(true);
endResetModel();
return true;
}
bool VersionFinal::usesLegacyCustomJson()
{
return QFile::exists(PathCombine(m_instance->instanceRoot(), "custom.json"));
}
2014-03-02 03:36:47 +05:30
QList<std::shared_ptr<OneSixLibrary> > VersionFinal::getActiveNormalLibs()
{
QList<std::shared_ptr<OneSixLibrary> > output;
for (auto lib : libraries)
{
2013-08-05 06:59:50 +05:30
if (lib->isActive() && !lib->isNative())
{
output.append(lib);
}
}
return output;
}
2014-03-02 03:36:47 +05:30
QList<std::shared_ptr<OneSixLibrary> > VersionFinal::getActiveNativeLibs()
{
QList<std::shared_ptr<OneSixLibrary> > output;
for (auto lib : libraries)
{
2013-08-05 06:59:50 +05:30
if (lib->isActive() && lib->isNative())
{
output.append(lib);
}
}
return output;
}
2013-08-05 06:59:50 +05:30
2014-03-02 03:36:47 +05:30
std::shared_ptr<VersionFinal> VersionFinal::fromJson(const QJsonObject &obj)
{
2014-03-02 03:36:47 +05:30
std::shared_ptr<VersionFinal> version(new VersionFinal(0));
try
{
VersionBuilder::readJsonAndApplyToVersion(version.get(), obj);
}
catch(MMCError & err)
{
return 0;
}
return version;
}
2013-08-05 06:59:50 +05:30
2014-03-02 03:36:47 +05:30
QVariant VersionFinal::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
int row = index.row();
int column = index.column();
2014-05-10 05:23:32 +05:30
if (row < 0 || row >= VersionPatches.size())
return QVariant();
if (role == Qt::DisplayRole)
{
switch (column)
{
case 0:
2014-05-10 05:23:32 +05:30
return VersionPatches.at(row)->getPatchName();
case 1:
2014-05-10 05:23:32 +05:30
return VersionPatches.at(row)->getPatchVersion();
default:
return QVariant();
}
}
return QVariant();
}
2014-03-02 03:36:47 +05:30
QVariant VersionFinal::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();
}
2014-03-02 03:36:47 +05:30
Qt::ItemFlags VersionFinal::flags(const QModelIndex &index) const
{
if (!index.isValid())
return Qt::NoItemFlags;
return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
}
2014-03-02 03:36:47 +05:30
int VersionFinal::rowCount(const QModelIndex &parent) const
{
2014-05-10 05:23:32 +05:30
return VersionPatches.size();
}
2014-03-02 03:36:47 +05:30
int VersionFinal::columnCount(const QModelIndex &parent) const
{
return 2;
}
QMap<QString, int> VersionFinal::getExistingOrder() const
{
QMap<QString, int> order;
// default
{
2014-05-10 05:23:32 +05:30
for (auto file : VersionPatches)
{
2014-05-10 05:23:32 +05:30
order.insert(file->getPatchID(), file->getOrder());
}
}
// overriden
{
QMap<QString, int> overridenOrder = VersionBuilder::readOverrideOrders(m_instance);
for (auto id : order.keys())
{
if (overridenOrder.contains(id))
{
order[id] = overridenOrder[id];
}
}
}
return order;
}
void VersionFinal::move(const int index, const MoveDirection direction)
{
int theirIndex;
2014-05-10 05:23:32 +05:30
int theirIndex_qt;
if (direction == MoveUp)
{
2014-05-10 05:23:32 +05:30
theirIndex_qt = theirIndex = index - 1;
}
else
{
theirIndex = index + 1;
2014-05-10 05:23:32 +05:30
theirIndex_qt = index + 2;
}
2014-05-10 05:23:32 +05:30
auto from = versionPatch(index);
auto to = versionPatch(theirIndex);
if (!from || !to || !from->isMoveable() || !from->isMoveable())
{
return;
}
2014-05-05 03:40:59 +05:30
if(direction == MoveDown)
{
2014-05-10 05:23:32 +05:30
beginMoveRows(QModelIndex(), index, index, QModelIndex(), theirIndex_qt);
2014-05-05 03:40:59 +05:30
}
else
{
2014-05-10 05:23:32 +05:30
beginMoveRows(QModelIndex(), index, index, QModelIndex(), theirIndex_qt);
}
2014-05-10 05:23:32 +05:30
VersionPatches.swap(index, theirIndex);
endMoveRows();
auto order = getExistingOrder();
2014-05-10 05:23:32 +05:30
order[from->getPatchID()] = theirIndex;
order[to->getPatchID()] = index;
if (!VersionBuilder::writeOverrideOrders(order, m_instance))
{
throw MMCError(tr("Couldn't save the new order"));
}
else
{
reapply();
}
}
void VersionFinal::resetOrder()
{
QDir(m_instance->instanceRoot()).remove("order.json");
reapply();
}
void VersionFinal::reapply(const bool alreadyReseting)
{
if (!alreadyReseting)
{
beginResetModel();
}
clear();
auto existingOrders = getExistingOrder();
QList<int> orders = existingOrders.values();
std::sort(orders.begin(), orders.end());
2014-05-10 05:23:32 +05:30
QList<VersionPatchPtr> newVersionFiles;
for (auto order : orders)
{
auto file = versionPatch(existingOrders.key(order));
newVersionFiles.append(file);
file->applyTo(this);
}
2014-05-10 05:23:32 +05:30
VersionPatches.swap(newVersionFiles);
2014-03-20 03:53:59 +05:30
finalize();
if (!alreadyReseting)
{
endResetModel();
}
}
2014-03-20 03:53:59 +05:30
void VersionFinal::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);
}
2014-03-20 03:53:59 +05:30
if (assets.isEmpty())
{
assets = "legacy";
}
auto finalizeArguments = [&]( QString & minecraftArguments, const QString & processArguments ) -> void
2014-03-20 03:53:59 +05:30
{
if (!minecraftArguments.isEmpty())
return;
2014-03-20 03:53:59 +05:30
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}";
2014-03-20 03:53:59 +05:30
}
};
finalizeArguments(vanillaMinecraftArguments, vanillaProcessArguments);
finalizeArguments(minecraftArguments, processArguments);
2014-03-20 03:53:59 +05:30
}