public void StartGame_WithFinishInput_ShouldEndGame()
{
this.mockReader = new MockIReader("finish").MockReader.Object;
var engine = new GameEngine(this.gameLogic, this.mockPrinter, this.mockReader, this.db, this.topScoreController, this.gamesController);
engine.StartGame();
}
private void Load(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea,
EngineDescription buildInfo)
{
Name = new StringID(values.GetInteger("name stringid"));
LoadPermutations(values, reader, metaArea, buildInfo);
}
public List<LocalizedString> LoadStrings(IReader reader)
{
var result = new List<LocalizedString>();
if (StringCount == 0)
return result;
byte[] stringData = ReadLocaleData(reader);
using (var stringReader = new EndianReader(new MemoryStream(stringData), Endian.BigEndian))
{
reader.SeekTo(LocaleIndexTableLocation.AsOffset());
// Read each locale
for (int i = 0; i < StringCount; i++)
{
// Read the offset and stringID
StringID id;
int offset;
ReadLocalePointer(reader, out id, out offset);
if (offset >= stringReader.Length)
break; // Bad table - bail out so we don't end up in a huge memory-hogging loop
stringReader.SeekTo(offset);
string locale = stringReader.ReadUTF8();
result.Add(new LocalizedString(id, locale));
}
}
return result;
}
public void StartGame_WithInInvalidCommand_ShouldNotThrow()
{
this.mockReader = new MockIReader("invalid").GetSpecialReader("invalid");
var engine = new GameEngine(this.gameLogic, this.mockPrinter, this.mockReader, this.db, this.topScoreController, this.gamesController);
engine.StartGame();
}
public ThirdGenCacheFile(IReader reader, EngineDescription buildInfo, string buildString)
{
_buildInfo = buildInfo;
_segmenter = new FileSegmenter(buildInfo.SegmentAlignment);
Allocator = new MetaAllocator(this, 0x10000);
Load(reader, buildString);
}
public Engine()
{
this.writer = new ConsoleWriter();
this.reader = new ConsoleReader();
this.foodFactory = new FoodFactory();
this.moodFactory = new MoodFactory();
}
public Core(ILogicController controller, IReader reader, IWriter writer, IGameInstance game)
{
this.controller = controller;
this.reader = reader;
this.writer = writer;
this.game = game;
}
private static byte[] ReadByteArray(IReader reader)
{
int size = reader.ReadInt32();
if (size <= 0)
return new byte[0];
return reader.ReadBlock(size);
}
private static void ReadBlocks(IReader reader, ContainerReader containerFile, TagContainer tags)
{
while (containerFile.NextBlock())
{
switch (containerFile.BlockName)
{
case "data":
// Data block
tags.AddDataBlock(ReadDataBlock(reader, containerFile.BlockVersion));
break;
case "tag!":
// Extracted tag
tags.AddTag(ReadTag(reader, containerFile.BlockVersion));
break;
case "ersp":
// Extracted Raw Resource Page
tags.AddExtractedResourcePage(ReadExtractedResourcePage(reader, containerFile.BlockVersion));
break;
case "rspg":
// Resource page
tags.AddResourcePage(ReadResourcePage(reader, containerFile.BlockVersion));
break;
case "rsrc":
// Resource info
tags.AddResource(ReadResource(reader, containerFile.BlockVersion));
break;
}
}
}
public GameEngine(IReader reader, IRenderer renderer)
{
Reader = reader;
Renderer = renderer;
this.creepsList = new List<Npc>();
this.items = new List<Item>();
}
private long _offset; // The offset that the reader is currently at
#endregion Fields
#region Constructors
/// <summary>
/// (private) Constructs a new StructureReader.
/// </summary>
/// <param name="reader">The IReader to read from.</param>
private StructureReader(IReader reader)
{
_reader = reader;
_baseOffset = reader.Position;
_offset = _baseOffset;
_collection = new StructureValueCollection();
}
public CSVReaderWriter(IReader readerStream)
{
WriterStream = null;
readerStream.ThrowIfNull("readerStream");
ReaderStream = readerStream;
}
public static uint GetTagAddress(IReader memoryReader, ushort index, uint exeBase)
{
//uint newcountaddr = MaxTagCountAddress;
// Read the tag count and validate the tag index
memoryReader.SeekTo(MaxTagCountAddress + exeBase);
var maxIndex = memoryReader.ReadUInt16();
if (index >= maxIndex)
return 0;
// Read the tag index table to get the index of the tag in the address table
memoryReader.SeekTo(TagIndexArrayPointerAddress + exeBase);
var tagIndexTableAddress = memoryReader.ReadUInt32();
if (tagIndexTableAddress == 0)
return 0;
memoryReader.SeekTo(tagIndexTableAddress + index * 4);
var addressIndex = memoryReader.ReadInt32();
if (addressIndex < 0)
return 0;
// Read the tag's address in the address table
memoryReader.SeekTo(TagAddressArrayPointerAddress + exeBase);
var tagAddressTableAddress = memoryReader.ReadUInt32();
if (tagAddressTableAddress == 0)
return 0;
memoryReader.SeekTo(tagAddressTableAddress + addressIndex * 4);
return memoryReader.ReadUInt32();
}
/// <summary>
/// Reads the vertex buffers for a model from a stream and passes them to an IModelProcessor.
/// </summary>
/// <param name="reader">The stream to read the vertex buffers from.</param>
/// <param name="model">The model's metadata.</param>
/// <param name="sectionsToRead">
/// A BitArray controlling which sections to read. Indices which are set to to true will be
/// read.
/// </param>
/// <param name="buildInfo">Information about the cache file's target engine.</param>
/// <param name="processor">The IModelProcessor to pass the read model data to.</param>
private static void ReadVertexBuffers(IReader reader, IRenderModel model, BitArray sectionsToRead,
EngineDescription buildInfo, IModelProcessor processor)
{
for (int i = 0; i < model.Sections.Length; i++)
ReadSectionVertices(reader, model.Sections[i], model.BoundingBoxes[0], buildInfo,
sectionsToRead[i] ? processor : null);
}
public FourthGenCacheFile(IReader map_reader, IReader tag_reader, IReader string_reader, IReader tagnames_reader, EngineDescription buildInfo, string buildString)
{
_buildInfo = buildInfo;
_segmenter = new FileSegmenter(buildInfo.SegmentAlignment);
Allocator = new MetaAllocator(this, 0x10000);
Load(map_reader, tag_reader, string_reader, tagnames_reader, buildString);
}
public SecondGenCacheFile(IReader reader, BuildInformation buildInfo, string buildString)
{
_buildInfo = buildInfo;
_segmenter = new FileSegmenter(buildInfo.SegmentAlignment);
Allocator = new MetaAllocator(this, 0x10000);
Load(reader, buildInfo, buildString);
}
public static Patch LoadPatch(IReader reader, bool isAlteration)
{
Patch patch = new Patch();
SegmentChange change = new SegmentChange(0, 0, 0, 0, true);
patch.Author = "Ascension/Alteration Patch";
patch.Description = "Ascension/Alteration Patch";
if (isAlteration)
{
//do shitty alteration stuff
byte authorLength = reader.ReadByte();
patch.Author = reader.ReadAscii((int)authorLength);
byte descLength = reader.ReadByte();
patch.Description = reader.ReadAscii((int)descLength);
}
//create ascension patch object and change segment
while (!reader.EOF)
{
//get valuable info
var segmentOffset = reader.ReadUInt32();
var segmentSize = reader.ReadInt32();
var segmentData = reader.ReadBlock(segmentSize);
//Add change data
change.DataChanges.Add(new DataChange(segmentOffset, segmentData));
}
patch.SegmentChanges.Add(change);
return patch;
}
public static void MarkovRun(IReader reader, IReworder reworder,
int order, int repeat, bool randomizedRestack,
bool train, bool proba, string questionFilePath, string encyclopediaFilePath, string outFolder)
{
string encyclopediaName = Path.GetFileNameWithoutExtension(encyclopediaFilePath);
string summary = "Markov_" + reworder.GetType().Name + "_" +
reader.GetType().Name + "_" + order.ToString() + "_" + repeat.ToString() + "_" + randomizedRestack.ToString() + "_" +
encyclopediaName;
Console.Write("\n" + summary);
MarkovMatcher mm = new MarkovMatcher(reader, reworder, order, repeat, randomizedRestack);
mm.Learn(encyclopediaFilePath);
string[] answers = mm.Answer(questionFilePath, train, proba);
if (train)
{
EvaluateAndPrintScores(questionFilePath, answers);
}
else
{
string[] ids = TextToData.ImportColumn(questionFilePath, 0);
Submissions.Write(answers, ids, outFolder + summary + ".csv");
}
Console.WriteLine();
}
/// <summary>
/// Reads an index buffer from a stream.
/// </summary>
/// <param name="reader">The stream to read from.</param>
/// <param name="count">The number of indices to read.</param>
/// <returns>The index buffer that was read.</returns>
public static ushort[] ReadIndexBuffer(IReader reader, int count)
{
ushort[] indices = new ushort[count];
for (int i = 0; i < count; i++)
indices[i] = reader.ReadUInt16();
return indices;
}
public void SetUp()
{
_reader = MockRepository.GenerateStub<IReader<Artist>>();
_writer = MockRepository.GenerateStub<IWriter<Artist>>();
_operationOutput = new ExceptionOperationOutput();
}
public object ReadType(IReader reader)
{
if (ctor == null)
return ReadTypeUsingType(reader);
else
return ReadTypeUsingCtor(reader);
}
public ScriptContext LoadContext(IReader reader)
{
var values = LoadTag(reader);
return new ScriptContext()
{
ObjectReferences = ReadObjects(reader, values, _referencedObjects),
TriggerVolumes = ReadObjects(reader, values, _triggerVolumes),
CutsceneFlags = ReadObjects(reader, values, _cutsceneFlags),
CutsceneCameraPoints = ReadObjects(reader, values, _cutsceneCameraPoints),
CutsceneTitles = ReadObjects(reader, values, _cutsceneTitles),
DeviceGroups = ReadObjects(reader, values, _deviceGroups),
AISquadGroups = ReadObjects(reader, values, _aiSquadGroups),
AISquads = ReadObjects(reader, values, _aiSquads),
AIObjects = ReadObjects(reader, values, _aiObjects),
StartingProfiles = ReadObjects(reader, values, _startingProfiles),
ZoneSets = ReadObjects(reader, values, _zoneSets),
ObjectFolders = ReadObjects(reader, values, _objectFolders),
PointSets = ReadPointSets(reader, values),
AISquadSingleLocations = _aiSquadSingleLocations,
AIObjectWaves = _aiObjectWaves,
PointSetPoints = _pointSetPoints
};
}
/// <summary>
/// Compares two sets of file segments and the segment contents.
/// </summary>
/// <param name="originalSegments">The original set of file segments.</param>
/// <param name="originalReader">The stream to use to read from the original file.</param>
/// <param name="newSegments">The modified set of file segments.</param>
/// <param name="newReader">The stream to use to read from the modified file.</param>
/// <returns>The differences that were found.</returns>
public static List<SegmentChange> CompareSegments(IEnumerable<FileSegment> originalSegments, IReader originalReader,
IEnumerable<FileSegment> newSegments, IReader newReader)
{
List<FileSegment> originalList = originalSegments.ToList();
List<FileSegment> newList = newSegments.ToList();
if (originalList.Count != newList.Count)
throw new InvalidOperationException("The files have different segment counts");
var results = new List<SegmentChange>();
for (int i = 0; i < originalList.Count; i++)
{
FileSegment originalSegment = originalList[i];
FileSegment newSegment = newList[i];
List<DataChange> changes = DataComparer.CompareData(originalReader, (uint) originalSegment.Offset,
originalSegment.ActualSize, newReader, (uint) newSegment.Offset, newSegment.ActualSize,
originalSegment.ResizeOrigin != SegmentResizeOrigin.Beginning);
if (changes.Count > 0 || originalSegment.Size != newSegment.Size)
{
var change = new SegmentChange((uint) originalSegment.Offset, originalSegment.ActualSize, (uint) newSegment.Offset,
newSegment.ActualSize, originalSegment.ResizeOrigin != SegmentResizeOrigin.Beginning);
change.DataChanges.AddRange(changes);
results.Add(change);
}
}
return results;
}
public IModel Parse(IReader reader)
{
int numLines;
if (lineMatcher.Matches(reader, 0, out numLines))
{
string[] lines = reader.ReadLines(numLines);
int lineNo = 0;
List<string> data = new List<string>();
List<string> comment = new List<string>();
foreach (string line in lines)
{
string dataLine = dataParser.Parse(lineNo, line);
if (!string.IsNullOrEmpty(dataLine))
{
data.Add(dataLine);
}
string commentLine = commentParser.Parse(lineNo, line);
if (!string.IsNullOrEmpty(commentLine))
{
comment.Add(commentLine);
}
lineNo++;
}
IModel model = modelFactory(name, string.Join(" ", data), string.Join("\n", comment));
if (impliedModelParsers != null)
{
return impliedModelParsers.Aggregate(model, (current, impliedParser) => impliedParser.Matches(current) ? impliedParser.Parse(current) : current);
}
return model;
}
return null;
}
public IModel Parse(IReader reader)
{
IModel currentModel = modelParser.Parse(reader);
IModel childModel = childrenParser.Parse(reader);
List<IModel> children = new List<IModel>();
while (childModel != null)
{
children.Add(childModel);
childModel = childrenParser.Parse(reader);
}
HierarchyModel currentHierarchy = currentModel as HierarchyModel;
if (currentHierarchy != null && children.Count > 0)
{
if (currentHierarchy.ChildModels.Length == 1)
{
return new HierarchyModel(currentHierarchy.Model, new IModel[]
{
new HierarchyModel(currentHierarchy.ChildModels[0], children.ToArray())
});
}
}
return children.Count == 0 ? currentModel : new HierarchyModel(currentModel, children.ToArray());
}
private static void ReadPatchInfo(IReader reader, byte version, Patch output)
{
// Version 0 (all versions)
output.MapID = reader.ReadInt32();
output.MapInternalName = reader.ReadAscii();
output.Name = reader.ReadUTF16();
output.Description = reader.ReadUTF16();
output.Author = reader.ReadUTF16();
int screenshotLength = reader.ReadInt32();
if (screenshotLength > 0)
output.Screenshot = reader.ReadBlock(screenshotLength);
// Version 1
if (version >= 1)
{
output.MetaPokeBase = reader.ReadUInt32();
output.MetaChangesIndex = reader.ReadSByte();
}
// Version 2
if (version >= 2)
output.OutputName = reader.ReadAscii();
else
output.OutputName = "";
}
/// <summary>
/// Initializes a new instance of the <see cref="ThirdGenLanguagePackLoader" /> class.
/// </summary>
/// <param name="cacheFile">The cache file.</param>
/// <param name="languageGlobals">The language globals.</param>
/// <param name="buildInfo">Information about the cache file's engine.</param>
/// <param name="reader">The stream to read from.</param>
public ThirdGenLanguagePackLoader(ICacheFile cacheFile, ThirdGenLanguageGlobals languageGlobals,
EngineDescription buildInfo, IReader reader)
{
_languageGlobals = languageGlobals;
_languages = languageGlobals.Languages.Where(l => l.StringCount != 0).Select(l => l.Language).ToList();
LoadGroups(reader, cacheFile, buildInfo);
}
public EventEngine(IReader reader, IWriter writer, IEventHolder eventHolder, IEventLogger eventLogger)
{
this.reader = reader;
this.writer = writer;
this.eventHolder = eventHolder;
this.eventLogger = eventLogger;
}
private static Patch ReadBlocks(IReader reader, ContainerReader container)
{
var result = new Patch();
while (container.NextBlock())
{
switch (container.BlockName)
{
case "titl":
ReadPatchInfo(reader, container.BlockVersion, result);
break;
case "segm":
ReadSegmentChanges(reader, result);
break;
case "blfc":
ReadBlfInfo(reader, result);
break;
#region Deprecated
case "meta":
ReadMetaChanges(reader, result);
break;
case "locl":
ReadLocaleChanges(reader, result);
break;
#endregion Deprecated
}
}
return result;
}
/// <summary>
/// Loads a cache file from a stream.
/// </summary>
/// <param name="reader">The stream to read from.</param>
/// <param name="engineDb">The engine database to use to process the cache file.</param>
/// <param name="engineInfo">On output, this will contain the cache file's engine description.</param>
/// <returns>The cache file that was loaded.</returns>
/// <exception cref="ArgumentException">Thrown if the cache file is invalid.</exception>
/// <exception cref="NotSupportedException">Thrown if the cache file's target engine is not supported.</exception>
public static ICacheFile LoadCacheFile(IReader reader, EngineDatabase engineDb, out EngineDescription engineInfo)
{
// Set the reader's endianness based upon the file's header magic
reader.SeekTo(0);
byte[] headerMagic = reader.ReadBlock(4);
reader.Endianness = DetermineCacheFileEndianness(headerMagic);
// Load engine version info
var version = new CacheFileVersionInfo(reader);
if (version.Engine != EngineType.SecondGeneration && version.Engine != EngineType.ThirdGeneration)
throw new NotSupportedException("Engine not supported");
// Load build info
engineInfo = engineDb.FindEngineByVersion(version.BuildString);
if (engineInfo == null)
throw new NotSupportedException("Engine version \"" + version.BuildString + "\" not supported");
// Load the cache file depending upon the engine version
switch (version.Engine)
{
case EngineType.SecondGeneration:
return new SecondGenCacheFile(reader, engineInfo, version.BuildString);
case EngineType.ThirdGeneration:
return new ThirdGenCacheFile(reader, engineInfo, version.BuildString);
default:
throw new NotSupportedException("Engine not supported");
}
}
public override void Deserialize(IReader reader)
{
base.Deserialize(reader);
leavingPlayerId = reader.ReadVarUhLong();
}
public override void Deserialize(IReader reader)
{
base.Deserialize(reader);
}
public Summary(IReader reader1)
{
reader = reader1;
}
public Engine(IReader reader, IWriter writer)
{
this.reader = reader;
this.writer = writer;
this.soldiers = new List <Soldier>();
}
public void ReplayListPush(IReader reader)
{
throw new NotSupportedException();
}
public override void Deserialize(AbstractMethodPointer obj, IReader reader)
{
obj.signature = (string)reader.GetFieldValue("ptr");
}
public ReportBuilderLinqReadAll(IReader reader, IWriter writer) : base(reader, writer)
{
}
/// <summary>
/// Конструктор.
/// </summary>
/// <param name="reader">Ридер.</param>
public Counter(IReader reader)
{
this.reader = reader;
}
public ListCharactersController(IWoWDbContext dbContext, IReader reader, IWriter writer)
{
this.dbContext = dbContext;
this.reader = reader;
this.writer = writer;
}
public Engine(IReader reader, IWriter writer)
{
this.reader = reader;
this.writer = writer;
this.storageMaster = new StorageMaster();
}
public Engine(IReader reader, IWriter writer, IParser parser)
{
this.reader = reader;
this.writer = writer;
this.parser = parser;
}
/// <summary>
/// Builds a Patch by comparing two cache files.
/// </summary>
/// <param name="originalFile">The original cache file.</param>
/// <param name="originalReader">The stream to use to read from the original cache file.</param>
/// <param name="newFile">The modified cache file.</param>
/// <param name="newReader">The stream to use to read from the modified cache file.</param>
/// <param name="output">The Patch to store differences to.</param>
public static void BuildPatch(ICacheFile originalFile, IReader originalReader, ICacheFile newFile, IReader newReader,
Patch output)
{
output.MapInternalName = originalFile.InternalName;
output.MetaPokeBase = newFile.MetaArea.BasePointer;
List <SegmentChange> segmentChanges = SegmentComparer.CompareSegments(originalFile.Segments, originalReader,
newFile.Segments, newReader);
output.SegmentChanges.AddRange(segmentChanges);
output.MetaChangesIndex = FindMetaChanges(segmentChanges, newFile);
}
private void ConnectScud(IPAddress address, int port)
{
_scudReader = ScudReader.GetInstance(address, port);
_scudReader.Connect();
}
internal TES4_DATA(IReader headerReader, IReader dataReader, uint overrideDataSize = 0) : base(headerReader, dataReader, overrideDataSize)
{
this.Value = dataReader.ReadUInt32(0);
}
public virtual Object ReadObject(Type returnType, String elementName, int id, IReader reader)
{
if (!XmlDictionary.EntityRefElement.Equals(elementName))
{
throw new Exception("Element '" + elementName + "' not supported");
}
String idIndexValue = reader.GetAttributeValue(idNameIndex);
sbyte idIndex = idIndexValue != null?SByte.Parse(idIndexValue) : ObjRef.PRIMARY_KEY_INDEX;
reader.NextTag();
Type realType = (Type)reader.ReadObject();
Object objId = reader.ReadObject();
Object version = reader.ReadObject();
if (objId != null || version != null)
{
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(realType, true);
if (metaData != null)
{
if (objId != null)
{
PrimitiveMember idMember = metaData.GetIdMemberByIdIndex(idIndex);
if (objId.Equals(idMember.NullEquivalentValue))
{
objId = null;
}
}
if (version != null)
{
PrimitiveMember versionMember = metaData.VersionMember;
if (versionMember != null)
{
if (version.Equals(versionMember.NullEquivalentValue))
{
version = null;
}
}
}
}
}
IObjRef obj = ObjRefFactory.CreateObjRef(realType, idIndex, objId, version);
return(obj);
}
public Engine()
{
this.pizza = null;
this.reader = new ConsoleReader();
this.writer = new ConsoleWriter();
}
public override void Deserialize(IReader reader)
{
skillId = reader.ReadVarUhInt();
}
public void Deserialize <T>(IReader reader, T toDeserialize) => DeserializeMethodCache <T> .Deserialize(this, reader, _policy, toDeserialize);
public override void Deserialize(IReader reader)
{
}
object IBasicTypeSerializer.Deserialize(IReader reader) => (object)reader.ReadShort();
internal object Resolve(
Schema.Schema writerSchema,
Schema.Schema readerSchema,
IReader d,
Type type)
{
try
{
if (readerSchema.Tag == Schema.Schema.Type.Union && writerSchema.Tag != Schema.Schema.Type.Union)
{
readerSchema = FindBranch(readerSchema as UnionSchema, writerSchema);
}
switch (writerSchema.Tag)
{
case Schema.Schema.Type.Null:
return(null);
case Schema.Schema.Type.Boolean:
return(d.ReadBoolean());
case Schema.Schema.Type.Int:
return(d.ReadInt());
case Schema.Schema.Type.Long:
return(ResolveLong(type, d));
case Schema.Schema.Type.Float:
return(d.ReadFloat());
case Schema.Schema.Type.Double:
return(d.ReadDouble());
case Schema.Schema.Type.String:
return(ResolveString(type, d));
case Schema.Schema.Type.Bytes:
return(d.ReadBytes());
case Schema.Schema.Type.Error:
case Schema.Schema.Type.Record:
return(ResolveRecord((RecordSchema)writerSchema, (RecordSchema)readerSchema, d, type));
case Schema.Schema.Type.Enumeration:
return(ResolveEnum((EnumSchema)writerSchema, readerSchema, d, type));
case Schema.Schema.Type.Fixed:
return(ResolveFixed((FixedSchema)writerSchema, readerSchema, d, type));
case Schema.Schema.Type.Array:
return(ResolveArray(writerSchema, readerSchema, d, type));
case Schema.Schema.Type.Map:
return(ResolveMap((MapSchema)writerSchema, readerSchema, d, type));
case Schema.Schema.Type.Union:
return(ResolveUnion((UnionSchema)writerSchema, readerSchema, d, type));
default:
throw new AvroException("Unknown schema type: " + writerSchema);
}
}
catch (Exception e)
{
throw new AvroTypeMismatchException($"Unable to deserialize [{writerSchema.Name}] of schema [{writerSchema.Tag}] to the target type [{type}]", e);
}
}
private static DataBlock ReadDataBlock(IReader reader, byte version)
{
if (version > 4)
{
throw new InvalidOperationException("Unrecognized \"data\" block version");
}
// Block data
uint originalAddress = reader.ReadUInt32();
int entryCount = (version >= 1) ? reader.ReadInt32() : 1;
int align = (version >= 3) ? reader.ReadInt32() : 4;
byte[] data = ReadByteArray(reader);
var block = new DataBlock(originalAddress, entryCount, align, data);
// Address fixups
int numAddressFixups = reader.ReadInt32();
for (int i = 0; i < numAddressFixups; i++)
{
uint dataAddress = reader.ReadUInt32();
int writeOffset = reader.ReadInt32();
block.AddressFixups.Add(new DataBlockAddressFixup(dataAddress, writeOffset));
}
// Tagref fixups
int numTagFixups = reader.ReadInt32();
for (int i = 0; i < numTagFixups; i++)
{
var datum = new DatumIndex(reader.ReadUInt32());
int writeOffset = reader.ReadInt32();
block.TagFixups.Add(new DataBlockTagFixup(datum, writeOffset));
}
// Resource reference fixups
int numResourceFixups = reader.ReadInt32();
for (int i = 0; i < numResourceFixups; i++)
{
var datum = new DatumIndex(reader.ReadUInt32());
int writeOffset = reader.ReadInt32();
block.ResourceFixups.Add(new DataBlockResourceFixup(datum, writeOffset));
}
if (version >= 2)
{
// StringID fixups
int numSIDFixups = reader.ReadInt32();
for (int i = 0; i < numSIDFixups; i++)
{
string str = reader.ReadAscii();
int writeOffset = reader.ReadInt32();
block.StringIDFixups.Add(new DataBlockStringIDFixup(str, writeOffset));
}
}
if (version >= 4)
{
// Shader fixups
int numShaderFixups = reader.ReadInt32();
for (int i = 0; i < numShaderFixups; i++)
{
int writeOffset = reader.ReadInt32();
int shaderDataSize = reader.ReadInt32();
byte[] shaderData = reader.ReadBlock(shaderDataSize);
block.ShaderFixups.Add(new DataBlockShaderFixup(writeOffset, shaderData));
}
}
return(block);
}
public override void Deserialize(IReader reader)
{
allowed = reader.ReadBoolean();
}
public ExceptionPart(IReader reader) : base(reader)
{
}
public override void Deserialize(IReader reader)
{
uid = reader.ReadUTF();
failure = reader.ReadSByte();
}
public Service(IReader reader, IWriter writer)
{
_reader = reader;
_writer = writer;
}
//[Inject]
public void Read(IReader read)
{
_reader = read;
Console.WriteLine("Prepare reder");
}
public RazorTemplateEngine(IContext context, Configuration.Template template, IReader templateReader)
{
_context = context;
_template = template;
_templateReader = templateReader;
_engine = new RazorEngine();
}
public override void Deserialize(IReader reader)
{
nuggetsForPrism = reader.ReadVarUhInt();
nuggetsForPlayer = reader.ReadVarUhInt();
}
public Summary(IReader reader)
{
_reader = reader;
}
