2017-04-20 08:52:04 +05:30
|
|
|
#include "minecraft/onesix/OneSixInstance.h"
|
2016-10-03 04:25:54 +05:30
|
|
|
|
|
|
|
#include "InstanceImportTask.h"
|
|
|
|
#include "BaseInstance.h"
|
|
|
|
#include "BaseInstanceProvider.h"
|
|
|
|
#include "FileSystem.h"
|
|
|
|
#include "Env.h"
|
|
|
|
#include "MMCZip.h"
|
|
|
|
#include "NullInstance.h"
|
|
|
|
#include "settings/INISettingsObject.h"
|
|
|
|
#include "icons/IIconList.h"
|
2016-10-26 21:42:33 +05:30
|
|
|
#include <QtConcurrentRun>
|
2017-04-22 01:53:31 +05:30
|
|
|
|
|
|
|
// FIXME: this does not belong here, it's Minecraft/Curse specific
|
2017-04-20 08:52:04 +05:30
|
|
|
#include "minecraft/curse/FileResolvingTask.h"
|
|
|
|
#include "minecraft/curse/PackManifest.h"
|
|
|
|
#include "Json.h"
|
2016-10-03 04:25:54 +05:30
|
|
|
|
|
|
|
InstanceImportTask::InstanceImportTask(SettingsObjectPtr settings, const QUrl sourceUrl, BaseInstanceProvider * target,
|
|
|
|
const QString &instName, const QString &instIcon, const QString &instGroup)
|
|
|
|
{
|
|
|
|
m_globalSettings = settings;
|
|
|
|
m_sourceUrl = sourceUrl;
|
|
|
|
m_target = target;
|
|
|
|
m_instName = instName;
|
|
|
|
m_instIcon = instIcon;
|
|
|
|
m_instGroup = instGroup;
|
|
|
|
}
|
|
|
|
|
|
|
|
void InstanceImportTask::executeTask()
|
|
|
|
{
|
|
|
|
InstancePtr newInstance;
|
|
|
|
|
|
|
|
if (m_sourceUrl.isLocalFile())
|
|
|
|
{
|
|
|
|
m_archivePath = m_sourceUrl.toLocalFile();
|
|
|
|
extractAndTweak();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
setStatus(tr("Downloading modpack:\n%1").arg(m_sourceUrl.toString()));
|
|
|
|
m_downloadRequired = true;
|
|
|
|
|
|
|
|
const QString path = m_sourceUrl.host() + '/' + m_sourceUrl.path();
|
|
|
|
auto entry = ENV.metacache()->resolveEntry("general", path);
|
|
|
|
entry->setStale(true);
|
|
|
|
m_filesNetJob.reset(new NetJob(tr("Modpack download")));
|
|
|
|
m_filesNetJob->addNetAction(Net::Download::makeCached(m_sourceUrl, entry));
|
|
|
|
m_archivePath = entry->getFullPath();
|
|
|
|
auto job = m_filesNetJob.get();
|
|
|
|
connect(job, &NetJob::succeeded, this, &InstanceImportTask::downloadSucceeded);
|
|
|
|
connect(job, &NetJob::progress, this, &InstanceImportTask::downloadProgressChanged);
|
|
|
|
connect(job, &NetJob::failed, this, &InstanceImportTask::downloadFailed);
|
|
|
|
m_filesNetJob->start();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void InstanceImportTask::downloadSucceeded()
|
|
|
|
{
|
|
|
|
extractAndTweak();
|
2017-04-22 01:53:31 +05:30
|
|
|
m_filesNetJob.reset();
|
2016-10-03 04:25:54 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void InstanceImportTask::downloadFailed(QString reason)
|
|
|
|
{
|
|
|
|
emitFailed(reason);
|
2017-04-22 01:53:31 +05:30
|
|
|
m_filesNetJob.reset();
|
2016-10-03 04:25:54 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void InstanceImportTask::downloadProgressChanged(qint64 current, qint64 total)
|
|
|
|
{
|
|
|
|
setProgress(current / 2, total);
|
|
|
|
}
|
|
|
|
|
|
|
|
static QFileInfo findRecursive(const QString &dir, const QString &name)
|
|
|
|
{
|
|
|
|
for (const auto info : QDir(dir).entryInfoList(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files, QDir::DirsLast))
|
|
|
|
{
|
|
|
|
if (info.isFile() && info.fileName() == name)
|
|
|
|
{
|
|
|
|
return info;
|
|
|
|
}
|
|
|
|
else if (info.isDir())
|
|
|
|
{
|
|
|
|
const QFileInfo res = findRecursive(info.absoluteFilePath(), name);
|
|
|
|
if (res.isFile() && res.exists())
|
|
|
|
{
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return QFileInfo();
|
|
|
|
}
|
|
|
|
|
|
|
|
void InstanceImportTask::extractAndTweak()
|
|
|
|
{
|
|
|
|
setStatus(tr("Extracting modpack"));
|
2016-10-26 21:42:33 +05:30
|
|
|
m_stagingPath = m_target->getStagedInstancePath();
|
|
|
|
QDir extractDir(m_stagingPath);
|
2017-04-22 02:00:39 +05:30
|
|
|
qDebug() << "Attempting to create instance from" << m_archivePath;
|
2016-10-26 21:42:33 +05:30
|
|
|
|
|
|
|
m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractDir, m_archivePath, extractDir.absolutePath());
|
|
|
|
connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &InstanceImportTask::extractFinished);
|
|
|
|
connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &InstanceImportTask::extractAborted);
|
|
|
|
m_extractFutureWatcher.setFuture(m_extractFuture);
|
|
|
|
}
|
|
|
|
|
|
|
|
void InstanceImportTask::extractFinished()
|
|
|
|
{
|
|
|
|
if (m_extractFuture.result().isEmpty())
|
2016-10-03 04:25:54 +05:30
|
|
|
{
|
2016-10-26 21:42:33 +05:30
|
|
|
m_target->destroyStagingPath(m_stagingPath);
|
2016-10-03 04:25:54 +05:30
|
|
|
emitFailed(tr("Failed to extract modpack"));
|
|
|
|
return;
|
|
|
|
}
|
2016-10-26 21:42:33 +05:30
|
|
|
QDir extractDir(m_stagingPath);
|
2017-04-22 01:53:31 +05:30
|
|
|
|
2017-04-22 02:00:39 +05:30
|
|
|
qDebug() << "Fixing permissions for extracted pack files...";
|
2017-04-22 01:53:31 +05:30
|
|
|
QDirIterator it(extractDir, QDirIterator::Subdirectories);
|
|
|
|
while (it.hasNext())
|
|
|
|
{
|
|
|
|
auto filepath = it.next();
|
|
|
|
QFileInfo file(filepath);
|
|
|
|
auto permissions = QFile::permissions(filepath);
|
|
|
|
auto origPermissions = permissions;
|
|
|
|
if(file.isDir())
|
|
|
|
{
|
|
|
|
// Folder +rwx for current user
|
|
|
|
permissions |= QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser | QFileDevice::Permission::ExeUser;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// File +rw for current user
|
|
|
|
permissions |= QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser;
|
|
|
|
}
|
|
|
|
if(origPermissions != permissions)
|
|
|
|
{
|
|
|
|
if(!QFile::setPermissions(filepath, permissions))
|
|
|
|
{
|
|
|
|
qWarning() << "Could not fix" << filepath;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
qDebug() << "Fixed" << filepath;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-03 04:25:54 +05:30
|
|
|
const QFileInfo instanceCfgFile = findRecursive(extractDir.absolutePath(), "instance.cfg");
|
2017-04-20 08:52:04 +05:30
|
|
|
const QFileInfo curseJson = findRecursive(extractDir.absolutePath(), "manifest.json");
|
|
|
|
if (instanceCfgFile.isFile())
|
|
|
|
{
|
2017-04-22 02:00:39 +05:30
|
|
|
qDebug() << "Pack appears to be exported from MultiMC.";
|
2017-04-20 08:52:04 +05:30
|
|
|
processMultiMC(instanceCfgFile);
|
|
|
|
}
|
|
|
|
else if (curseJson.isFile())
|
|
|
|
{
|
2017-04-22 02:00:39 +05:30
|
|
|
qDebug() << "Pack appears to be from Curse.";
|
2017-04-20 08:52:04 +05:30
|
|
|
processCurse(curseJson);
|
|
|
|
}
|
|
|
|
else
|
2016-10-03 04:25:54 +05:30
|
|
|
{
|
2017-04-22 01:53:31 +05:30
|
|
|
qCritical() << "Archive does not contain a recognized modpack type.";
|
2016-10-26 21:42:33 +05:30
|
|
|
m_target->destroyStagingPath(m_stagingPath);
|
2017-04-20 08:52:04 +05:30
|
|
|
emitFailed(tr("Archive does not contain a recognized modpack type."));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void InstanceImportTask::extractAborted()
|
|
|
|
{
|
|
|
|
m_target->destroyStagingPath(m_stagingPath);
|
|
|
|
emitFailed(tr("Instance import has been aborted."));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
void InstanceImportTask::processCurse(const QFileInfo & manifest)
|
|
|
|
{
|
|
|
|
Curse::Manifest pack;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
Curse::loadManifest(pack, manifest.absoluteFilePath());
|
|
|
|
}
|
|
|
|
catch (JSONValidationError & e)
|
|
|
|
{
|
2017-04-22 01:53:31 +05:30
|
|
|
m_target->destroyStagingPath(m_stagingPath);
|
2017-04-20 08:52:04 +05:30
|
|
|
emitFailed(tr("Could not understand curse manifest:\n") + e.cause());
|
2016-10-03 04:25:54 +05:30
|
|
|
return;
|
|
|
|
}
|
2017-04-20 08:52:04 +05:30
|
|
|
m_packRoot = manifest.absolutePath();
|
|
|
|
QString configPath = FS::PathCombine(m_packRoot, "instance.cfg");
|
2017-04-22 01:53:31 +05:30
|
|
|
if(!pack.overrides.isEmpty())
|
|
|
|
{
|
|
|
|
QString overridePath = FS::PathCombine(m_packRoot, pack.overrides);
|
|
|
|
QString mcPath = FS::PathCombine(m_packRoot, "minecraft");
|
|
|
|
if (!QFile::rename(overridePath, mcPath))
|
|
|
|
{
|
|
|
|
m_target->destroyStagingPath(m_stagingPath);
|
|
|
|
emitFailed(tr("Could not rename the curse overrides:\n") + pack.overrides);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QString forgeVersion;
|
|
|
|
for(auto &loader: pack.minecraft.modLoaders)
|
|
|
|
{
|
|
|
|
auto id = loader.id;
|
|
|
|
if(id.startsWith("forge-"))
|
|
|
|
{
|
|
|
|
id.remove("forge-");
|
|
|
|
forgeVersion = id;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
qWarning() << "Unknown mod loader in curse manifest:" << id;
|
|
|
|
}
|
|
|
|
|
2017-04-20 08:52:04 +05:30
|
|
|
auto instanceSettings = std::make_shared<INISettingsObject>(configPath);
|
|
|
|
instanceSettings->registerSetting("InstanceType", "Legacy");
|
|
|
|
instanceSettings->set("InstanceType", "OneSix");
|
|
|
|
OneSixInstance instance(m_globalSettings, instanceSettings, m_packRoot);
|
|
|
|
instance.setIntendedVersionId(pack.minecraft.version);
|
2017-04-22 01:53:31 +05:30
|
|
|
if(!forgeVersion.isEmpty())
|
|
|
|
{
|
|
|
|
instance.setComponentVersion("net.minecraftforge", forgeVersion);
|
|
|
|
}
|
2017-04-20 08:52:04 +05:30
|
|
|
instance.setName(m_instName);
|
|
|
|
instance.setIconKey(m_instIcon);
|
2017-04-22 01:53:31 +05:30
|
|
|
m_curseResolver.reset(new Curse::FileResolvingTask(pack));
|
|
|
|
connect(m_curseResolver.get(), &Curse::FileResolvingTask::succeeded, [&]()
|
2017-04-20 08:52:04 +05:30
|
|
|
{
|
2017-04-22 01:53:31 +05:30
|
|
|
auto results = m_curseResolver->getResults();
|
|
|
|
m_filesNetJob.reset(new NetJob(tr("Curse mod download")));
|
|
|
|
for(auto result: results.files)
|
|
|
|
{
|
|
|
|
auto path = FS::PathCombine(m_packRoot, "minecraft/mods", result.fileName);
|
|
|
|
auto dl = Net::Download::makeFile(result.url,path);
|
|
|
|
m_filesNetJob->addNetAction(dl);
|
|
|
|
}
|
|
|
|
m_curseResolver.reset();
|
|
|
|
connect(m_filesNetJob.get(), &NetJob::succeeded, this, [&]()
|
|
|
|
{
|
|
|
|
m_filesNetJob.reset();
|
|
|
|
if (!m_target->commitStagedInstance(m_stagingPath, m_packRoot, m_instName, m_instGroup))
|
|
|
|
{
|
|
|
|
m_target->destroyStagingPath(m_stagingPath);
|
|
|
|
emitFailed(tr("Unable to commit instance"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
emitSucceeded();
|
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_filesNetJob.get(), &NetJob::failed, [&](QString reason)
|
|
|
|
{
|
|
|
|
m_target->destroyStagingPath(m_stagingPath);
|
|
|
|
m_filesNetJob.reset();
|
|
|
|
emitFailed(reason);
|
|
|
|
});
|
|
|
|
connect(m_filesNetJob.get(), &NetJob::progress, [&](qint64 current, qint64 total)
|
|
|
|
{
|
|
|
|
setProgress(current, total);
|
|
|
|
});
|
|
|
|
setStatus(tr("Downloading mods..."));
|
|
|
|
m_filesNetJob->start();
|
2017-04-20 08:52:04 +05:30
|
|
|
}
|
2017-04-22 01:53:31 +05:30
|
|
|
);
|
|
|
|
connect(m_curseResolver.get(), &Curse::FileResolvingTask::failed, [&](QString reason)
|
2017-04-20 08:52:04 +05:30
|
|
|
{
|
|
|
|
m_target->destroyStagingPath(m_stagingPath);
|
2017-04-22 01:53:31 +05:30
|
|
|
m_curseResolver.reset();
|
|
|
|
emitFailed(tr("Unable to resolve Curse mod IDs:\n") + reason);
|
|
|
|
});
|
|
|
|
connect(m_curseResolver.get(), &Curse::FileResolvingTask::progress, [&](qint64 current, qint64 total)
|
|
|
|
{
|
|
|
|
setProgress(current, total);
|
|
|
|
});
|
|
|
|
connect(m_curseResolver.get(), &Curse::FileResolvingTask::status, [&](QString status)
|
|
|
|
{
|
|
|
|
setStatus(status);
|
|
|
|
});
|
|
|
|
m_curseResolver->start();
|
2017-04-20 08:52:04 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void InstanceImportTask::processMultiMC(const QFileInfo & config)
|
|
|
|
{
|
2016-10-03 04:25:54 +05:30
|
|
|
// FIXME: copy from FolderInstanceProvider!!! FIX IT!!!
|
2017-04-20 08:52:04 +05:30
|
|
|
auto instanceSettings = std::make_shared<INISettingsObject>(config.absoluteFilePath());
|
2016-10-03 04:25:54 +05:30
|
|
|
instanceSettings->registerSetting("InstanceType", "Legacy");
|
|
|
|
|
2017-04-20 08:52:04 +05:30
|
|
|
QString actualDir = config.absolutePath();
|
2016-10-03 04:25:54 +05:30
|
|
|
NullInstance instance(m_globalSettings, instanceSettings, actualDir);
|
|
|
|
|
|
|
|
// reset time played on import... because packs.
|
|
|
|
instance.resetTimePlayed();
|
|
|
|
|
|
|
|
// set a new nice name
|
|
|
|
instance.setName(m_instName);
|
|
|
|
|
|
|
|
// if the icon was specified by user, use that. otherwise pull icon from the pack
|
|
|
|
if (m_instIcon != "default")
|
|
|
|
{
|
|
|
|
instance.setIconKey(m_instIcon);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_instIcon = instance.iconKey();
|
|
|
|
auto importIconPath = FS::PathCombine(instance.instanceRoot(), m_instIcon + ".png");
|
|
|
|
if (QFile::exists(importIconPath))
|
|
|
|
{
|
|
|
|
// import icon
|
|
|
|
auto iconList = ENV.icons();
|
|
|
|
if (iconList->iconFileExists(m_instIcon))
|
|
|
|
{
|
|
|
|
iconList->deleteIcon(m_instIcon);
|
|
|
|
}
|
|
|
|
iconList->installIcons({importIconPath});
|
|
|
|
}
|
|
|
|
}
|
2016-10-26 21:42:33 +05:30
|
|
|
if (!m_target->commitStagedInstance(m_stagingPath, actualDir, m_instName, m_instGroup))
|
2016-10-03 04:25:54 +05:30
|
|
|
{
|
2016-10-26 21:42:33 +05:30
|
|
|
m_target->destroyStagingPath(m_stagingPath);
|
2016-10-03 04:25:54 +05:30
|
|
|
emitFailed(tr("Unable to commit instance"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
emitSucceeded();
|
|
|
|
}
|