예제 #1
0
 static bool GetDlcInstalledStatus(IronFrontInfo spec) {
     return spec.IFDlcSourcePath.Exists;
 }
예제 #2
0
 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;
     }
 }
예제 #3
0
        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();
        }
예제 #4
0
 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;
 }
예제 #5
0
 bool ConfirmSpaceAvailable(IronFrontInfo ifaSpec) {
     return (ConfirmTempSpaceAvailable(ifaSpec) && ConfirmDestinationSpaceAvailable(ifaSpec));
 }
예제 #6
0
 bool ConfirmDestinationSpaceAvailable(IronFrontInfo ifaspec) {
     return GetDrive(ifaspec.GamePath).AvailableFreeSpace > RequiredFreeSpace;
 }
예제 #7
0
 static GamePatch GetFirstRequiredGamePatch(IronFrontInfo spec) {
     return
         communityGamePatches.LastOrDefault(
             gamePatch => GetPatchStatus(spec, gamePatch.ChecksumFile, gamePatch.From.Checksum));
 }
예제 #8
0
 void PatchFrom4(IronFrontInfo ifaSpec) {
     var esd = !ConfirmChecksum(ifaSpec.IronFrontExePath, OfficialGameInfo.Disk4ExeSha);
     InstallOfficialPatch4To5(ifaSpec, esd);
 }
예제 #9
0
 static DlcPatch GetFirstRequiredDlcPatch(IronFrontInfo spec, DlcEdition edition) {
     return
         communityDlcPatches.LastOrDefault(
             dlcPatch => GetPatchStatus(spec, dlcPatch.ChecksumFile, dlcPatch.GetFromChecksum(edition)));
 }
예제 #10
0
        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;
            }
        }
예제 #11
0
        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;
            }
        }
예제 #12
0
 void ApplyLatestPatches(IronFrontInfo spec) {
     if (!GetGameLatestPatchedStatus(spec))
         HandleGameCommunityPatches(spec);
     if (GetDlcInstalledStatus(spec) && !GetDlcLatestPatchedStatus(spec))
         HandleDlcCommunityPatches(spec);
 }
예제 #13
0
        public bool ConfirmPatchedToLatestVersion(IronFrontInfo spec) {
            var gamePatched = GetGameLatestPatchedStatus(spec);
            if (!GetDlcInstalledStatus(spec))
                return gamePatched;

            return gamePatched && GetDlcLatestPatchedStatus(spec);
        }
예제 #14
0
 void DownloadAndInstallCommunityPatch(IronFrontInfo spec, string patchFile) {
     using (new TmpDirectory(spec.TempPath)) {
         Status(patchFile, spec.Status,
             status => DownloadAndInstallCommunityPatchInternal(patchFile, spec.TempPath, status, spec.GamePath));
     }
 }
예제 #15
0
 static bool GetPatchStatus(IronFrontInfo spec, string file, string sha) {
     return ConfirmChecksum(spec.GamePath.GetChildFileWithName(file), sha);
 }
예제 #16
0
        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());
        }
예제 #17
0
 static bool GetGameLatestPatchedStatus(IronFrontInfo spec) {
     var latestGamePatch = communityGamePatches.Last();
     return GetPatchStatus(spec, latestGamePatch.ChecksumFile, latestGamePatch.To.Checksum);
 }
예제 #18
0
 void InstallOfficialPatch4To5(IronFrontInfo ifaSpec, bool esd) {
     InstallOfficialPatch(esd ? OfficialGameInfo.Patch4To5Esd : OfficialGameInfo.Patch4To5, ifaSpec.TempPath,
         ifaSpec.Status);
 }
예제 #19
0
 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;
     }
 }
예제 #20
0
 bool ConfirmTempSpaceAvailable(IronFrontInfo ifaSpec) {
     return GetDrive(ifaSpec.TempPath).AvailableFreeSpace > RequiredTempFreeSpace;
 }
예제 #21
0
 void ProcessMainIF(IronFrontInfo spec) {
     Status("main conversion", spec.Status,
         status => ProcessIFDirectory(spec.IFSourcePath, spec.GameIFPath, spec.TempPath, status),
         RepoStatus.Processing);
 }
예제 #22
0
        // 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));
        }
예제 #23
0
        void CleanInstall(IronFrontInfo info) {
            InstallOfficialPatches(info);

            ProcessMainIF(info);
            var dlcProcessed = ProcessDlc(info);
            ProcessCommunityGamePatches(info);

            if (dlcProcessed)
                ProcessCommunityDlcPatches(info.IFDlcSourcePath, info);
        }