public ExtendedList <T> Parse(
MutagenFrame frame,
BinaryMasterParseRecordDelegate <T> transl,
ICollectionGetter <RecordType>?triggeringRecord = null,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new ExtendedList <T>();
while (!frame.Complete)
{
var nextRecord = HeaderTranslation.GetNextRecordType(frame.Reader);
nextRecord = recordTypeConverter.ConvertToStandard(nextRecord);
if (!triggeringRecord?.Contains(nextRecord) ?? false)
{
break;
}
if (!IsLoqui)
{
frame.Position += frame.MetaData.Constants.SubConstants.HeaderLength;
}
var startingPos = frame.Position;
if (transl(frame, nextRecord, out var subIitem, recordTypeConverter))
{
ret.Add(subIitem);
}
if (frame.Position == startingPos)
{
throw new ArgumentException($"Parsed item on the list consumed no data: {subIitem}");
}
}
return(ret);
}
public ExtendedList <T> Parse(
MutagenFrame frame,
RecordType triggeringRecord,
BinaryMasterParseDelegate <T> transl,
RecordTypeConverter?recordTypeConverter = null,
bool skipHeader = false)
{
var ret = new ExtendedList <T>();
triggeringRecord = recordTypeConverter.ConvertToCustom(triggeringRecord);
while (!frame.Complete && !frame.Reader.Complete)
{
if (!frame.Reader.TryGetSubrecord(triggeringRecord, out var header))
{
break;
}
if (!IsLoqui || skipHeader)
{
frame.Position += header.HeaderLength;
}
var startingPos = frame.Position;
if (transl(skipHeader ? frame.SpawnWithLength(header.ContentLength) : frame, out var subItem, recordTypeConverter))
{
ret.Add(subItem);
}
if (frame.Position == startingPos)
{
frame.Position += frame.MetaData.Constants.SubConstants.HeaderLength;
throw new ArgumentException($"Parsed item on the list consumed no data: {subItem}");
}
}
return(ret);
}
/// <summary>
/// Parses a stream to retrieve all ModKeys in expected plugin file format
/// </summary>
/// <param name="stream">Stream to read from</param>
/// <returns>List of modkeys representing a load order</returns>
/// <exception cref="ArgumentException">Line in plugin stream is unexpected</exception>
public static IExtendedList <ModKey> ProcessLoadOrder(Stream stream)
{
var ret = new ExtendedList <ModKey>();
using var streamReader = new StreamReader(stream);
while (!streamReader.EndOfStream)
{
var str = streamReader.ReadLine();
var commentIndex = str.IndexOf('#');
if (commentIndex != -1)
{
str = str.Substring(0, commentIndex);
}
if (string.IsNullOrWhiteSpace(str))
{
continue;
}
str = str.Trim();
if (!ModKey.TryFactory(str, out var key))
{
throw new ArgumentException($"Load order file had malformed line: {str}");
}
ret.Add(key);
}
return(ret);
}
/// <summary>
/// Constructs a load order from a list of mods and a data folder.
/// Load Order is sorted to the order the game will load the mod files: by file's date modified timestamp.
/// </summary>
/// <param name="modsToInclude">Mods to include</param>
/// <param name="dataPath">Path to data folder</param>
/// <param name="throwOnMissingMods">Whether to throw and exception if mods are missing</param>
/// <returns>List of modkeys in load order, excluding missing mods</returns>
/// <exception cref="FileNotFoundException">If throwOnMissingMods true and file is missing</exception>
public static IExtendedList <ModKey> AlignLoadOrder(
IEnumerable <ModKey> modsToInclude,
DirectoryPath dataPath,
bool throwOnMissingMods = false)
{
List <(ModKey ModKey, DateTime Write)> list = new List <(ModKey ModKey, DateTime Write)>();
var loadOrder = new ExtendedList <ModKey>();
foreach (var key in modsToInclude)
{
FilePath file = new FilePath(
Path.Combine(dataPath.Path, key.ToString()));
if (!file.Exists)
{
if (throwOnMissingMods)
{
throw new FileNotFoundException($"Expected mod was missing: {file}");
}
continue;
}
list.Add((key, file.Info.LastWriteTime));
}
loadOrder.AddRange(list
.OrderBy(i => i.Write)
.Select(i => i.ModKey));
return(loadOrder);
}
public static ExtendedList <T>?CastExtendedListIfAny <T>(this ExtendedList <T> enumer)
{
if (enumer.Count == 0)
{
return(null);
}
return(enumer);
}
/// <summary>
/// Retrieve the priority level of this WeaponStats instance, if it is not null and contains at least one valid value.
/// </summary>
/// <param name="keywords">List of keywords currently applied to a weapon.</param>
/// <returns>int</returns>
public int GetPriority(ExtendedList <IFormLinkGetter <IKeywordGetter> >?keywords)
{
if ((keywords != null) && (!ShouldSkip()) && keywords.Any(kywd => Keyword.Equals(kywd)))
{
return(Priority);
}
return(Constants.DefaultPriority);
}
public static void EqualsKeywords(ExtendedList <IFormLinkGetter <IKeywordGetter> >?a,
ExtendedList <IFormLinkGetter <IKeywordGetter> >?b)
{
Assert.True(a != null && b != null || a == null && b == null);
var diff = a !.Except(b !).ToArray();
Assert.Empty(diff);
}
public CardTypes DrawCard()
{
if (deck.Count == 0)
{
deck = CreateDeck();
}
return(deck.PopValue());
}
public bool Contains(object value)
{
if (!(value is TOuter))
{
return(false);
}
return(_innerSet.Contains(_transformIn((TOuter)value)) || ExtendedList.Contains(value));
}
public void JsonSerialization_MiscClasses()
{
var ext_list_double = new ExtendedList <double>(0);
var ext_list_double_json = JsonConvert.SerializeObject(ext_list_double);
var ext_list_double_dser = JsonConvert.DeserializeObject <ExtendedList <double> >(ext_list_double_json);
var vec = new Vector3(1, 2, 3);
var vec_json = JsonConvert.SerializeObject(vec);
var vec_dser = JsonConvert.DeserializeObject <Vector3>(vec_json);
Assert.AreEqual(vec.Length, vec_dser.Length, 1e-10);
}
public ExtendedList <CardTypes> CreateDeck()
{
ExtendedList <CardTypes> deck = new ExtendedList <CardTypes>();
deck.AddRedundant(CardTypes.CurrentSectorSound, 10);
deck.AddRedundant(CardTypes.AnySectorSound, 10);
deck.AddRedundant(CardTypes.NoSound, 5);
deck.Shuffle();
return(deck);
}
partial void CustomCtor()
{
var frame = new MutagenFrame(new MutagenMemoryReadStream(_data, _package.MetaData))
{
Position = 0x04
};
var ret = new ExtendedList <IScriptEntryGetter>();
ret.AddRange(VirtualMachineAdapterBinaryCreateTranslation.ReadEntries(frame, this.ObjectFormat));
this.Scripts = ret;
this.ScriptsEndingPos = checked ((int)frame.Position);
}
public InputTextProcessor(Game game)
{
keys = new ExtendedList<Keys>();
keys.EnableRaisingEvents = false;
manager = new KeyboardManager(game);
manager.PressingDelay = 1000;
manager.PressingFrequency = 60;
manager.Pressed += OnKeyPressed;
manager.Pressing += OnKeyPressing;
manager.Released += OnKeyRelease;
manager.EnableCapture = false;
game.Components.Add(manager);
this.game = game;
}
void SetUp()
{
playerRolesToGive = new ExtendedList <ClientController.PlayerState>();
playerTurnDict = new Dictionary <int, PlayerTurnData>();
states = new Dictionary <ServerState, IStateController>();
states.Add(ServerState.SetUp, new SetUpServerState(this, serverCommunication));
states.Add(ServerState.WaitingPlayers, new WaitingPlayersServerState(this, serverCommunication));
states.Add(ServerState.Processing, new ProcessingServerState(this, serverCommunication));
states.Add(ServerState.Updating, new UpdatingServerState(this, serverCommunication));
states.Add(ServerState.EndGame, new EndGameServerState(this));
_turnCountdown = _turnLimit;
}
public static ExtendedList<IFormLinkGetter<IIdleAnimationGetter>> ParseAnimations(IMutagenReadStream stream)
{
var subFrame = stream.ReadSubrecordFrame();
var ret = new ExtendedList<IFormLinkGetter<IIdleAnimationGetter>>();
int pos = 0;
while (pos < subFrame.Content.Length)
{
ret.Add(
new FormLink<IIdleAnimationGetter>(
FormKeyBinaryTranslation.Instance.Parse(subFrame.Content.Slice(pos), stream.MetaData.MasterReferences!)));
pos += 4;
}
return ret;
}
public AlienFeedbackGroupHelper(GameObject uiObject) : base(uiObject)
{
leftTop = uiObject.transform.Find("TopLeft").GetComponent <Image>();
leftBottom = uiObject.transform.Find("BottomLeft").GetComponent <Image>();
rightTop = uiObject.transform.Find("TopRight").GetComponent <Image>();
rightBottom = uiObject.transform.Find("BottomRight").GetComponent <Image>();
EnableImage(false);
shuffleList = new ExtendedList <Image>();
shuffleList.Add(leftTop);
shuffleList.Add(leftBottom);
shuffleList.Add(rightTop);
shuffleList.Add(rightBottom);
}
public static void AddImplicitMasters(RunSynthesisMutagenPatcher settings, ExtendedList <LoadOrderListing> loadOrderListing)
{
HashSet <ModKey> referencedMasters = new HashSet <ModKey>();
foreach (var item in loadOrderListing.OnlyEnabled())
{
MasterReferenceReader reader = MasterReferenceReader.FromPath(Path.Combine(settings.DataFolderPath, item.ModKey.FileName), settings.GameRelease);
referencedMasters.Add(reader.Masters.Select(m => m.Master));
}
for (int i = 0; i < loadOrderListing.Count; i++)
{
var listing = loadOrderListing[i];
if (!listing.Enabled && referencedMasters.Contains(listing.ModKey))
{
loadOrderListing[i] = new LoadOrderListing(listing.ModKey, enabled: true);
}
}
}
public int Add(object value)
{
if (!(value is TOuter))
{
return(-1);
}
var item = (TOuter)value;
var inner = _transformIn(item);
if (inner != null)
{
return(InnerList.Add(inner));
}
var index = ExtendedList.Add(item);
return(_innerSet.Count + index);
}
public void AddImplicitMasters()
{
using var tmpFolder = Utility.GetTempFolder();
using var dataFolder = Utility.SetupDataFolder(tmpFolder, GameRelease.Oblivion);
var pluginsPath = Path.Combine(dataFolder.Dir.Path, "Plugins.txt");
File.WriteAllLines(
pluginsPath,
new string[]
{
Utility.TestModKey.FileName,
Utility.OverrideModKey.FileName
});
var mod = new OblivionMod(Utility.TestModKey);
mod.WriteToBinary(Path.Combine(dataFolder.Dir.Path, Utility.TestModKey.FileName));
var mod2 = new OblivionMod(Utility.OverrideModKey);
mod2.Npcs.Add(new Npc(mod.GetNextFormKey()));
mod2.WriteToBinary(Path.Combine(dataFolder.Dir.Path, Utility.OverrideModKey.FileName));
var list = new ExtendedList <LoadOrderListing>()
{
new LoadOrderListing(Utility.TestModKey, false),
new LoadOrderListing(Utility.OverrideModKey, true),
};
Mutagen.Bethesda.Synthesis.Internal.Utility.AddImplicitMasters(
new RunSynthesisMutagenPatcher()
{
DataFolderPath = dataFolder.Dir.Path,
GameRelease = GameRelease.Oblivion
},
list);
list.Should().HaveCount(2);
list[0].Should().Be(new LoadOrderListing(Utility.TestModKey, true));
list[1].Should().Be(new LoadOrderListing(Utility.OverrideModKey, true));
}
/**********************/
/*** IMPLEMENTATION ***\
* /**********************/
private void Form1_Load(object sender, EventArgs e)
{
AllAnswers = new ExtendedList <string>();
AllAnswers.OnAdd += new EventHandler(ParseReceivedAnswer);
ref_playground = new Form_Playground(this)
{
MdiParent = this
};
ref_playground.Show();
// Create Displayfunction.
Function displayFunction = new Function()
{
index = 0,
name = "Anzeiger"
};
AllFunctions.Add(displayFunction);
}
public ExtendedList <T> Parse(
MutagenFrame frame,
RecordType triggeringRecord,
BinarySubParseDelegate <T> transl)
{
var ret = new ExtendedList <T>();
while (!frame.Complete && !frame.Reader.Complete)
{
if (!HeaderTranslation.TryGetRecordType(frame.Reader, triggeringRecord))
{
break;
}
var startingPos = frame.Position;
MutagenFrame subFrame;
if (!IsLoqui)
{
var subHeader = frame.ReadSubrecord();
subFrame = frame.ReadAndReframe(subHeader.ContentLength);
}
else
{
subFrame = frame;
}
if (transl(subFrame, out var subItem))
{
ret.Add(subItem);
}
if (frame.Position == startingPos)
{
frame.Position += frame.MetaData.Constants.SubConstants.HeaderLength;
throw new ArgumentException($"Parsed item on the list consumed no data: {subItem}");
}
}
return(ret);
}
public static ExtendedList <T> CastExtendedList <T>(this ExtendedList <T> enumer)
{
return(enumer);
}
public static void FillBinaryPointToPointConnections(MutagenFrame frame, IPathGridInternal item)
{
if (!frame.TryReadSubrecord(RecordTypes.DATA, out var subMeta))
{
return;
}
uint ptCount = frame.Reader.ReadUInt16();
if (!frame.Reader.TryReadSubrecord(PGRP, out subMeta))
{
return;
}
var pointDataSpan = frame.Reader.ReadSpan(subMeta.ContentLength);
var bytePointsNum = pointDataSpan.Length / POINT_LEN;
if (bytePointsNum != ptCount)
{
throw new ArgumentException($"Unexpected point byte length, when compared to expected point count. {pointDataSpan.Length} bytes: {bytePointsNum} != {ptCount} points.");
}
bool readPGRR = false;
for (int recAttempt = 0; recAttempt < 2; recAttempt++)
{
if (frame.Reader.Complete)
{
break;
}
subMeta = frame.GetSubrecord();
switch (subMeta.RecordType.TypeInt)
{
case 0x47414750: //"PGAG":
frame.Reader.Position += subMeta.HeaderLength;
if (ByteArrayBinaryTranslation <MutagenFrame, MutagenWriter> .Instance.Parse(
frame.SpawnWithLength(subMeta.ContentLength, checkFraming: false),
item: out var unknownBytes))
{
item.PGAG = unknownBytes;
}
else
{
item.PGAG = default;
}
break;
case 0x52524750: // "PGRR":
frame.Reader.Position += subMeta.HeaderLength;
var connectionInts = frame.Reader.ReadSpan(subMeta.ContentLength).AsInt16Span();
int numPts = pointDataSpan.Length / POINT_LEN;
PathGridPoint[] pathGridPoints = new PathGridPoint[numPts];
for (int i = 0; i < numPts; i++)
{
var pt = ReadPathGridPoint(pointDataSpan, out var numConn);
pt.Connections.AddRange(connectionInts.Slice(0, numConn).ToArray());
pathGridPoints[i] = pt;
pointDataSpan = pointDataSpan.Slice(16);
connectionInts = connectionInts.Slice(numConn);
}
item.PointToPointConnections = pathGridPoints.ToExtendedList();
readPGRR = true;
break;
default:
break;
}
}
if (!readPGRR)
{
ExtendedList <PathGridPoint> list = new ExtendedList <PathGridPoint>();
while (pointDataSpan.Length > 0)
{
list.Add(
ReadPathGridPoint(pointDataSpan, out var numConn));
pointDataSpan = pointDataSpan.Slice(16);
}
item.PointToPointConnections = list;
}
}
public EventDeck()
{
deck = CreateDeck();
}
