static bool GetDlcInstalledStatus(IronFrontInfo spec) {
return spec.IFDlcSourcePath.Exists;
}
void ProcessCommunityDlcPatches(IAbsoluteDirectoryPath dlcPath, IronFrontInfo spec) {
if (!dlcPath.Exists)
return;
var dlcEdition = GetDlcType(spec.IFDlcSourcePath);
string lastVersion = null;
foreach (var dlcPatch in communityDlcPatches) {
if (lastVersion != null && dlcPatch.From.Version != lastVersion)
continue;
DownloadAndInstallCommunityPatch(spec, dlcPatch.GetFileName(spec.Game, dlcEdition));
lastVersion = dlcPatch.To.Version;
}
}
void Confirmations(IronFrontInfo message) {
if (!ConfirmTempSpaceAvailable(message)) {
throw new TemporaryDriveFullException("Drive Full", RequiredTempFreeSpace,
GetDrive(message.TempPath).AvailableFreeSpace, message.TempPath);
}
if (!ConfirmDestinationSpaceAvailable(message)) {
throw new DestinationDriveFullException("Drive Full", RequiredFreeSpace,
GetDrive(message.GamePath).AvailableFreeSpace, message.GamePath);
}
if (Tools.Processes.Uac.CheckUac())
throw new ElevationRequiredException();
}
bool ProcessDlc(IronFrontInfo spec) {
var dlcInstalled = GetDlcInstalledStatus(spec);
if (dlcInstalled) {
Status("dlc conversion", spec.Status,
status => ProcessIFDirectory(spec.IFDlcSourcePath, spec.GameIFDlcPath, spec.TempPath, status),
RepoStatus.Processing);
}
return dlcInstalled;
}
bool ConfirmSpaceAvailable(IronFrontInfo ifaSpec) {
return (ConfirmTempSpaceAvailable(ifaSpec) && ConfirmDestinationSpaceAvailable(ifaSpec));
}
bool ConfirmDestinationSpaceAvailable(IronFrontInfo ifaspec) {
return GetDrive(ifaspec.GamePath).AvailableFreeSpace > RequiredFreeSpace;
}
static GamePatch GetFirstRequiredGamePatch(IronFrontInfo spec) {
return
communityGamePatches.LastOrDefault(
gamePatch => GetPatchStatus(spec, gamePatch.ChecksumFile, gamePatch.From.Checksum));
}
void PatchFrom4(IronFrontInfo ifaSpec) {
var esd = !ConfirmChecksum(ifaSpec.IronFrontExePath, OfficialGameInfo.Disk4ExeSha);
InstallOfficialPatch4To5(ifaSpec, esd);
}
static DlcPatch GetFirstRequiredDlcPatch(IronFrontInfo spec, DlcEdition edition) {
return
communityDlcPatches.LastOrDefault(
dlcPatch => GetPatchStatus(spec, dlcPatch.ChecksumFile, dlcPatch.GetFromChecksum(edition)));
}
void HandleGameCommunityPatches(IronFrontInfo spec) {
var first = GetFirstRequiredGamePatch(spec);
if (first == null)
throw new UnrecognizedIFVersionException("Unrecognized IF version");
string lastVersion = null;
foreach (var gamePatch in communityGamePatches.Skip(communityGamePatches.IndexOf(first))) {
if (lastVersion != null && gamePatch.From.Version != lastVersion)
continue;
DownloadAndInstallCommunityPatch(spec, gamePatch.GetFileName(spec.Game));
lastVersion = gamePatch.To.Version;
}
}
void HandleDlcCommunityPatches(IronFrontInfo spec) {
var dlcEdition = GetDlcType(spec.IFDlcSourcePath);
var first = GetFirstRequiredDlcPatch(spec, dlcEdition);
if (first == null)
throw new UnrecognizedIFVersionException("Unsupported IFDLC version");
string lastVersion = null;
foreach (var dlcPatch in communityDlcPatches.Skip(communityDlcPatches.IndexOf(first))) {
if (lastVersion != null && dlcPatch.From.Version != lastVersion)
continue;
DownloadAndInstallCommunityPatch(spec, dlcPatch.GetFileName(spec.Game, dlcEdition));
lastVersion = dlcPatch.To.Version;
}
}
void ApplyLatestPatches(IronFrontInfo spec) {
if (!GetGameLatestPatchedStatus(spec))
HandleGameCommunityPatches(spec);
if (GetDlcInstalledStatus(spec) && !GetDlcLatestPatchedStatus(spec))
HandleDlcCommunityPatches(spec);
}
public bool ConfirmPatchedToLatestVersion(IronFrontInfo spec) {
var gamePatched = GetGameLatestPatchedStatus(spec);
if (!GetDlcInstalledStatus(spec))
return gamePatched;
return gamePatched && GetDlcLatestPatchedStatus(spec);
}
void DownloadAndInstallCommunityPatch(IronFrontInfo spec, string patchFile) {
using (new TmpDirectory(spec.TempPath)) {
Status(patchFile, spec.Status,
status => DownloadAndInstallCommunityPatchInternal(patchFile, spec.TempPath, status, spec.GamePath));
}
}
static bool GetPatchStatus(IronFrontInfo spec, string file, string sha) {
return ConfirmChecksum(spec.GamePath.GetChildFileWithName(file), sha);
}
void InstallOfficialPatches(IronFrontInfo ifaSpec) {
if (!ifaSpec.IronFrontExePath.Exists)
throw new UnsupportedIFAVersionException("exe not found");
var exeVersion = GetExeVersion(ifaSpec.IronFrontExePath);
if (IsRequiredVersion(exeVersion))
return;
if (exeVersion.Major != 1)
throw new UnsupportedIFAVersionException(exeVersion.ToString());
switch (exeVersion.Minor) {
case 60:
PatchFrom0(ifaSpec);
break;
case 63:
PatchFrom3(ifaSpec);
break;
case 64:
PatchFrom4(ifaSpec);
break;
default:
throw new UnsupportedIFAVersionException(exeVersion.ToString());
}
exeVersion = GetExeVersion(ifaSpec.IronFrontExePath);
if (exeVersion < requiredVersion)
throw new UnsupportedIFAVersionException(exeVersion.ToString());
}
static bool GetGameLatestPatchedStatus(IronFrontInfo spec) {
var latestGamePatch = communityGamePatches.Last();
return GetPatchStatus(spec, latestGamePatch.ChecksumFile, latestGamePatch.To.Checksum);
}
void InstallOfficialPatch4To5(IronFrontInfo ifaSpec, bool esd) {
InstallOfficialPatch(esd ? OfficialGameInfo.Patch4To5Esd : OfficialGameInfo.Patch4To5, ifaSpec.TempPath,
ifaSpec.Status);
}
void ProcessCommunityGamePatches(IronFrontInfo spec) {
string lastVersion = null;
foreach (var gamePatch in communityGamePatches) {
if (lastVersion != null && gamePatch.From.Version != lastVersion)
continue;
DownloadAndInstallCommunityPatch(spec, gamePatch.GetFileName(spec.Game));
lastVersion = gamePatch.To.Version;
}
}
bool ConfirmTempSpaceAvailable(IronFrontInfo ifaSpec) {
return GetDrive(ifaSpec.TempPath).AvailableFreeSpace > RequiredTempFreeSpace;
}
void ProcessMainIF(IronFrontInfo spec) {
Status("main conversion", spec.Status,
status => ProcessIFDirectory(spec.IFSourcePath, spec.GameIFPath, spec.TempPath, status),
RepoStatus.Processing);
}
// TODO: The actionHandler concept should be refactored out of this domain service...
public void Install(IronFrontInfo info, Action<StatusRepo, string, Action> actionHandler) {
Confirmations(info);
if (info.IsInstalled()) {
if (!ConfirmPatchedToLatestVersion(info))
actionHandler(info.Status, "IFA Patching", () => ApplyLatestPatches(info));
return;
}
actionHandler(info.Status, "IFA Conversion", () => CleanInstall(info));
}
void CleanInstall(IronFrontInfo info) {
InstallOfficialPatches(info);
ProcessMainIF(info);
var dlcProcessed = ProcessDlc(info);
ProcessCommunityGamePatches(info);
if (dlcProcessed)
ProcessCommunityDlcPatches(info.IFDlcSourcePath, info);
}
