public static void ReloadParams()
{
if (!File.Exists(ParamPath))
{
Debug.Log("DS2 enc_regulation.bnd.dcx not found");
return;
}
if (!BND4.Is(DarkSoulsTools.GetOverridenPath(ParamPath)))
{
Debug.Log("Decrypt your regulation by saving in Yapped");
return;
}
BND4 paramBnd = BND4.Read(DarkSoulsTools.GetOverridenPath(ParamPath));
EnemyParam = PARAM.Read(paramBnd.Files.Find(x => Path.GetFileName(x.Name) == "EnemyParam.param").Bytes);
PARAM.Layout layout = PARAM.Layout.ReadXMLFile($@"{Application.dataPath.Replace('/', '\\')}\dstools\ParamLayouts\DS2SOTFS\{EnemyParam.ID}.xml");
EnemyParam.SetLayout(layout);
// Build and cache the enemy param dictionary
ParamDictionary = new Dictionary <long, PARAM.Row>();
foreach (var row in EnemyParam.Rows)
{
ParamDictionary.Add(row.ID, row);
}
}
public static void ReloadParams()
{
if (!File.Exists(ParamPath))
{
Debug.Log("Data0.bdt not found. This will make treasure editor have less functionality.");
return;
}
BND4 paramBnd = SFUtil.DecryptDS3Regulation(DarkSoulsTools.GetOverridenPath(ParamPath));
DS3Param = PARAM.Read(paramBnd.Files.Find(x => Path.GetFileName(x.Name) == "ItemLotParam.param").Bytes);
PARAM.Layout layout = PARAM.Layout.ReadXMLFile($@"{Application.dataPath.Replace('/', '\\')}\dstools\ParamLayouts\DS3\{DS3Param.ID}.xml");
DS3Param.SetLayout(layout);
// Build and cache the item name list
HashSet <int> usedItemIds = new HashSet <int>();
ItemNameList = new List <Tuple <int, string> >();
foreach (var row in DS3Param.Rows)
{
ItemLotParam param = new ItemLotParam(row);
foreach (int id in param.ItemID)
{
if (!usedItemIds.Contains(id))
{
usedItemIds.Add(id);
ItemNameList.Add(new Tuple <int, string>(id, FMGUtils.LookupItemName(id)));
}
}
}
ItemNameList.Sort((a, b) => StringComparer.InvariantCulture.Compare(a.Item2, b.Item2));
}
private static void LoadParamFromBinder(IBinder parambnd)
{
// Load every param in the regulation
// _params = new Dictionary<string, PARAM>();
foreach (var f in parambnd.Files)
{
if (!f.Name.ToUpper().EndsWith(".PARAM") || Path.GetFileNameWithoutExtension(f.Name).StartsWith("default_"))
{
continue;
}
if (f.Name.EndsWith("LoadBalancerParam.param"))
{
continue;
}
if (_params.ContainsKey(Path.GetFileNameWithoutExtension(f.Name)))
{
continue;
}
PARAM p = PARAM.Read(f.Bytes);
if (!_paramdefs.ContainsKey(p.ParamType))
{
continue;
}
p.ApplyParamdef(_paramdefs[p.ParamType]);
_params.Add(Path.GetFileNameWithoutExtension(f.Name), p);
}
}
private void LoadRegulation(string path)
{
BND4 bnd;
try
{
bnd = SFUtil.DecryptDS3Regulation(path);
}
catch (Exception ex)
{
ShowError($"Failed to load regulation file:\r\n\r\n{path}\r\n\r\n{ex}");
return;
}
paramFiles = new List <ParamFile>();
foreach (BinderFile file in bnd.Files)
{
if (Path.GetExtension(file.Name) == ".param")
{
try
{
PARAM param = PARAM.Read(file.Bytes);
paramFiles.Add(new ParamFile(Path.GetFileNameWithoutExtension(file.Name), param, layouts));
}
catch
{
}
}
}
paramFiles.Sort((p1, p2) => p1.Name.CompareTo(p2.Name));
dgvParams.DataSource = paramFiles;
}
public static PARAM GetParam(string paramName)
{
if (!ParamBNDs.ContainsKey(GameDataManager.GameType))
{
throw new InvalidOperationException("ParamBND not loaded :tremblecat:");
}
if (!LoadedParams.ContainsKey(GameDataManager.GameType))
{
LoadedParams.Add(GameDataManager.GameType, new Dictionary <string, PARAM>());
}
if (LoadedParams[GameDataManager.GameType].ContainsKey(paramName))
{
return(LoadedParams[GameDataManager.GameType][paramName]);
}
else
{
foreach (var f in ParamBNDs[GameDataManager.GameType].Files)
{
if (f.Name.ToUpper().Contains(paramName.ToUpper()))
{
var p = PARAM.Read(f.Bytes);
LoadedParams[GameDataManager.GameType].Add(paramName, p);
return(p);
}
}
}
throw new InvalidOperationException($"Param '{paramName}' not found :tremblecat:");
}
public static void LoadParams(SQLiteConnection con, string paramdefFilepath, IList <string> paramDirs)
{
// The metadata tables should be created ahead of time.
CreateBndMetadataTables(con);
CreateBndTableOfContentsTable(con);
CreateParamMetadataTables(con);
// Reading an original paramdefbnd
var paramdefs = new Dictionary <string, PARAMDEF>();
var paramdefbnd = BND3.Read(paramdefFilepath);
foreach (BinderFile file in paramdefbnd.Files)
{
var paramdef = PARAMDEF.Read(file.Bytes);
paramdefs[paramdef.ParamType] = paramdef;
}
ReadParamdefsIntoDatabase(con, paramdefs.Values.ToList());
// Loading parambnd
List <string> paramFilepaths = new List <string>();
foreach (var paramDir in paramDirs)
{
// DeS has both a gameparam.parambnd.dcx and a gameparamna.parambnd.dcx.
// Only grab gameparamna.parambnd.dcx if we have it.
string filterPattern = "*.parambnd.dcx";
if (Directory.GetFiles(paramDir, "*gameparamna.parambnd.dcx").Length > 0)
{
Console.WriteLine("Skipping gameparam.parambnd.dcx");
filterPattern = "*gameparamna.parambnd.dcx";
}
paramFilepaths.AddRange(Directory.GetFiles(paramDir, filterPattern));
}
foreach (var paramFilepath in paramFilepaths)
{
// Have to construct Table of Contents as we go through, since the info isn't all at BND level, but is needed when reconstructing
var bndContents = new List <BndContentsEntry>();
Console.WriteLine("Loading file: " + paramFilepath);
var parambnd = BND3.Read(paramFilepath);
foreach (BinderFile file in parambnd.Files)
{
PARAM param = PARAM.Read(file.Bytes);
// DSR doesn't seem to like applying carefully, specifically SP_EFFECT_PARAM_ST in Gameparam. At minimum.
param.ApplyParamdef(paramdefs[param.ParamType]);
var entry = new BndContentsEntry(paramFilepath, file.ID, file.Name, file.Flags, file.CompressionType, param.ParamType);
bndContents.Add(entry);
ReadParamIntoDatabase(con, Path.GetFileNameWithoutExtension(file.Name), param);
}
// Create the metadata tables
ReadBndMetadataIntoDatabase(con, paramFilepath, parambnd);
ReadBndTableOfContentsIntoDatabase(con, Path.GetFileName(paramFilepath), bndContents);
}
}
public void Write(string name, PARAM param)
{
var existingParamFile = Regulation.Files
.First(f => f.Name.EndsWith($"{name}.param"));
var existingParam = PARAM.Read(existingParamFile.Bytes);
existingParam.Rows = param.Rows;
existingParam.ApplyParamdef(param.AppliedParamdef);
existingParamFile.Bytes = existingParam.Write();
}
public GameParamHandler(Dictionary <string, PARAMDEF> paramdefs, TextHandler text, byte[] paramBNDData)
{
ParamDefs = paramdefs;
ParamBnd = BND3.Read(paramBNDData);
foreach (BinderFile file in ParamBnd.Files)
{
string name = Path.GetFileNameWithoutExtension(file.Name);
PARAM param = PARAM.Read(file.Bytes);
PARAMDEF p = ParamDefs[param.ParamType];
param.ApplyParamdef(p);
Params[name] = param;
}
AI = new ParamDict <NPCThought>("NpcThinkParam", this, text);
Armor = new ParamDict <Armor>("EquipParamProtector", this, text);
ArmorUpgrades = new ParamDict <ArmorUpgrade>("ReinforceParamProtector", this, text);
AttacksPC = new ParamDict <Attack>("AtkParam_Pc", this, text);
AttacksNPC = new ParamDict <Attack>("AtkParam_Npc", this, text);
BehaviorsPC = new ParamDict <Behavior>("BehaviorParam_PC", this, text);
BehaviorsNPC = new ParamDict <Behavior>("BehaviorParam", this, text);
Bullets = new ParamDict <Bullet>("Bullet", this, text);
CalcCorrects = new ParamDict <CalcCorrect>("CalcCorrectGraph", this, text);
ChrInits = new ParamDict <ChrInit>("CharaInitParam", this, text);
CoolTimes = new ParamDict <CoolTime>("CoolTimeParam", this, text);
UpgradeMaterials = new ParamDict <EquipMtrlSet>("EquipMtrlSetParam", this, text);
FaceGens = new ParamDict <FaceGen>("FaceGenParam", this, text);
GameAreas = new ParamDict <GameArea>("GameAreaParam", this, text);
Goods = new ParamDict <Good>("EquipParamGoods", this, text);
HitMtrls = new ParamDict <HitMtrl>("HitMtrlParam", this, text);
ItemLots = new ParamDict <ItemLot>("ItemLotParam", this, text);
Knockbacks = new ParamDict <Knockback>("KnockBackParam", this, text);
LockCams = new ParamDict <LockCam>("LockCamParam", this, text);
Magic = new ParamDict <Magic>("Magic", this, text);
Movement = new ParamDict <Move>("MoveParam", this, text);
MenuColorTables = new ParamDict <MenuColorTable>("MenuColorTableParam", this, text);
NPCs = new ParamDict <NPC>("NpcParam", this, text);
ObjActs = new ParamDict <ObjAct>("ObjActParam", this, text);
Objects = new ParamDict <GameObject>("ObjectParam", this, text);
Rings = new ParamDict <Accessory>("EquipParamAccessory", this, text);
ShopLineups = new ParamDict <ShopLineup>("ShopLineupParam", this, text);
Skeletons = new ParamDict <Skeleton>("SkeletonParam", this, text);
SpEffects = new ParamDict <SpEffect>("SpEffectParam", this, text);
SpEffectVFXs = new ParamDict <SpEffectVFX>("SpEffectVfxParam", this, text);
Talks = new ParamDict <Talk>("TalkParam", this, text);
Throws = new ParamDict <Throw>("ThrowParam", this, text);
Weapons = new ParamDict <Weapon>("EquipParamWeapon", this, text);
WeaponUpgrades = new ParamDict <WeaponUpgrade>("ReinforceParamWeapon", this, text);
WhiteCoolTimes = new ParamDict <WhiteCoolTime>("WhiteCoolTimeParam", this, text);
}
private static PARAM GetParam(BND4 parambnd, string paramfile)
{
var bndfile = parambnd.Files.Find(x => Path.GetFileName(x.Name) == paramfile);
if (bndfile != null)
{
return(PARAM.Read(bndfile.Bytes));
}
// Otherwise the param is a loose param
if (File.Exists($@"{AssetLocator.GameModDirectory}\Param\{paramfile}"))
{
return(PARAM.Read($@"{AssetLocator.GameModDirectory}\Param\{paramfile}"));
}
if (File.Exists($@"{AssetLocator.GameRootDirectory}\Param\{paramfile}"))
{
return(PARAM.Read($@"{AssetLocator.GameRootDirectory}\Param\{paramfile}"));
}
return(null);
}
// Load params from given path, relative to current dir
public Dictionary <string, PARAM> LoadParams(string path, Dictionary <string, PARAM.Layout> layouts = null, bool allowError = false)
{
layouts = layouts ?? LoadLayouts();
return(LoadBnd(path, (data, paramPath) =>
{
PARAM param;
try
{
param = PARAM.Read(data);
}
catch (Exception e)
{
if (!allowError)
{
throw new Exception($"Failed to load param {paramPath}: " + e);
}
// For DS3 this also includes draw params, so just silently fail
// TODO: Find a better way to load all params reliably
return null;
}
if (layouts == null)
{
return param;
}
else if (layouts.ContainsKey(param.ParamType))
{
PARAM.Layout layout = layouts[param.ParamType];
if (layout.Size == param.DetectedSize)
{
param.ApplyParamdef(layout.ToParamdef(param.ParamType, out var _));
return param;
}
else
{
// Console.WriteLine($"Mismatched size for {path} - {layout.Size} vs {param.DetectedSize} actual");
}
}
return null;
}));
}
private void UnpackGameBNDFile()
{
// Reading an original paramdefbnd
paramDefs = new Dictionary <string, PARAMDEF>();
paramDefBnd = BND3.Read(pathToParamDef);
foreach (BinderFile file in paramDefBnd.Files)
{
var paramdef = PARAMDEF.Read(file.Bytes);
paramDefs[paramdef.ParamType] = paramdef;
}
parms = new Dictionary <string, PARAM>();
paramBnd = BND3.Read(pathToParamDataFile);
foreach (BinderFile file in paramBnd.Files)
{
string name = Path.GetFileNameWithoutExtension(file.Name);
var param = PARAM.Read(file.Bytes);
param.ApplyParamdef(paramDefs[param.ParamType]);
parms[name] = param;
}
}
public RegulationFileParamDumpReader(FileInfo path)
{
var regulation = RegulationFile.Load(path);
Params = regulation.Files
.Where(f => f.Name.EndsWith(".param"))
.ToDictionary(file => Path.GetFileNameWithoutExtension(file.Name), file => PARAM.Read(file.Bytes));
}
private static void LoadParamsDS2()
{
var dir = AssetLocator.GameRootDirectory;
var mod = AssetLocator.GameModDirectory;
if (!File.Exists($@"{dir}\enc_regulation.bnd.dcx"))
{
MessageBox.Show("Could not find DS2 regulation file. Functionality will be limited.", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (!BND4.Is($@"{dir}\enc_regulation.bnd.dcx"))
{
MessageBox.Show("Use yapped to decrypt your DS2 regulation file. Functionality will be limited.", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Keep track of loaded params as we load loose and regulation params
HashSet <string> loadedParams = new HashSet <string>();
// Load params
List <string> scandir = new List <string>();
if (mod != null && Directory.Exists($@"{mod}\Param"))
{
scandir.Add($@"{mod}\Param");
}
scandir.Add($@"{dir}\Param");
foreach (var d in scandir)
{
var paramfiles = Directory.GetFileSystemEntries(d, @"*.param");
foreach (var p in paramfiles)
{
bool blacklisted = false;
var name = Path.GetFileNameWithoutExtension(p);
foreach (var bl in _ds2ParamBlacklist)
{
if (name.StartsWith(bl))
{
blacklisted = true;
}
}
if (blacklisted)
{
continue;
}
var lp = PARAM.Read(p);
var fname = lp.ParamType;
PARAMDEF def = AssetLocator.GetParamdefForParam(fname);
lp.ApplyParamdef(def);
if (!_params.ContainsKey(name))
{
_params.Add(name, lp);
}
}
}
// Load params
var param = $@"{mod}\enc_regulation.bnd.dcx";
if (!File.Exists(param))
{
param = $@"{dir}\enc_regulation.bnd.dcx";
}
BND4 paramBnd = BND4.Read(param);
EnemyParam = GetParam(paramBnd, "EnemyParam.param");
if (EnemyParam != null)
{
PARAMDEF def = AssetLocator.GetParamdefForParam(EnemyParam.ParamType);
EnemyParam.ApplyParamdef(def);
}
LoadParamFromBinder(paramBnd);
}
public static LoadParamsResult LoadParams(string paramPath, Dictionary <string, ParamInfo> paramInfo,
Dictionary <string, PARAM.Layout> layouts, GameMode gameMode, bool hideUnusedParams)
{
if (!File.Exists(paramPath))
{
ShowError($"Parambnd not found:\r\n{paramPath}\r\nPlease browse to the Data0.bdt or parambnd you would like to edit.");
return(null);
}
var result = new LoadParamsResult();
try
{
if (BND4.Is(paramPath))
{
result.ParamBND = BND4.Read(paramPath);
result.Encrypted = false;
}
else if (BND3.Is(paramPath))
{
result.ParamBND = BND3.Read(paramPath);
result.Encrypted = false;
}
else if (gameMode.Game == GameMode.GameType.DarkSouls2)
{
result.ParamBND = DecryptDS2Regulation(paramPath);
result.Encrypted = true;
}
else if (gameMode.Game == GameMode.GameType.DarkSouls3)
{
result.ParamBND = SFUtil.DecryptDS3Regulation(paramPath);
result.Encrypted = true;
}
else
{
throw new FormatException("Unrecognized file format.");
}
}
catch (DllNotFoundException ex) when(ex.Message.Contains("oo2core_6_win64.dll"))
{
ShowError("In order to load Sekiro params, you must copy oo2core_6_win64.dll from Sekiro into Yapped's lib folder.");
return(null);
}
catch (Exception ex)
{
ShowError($"Failed to load parambnd:\r\n{paramPath}\r\n\r\n{ex}");
return(null);
}
result.ParamWrappers = new List <ParamWrapper>();
foreach (BinderFile file in result.ParamBND.Files.Where(f => f.Name.EndsWith(".param")))
{
string name = Path.GetFileNameWithoutExtension(file.Name);
if (paramInfo.ContainsKey(name))
{
if (paramInfo[name].Blocked || paramInfo[name].Hidden && hideUnusedParams)
{
continue;
}
}
try
{
PARAM param = PARAM.Read(file.Bytes);
PARAM.Layout layout = null;
if (layouts.ContainsKey(param.ID))
{
layout = layouts[param.ID];
}
string description = null;
if (paramInfo.ContainsKey(name))
{
description = paramInfo[name].Description;
}
var wrapper = new ParamWrapper(name, param, layout, description);
result.ParamWrappers.Add(wrapper);
}
catch (Exception ex)
{
ShowError($"Failed to load param file: {name}.param\r\n\r\n{ex}");
}
}
result.ParamWrappers.Sort();
return(result);
}
public static LoadParamsResult LoadParams(string paramPath, Dictionary <string, ParamInfo> paramInfo,
Dictionary <string, PARAM.Layout> layouts, Dictionary <BinderFile, ParamWrapper> fileWrapperCache, GameMode gameMode, bool hideUnusedParams)
{
if (!File.Exists(paramPath))
{
ShowError($"Parambnd类型文件 {paramPath} 不存在！\r\n请选定要给要编辑的Data0.bdt文件或Parambnd类型文件。");
return(null);
}
var result = new LoadParamsResult();
try
{
if (BND4.Is(paramPath))
{
result.ParamBND = BND4.Read(paramPath);
result.Encrypted = false;
}
else if (BND3.Is(paramPath))
{
result.ParamBND = BND3.Read(paramPath);
result.Encrypted = false;
}
else if (gameMode.Game == GameMode.GameType.DarkSouls2)
{
result.ParamBND = DecryptDS2Regulation(paramPath);
result.Encrypted = true;
}
else if (gameMode.Game == GameMode.GameType.DarkSouls3)
{
result.ParamBND = SFUtil.DecryptDS3Regulation(paramPath);
result.Encrypted = true;
}
else
{
throw new FormatException("无法识别文件的数据格式！");
}
}
catch (DllNotFoundException ex) when(ex.Message.Contains("oo2core_6_win64.dll"))
{
ShowError("为了加载Sekiro参数，必须将文件oo2core_6_win64.dll从Sekiro复制到文件DSParamEditor.exe的同一目录中。");
return(null);
}
catch (Exception ex)
{
ShowError($"加载Parambnd类型文件失败！\r\n{paramPath}\r\n\r\n{ex}");
return(null);
}
fileWrapperCache.Clear();
result.ParamWrappers = new List <ParamWrapper>();
foreach (var file in result.ParamBND.Files.Where(f => f.Name.EndsWith(".param")))
{
var name = Path.GetFileNameWithoutExtension(file.Name);
if (paramInfo.ContainsKey(name))
{
if (paramInfo[name].Blocked || paramInfo[name].Hidden && hideUnusedParams)
{
continue;
}
}
try
{
var param = PARAM.Read(file.Bytes);
PARAM.Layout layout = null;
if (layouts.ContainsKey(param.ParamType))
{
layout = layouts[param.ParamType];
}
string description = null;
if (paramInfo.ContainsKey(name))
{
description = paramInfo[name].Description;
}
var wrapper = new ParamWrapper(name, param, layout, description);
result.ParamWrappers.Add(wrapper);
fileWrapperCache[file] = wrapper;
}
catch (Exception ex)
{
ShowError($"加载参数文件：{name}.param失败！\r\n\r\n{ex}");
}
}
result.ParamWrappers.Sort();
return(result);
}
static void translateParams(string a, string b)
{
string paramDir = a.EndsWith("\\") ? a.Substring(a.Length - 1, 1) : a;
string paramDefDir = b.EndsWith("\\") ? b.Substring(b.Length - 1, 1) : b;
string[] paramFileList = Directory.GetFiles(paramDir);
string[] paramDefFileList = Directory.GetFiles(paramDefDir);
List <string> paramFileNameList = new List <string>();
List <PARAMDEF> paramDefs = new List <PARAMDEF>();
List <PARAM> paramaroos = new List <PARAM>();
Console.WriteLine("### " + paramDir);
Console.WriteLine("### " + paramDefDir + "\n");
for (int i = 0; i < paramFileList.Length; i++)
{
string fn = paramFileList[i].Substring(paramDir.Length + 1, paramFileList[i].Length - (paramDir.Length + 1));
paramFileNameList.Add(fn);
paramaroos.Add(PARAM.Read(File.ReadAllBytes(paramFileList[i])));
}
for (int i = 0; i < paramDefFileList.Length; i++)
{
paramDefs.Add(PARAMDEF.Read(File.ReadAllBytes(paramDefFileList[i])));
}
for (int i = 0; i < paramaroos.Count; i++)
{
PARAM p = paramaroos[i];
for (int j = 0; j < paramDefs.Count; j++)
{
PARAMDEF pd = paramDefs[j];
if (p.ParamType.Equals(pd.ParamType))
{
p.ApplyParamdef(pd);
}
}
}
TranslationClient client = TranslationClient.Create(GoogleCredential.FromFile("C:\\Users\\dmtin\\google-translate-api-key.txt"));
for (int i = 0; i < paramaroos.Count; i++)
{
Console.WriteLine("\n\n\n\n==================" + paramaroos[i].ParamType + "==================");
for (int j = 0; j < paramaroos[i].Rows.Count; j++)
{
PARAM.Row row = paramaroos[i].Rows[j];
try
{
if (row.Name != null && !row.Name.Trim().Equals("") && !row.Name.Trim().Equals("0"))
{
TranslationResult response = client.TranslateText(row.Name, LanguageCodes.English, LanguageCodes.Japanese); // Translate request
if (response != null && response.TranslatedText != null && response.TranslatedText.Trim().Length > 0)
{
row.Name = response.TranslatedText;
}
}
}
catch (Exception ex) { Console.WriteLine("EXCEPTION :: " + ex.Message); }
Console.WriteLine(row.ID + ":: " + row.Name);
}
}
Directory.CreateDirectory(paramDir + "\\translated\\");
for (int i = 0; i < paramaroos.Count; i++)
{
string outPath = paramDir + "\\translated\\" + paramFileNameList[i];
byte[] outData = paramaroos[i].Write();
File.WriteAllBytes(outPath, outData);
}
Console.WriteLine("\n\n Done!");
}
private void btnDump_Click(object sender, EventArgs e)
{
BND4 bnd;
try
{
bnd = SFUtil.DecryptDS3Regulation(txtRegulation.Text);
}
catch (Exception ex)
{
MessageBox.Show($"Failed to load regulation:\r\n\r\n{txtRegulation.Text}\r\n\r\n{ex}");
return;
}
var translations = new Dictionary <string, string>();
var xml = new XmlDocument();
xml.Load("translations.xml");
foreach (XmlNode text in xml.SelectNodes("translations/text"))
{
string jp = text.SelectSingleNode("jp").InnerText;
string en = text.SelectSingleNode("en").InnerText;
translations[WebUtility.HtmlDecode(jp)] = WebUtility.HtmlDecode(en);
}
var package = new ExcelPackage();
foreach (BinderFile file in bnd.Files)
{
if (Path.GetExtension(file.Name) == ".param")
{
PARAM param = PARAM.Read(file.Bytes);
string layoutPath = $"Layouts\\{param.ID}.xml";
txtStatus.AppendText(file.Name + "\r\n");
var worksheet = package.Workbook.Worksheets.Add(Path.GetFileNameWithoutExtension(file.Name));
PARAM.Layout layout;
if (File.Exists(layoutPath))
{
layout = PARAM.Layout.ReadXMLFile(layoutPath);
if (layout.Size != param.DetectedSize)
{
layout = new PARAM.Layout();
for (int i = 0; i < param.DetectedSize / 4; i++)
{
layout.Add(new PARAM.Layout.Entry(CellType.u32, $"unk0x{i * 4:X4}", (uint)0));
}
for (int i = 0; i < param.DetectedSize % 4; i++)
{
layout.Add(new PARAM.Layout.Entry(CellType.u8, "unkb" + i, (byte)0));
}
}
}
else
{
layout = new PARAM.Layout();
}
param.SetLayout(layout);
List <PARAM.Row> rows = param.Rows;
worksheet.Cells[1, 1].Value = "ID";
worksheet.Cells[1, 2].Value = "Name";
worksheet.Cells[1, 3].Value = "Translated";
int columnCount = 3;
foreach (PARAM.Layout.Entry lv in layout)
{
if (lv.Type != CellType.dummy8)
{
worksheet.Cells[1, ++columnCount].Value = lv.Name;
}
}
for (int i = 0; i < rows.Count; i++)
{
PARAM.Row row = rows[i];
worksheet.Cells[i + 2, 1].Value = row.ID;
if (row.Name != null)
{
if (translations.ContainsKey(row.Name))
{
worksheet.Cells[i + 2, 2].Value = row.Name;
worksheet.Cells[i + 2, 3].Value = translations[row.Name];
}
else if (row.Name.Contains(" -- "))
{
worksheet.Cells[i + 2, 2].Value = row.Name.Substring(row.Name.IndexOf(" -- ") + 4);
worksheet.Cells[i + 2, 3].Value = row.Name.Substring(0, row.Name.IndexOf(" -- "));
}
}
else
{
worksheet.Cells[i + 2, 2].Value = row.Name;
}
columnCount = 3;
foreach (PARAM.Cell cell in row.Cells)
{
CellType type = cell.Type;
if (type != CellType.dummy8)
{
var range = worksheet.Cells[i + 2, ++columnCount];
if (type == CellType.f32)
{
range.Value = (double)(float)cell.Value;
}
else if (type == CellType.b8 || type == CellType.b16 || type == CellType.b32)
{
bool b = (bool)cell.Value;
range.Value = b.ToString();
range.Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
range.Style.Fill.BackgroundColor.SetColor(b ? Color.LightGreen : Color.LightPink);
}
else if (type == CellType.x8)
{
range.Value = $"0x{cell.Value:X2}";
range.Style.HorizontalAlignment = OfficeOpenXml.Style.ExcelHorizontalAlignment.Right;
}
else if (type == CellType.x16)
{
range.Value = $"0x{cell.Value:X4}";
range.Style.HorizontalAlignment = OfficeOpenXml.Style.ExcelHorizontalAlignment.Right;
}
else if (type == CellType.x32)
{
range.Value = $"0x{cell.Value:X8}";
range.Style.HorizontalAlignment = OfficeOpenXml.Style.ExcelHorizontalAlignment.Right;
}
else
{
range.Value = cell.Value;
}
}
}
}
worksheet.Row(1).Style.Font.Bold = true;
worksheet.Column(1).Style.Font.Bold = true;
worksheet.View.FreezePanes(2, 4);
worksheet.Cells[worksheet.Dimension.Address].AutoFitColumns();
}
}
FileInfo f = new FileInfo(Path.Combine(txtOutput.Text, "dump.xlsx"));
package.SaveAs(f);
}
