ModPackage Class Reference

Inheritance diagram for ModPackage:

Classes
struct	SheetIndex

Public Member Functions
void	CopyContentTo (string dir)
IReadOnlyList< FileInfo >	ParseTalkText (DirectoryInfo dir)
IReadOnlyList< FileInfo >	ParseMap (DirectoryInfo dir, bool addToList=true)
IReadOnlyList< FileInfo >	ParseMapPiece (DirectoryInfo dir, bool addToList=true)
IReadOnlyList< FileInfo >	ParseTextureReplace (DirectoryInfo dir)
IReadOnlyList< FileInfo >	ParseTexture (DirectoryInfo dir)
IReadOnlyList< FileInfo >	ParsePortrait (DirectoryInfo dir)
void	ParseLangMod (DirectoryInfo dir)
IReadOnlyList< FileInfo >	ParseSound (DirectoryInfo dir)
override void	GenerateCustomContentProfiles ()
override SortedDictionary< string, string >	ExportSourceLocalizations ()
override void	ImportSourceLocalizations (IReadOnlyDictionary< string, string > texts)
override void	ClearSourceLocalizations (string lang)
override string	UpdateSourceLocalizationFile (string lang, bool force=false)
void	AddOrUpdateLang (DirectoryInfo dir)
void	UpdateDialogs (DirectoryInfo dir, string dirTemp)
void	UpdateTalks (DirectoryInfo dir, string dirTemp)
void	UpdateExcelBook (FileInfo f, string dirTemp, bool updateOnlyText)
int	UpdateExcelSheet (ISheet destSheet, ISheet oldSheet, bool updateOnlytext)

Public Attributes
Action< UINote >	onBuildConfig
Action	onResetConfig
string	configPath

Detailed Description

Definition at line 10 of file ModPackage.cs.

Member Function Documentation

AddOrUpdateLang()

void ModPackage.AddOrUpdateLang ( DirectoryInfo  dir )

inline

Definition at line 376 of file ModPackage.cs.

    {
        Core core = EClass.core;
        SourceManager sources = core.sources;
        DirectoryInfo[] directories = dir.GetDirectories();
        foreach (DirectoryInfo directoryInfo in directories)
        {
            if (!directoryInfo.Name.StartsWith("_") && !TryAddLang(directoryInfo, isNew: false))
            {
                Debug.Log("Generating Language Mod Contents:" + directoryInfo.FullName);
                IO.CopyDir(CorePath.packageCore + "Lang/EN", directoryInfo.FullName);
                Directory.CreateDirectory(directoryInfo.FullName + "/Dialog");
                IO.CopyDir(CorePath.packageCore + "Lang/_Dialog", directoryInfo.FullName + "/Dialog");
                sources.ExportSourceTexts(directoryInfo.FullName + "/Game");
                IO.Copy(CorePath.packageCore + "Lang/lang.ini", directoryInfo.FullName + "/");
                TryAddLang(directoryInfo, isNew: true);
            }
        }
        bool TryAddLang(DirectoryInfo dirLang, bool isNew)
        {
            string name = dirLang.Name;
            FileInfo[] files = dirLang.GetFiles();
            foreach (FileInfo fileInfo in files)
            {
                if (fileInfo.Name == "lang.ini")
                {
                    LangSetting langSetting = new LangSetting(fileInfo.FullName)
                    {
                        id = name,
                        dir = dirLang.FullName + "/"
                    };
                    if (isNew)
                    {
                        langSetting.SetVersion();
                    }
                    else if ((Application.isEditor || Lang.runUpdate) && !Lang.IsBuiltin(dirLang.Name) && langSetting.GetVersion() < core.version.GetInt())
                    {
                        sources.Init();
                        Log.system = "Updated Language Files:" + Environment.NewLine + Environment.NewLine;
                        Debug.Log("Updating Language:" + langSetting.name + "/" + langSetting.GetVersion() + "/" + core.version.GetInt());
                        string text = dirLang.FullName + "/Game";
                        Directory.Move(text, text + "_temp");
                        sources.ExportSourceTexts(text);
                        sources.UpdateSourceTexts(text);
                        IO.DeleteDirectory(text + "_temp");
                        text = dirLang.FullName + "/Dialog";
                        Directory.Move(text, text + "_temp");
                        IO.CopyDir(CorePath.packageCore + "Lang/_Dialog", text);
                        UpdateDialogs(new DirectoryInfo(text), text + "_temp");
                        IO.DeleteDirectory(text + "_temp");
                        text = dirLang.FullName + "/Data";
                        IO.CopyDir(text, text + "_temp");
                        IO.Copy(CorePath.packageCore + "Lang/EN/Data/god_talk.xlsx", text);
                        IO.Copy(CorePath.packageCore + "Lang/EN/Data/chara_talk.xlsx", text);
                        UpdateTalks(new DirectoryInfo(text), text + "_temp");
                        IO.DeleteDirectory(text + "_temp");
                        langSetting.SetVersion();
                        IO.SaveText(dirLang.FullName + "/update.txt", Log.system);
                    }
                    MOD.langs[name] = langSetting;
                    return true;
                }
            }
            return false;
        }
    }

References EClass.core, Debug, LangSetting.GetVersion(), Lang.IsBuiltin(), MOD.langs, LangSetting.name, CorePath.packageCore, Lang.runUpdate, LangSetting.SetVersion(), Core.sources, Log.system, UpdateDialogs(), and UpdateTalks().

Referenced by ModManager.ParseExtra().

ClearSourceLocalizations()

override void ModPackage.ClearSourceLocalizations ( string  lang )

inline

Definition at line 338 of file ModPackage.cs.

    {
        Mapping.RebuildLangModMapping(lang);
        for (FileInfo fileInfo = Mapping.RelocateFile("SourceLocalization.json"); fileInfo != null; fileInfo = Mapping.RelocateFile("SourceLocalization.json"))
        {
            fileInfo.Delete();
            Debug.Log("#source-localization deleted " + fileInfo.ShortPath());
        }
        Mapping.RebuildLangModMapping(Lang.langCode);
    }

References Debug, and Lang.langCode.

CopyContentTo()

void ModPackage.CopyContentTo ( string  dir )

inline

Definition at line 25 of file ModPackage.cs.

    {
        IO.DeleteDirectory(dir);
        IO.CopyAll(dirInfo.FullName, dir);
        EClass.ui.Say(dir);
    }

References EClass.ui.

Referenced by LayerMod.SetModRow().

ExportSourceLocalizations()

override SortedDictionary< string, string > ModPackage.ExportSourceLocalizations ( )

inline

Definition at line 307 of file ModPackage.cs.

    {
        SortedDictionary<string, string> sortedDictionary = new SortedDictionary<string, string>();
        try
        {
            foreach (SourceData.BaseRow sourceRow in sourceRows)
            {
                foreach (KeyValuePair<string, string> item in sourceRow.ExportTexts(sourceRow.UseAlias ? "alias" : "id"))
                {
                    item.Deconstruct(out var key, out var value);
                    string key2 = key;
                    string value2 = value;
                    sortedDictionary[key2] = value2;
                }
            }
        }
        catch (Exception arg)
        {
            Debug.LogError($"#source failed to export localization for {title}/{id}\n{arg}");
        }
        return sortedDictionary;
    }

References $, Debug, and item.

Referenced by UpdateSourceLocalizationFile().

GenerateCustomContentProfiles()

override void ModPackage.GenerateCustomContentProfiles ( )

inline

Definition at line 209 of file ModPackage.cs.

    {
        customContent.Clear();
        foreach (SourceData.BaseRow sourceRow in sourceRows)
        {
            if (!(sourceRow is SourceChara.Row r))
            {
                if (!(sourceRow is SourceReligion.Row row))
                {
                    if (!(sourceRow is SourceZone.Row r2))
                    {
                        if (!(sourceRow is SourceElement.Row r3))
                        {
                            if (!(sourceRow is SourceMaterial.Row r4))
                            {
                                if (!(sourceRow is SourceStat.Row r5))
                                {
                                    if (!(sourceRow is SourceThing.Row r6))
                                    {
                                        if (!(sourceRow is SourceBlock.Row r7))
                                        {
                                            if (!(sourceRow is SourceFloor.Row r8))
                                            {
                                                if (!(sourceRow is SourceObj.Row r9))
                                                {
                                                    if (!(sourceRow is SourceDeco.Row r10))
                                                    {
                                                        if (!(sourceRow is SourceCellEffect.Row r11))
                                                        {
                                                            if (!(sourceRow is SourceFaction.Row) && sourceRow is SourceQuest.Row)
                                                            {
                                                            }
                                                        }
                                                        else
                                                        {
                                                            customContent.Add(CustomCellEffectContent.CreateFromRow(r11, this));
                                                        }
                                                    }
                                                    else
                                                    {
                                                        customContent.Add(CustomDecoContent.CreateFromRow(r10, this));
                                                    }
                                                }
                                                else
                                                {
                                                    customContent.Add(CustomObjContent.CreateFromRow(r9, this));
                                                }
                                            }
                                            else
                                            {
                                                customContent.Add(CustomFloorContent.CreateFromRow(r8, this));
                                            }
                                        }
                                        else
                                        {
                                            customContent.Add(CustomBlockContent.CreateFromRow(r7, this));
                                        }
                                    }
                                    else
                                    {
                                        ModUtil.FixDefaultThingRowPref(r6);
                                        customContent.Add(CustomThingContent.CreateFromRow(r6, this));
                                    }
                                }
                                else
                                {
                                    customContent.Add(CustomStatContent.CreateFromRow(r5, this));
                                }
                            }
                            else
                            {
                                customContent.Add(CustomMaterialContent.CreateFromRow(r4, this));
                            }
                        }
                        else
                        {
                            customContent.Add(CustomElementContent.CreateFromRow(r3, this));
                        }
                    }
                    else
                    {
                        customContent.Add(CustomZoneContent.CreateFromRow(r2, this));
                    }
                }
                else if (row.id.StartsWith("cwl") || row.id.StartsWith("custom"))
                {
                    customContent.Add(CustomReligionContent.CreateFromRow(row, this));
                }
            }
            else
            {
                ModUtil.FixDefaultCharaRowPref(r);
                customContent.Add(CustomCharaContent.CreateFromRow(r, this));
            }
        }
        customContent.RemoveAll((ICustomContent p) => p == null);
    }

References CustomBlockContent.CreateFromRow(), CustomCellEffectContent.CreateFromRow(), CustomCharaContent.CreateFromRow(), CustomDecoContent.CreateFromRow(), CustomElementContent.CreateFromRow(), CustomFloorContent.CreateFromRow(), CustomMaterialContent.CreateFromRow(), CustomObjContent.CreateFromRow(), CustomStatContent.CreateFromRow(), CustomThingContent.CreateFromRow(), and CustomZoneContent.CreateFromRow().

ImportSourceLocalizations()

override void ModPackage.ImportSourceLocalizations ( IReadOnlyDictionary< string, string >  texts )

inline

Definition at line 330 of file ModPackage.cs.

    {
        foreach (SourceData.BaseRow sourceRow in sourceRows)
        {
            sourceRow.ImportTexts(texts, sourceRow.UseAlias ? "alias" : "id");
        }
    }

ParseLangMod()

void ModPackage.ParseLangMod ( DirectoryInfo  dir )

inline

Definition at line 167 of file ModPackage.cs.

    {
        if (Mapping == null)
        {
            Mapping = new FileMapping(dir.Parent);
        }
        Mapping.RebuildLangModMapping(EClass.core.config?.lang ?? EClass.core.debug.langCode.ToString());
        Lang.excelDialog = null;
        Debug.Log("LangMod: " + string.Join(", ", Mapping.OrderedLangMods));
        if (Mapping.SourceSheets.Count > 0)
        {
            Debug.Log($"Source Sheets: {Mapping.SourceSheets.Count}, {Mapping.SourceLangMod}");
        }
    }

References $, Core.config, EClass.core, Core.debug, Debug, CoreConfig.lang, and CoreDebug.langCode.

Referenced by ModManager.ParseExtra().

ParseMap()

IReadOnlyList< FileInfo > ModPackage.ParseMap ( DirectoryInfo  dir, bool  addToList = true  )

inline

Definition at line 50 of file ModPackage.cs.

    {
        List<FileInfo> list = new List<FileInfo>();
        FileInfo[] files = dir.GetFiles("*.z", SearchOption.TopDirectoryOnly);
        foreach (FileInfo fileInfo in files)
        {
            string key = Path.ChangeExtension(fileInfo.Name, null);
            if (addToList)
            {
                MOD.listMaps.Add(fileInfo);
            }
            maps[key] = fileInfo;
            list.Add(fileInfo);
        }
        if (list.Count > 0)
        {
            Debug.Log($"Map: {maps.Count}");
        }
        return list;
    }

References $, Debug, and MOD.listMaps.

Referenced by ModManager.ParseExtra().

ParseMapPiece()

IReadOnlyList< FileInfo > ModPackage.ParseMapPiece ( DirectoryInfo  dir, bool  addToList = true  )

inline

Definition at line 71 of file ModPackage.cs.

    {
        List<FileInfo> list = new List<FileInfo>();
        FileInfo[] files = dir.GetFiles("*.mp", SearchOption.TopDirectoryOnly);
        foreach (FileInfo fileInfo in files)
        {
            string key = Path.ChangeExtension(fileInfo.Name, null);
            if (addToList)
            {
                MOD.listPartialMaps.Add(fileInfo);
            }
            partialMaps[key] = fileInfo;
            list.Add(fileInfo);
        }
        if (list.Count > 0)
        {
            Debug.Log($"PartialMap: {partialMaps.Count}");
        }
        return list;
    }

References $, Debug, and MOD.listPartialMaps.

Referenced by ModManager.ParseExtra().

ParsePortrait()

IReadOnlyList< FileInfo > ModPackage.ParsePortrait ( DirectoryInfo  dir )

inline

Definition at line 129 of file ModPackage.cs.

    {
        List<FileInfo> list = new List<FileInfo>();
        FileInfo[] files = dir.GetFiles("*.png", SearchOption.TopDirectoryOnly);
        foreach (FileInfo fileInfo in files)
        {
            string name = fileInfo.Name;
            if (name.StartsWith("BG_", StringComparison.Ordinal))
            {
                Portrait.modPortraitBGs.Add(fileInfo);
            }
            else if (name.StartsWith("BGF_", StringComparison.Ordinal))
            {
                Portrait.modPortraitBGFs.Add(fileInfo);
            }
            else if (name.EndsWith("-full.png", StringComparison.Ordinal))
            {
                Portrait.modFull.Add(fileInfo);
            }
            else if (name.EndsWith("-overlay.png", StringComparison.Ordinal))
            {
                Portrait.modOverlays.Add(fileInfo);
            }
            else
            {
                Portrait.modPortraits.Add(fileInfo);
            }
            Portrait.allIds.Add(name);
            portraits[name] = fileInfo;
            list.Add(fileInfo);
        }
        if (list.Count > 0)
        {
            Debug.Log($"Portrait: {portraits.Count}");
        }
        return list;
    }

References $, ModItemList< T >.Add(), Portrait.allIds, Debug, Portrait.modFull, Portrait.modOverlays, Portrait.modPortraitBGFs, Portrait.modPortraitBGs, and Portrait.modPortraits.

Referenced by ModManager.ParseExtra().

ParseSound()

IReadOnlyList< FileInfo > ModPackage.ParseSound ( DirectoryInfo  dir )

inline

Definition at line 182 of file ModPackage.cs.

    {
        List<FileInfo> list = new List<FileInfo>();
        FileInfo[] files = dir.GetFiles("*.*", SearchOption.AllDirectories);
        foreach (FileInfo fileInfo in files)
        {
            if (ModUtil.GetAudioType(fileInfo.Extension) != AudioType.UNKNOWN)
            {
                string key = Path.ChangeExtension(Path.GetRelativePath(dir.FullName, fileInfo.FullName).NormalizePath(), null);
                Dictionary<string, FileInfo> dictionary = MOD.sounds;
                FileInfo value = (sounds[key] = fileInfo);
                dictionary[key] = value;
                list.Add(fileInfo);
            }
        }
        if (list.Count > 0)
        {
            Debug.Log($"Sound: {sounds.Count}");
        }
        int num = sounds.Keys.Count((string k) => k.StartsWith("BGM/"));
        if (num > 0)
        {
            Debug.Log($"BGM: {num}");
        }
        return list;
    }

References $, Debug, and MOD.sounds.

Referenced by ModManager.ParseExtra().

ParseTalkText()

IReadOnlyList< FileInfo > ModPackage.ParseTalkText ( DirectoryInfo  dir )

inline

Definition at line 32 of file ModPackage.cs.

    {
        List<FileInfo> list = new List<FileInfo>();
        FileInfo[] files = dir.GetFiles("*.xlsx", SearchOption.TopDirectoryOnly);
        foreach (FileInfo fileInfo in files)
        {
            ExcelData excelData = new ExcelData(fileInfo.FullName);
            TalkText.modList.Add(excelData);
            talkTexts.Add(excelData);
            list.Add(fileInfo);
        }
        if (list.Count > 0)
        {
            Debug.Log($"TalkText: {talkTexts.Count}");
        }
        return list;
    }

References $, Debug, and TalkText.modList.

Referenced by ModManager.ParseExtra().

ParseTexture()

IReadOnlyList< FileInfo > ModPackage.ParseTexture ( DirectoryInfo  dir )

inline

Definition at line 109 of file ModPackage.cs.

    {
        List<FileInfo> list = new List<FileInfo>();
        FileInfo[] files = dir.GetFiles("*.png", SearchOption.AllDirectories);
        foreach (FileInfo fileInfo in files)
        {
            string key = Path.ChangeExtension(Path.GetRelativePath(dir.FullName, fileInfo.FullName).NormalizePath(), null);
            string text = Path.ChangeExtension(fileInfo.FullName, null);
            Dictionary<string, string> dictModItems = SpriteReplacer.dictModItems;
            string value = (textures[key] = text);
            dictModItems[key] = value;
            list.Add(fileInfo);
        }
        if (list.Count > 0)
        {
            Debug.Log($"Texture: {textures.Count}");
        }
        return list;
    }

References $, Debug, and SpriteReplacer.dictModItems.

Referenced by ModManager.ParseExtra().

ParseTextureReplace()

IReadOnlyList< FileInfo > ModPackage.ParseTextureReplace ( DirectoryInfo  dir )

inline

Definition at line 92 of file ModPackage.cs.

    {
        List<FileInfo> list = new List<FileInfo>();
        FileInfo[] files = dir.GetFiles("*.png", SearchOption.TopDirectoryOnly);
        foreach (FileInfo fileInfo in files)
        {
            string key = Path.ChangeExtension(fileInfo.Name, null);
            textureReplaces[key] = fileInfo;
            list.Add(fileInfo);
        }
        if (list.Count > 0)
        {
            Debug.Log($"Texture Replace: {textureReplaces.Count}");
        }
        return list;
    }

References $, and Debug.

Referenced by ModManager.ParseExtra().

UpdateDialogs()

void ModPackage.UpdateDialogs ( DirectoryInfo  dir, string  dirTemp  )

inline

Definition at line 443 of file ModPackage.cs.

    {
        DirectoryInfo[] directories = dir.GetDirectories();
        foreach (DirectoryInfo directoryInfo in directories)
        {
            UpdateDialogs(directoryInfo, dirTemp + "/" + directoryInfo.Name);
        }
        FileInfo[] files = dir.GetFiles();
        foreach (FileInfo fileInfo in files)
        {
            if (fileInfo.Name.EndsWith("xlsx"))
            {
                UpdateExcelBook(fileInfo, dirTemp, updateOnlyText: true);
            }
        }
    }

References UpdateDialogs(), and UpdateExcelBook().

Referenced by AddOrUpdateLang(), and UpdateDialogs().

UpdateExcelBook()

void ModPackage.UpdateExcelBook ( FileInfo  f, string  dirTemp, bool  updateOnlyText  )

inline

Definition at line 472 of file ModPackage.cs.

    {
        string path = dirTemp + "/" + f.Name;
        if (!File.Exists(path))
        {
            return;
        }
        XSSFWorkbook xSSFWorkbook;
        using (FileStream @is = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
        {
            xSSFWorkbook = new XSSFWorkbook((Stream)@is);
        }
        XSSFWorkbook xSSFWorkbook2;
        using (FileStream is2 = File.Open(f.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
        {
            xSSFWorkbook2 = new XSSFWorkbook((Stream)is2);
        }
        for (int i = 0; i < xSSFWorkbook2.NumberOfSheets; i++)
        {
            ISheet sheetAt = xSSFWorkbook2.GetSheetAt(i);
            ISheet sheet = xSSFWorkbook.GetSheet(sheetAt.SheetName);
            if (sheet == null)
            {
                Log.system = Log.system + "Old sheet not found:" + sheetAt.SheetName + Environment.NewLine;
                continue;
            }
            int num = UpdateExcelSheet(sheetAt, sheet, updateOnlyText);
            Log.system = Log.system + ((num == 0) ? "(No Changes) " : "(Updated) ") + f.FullName + "(" + sheetAt.SheetName + ")" + Environment.NewLine;
            if (num != 0)
            {
                Log.system = Log.system + num + Environment.NewLine;
            }
            Log.system += Environment.NewLine;
        }
        using FileStream stream = new FileStream(f.FullName, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
        xSSFWorkbook2.Write(stream);
    }

References UpdateExcelSheet().

Referenced by UpdateDialogs(), and UpdateTalks().

UpdateExcelSheet()

int ModPackage.UpdateExcelSheet ( ISheet  destSheet, ISheet  oldSheet, bool  updateOnlytext  )

inline

Definition at line 510 of file ModPackage.cs.

    {
        Dictionary<string, string[]> dictionary = new Dictionary<string, string[]>();
        int num = 0;
        int num2 = 0;
        int num3 = 10;
        IRow row = destSheet.GetRow(0);
        IRow row2 = oldSheet.GetRow(0);
        List<SheetIndex> list = new List<SheetIndex>();
        int cellnum = FindField(row, "id");
        int cellnum2 = FindField(row2, "id");
        for (int i = 0; i < row.LastCellNum; i++)
        {
            ICell cell = row.GetCell(i);
            if (cell == null)
            {
                break;
            }
            string stringCellValue = cell.StringCellValue;
            if (stringCellValue == "id" || (updateOnlytext && stringCellValue != "text"))
            {
                continue;
            }
            for (int j = 0; j < row2.LastCellNum; j++)
            {
                cell = row2.GetCell(j);
                if (cell == null)
                {
                    break;
                }
                if (cell.StringCellValue == stringCellValue)
                {
                    list.Add(new SheetIndex
                    {
                        dest = i,
                        old = j
                    });
                    Debug.Log(destSheet.SheetName + "/" + stringCellValue + "/" + i + "/" + j);
                    break;
                }
            }
        }
        for (int k = 2; k <= oldSheet.LastRowNum; k++)
        {
            IRow row3 = oldSheet.GetRow(k);
            if (row3 == null)
            {
                if (num2 >= num3)
                {
                    break;
                }
                num2++;
                continue;
            }
            num2 = 0;
            ICell cell2 = row3.GetCell(cellnum2);
            if (cell2 == null)
            {
                continue;
            }
            string text = ((cell2.CellType == CellType.Numeric) ? cell2.NumericCellValue.ToString() : cell2.StringCellValue);
            if (text.IsEmpty())
            {
                continue;
            }
            string[] array = new string[list.Count];
            for (int l = 0; l < list.Count; l++)
            {
                ICell cell3 = row3.GetCell(list[l].old);
                if (cell3 != null)
                {
                    string stringCellValue2 = cell3.StringCellValue;
                    if (!stringCellValue2.IsEmpty())
                    {
                        array[l] = stringCellValue2;
                    }
                }
            }
            dictionary.Add(text, array);
        }
        num2 = 0;
        for (int m = 2; m <= destSheet.LastRowNum; m++)
        {
            IRow row4 = destSheet.GetRow(m);
            if (row4 == null)
            {
                if (num2 >= num3)
                {
                    break;
                }
                num2++;
                continue;
            }
            num2 = 0;
            ICell cell4 = row4.GetCell(cellnum);
            if (cell4 == null)
            {
                continue;
            }
            string text2 = ((cell4.CellType == CellType.Numeric) ? cell4.NumericCellValue.ToString() : cell4.StringCellValue);
            if (text2.IsEmpty() || !dictionary.ContainsKey(text2))
            {
                continue;
            }
            string[] array2 = dictionary[text2];
            for (int n = 0; n < list.Count; n++)
            {
                ICell cell5 = row4.GetCell(list[n].dest) ?? row4.CreateCell(list[n].dest, CellType.String);
                if (cell5 != null)
                {
                    cell5.SetCellValue(array2[n]);
                    cell5.SetCellType(CellType.String);
                    cell5.SetAsActiveCell();
                    num++;
                }
            }
        }
        return num;
        static int FindField(IRow row5, string id)
        {
            for (int num4 = 0; num4 < row5.LastCellNum; num4++)
            {
                ICell cell6 = row5.GetCell(num4);
                if (cell6 == null)
                {
                    break;
                }
                if (cell6.StringCellValue == id)
                {
                    return num4;
                }
            }
            return -1;
        }
    }

References Debug.

Referenced by UpdateExcelBook().

UpdateSourceLocalizationFile()

override string ModPackage.UpdateSourceLocalizationFile ( string  lang, bool  force = false  )

inline

Definition at line 349 of file ModPackage.cs.

    {
        if (!base.IsSourceLocalizable)
        {
            return null;
        }
        IReadOnlyDictionary<string, string> modEntries = SourceLocalization.GetModEntries(id, lang);
        SortedDictionary<string, string> sortedDictionary = ExportSourceLocalizations();
        SortedDictionary<string, string> final = new SortedDictionary<string, string>();
        foreach (var (key, defaultValue) in sortedDictionary)
        {
            final[key] = modEntries.GetValueOrDefault(key, defaultValue);
        }
        string text3 = Path.Combine(dirInfo.FullName, "LangMod/" + lang + "/SourceLocalization.json");
        if (force || modEntries.Count != final.Count || modEntries.Any((KeyValuePair<string, string> kv) => !final.ContainsKey(kv.Key)))
        {
            JsonSerializerSettings setting = new JsonSerializerSettings
            {
                PreserveReferencesHandling = PreserveReferencesHandling.None,
                NullValueHandling = NullValueHandling.Ignore
            };
            IO.SaveFile(text3, final, compress: false, setting);
            SourceLocalization.UpdateModEntries(id, lang, final);
        }
        return text3;
    }

References ExportSourceLocalizations().

Referenced by LayerMod.SetModRow().

UpdateTalks()

void ModPackage.UpdateTalks ( DirectoryInfo  dir, string  dirTemp  )

inline

Definition at line 460 of file ModPackage.cs.

    {
        FileInfo[] files = dir.GetFiles();
        foreach (FileInfo fileInfo in files)
        {
            if (fileInfo.Name == "god_talk.xlsx" || fileInfo.Name == "chara_talk.xlsx")
            {
                UpdateExcelBook(fileInfo, dirTemp, updateOnlyText: false);
            }
        }
    }

References UpdateExcelBook().

Referenced by AddOrUpdateLang().

Member Data Documentation

configPath

string ModPackage.configPath

Definition at line 23 of file ModPackage.cs.

Referenced by LayerModConfig.Show().

onBuildConfig

Action<UINote> ModPackage.onBuildConfig

Definition at line 19 of file ModPackage.cs.

Referenced by LayerMod.SetModRow(), and LayerModConfig.Show().

onResetConfig

Action ModPackage.onResetConfig

Definition at line 21 of file ModPackage.cs.

Referenced by LayerModConfig.Show().

---

The documentation for this class was generated from the following file:

• Elin/ModPackage.cs