Exemple #1
0
        private static bool AddModEntryToVersionManifest(VersionManifest manifest, ModDef.ManifestEntry modEntry, bool addToDB = false)
        {
            if (modEntry.Path == null)
            {
                return(false);
            }

            VersionManifestAddendum addendum = null;

            if (!string.IsNullOrEmpty(modEntry.AddToAddendum))
            {
                addendum = manifest.GetAddendumByName(modEntry.AddToAddendum);

                // create the addendum if it doesn't exist
                if (addendum == null)
                {
                    Log($"\t\tCreated addendum: {modEntry.AddToAddendum}");
                    addendum = new VersionManifestAddendum(modEntry.AddToAddendum);
                    manifest.ApplyAddendum(addendum);
                }
            }

            // add to DB
            if (addToDB && Path.GetExtension(modEntry.Path).ToLower() == ".json")
            {
                var type = (BattleTechResourceType)Enum.Parse(typeof(BattleTechResourceType), modEntry.Type);
                using (var metadataDatabase = new MetadataDatabase())
                {
                    VersionManifestHotReload.InstantiateResourceAndUpdateMDDB(type, modEntry.Path, metadataDatabase);
                    Log($"\t\tAdding to MDDB! {type} {modEntry.Path}");
                }
            }

            // add assetbundle path so it can be changed when the assetbundle path is requested
            if (modEntry.Type == "AssetBundle")
            {
                ModAssetBundlePaths[modEntry.Id] = modEntry.Path;
            }

            // add to addendum instead of adding to manifest
            if (addendum != null)
            {
                Log($"\t\tAddOrUpdate => {modEntry.Id} ({modEntry.Type}) to addendum {addendum.Name}");
                addendum.AddOrUpdate(modEntry.Id, modEntry.Path, modEntry.Type, DateTime.Now, modEntry.AssetBundleName, modEntry.AssetBundlePersistent);
                return(true);
            }

            // not added to addendum, not added to jsonmerges
            Log($"\t\tAddOrUpdate => {modEntry.Id} ({modEntry.Type})");
            manifest.AddOrUpdate(modEntry.Id, modEntry.Path, modEntry.Type, DateTime.Now, modEntry.AssetBundleName, modEntry.AssetBundlePersistent);
            return(true);
        }
Exemple #2
0
        private static bool AddModEntryToDB(MetadataDatabase db, string absolutePath, string typeStr)
        {
            if (Path.GetExtension(absolutePath)?.ToLower() != ".json")
            {
                return(false);
            }

            var type         = (BattleTechResourceType)Enum.Parse(typeof(BattleTechResourceType), typeStr);
            var relativePath = GetRelativePath(absolutePath, GameDirectory);

            switch (type) // switch is to avoid poisoning the output_log.txt with known types that don't use MDD
            {
            case BattleTechResourceType.TurretDef:
            case BattleTechResourceType.UpgradeDef:
            case BattleTechResourceType.VehicleDef:
            case BattleTechResourceType.ContractOverride:
            case BattleTechResourceType.SimGameEventDef:
            case BattleTechResourceType.LanceDef:
            case BattleTechResourceType.MechDef:
            case BattleTechResourceType.PilotDef:
            case BattleTechResourceType.WeaponDef:
                var writeTime = File.GetLastWriteTimeUtc(absolutePath);
                if (!dbCache.ContainsKey(relativePath) || dbCache[relativePath] != writeTime)
                {
                    try
                    {
                        VersionManifestHotReload.InstantiateResourceAndUpdateMDDB(type, absolutePath, db);
                        dbCache[relativePath] = writeTime;
                        return(true);
                    }
                    catch (Exception e)
                    {
                        Log($"\tAdd to DB failed for {Path.GetFileName(absolutePath)}, exception caught:");
                        Log($"\t\t{e.Message}");
                        return(false);
                    }
                }
                break;
            }

            return(false);
        }
Exemple #3
0
        internal static void TryAddToVersionManifest(VersionManifest manifest)
        {
            if (!hasLoadedMods)
            {
                LoadMods();
            }

            var breakMyGame = File.Exists(Path.Combine(ModDirectory, "break.my.game"));

            LogWithDate("Adding in mod manifests!");

            if (breakMyGame)
            {
                var mddPath       = Path.Combine(Path.Combine(StreamingAssetsDirectory, "MDD"), "MetadataDatabase.db");
                var mddBackupPath = mddPath + ".orig";

                Log($"\tBreak my game mode enabled! All new modded content (doesn't currently support merges) will be added to the DB.");

                if (!File.Exists(mddBackupPath))
                {
                    Log($"\t\tBacking up metadata database to {Path.GetFileName(mddBackupPath)}");
                    File.Copy(mddPath, mddBackupPath);
                }
            }

            foreach (var modName in modLoadOrder)
            {
                if (!ModManifest.ContainsKey(modName))
                {
                    continue;
                }

                Log($"\t{modName}:");
                foreach (var modEntry in ModManifest[modName])
                {
                    var existingEntry = manifest.Find(x => x.Id == modEntry.Id);
                    VersionManifestAddendum addendum = null;

                    if (!string.IsNullOrEmpty(modEntry.AddToAddendum))
                    {
                        addendum = manifest.GetAddendumByName(modEntry.AddToAddendum);

                        // create the addendum if it doesn't exist
                        if (addendum == null)
                        {
                            Log($"\t\tCreated addendum {modEntry.AddToAddendum}:");
                            addendum = new VersionManifestAddendum(modEntry.AddToAddendum);
                            manifest.ApplyAddendum(addendum);
                        }
                    }

                    if (modEntry.Type == null)
                    {
                        // null type means that we have to find existing entry with the same rel path to fill in the entry
                        // TODO: + 16 is a little bizzare looking, it's the length of the substring + 1 because we want to get rid of it and the \
                        var relPath = modEntry.Path.Substring(modEntry.Path.LastIndexOf("StreamingAssets", StringComparison.Ordinal) + 16);
                        var fakeStreamingAssetsPath = Path.Combine(StreamingAssetsDirectory, relPath);

                        existingEntry = manifest.Find(x => Path.GetFullPath(x.FilePath) == Path.GetFullPath(fakeStreamingAssetsPath));

                        if (existingEntry == null)
                        {
                            continue;
                        }

                        modEntry.Id   = existingEntry.Id;
                        modEntry.Type = existingEntry.Type;
                    }

                    if (Path.GetExtension(modEntry.Path).ToLower() == ".json" && modEntry.ShouldMergeJSON && existingEntry != null)
                    {
                        // read the manifest pointed entry and hash the contents
                        JsonHashToId[File.ReadAllText(existingEntry.FilePath).GetHashCode()] = modEntry.Id;

                        // The manifest already contains this information, so we need to queue it to be merged
                        var partialJson = File.ReadAllText(modEntry.Path);

                        if (!JsonMerges.ContainsKey(modEntry.Id))
                        {
                            JsonMerges.Add(modEntry.Id, new List <string>());
                        }

                        if (JsonMerges[modEntry.Id].Contains(partialJson))
                        {
                            Log($"\t\tAlready added {modEntry.Id} to JsonMerges");
                            continue;
                        }

                        Log($"\t\tAdding {modEntry.Id} to JsonMerges");
                        JsonMerges[modEntry.Id].Add(partialJson);
                        continue;
                    }

                    if (breakMyGame && Path.GetExtension(modEntry.Path).ToLower() == ".json")
                    {
                        var type = (BattleTechResourceType)Enum.Parse(typeof(BattleTechResourceType), modEntry.Type);
                        using (var metadataDatabase = new MetadataDatabase())
                        {
                            VersionManifestHotReload.InstantiateResourceAndUpdateMDDB(type, modEntry.Path, metadataDatabase);
                            Log($"\t\tAdding to MDDB! {type} {modEntry.Path}");
                        }
                    }

                    if (!string.IsNullOrEmpty(modEntry.AddToAddendum))
                    {
                        Log($"\t\tAddOrUpdate {modEntry.Type} {modEntry.Id} to addendum {addendum.Name}");
                        addendum.AddOrUpdate(modEntry.Id, modEntry.Path, modEntry.Type, DateTime.Now, modEntry.AssetBundleName, modEntry.AssetBundlePersistent);
                        continue;
                    }

                    // This is a new definition or a replacement that doesn't get merged, so add or update the manifest
                    Log($"\t\tAddOrUpdate {modEntry.Type} {modEntry.Id}");
                    manifest.AddOrUpdate(modEntry.Id, modEntry.Path, modEntry.Type, DateTime.Now, modEntry.AssetBundleName, modEntry.AssetBundlePersistent);
                }
            }

            Log("");
        }