sneedmc/logic/minecraft/MinecraftProfile.cpp

494 lines
10 KiB
C++
Raw Normal View History

2015-02-02 22:25:30 +00:00
/* Copyright 2013-2015 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 <QJsonDocument>
#include <QJsonArray>
#include <QDebug>
#include <pathutils.h>
2015-02-09 00:51:14 +00:00
#include "minecraft/MinecraftProfile.h"
2015-01-27 21:31:07 +00:00
#include "ProfileUtils.h"
#include "NullProfileStrategy.h"
#include "Exception.h"
2014-05-08 19:20:10 +00:00
2015-01-27 21:31:07 +00:00
MinecraftProfile::MinecraftProfile(ProfileStrategy *strategy)
: QAbstractListModel()
{
2015-01-27 21:31:07 +00:00
setStrategy(strategy);
clear();
}
2015-01-27 21:31:07 +00:00
void MinecraftProfile::setStrategy(ProfileStrategy* strategy)
{
Q_ASSERT(strategy != nullptr);
if(m_strategy != nullptr)
{
delete m_strategy;
m_strategy = nullptr;
}
m_strategy = strategy;
m_strategy->profile = this;
}
ProfileStrategy* MinecraftProfile::strategy()
{
return m_strategy;
}
void MinecraftProfile::reload()
{
beginResetModel();
2015-01-27 21:31:07 +00:00
m_strategy->load();
reapplySafe();
endResetModel();
}
2015-01-27 21:31:07 +00:00
void MinecraftProfile::clear()
{
id.clear();
2014-05-09 23:53:32 +00:00
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();
}
2015-01-27 21:31:07 +00:00
void MinecraftProfile::clearPatches()
{
2015-01-27 21:31:07 +00:00
beginResetModel();
VersionPatches.clear();
endResetModel();
}
2014-03-30 22:19:43 +00:00
2015-01-27 21:31:07 +00:00
void MinecraftProfile::appendPatch(ProfilePatchPtr patch)
2014-05-04 22:10:59 +00:00
{
2015-01-27 21:31:07 +00:00
int index = VersionPatches.size();
beginInsertRows(QModelIndex(), index, index);
VersionPatches.append(patch);
endInsertRows();
2014-05-04 22:10:59 +00:00
}
2015-01-27 21:31:07 +00:00
bool MinecraftProfile::remove(const int index)
{
auto patch = versionPatch(index);
if (!patch->isRemovable())
2015-04-13 21:26:52 +00:00
{
qDebug() << "Patch" << patch->getPatchID() << "is non-removable";
2014-05-04 22:10:59 +00:00
return false;
2015-04-13 21:26:52 +00:00
}
2015-01-27 21:31:07 +00:00
if(!m_strategy->removePatch(patch))
{
qCritical() << "Patch" << patch->getPatchID() << "could not be removed";
2014-05-04 22:10:59 +00:00
return false;
}
2015-01-27 21:31:07 +00:00
beginRemoveRows(QModelIndex(), index, index);
2014-05-09 23:53:32 +00:00
VersionPatches.removeAt(index);
endRemoveRows();
reapplySafe();
saveCurrentOrder();
2014-05-04 22:10:59 +00:00
return true;
}
2015-01-27 21:31:07 +00:00
bool MinecraftProfile::remove(const QString id)
2014-03-30 22:19:43 +00:00
{
int i = 0;
2014-05-09 23:53:32 +00:00
for (auto patch : VersionPatches)
2014-03-30 22:19:43 +00:00
{
2014-05-09 23:53:32 +00:00
if (patch->getPatchID() == id)
2014-03-30 22:19:43 +00:00
{
return remove(i);
}
i++;
}
return false;
}
bool MinecraftProfile::customize(int index)
{
auto patch = versionPatch(index);
if (!patch->isCustomizable())
{
qDebug() << "Patch" << patch->getPatchID() << "is not customizable";
return false;
}
if(!m_strategy->customizePatch(patch))
{
qCritical() << "Patch" << patch->getPatchID() << "could not be customized";
return false;
}
reapplySafe();
saveCurrentOrder();
// FIXME: maybe later in unstable
// emit dataChanged(createIndex(index, 0), createIndex(index, columnCount(QModelIndex()) - 1));
return true;
}
2015-09-26 02:04:09 +00:00
bool MinecraftProfile::revertToBase(int index)
{
auto patch = versionPatch(index);
if (!patch->isRevertible())
{
qDebug() << "Patch" << patch->getPatchID() << "is not revertible";
return false;
}
if(!m_strategy->revertPatch(patch))
{
qCritical() << "Patch" << patch->getPatchID() << "could not be reverted";
return false;
}
reapplySafe();
saveCurrentOrder();
// FIXME: maybe later in unstable
// emit dataChanged(createIndex(index, 0), createIndex(index, columnCount(QModelIndex()) - 1));
return true;
}
2015-01-27 21:31:07 +00:00
QString MinecraftProfile::versionFileId(const int index) const
{
2014-05-09 23:53:32 +00:00
if (index < 0 || index >= VersionPatches.size())
{
return QString();
}
2014-05-09 23:53:32 +00:00
return VersionPatches.at(index)->getPatchID();
}
2014-03-30 22:19:43 +00:00
2015-01-27 21:31:07 +00:00
ProfilePatchPtr MinecraftProfile::versionPatch(const QString &id)
{
2014-05-09 23:53:32 +00:00
for (auto file : VersionPatches)
{
2014-05-09 23:53:32 +00:00
if (file->getPatchID() == id)
{
return file;
}
}
return nullptr;
}
2015-01-27 21:31:07 +00:00
ProfilePatchPtr MinecraftProfile::versionPatch(int index)
2014-05-09 23:53:32 +00:00
{
if(index < 0 || index >= VersionPatches.size())
return nullptr;
2014-05-09 23:53:32 +00:00
return VersionPatches[index];
}
2015-01-27 21:31:07 +00:00
bool MinecraftProfile::isVanilla()
2014-03-30 22:19:43 +00:00
{
for(auto patchptr: VersionPatches)
{
if(patchptr->isCustom())
return false;
}
2014-05-04 22:10:59 +00:00
return true;
}
2015-01-27 21:31:07 +00:00
bool MinecraftProfile::revertToVanilla()
{
// remove patches, if present
auto VersionPatchesCopy = VersionPatches;
for(auto & it: VersionPatchesCopy)
{
if (!it->isCustom())
{
continue;
}
if(it->isRevertible() || it->isRemovable())
{
if(!remove(it->getPatchID()))
2014-05-04 22:10:59 +00:00
{
qWarning() << "Couldn't remove" << it->getPatchID() << "from profile!";
reapplySafe();
saveCurrentOrder();
2014-05-04 22:10:59 +00:00
return false;
}
}
}
reapplySafe();
saveCurrentOrder();
return true;
}
2015-01-27 21:31:07 +00:00
QList<std::shared_ptr<OneSixLibrary> > MinecraftProfile::getActiveNormalLibs()
{
QList<std::shared_ptr<OneSixLibrary> > output;
for (auto lib : libraries)
{
2013-08-05 01:29:50 +00:00
if (lib->isActive() && !lib->isNative())
{
2014-09-06 16:16:56 +00:00
for (auto other : output)
{
if (other->rawName() == lib->rawName())
{
qWarning() << "Multiple libraries with name" << lib->rawName() << "in library list!";
2014-09-06 16:16:56 +00:00
continue;
}
}
output.append(lib);
}
}
return output;
}
2015-01-27 21:31:07 +00:00
QList<std::shared_ptr<OneSixLibrary> > MinecraftProfile::getActiveNativeLibs()
{
QList<std::shared_ptr<OneSixLibrary> > output;
for (auto lib : libraries)
{
2013-08-05 01:29:50 +00:00
if (lib->isActive() && lib->isNative())
{
output.append(lib);
}
}
return output;
}
2013-08-05 01:29:50 +00:00
2015-01-27 21:31:07 +00:00
std::shared_ptr<MinecraftProfile> MinecraftProfile::fromJson(const QJsonObject &obj)
{
2015-01-27 21:31:07 +00:00
std::shared_ptr<MinecraftProfile> version(new MinecraftProfile(new NullProfileStrategy()));
try
{
version->clear();
auto file = VersionFile::fromJson(QJsonDocument(obj), QString(), false);
file->applyTo(version.get());
version->appendPatch(file);
}
catch(Exception &err)
{
return 0;
}
return version;
}
2013-08-05 01:29:50 +00:00
2015-01-27 21:31:07 +00:00
QVariant MinecraftProfile::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
int row = index.row();
int column = index.column();
2014-05-09 23:53:32 +00:00
if (row < 0 || row >= VersionPatches.size())
return QVariant();
if (role == Qt::DisplayRole)
{
switch (column)
{
case 0:
2014-05-09 23:53:32 +00:00
return VersionPatches.at(row)->getPatchName();
case 1:
{
auto patch = VersionPatches.at(row);
if(patch->isCustom())
{
return QString("%1 (Custom)").arg(patch->getPatchVersion());
}
else
{
return patch->getPatchVersion();
}
}
default:
return QVariant();
}
}
return QVariant();
}
2015-01-27 21:31:07 +00:00
QVariant MinecraftProfile::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();
}
2015-01-27 21:31:07 +00:00
Qt::ItemFlags MinecraftProfile::flags(const QModelIndex &index) const
{
if (!index.isValid())
return Qt::NoItemFlags;
return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
}
2015-01-27 21:31:07 +00:00
int MinecraftProfile::rowCount(const QModelIndex &parent) const
{
2014-05-09 23:53:32 +00:00
return VersionPatches.size();
}
2015-01-27 21:31:07 +00:00
int MinecraftProfile::columnCount(const QModelIndex &parent) const
{
return 2;
}
2015-01-27 21:31:07 +00:00
void MinecraftProfile::saveCurrentOrder() const
{
2015-01-27 21:31:07 +00:00
ProfileUtils::PatchOrder order;
for(auto item: VersionPatches)
{
if(!item->isMoveable())
continue;
order.append(item->getPatchID());
}
2015-01-27 21:31:07 +00:00
m_strategy->saveOrder(order);
}
2015-01-27 21:31:07 +00:00
void MinecraftProfile::move(const int index, const MoveDirection direction)
{
int theirIndex;
if (direction == MoveUp)
{
theirIndex = index - 1;
}
else
{
theirIndex = index + 1;
}
2015-01-27 21:31:07 +00:00
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;
2014-05-09 23:53:32 +00:00
auto from = versionPatch(index);
auto to = versionPatch(theirIndex);
2015-01-27 21:31:07 +00:00
if (!from || !to || !to->isMoveable() || !from->isMoveable())
{
return;
}
beginMoveRows(QModelIndex(), index, index, QModelIndex(), togap);
2014-05-09 23:53:32 +00:00
VersionPatches.swap(index, theirIndex);
endMoveRows();
reapplySafe();
saveCurrentOrder();
}
2015-01-27 21:31:07 +00:00
void MinecraftProfile::resetOrder()
{
2015-01-27 21:31:07 +00:00
m_strategy->resetOrder();
reload();
}
2015-01-27 21:31:07 +00:00
void MinecraftProfile::reapply()
{
clear();
for(auto file: VersionPatches)
{
file->applyTo(this);
}
2014-03-19 22:23:59 +00:00
finalize();
}
2014-03-19 22:23:59 +00:00
bool MinecraftProfile::reapplySafe()
{
try
{
reapply();
}
catch (Exception & error)
{
clear();
qWarning() << "Couldn't apply profile patches because: " << error.cause();
return false;
}
return true;
}
2015-01-27 21:31:07 +00:00
void MinecraftProfile::finalize()
2014-03-19 22:23:59 +00:00
{
// 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-19 22:23:59 +00:00
if (assets.isEmpty())
{
assets = "legacy";
}
auto finalizeArguments = [&]( QString & minecraftArguments, const QString & processArguments ) -> void
2014-03-19 22:23:59 +00:00
{
if (!minecraftArguments.isEmpty())
return;
2014-03-19 22:23:59 +00:00
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-19 22:23:59 +00:00
}
};
finalizeArguments(vanillaMinecraftArguments, vanillaProcessArguments);
finalizeArguments(minecraftArguments, processArguments);
2014-03-19 22:23:59 +00:00
}
2015-01-27 21:31:07 +00:00
void MinecraftProfile::installJarMods(QStringList selectedFiles)
{
2015-01-27 21:31:07 +00:00
m_strategy->installJarMods(selectedFiles);
}
2015-01-27 21:31:07 +00:00
/*
* TODO: get rid of this. Get rid of all order numbers.
*/
int MinecraftProfile::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;
}