/// <summary>
/// Change all Form Value greater than 40 to 40
/// </summary>
/// <param name="plugin"></param>
/// <returns></returns>
public static int ChangeFormIdGreater40To40(Plugin plugin)
{
if (plugin == null)
{
return -1;
}
var masters = plugin.Masters;
if (masters == null || masters.Length == 0)
{
return -1;
}
int countGreate40 = 0;
foreach (var record in plugin.Enumerate().OfType<Record>())
{
record.MatchRecordStructureToRecord();
if (record.Flags3 > 40)
{
var data = new byte[4];
TypeConverter.i2h(record.Flags3, data, 0);
if (data[0] > 40)
{
data[0] = 40;
record.Flags3 = TypeConverter.h2i(new ArraySegment<byte>(data, 0, 4));
countGreate40++;
}
}
}
return countGreate40;
}
public static int CleanUnusedStrings(Plugin plugin)
{
if (plugin == null)
{
return -1;
}
var masters = plugin.Masters;
if (masters == null || masters.Length == 0)
{
return -1;
}
LocalizedStringDict oldStrings = plugin.Strings;
plugin.Strings = new LocalizedStringDict();
foreach (var record in plugin.Enumerate().OfType<Record>())
{
record.MatchRecordStructureToRecord();
foreach (var sr in record.SubRecords)
{
var elements = record.EnumerateElements(sr, rawData: true).ToList();
foreach (var elem in elements)
{
if (elem.Structure != null && elem.Structure.type == ElementValueType.LString)
{
var data = elem.Data;
if (data.Count == 4)
{
string value;
uint id = TypeConverter.h2i(data);
if (id == 0)
{
continue;
}
if (oldStrings.TryGetValue(id, out value))
{
oldStrings.Remove(id);
plugin.Strings[id] = value;
}
}
}
}
}
}
return oldStrings.Count;
}
public void Reload(Plugin[] plugins)
{
this.Plugins = plugins;
this.listStrings.DataSource = null;
this.strings.Clear();
this.addStrings.Clear();
this.remStrings.Clear();
this.updateStrings.Clear();
var strPlugins = new List<string>();
foreach (var plugin in this.Plugins)
{
strPlugins.Add(plugin.Name);
}
this.cboPlugins.DataSource = strPlugins;
this.cboPlugins.SelectedIndex = 0;
this.PopulateStrings();
this.listStrings.DataSource = this.strings;
this.FitColumns();
this.UpdateStatusBar();
}
public static void StripEDIDs(Plugin p)
{
foreach (Rec r in p.Records)
{
StripEDIDsInternal(r);
}
}
public static void SanitizePlugin(Plugin plugin)
{
// performance update to prevent lists from updating currently selected record
bool oldHoldUpdates = BaseRecord.HoldUpdates;
try
{
BaseRecord.HoldUpdates = true;
if (plugin == null)
{
throw new ApplicationException("Cannot select plugin");
}
var hdr = plugin.Records.OfType<Rec>().FirstOrDefault(x => x.Name .StartsWith("TES"));
if (hdr == null)
{
throw new ApplicationException(Resources.PluginLacksAValidTes4RecordCannotContinue);
}
var toParse = new Queue<BaseRecord>(plugin.Records.OfType<BaseRecord>().Where(x => !x.Equals(hdr)));
plugin.Clear();
plugin.AddRecord(hdr);
var groups = new Dictionary<string, GroupRecord>();
foreach (string s in SanitizeOrder)
{
var gr = new GroupRecord(s);
plugin.AddRecord(gr);
groups[s] = gr;
}
bool looseGroupsWarning = false;
bool unknownRecordsWarning = false;
while (toParse.Count > 0)
{
var r = toParse.Dequeue();
if (r is GroupRecord)
{
var gr = (GroupRecord)r;
if (gr.ContentsType == "CELL" || gr.ContentsType == "WRLD" || gr.ContentsType == "DIAL")
{
var gr2 = groups[gr.ContentsType];
foreach (BaseRecord r2 in gr.Records)
{
gr2.AddRecord(r2);
}
gr.Clear();
}
else
{
foreach (BaseRecord r2 in gr.Records)
{
toParse.Enqueue(r2);
}
gr.Clear();
}
}
else if (r is Record)
{
var r2 = (Record)r;
if (LooseGroups.Contains(r2.Name))
{
looseGroupsWarning = true;
plugin.AddRecord(r2);
}
else
{
if (groups.ContainsKey(r2.Name))
{
groups[r2.Name].AddRecord(r2);
}
else
{
unknownRecordsWarning = true;
plugin.AddRecord(r2);
}
}
}
}
foreach (GroupRecord gr2 in groups.Values)
{
if (gr2.Records.Count == 0)
{
plugin.DeleteRecord(gr2);
}
}
if (looseGroupsWarning)
{
Alerts.Show(Resources.CannotSanitizeLooseGroups);
}
if (unknownRecordsWarning)
{
Alerts.Show(Resources.CannotSanitizeUnknownRecords);
}
plugin.InvalidateCache();
plugin.UpdateRecordCount();
/* int reccount = -1 + plugin.Records.Cast<Rec>().Sum(r => sanitizeCountRecords(r));
var tes4 = plugin.Records.OfType<Record>().FirstOrDefault(x => x.Name .StartsWith("TES"));
if (tes4 != null)
{
if (tes4.SubRecords.Count > 0 && tes4.SubRecords[0].Name == "HEDR" && tes4.SubRecords[0].Size >= 8)
{
byte[] data = tes4.SubRecords[0].GetData();
byte[] reccountbytes = TypeConverter.si2h(reccount);
for (int i = 0; i < 4; i++) data[4 + i] = reccountbytes[i];
tes4.SubRecords[0].SetData(data);
}
} */
}
finally
{
BaseRecord.HoldUpdates = oldHoldUpdates;
}
}
public static int InternalizeStrings(Plugin plugin)
{
bool anyModified = false;
int count = 0;
foreach (var record in plugin.Enumerate().OfType<Record>())
{
record.MatchRecordStructureToRecord();
foreach (var sr in record.SubRecords)
{
var elements = record.EnumerateElements(sr, rawData: true).ToList();
foreach (var elem in elements)
{
if (elem.Structure != null && elem.Structure.type == ElementValueType.LString)
{
var data = elem.Data;
uint id = TypeConverter.h2i(data);
if (id == 0)
{
continue;
}
if (data.Count == 4)
{
var str = plugin.LookupFormStrings(id);
if (!string.IsNullOrEmpty(str))
{
elem.AssignValue<ArraySegment<byte>>(new ArraySegment<byte>(TypeConverter.str2h(str)));
++count;
}
}
}
}
if (elements.Any(x => x.Changed))
{
// need to repack the structure
using (var ms = new MemoryStream(sr.GetReadonlyData().Length))
{
foreach (var seg in elements.Select(elem => elem.Data))
{
ms.Write(seg.Array, seg.Offset, seg.Count);
}
sr.SetData(ms.ToArray());
}
anyModified = true;
}
}
}
if (anyModified)
{
var tes4 = plugin.Records.OfType<Record>().FirstOrDefault(x => x.Name .StartsWith("TES"));
if (tes4 != null)
{
tes4.Flags1 &= ~0x00000080U;
}
}
return count;
}
public static uint getNextFormID(Plugin plugin)
{
var tes4 = plugin.Records.OfType<Record>().FirstOrDefault(x => x.Name .StartsWith("TES"));
if (tes4 != null && tes4.SubRecords.Count > 0 && tes4.SubRecords[0].Name == "HEDR" &&
tes4.SubRecords[0].Size >= 8)
{
byte[] data = tes4.SubRecords[0].GetData();
var formid = (uint)TypeConverter.GetObject<uint>(data, 8);
TypeConverter.i2h(formid + 1, data, 8);
tes4.SubRecords[0].SetData(data);
return formid;
}
throw new ApplicationException(Resources.PluginLacksAValidTes4RecordCannotContinue);
}
public static void Setup(Plugin[] plugins)
{
if (!Inited)
{
Init();
}
TokenStream.Reset();
edidList.Clear();
globals.Clear();
farVars.Clear();
var records = new Dictionary<uint, Record>();
uint mask;
var quests = new List<Pair<uint, Record>>();
var refs = new List<Pair<uint, Record>>();
var RefLookupTable = new Dictionary<uint, uint>();
for (uint i = 0; i < plugins.Length - 1; i++)
{
var plugin = plugins[i];
if (plugin == null)
{
continue;
}
if (plugin.Records.OfType<BaseRecord>().FirstOrDefault(x => x.Name == "TES4") == null)
{
continue;
}
mask = (uint)plugin.Masters.Count();
mask <<= 24;
uint id = i << 24;
foreach (Rec r in plugin.Records)
{
RecursePlugin(r, mask, id, records, quests, refs);
}
foreach (var recs in refs)
{
if (RefLookupTable.ContainsKey(recs.Key) && RefLookupTable[recs.Key] != 0)
{
quests.Add(new Pair<uint, Record>(RefLookupTable[recs.Key], recs.Value));
}
else if (records.ContainsKey(recs.Key))
{
Record r = records[recs.Key];
uint formID = 0;
foreach (SubRecord sr in r.SubRecords)
{
if (sr.Name == "SCRI")
{
byte[] bytes = sr.GetReadonlyData();
uint formid = TypeConverter.h2i(bytes[0], bytes[1], bytes[2], bytes[3]);
if ((formid & 0xff000000) == mask)
{
formID = (formid & 0xffffff) + id;
break;
}
}
}
quests.Add(new Pair<uint, Record>(formID, recs.Value));
}
}
RefLookupTable.Clear();
}
foreach (Rec r in plugins[plugins.Length - 1].Records)
{
RecursePlugin(r, records, quests, refs);
}
foreach (var recs in refs)
{
if (RefLookupTable.ContainsKey(recs.Key) && RefLookupTable[recs.Key] != 0)
{
quests.Add(new Pair<uint, Record>(RefLookupTable[recs.Key], recs.Value));
}
else if (records.ContainsKey(recs.Key))
{
Record r = records[recs.Key];
uint formID = 0;
foreach (SubRecord sr in r.SubRecords)
{
if (sr.Name == "SCRI")
{
byte[] bytes = sr.GetReadonlyData();
formID = TypeConverter.h2i(bytes[0], bytes[1], bytes[2], bytes[3]);
break;
}
}
quests.Add(new Pair<uint, Record>(formID, recs.Value));
}
}
foreach (var recs in records)
{
string edid = recs.Value.SubRecords[0].GetStrData().ToLowerInvariant();
if (recs.Value.Name == "GLOB")
{
TokenStream.AddGlobal(edid);
globals[edid] = recs.Key;
}
else
{
TokenStream.AddEdid(edid);
edidList[edid] = new Pair<uint, string>(recs.Key, recs.Value.Name);
}
}
edidList["player"] = new Pair<uint, string>(0x14, "NPC_");
TokenStream.AddEdid("player");
edidList["playerref"] = new Pair<uint, string>(0x14, "NPC_");
TokenStream.AddEdid("playerref");
var vars = new Dictionary<string, ushort>();
foreach (var quest in quests)
{
if (!records.ContainsKey(quest.Key))
{
continue;
}
Record scpt = records[quest.Key];
string edid = quest.Value.SubRecords[0].GetStrData();
for (int i = 0; i < scpt.SubRecords.Count - 1; i++)
{
if (scpt.SubRecords[i].Name == "SLSD")
{
byte[] bytes = scpt.SubRecords[i].GetReadonlyData();
vars[scpt.SubRecords[i + 1].GetStrData().ToLowerInvariant()] = TypeConverter.h2s(bytes[0], bytes[1]);
}
}
if (vars.Count > 0)
{
farVars[edid.ToLowerInvariant()] = vars;
vars = new Dictionary<string, ushort>();
}
}
}
public static int CreateStringStubs(Plugin plugin)
{
if (plugin == null)
{
return -1;
}
var masters = plugin.Masters;
if (masters == null || masters.Length == 0)
{
return -1;
}
int count = 0;
foreach (var record in plugin.Enumerate().OfType<Record>())
{
record.MatchRecordStructureToRecord();
foreach (var sr in record.SubRecords)
{
var elements = record.EnumerateElements(sr, rawData: true).ToList();
foreach (var elem in elements)
{
if (elem.Structure != null && elem.Structure.type == ElementValueType.LString)
{
var data = elem.Data;
if (data.Count == 4)
{
string value;
uint id = TypeConverter.h2i(data);
if (id == 0)
{
continue;
}
if (!plugin.Strings.TryGetValue(id, out value))
{
value = string.Format("STUB: {0} {1}", record.DescriptiveName, sr.DescriptiveName);
plugin.Strings[id] = value;
++count;
}
}
}
}
}
}
return count;
}
/// <summary>
/// Copy any strings references from master not currently in current plugin.
/// </summary>
/// <param name="plugin">
/// </param>
/// <returns>
/// The System.Int32.
/// </returns>
public static int CopyMasterStringReferences(Plugin plugin)
{
if (plugin == null)
{
return -1;
}
var masters = plugin.Masters;
if (masters == null || masters.Length == 0)
{
return -1;
}
int count = 0;
foreach (var record in plugin.Enumerate().OfType<Record>())
{
record.MatchRecordStructureToRecord();
foreach (var sr in record.SubRecords)
{
var elements = record.EnumerateElements(sr, rawData: true).ToList();
foreach (var elem in elements)
{
if (elem.Structure != null && elem.Structure.type == ElementValueType.LString)
{
var data = elem.Data;
if (data.Count == 4)
{
string value;
uint id = TypeConverter.h2i(data);
if (id == 0)
{
continue;
}
if (!plugin.Strings.TryGetValue(id, out value))
{
foreach (var master in masters.Reverse())
{
if (master.Strings.TryGetValue(id, out value))
{
++count;
plugin.Strings[id] = value;
break;
}
}
}
}
}
}
}
}
return count;
}
private bool TryGetCurrentPlugin(out Plugin plugin)
{
string pluginName = this.cboPlugins.SelectedItem.ToString();
plugin = this.Plugins.FirstOrDefault(a => a.Name == pluginName);
return plugin != null;
}
private LocalizedStringDict GetStringDict(Plugin plugin, LocalizedStringFormat format)
{
LocalizedStringDict strings = null;
switch (format)
{
case LocalizedStringFormat.Base:
strings = plugin.Strings;
break;
case LocalizedStringFormat.DL:
strings = plugin.DLStrings;
break;
case LocalizedStringFormat.IL:
strings = plugin.ILStrings;
break;
}
return strings;
}
public NewMediumLevelRecordEditor(Plugin p, Record r, SubRecord sr, SubrecordStructure ss)
{
this.InitializeComponent();
Icon = Resources.tesv_ico;
SuspendLayout();
this.sr = sr;
this.ss = ss;
this.p = p;
this.r = r;
// walk each element in standard fashion
int panelOffset = 0;
try
{
this.fpanel1.ColumnStyles[0] = new ColumnStyle(SizeType.Percent, 100.0f);
int maxWidth = this.fpanel1.Width - SystemInformation.VerticalScrollBarWidth - 8;
int leftOffset = 0; // 8;
foreach (var elem in ss.elements)
{
Control c = null;
if (elem.options != null && elem.options.Length > 1)
{
c = new OptionsElement();
}
else if (elem.flags != null && elem.flags.Length > 1)
{
c = new FlagsElement();
}
else
{
switch (elem.type)
{
case ElementValueType.LString:
c = new LStringElement();
break;
case ElementValueType.FormID:
c = new FormIDElement();
break;
case ElementValueType.Blob:
c = new HexElement();
break;
default:
c = new TextElement();
break;
}
}
if (c is IElementControl)
{
var ec = c as IElementControl;
ec.formIDLookup = p.GetRecordByID;
ec.formIDScan = p.EnumerateRecords;
ec.strIDLookup = p.LookupFormStrings;
ec.Element = elem;
if (elem.repeat > 0)
{
var ge = new RepeatingElement();
c = ge;
c.Left = leftOffset;
c.Width = maxWidth;
c.Top = panelOffset;
c.Anchor = c.Anchor | AnchorStyles.Left | AnchorStyles.Right;
ge.InnerControl = ec;
ge.Element = elem;
ec = ge;
}
else if (elem.optional > 0)
{
var re = new OptionalElement();
c = re;
c.Left = leftOffset;
c.Width = maxWidth;
c.Top = panelOffset;
c.Anchor = c.Anchor | AnchorStyles.Left | AnchorStyles.Right;
re.InnerControl = ec;
re.Element = elem;
ec = re;
c = re;
}
else
{
c.Left = leftOffset;
c.Width = maxWidth;
c.Top = panelOffset;
c.Anchor = c.Anchor | AnchorStyles.Left | AnchorStyles.Right;
}
this.controlMap.Add(elem, ec);
int idx = this.fpanel1.RowCount - 1;
this.fpanel1.Controls.Add(c, 0, idx);
var info = new RowStyle(SizeType.Absolute, c.Size.Height+2);
if (idx == 0)
this.fpanel1.RowStyles[0] = info;
else
this.fpanel1.RowStyles.Add(info);
panelOffset = 0;
++this.fpanel1.RowCount;
}
}
foreach (Element elem in r.EnumerateElements(sr, true))
{
var es = elem.Structure;
IElementControl c;
if (this.controlMap.TryGetValue(es, out c))
{
if (c is IGroupedElementControl)
{
var gc = c as IGroupedElementControl;
gc.Elements.Add(elem.Data);
}
else
{
c.Data = elem.Data;
}
}
}
}
catch
{
this.strWarnOnSave = "The subrecord doesn't appear to conform to the expected structure.\nThe formatted information may be incorrect.";
this.Error.SetError(this.bSave, this.strWarnOnSave);
this.Error.SetIconAlignment(this.bSave, ErrorIconAlignment.MiddleLeft);
AcceptButton = this.bCancel; // remove save as default button when exception occurs
CancelButton = this.bCancel;
UpdateDefaultButton();
}
ResumeLayout();
}
public CloneTool(Plugin destPlugin, bool bOverride = true)
{
this.plugin = destPlugin;
this.Override = bOverride;
}
public static void updateFormIDReference(Plugin plugin, uint oldFormID, uint newFormID)
{
uint refCount = 0;
updateFormIDReference(plugin, oldFormID, newFormID, ref refCount);
}
/// <summary>
/// Extract any internalized strings and put in string table.
/// </summary>
/// <param name="plugin">
/// </param>
/// <returns>
/// The System.Int32.
/// </returns>
public static int ExtractInternalStrings(Plugin plugin)
{
int count = 0;
// uint maxid = plugin.Masters.Max(x=>x.Strings.Count > 0 ? x.Strings.Keys.Max() : 0); // No need to check the masters string since the numbers are unique for every plugin
bool anyModified = false;
foreach (var record in plugin.Enumerate().OfType<Record>())
{
record.MatchRecordStructureToRecord();
foreach (var sr in record.SubRecords)
{
var elements = record.EnumerateElements(sr, rawData: true).ToList();
foreach (var elem in elements)
{
if (elem.Structure != null && elem.Structure.type == ElementValueType.LString)
{
var data = elem.Data;
uint id = TypeConverter.h2i(data);
if (id == 0)
{
continue;
}
if (data.Count == 4 && TypeConverter.IsLikelyString(data))
{
string str;
if (plugin.Strings.TryGetValue(id, out str))
{
continue;
}
}
if (data.Count != 4 || TypeConverter.IsLikelyString(data))
{
string value = TypeConverter.GetString(data);
if (!string.IsNullOrEmpty(value))
{
// uint nextid = Math.Max(maxid, plugin.Strings.Count == 0 ? 0 : plugin.Strings.Keys.Max()) + 1; // No need to check the masters strings since the numbers are unique for every plugin
uint nextid = (plugin.Strings.Count == 0 ? 0 : plugin.Strings.Keys.Max()) + 1;
int idx = plugin.Strings.FindValue(value);
if (idx >= 0)
{
nextid = plugin.Strings.ElementAt(idx).Key;
}
else
{
plugin.Strings[nextid] = value;
}
elem.AssignValue<ArraySegment<byte>>(
new ArraySegment<byte>((byte[])TypeConverter.i2h(nextid).Clone()));
++count;
}
}
}
}
if (elements.Any(x => x.Changed))
{
// need to repack the structure
using (var ms = new MemoryStream(sr.GetReadonlyData().Length))
{
foreach (var seg in elements.Select(elem => elem.Data))
{
ms.Write(seg.Array, seg.Offset, seg.Count);
}
sr.SetData(ms.ToArray());
}
anyModified = true;
}
}
}
if (anyModified)
{
var tes4 = plugin.Records.OfType<Record>().FirstOrDefault(x => x.Name .StartsWith("TES"));
if (tes4 != null)
{
tes4.Flags1 |= 0x00000080U;
}
}
return count;
}
public static void updateFormIDReference(Plugin plugin, uint oldFormID, uint newFormID, ref uint refCount)
{
foreach (Record record in plugin.Enumerate().OfType<Record>())
{
record.MatchRecordStructureToRecord();
foreach (SubRecord sr in record.SubRecords)
{
var elements = sr.EnumerateElements(true).ToList();
foreach (Element e in elements)
{
if (e.Structure != null && e.Structure.type == ElementValueType.FormID)
{
if ((uint)e.Value == oldFormID)
{
e.AssignValue<uint>((object)newFormID);
refCount++;
}
}
}
}
}
}
public void Start(Plugin p)
{
// p.ForEach(r => { if (r is Record) ++totalRecordCount; });
// p.While(r => { if (r is Record) { UpdateProgress(); return Process((Record)r); } });
var recordList = new List<Record>();
p.ForEach(
r => {
if (r is Record)
{
recordList.Add((Record)r);
}
});
this.totalRecordCount = recordList.Count;
foreach (var kvp in recordList.ToLookup((a) => a.Name))
{
if (!this.Process(kvp.Key, kvp.ToArray()))
{
return;
}
}
}
