internal Object(Script script, ScriptBlock block, AssetLoader loader)
: base(script, block)
{
var reader = loader.Reader;
loader.Expect((ushort)0x1234);
LocalVariableOffset = reader.ReadUInt16();
int functionSelectorListOffset = reader.ReadUInt16();
int variableSelectorCount = reader.ReadUInt16();
Codex <VariableSelector> variableSelectors = new Codex <VariableSelector>(variableSelectorCount);
Variables = variableSelectors;
for (int index = 0; index < variableSelectorCount; index++)
{
variableSelectors.Add(new VariableSelector(this, loader));
}
int functionSelectorCount = reader.ReadUInt16();
Codex <FunctionSelector> functionSelectors = new Codex <FunctionSelector>(functionSelectorCount);
Functions = functionSelectors;
for (int index = 0; index < functionSelectorCount; index++)
{
functionSelectors.Add(new FunctionSelector(this, loader));
}
loader.Expect((ushort)0);
for (int index = 0; index < functionSelectorCount; index++)
{
functionSelectors[index].ReadCodeOffset(loader);
}
loader.ExpectPosition(block.EndOffset);
}
public void Analyse(Codex codex)
{
if (curSample != null)
{
//temp
TempTasksManager.instance.UpdateCurrentTask(1);
particles.Play();
codex.AddSample(curSample);
}
/*
* if (!state)
* {
* if (curSample != null)
* {
* AnalyserOn();
* }
* }
* else
* {
* AnalyserOff();
* }
*/
}
internal Package(AssetLoader loader)
: base(loader)
{
loader.MakeBigEndian();
BinaryReader reader = Reader = loader.Reader;
ushort versionMajor = reader.ReadUInt16();
ushort versionMinor = reader.ReadUInt16();
reader.RequireZeroes(4);
int stringCount = reader.ReadInt32();
Codex <PackageString> strings = new Codex <PackageString>(stringCount);
for (int index = 0; index < stringCount; index++)
{
strings.Add(new PackageString(this, index, reader));
}
Strings = strings;
int fileCount = reader.ReadInt32();
for (int index = 0; index < fileCount; index++)
{
new PackageFile(this, index, loader);
}
}
static void ReloadDNAPool(Codex codex)
{
string DNAPath = codex.DNAPrefabPath;
string[] fileList = null;
if (System.IO.Directory.Exists(DNAPath))
{
fileList = System.IO.Directory.GetFiles(DNAPath, "*.prefab");
}
List <DNA> DNAPool = codex.DNAPool;
//remove empty
List <DNA> RemovedDNA = DNAPool.FindAll(dna => dna == null);
RemovedDNA.ForEach(dna => DNAPool.Remove(dna));
//insert new
if (fileList != null)
{
foreach (string fileName in fileList)
{
GameObject dnaGOPrefab = AssetDatabase.LoadAssetAtPath <GameObject>(fileName);
if (dnaGOPrefab == null)
{
continue;
}
DNA dnaPrefab = dnaGOPrefab.GetComponent <DNA>();
if (dnaPrefab != null && !DNAPool.Contains(dnaPrefab))
{
DNAPool.Add(dnaPrefab);
}
}
}
}
internal MCP(AssetManager manager, AssetLoader loader)
: base(manager, loader.Name)
{
var reader = loader.Reader;
EndOffset = checked ((int)loader.Length);
loader.Expect(Magic1 + 1);
loader.Expect(Magic2);
int table2Count = reader.ReadInt32();
int table2Offset = Table2Offset = reader.ReadInt32();
int table1Offset = Table1Offset = HeaderDataSize;
int table1Count = (table2Offset - table1Offset) / MCPTable1.DataSize;
reader.BaseStream.Position = table1Offset;
var table1 = new Codex <MCPTable1>(table1Count);
Table1 = table1;
for (int index = 0; index < table1Count; index++)
{
table1.Add(new MCPTable1(this, index, loader));
}
reader.BaseStream.Position = table2Offset;
var table2 = new Codex <MCPTable2>(table2Count);
Table2 = table2;
for (int index = 0; index < table2Count; index++)
{
table2.Add(new MCPTable2(this, index, loader));
}
}
protected virtual void CompileEntry(SuperGumpLayout layout, int x, int y, int idx, RuneCodexEntry entry)
{
var ui = UI;
if (x >= ui.Category.Entries.Width || y >= ui.Category.Entries.Height)
{
return;
}
layout.Add(
"entry/" + idx,
() =>
{
ui = UI;
int xOffset = 220 + (x * 70);
int yOffset = 50 + (y * 70);
int gx = x + ui.EntryScroll.X;
int gy = y + ui.EntryScroll.Y;
const int itemID = 7956;
bool s = entry != null && ui.Entry == entry;
if (entry != null)
{
AddButton(xOffset + 5, yOffset + 5, 24024, 24024, b => SelectEntry(gx, gy, idx, entry));
}
else if (Codex.CanAddEntries(User))
{
AddButton(xOffset + 5, yOffset + 5, 24024, 24024, b => AddEntry(gx, gy, idx));
}
AddImageTiled(xOffset, yOffset, 60, 60, 2702);
if (s)
{
AddItem(xOffset + 10, yOffset + 4, itemID, 2050);
AddItem(xOffset + 10, yOffset + 2, itemID, 1);
}
if (entry != null)
{
AddItem(xOffset + 10, yOffset, itemID, ui.Category.Hue);
AddHtml(
xOffset,
yOffset + 25,
60,
40,
GetEntryLabel(entry).WrapUOHtmlTag("center").WrapUOHtmlColor(Color.LawnGreen, false),
false,
false);
}
else if (Codex.CanAddEntries(User))
{
AddImage(xOffset + 25, yOffset, 2511, HighlightHue);
AddHtml(
xOffset, yOffset + 25, 60, 40, "Add".WrapUOHtmlTag("center").WrapUOHtmlColor(Color.Yellow, false), false, false);
}
});
}
static void UpdateCodex(Codex codex)
{
List <DNA> DNAPool = codex.DNAPool;
List <CodexEntry> Codex = codex.CodexEntries;
//remove empty
List <CodexEntry> RemovedCodex = Codex.FindAll(c => c.MotherDNA == null || c.FatherDNA == null);
RemovedCodex.ForEach(c => Codex.Remove(c));
for (int fatherID = 0; fatherID < DNAPool.Count; fatherID++)
{
for (int motherID = 0; motherID < DNAPool.Count; motherID++)
{
DNA fatherDNA = DNAPool[fatherID];
DNA motherDNA = DNAPool[motherID];
if (fatherDNA == null || motherDNA == null)
{
continue;
}
CodexEntry c = Codex.Find(entry => entry.FatherDNA == fatherDNA && entry.MotherDNA == motherDNA);
if (c != null)
{
continue;
}
c = new CodexEntry();
c.FatherDNA = fatherDNA;
c.MotherDNA = motherDNA;
Codex.Add(c);
}
}
}
internal Effect(AssetLoader loader)
: base(loader)
{
var reader = loader.Reader;
loader.ExpectMagic(Magic);
loader.Expect(0x10000);
loader.Expect(ContentStart);
int offsetOffset = reader.ReadInt32();
int pointerCount = reader.ReadInt32();
HashSet<int> pointers = new HashSet<int>();
int functionCount = reader.ReadInt32();
HashSet<int> functions = new HashSet<int>();
loader.Position = offsetOffset;
for (int index = 0; index < pointerCount; index++)
pointers.Add(reader.ReadInt32());
for (int index = 0; index < functionCount; index++)
functions.Add(reader.ReadInt32());
loader.Position = ContentStart;
int tokenCount = (offsetOffset - ContentStart) / 4;
Tokens = new Codex<EffectToken>(tokenCount);
for (int index = 0; index < tokenCount; index++)
Tokens.Add(new EffectToken(reader, pointers, functions));
for (int index = 0; index < tokenCount; index++)
Tokens[index].Link(Tokens);
Instructions = new Codex<EffectInstruction>();
for (int index = 0; index < tokenCount; )
Instructions.Add(new EffectInstruction(Tokens, ref index));
}
void Start()
{
Random.InitState(0xCA51B7);
Codex = Resources.Load <GameObject>("codex").GetComponent <Codex>();
Codex.DNAPool.ForEach(dna => DNANames.Add(dna.name));
}
public static void AddCodex(string fileName)
{
if (!String.IsNullOrEmpty(fileName))
{
Codex.Add(fileName.ToLower());
}
}
protected virtual void AddEntry(int gx, int gy, int idx)
{
var ui = UI;
ui.EntryPoint = new Point2D(gx, gy);
User.SendMessage("Select a rune book or recall rune to add to the Codex...");
Minimized = true;
Refresh(true);
ItemSelectTarget <Item> .Begin(
User,
(m, t) =>
{
if (Codex.Add(User, t, ui.Category, true))
{
Minimized = false;
SelectEntry(gx, gy, idx, ui.Category.Entries[gx, gy]);
}
else
{
AddEntry(gx, gy, idx);
}
},
m =>
{
Minimized = false;
Refresh(true);
});
}
protected virtual void AddCategory(int gx, int gy, int idx)
{
UI.CategoryPoint = new Point2D(gx, gy);
SelectCategory(gx, gy, idx, Codex.Categories[gx, gy] ?? (Codex.Categories[gx, gy] = new RuneCodexCategory()));
Codex.InvalidateProperties();
}
public Player(PlayerProfile profile, Codex codex)
{
Profile = profile;
Codex = codex;
DrawPile = new Pile(codex.GetStarter());
DiscardPile = new Pile();
Hand = new Hand();
}
protected virtual void CompileCategory(SuperGumpLayout layout, int x, int y, int idx, RuneCodexCategory cat)
{
if (x >= Codex.Categories.Width || y >= Codex.Categories.Height)
{
return;
}
layout.Add(
"cat/" + idx,
() =>
{
int xOffset = 220 + (x * 70);
int yOffset = 50 + (y * 70);
int gx = x + UI.CategoryScroll.X;
int gy = y + UI.CategoryScroll.Y;
const int itemID = 8901;
bool s = cat != null && UI.Category == cat;
if (cat != null)
{
AddButton(xOffset + 5, yOffset + 5, 24024, 24024, b => SelectCategory(gx, gy, idx, cat));
}
else if (Codex.CanAddCategories(User))
{
AddButton(xOffset + 5, yOffset + 5, 24024, 24024, b => AddCategory(gx, gy, idx));
}
AddImageTiled(xOffset, yOffset, 60, 60, 2702);
if (s)
{
AddItem(xOffset + 10, yOffset + 4, itemID, 2050);
AddItem(xOffset + 10, yOffset + 2, itemID, 1);
}
if (cat != null)
{
AddItem(xOffset + 10, yOffset, itemID, cat.Hue);
AddHtml(
xOffset,
yOffset + 25,
60,
40,
GetCategoryLabel(cat).WrapUOHtmlTag("center").WrapUOHtmlColor(Color.LawnGreen, false),
false,
false);
}
else if (Codex.CanAddCategories(User))
{
AddImage(xOffset + 25, yOffset, 2511, HighlightHue);
AddHtml(
xOffset, yOffset + 25, 60, 40, "Add".WrapUOHtmlTag("center").WrapUOHtmlColor(Color.Yellow, false), false, false);
}
});
}
internal void ReadDetailLevels(AssetLoader loader, int dataOffset, ArrayBackedList <byte> bufferData)
{
var detailLevels = new Codex <ModelDetailLevel>();
DetailLevels = detailLevels;
for (int index = 0; index < PartCount; index++)
{
detailLevels.Add(new ModelDetailLevel(this, index, loader, dataOffset, bufferData));
}
}
internal Message(AssetLoader loader)
: base(loader)
{
using (BinaryReader reader = loader.Reader) {
Version = (MessageVersion)reader.ReadInt32();
int fileLength, addonOffset = -1;
int count;
Codex <MessageItem> items = new Codex <MessageItem>();
Items = items;
switch (MajorVersion)
{
case 3:
fileLength = reader.ReadUInt16() + 6;
count = reader.ReadUInt16();
break;
case 4:
addonOffset = reader.ReadUInt16() + 6;
Unknowns.ReadInt16s(reader, 1);
count = reader.ReadUInt16();
break;
case 5:
addonOffset = reader.ReadInt32() + 6;
count = reader.ReadUInt16();
break;
default:
throw new NotImplementedException("Unimplemented version " + Version);
}
for (int index = 0; index < count; index++)
{
MessageItem item = new MessageItem(this, index, loader);
items.Add(item);
AddChild(item);
}
foreach (MessageItem item in items)
{
item.ReadText(reader);
}
if (addonOffset >= 0)
{
reader.BaseStream.Position = addonOffset;
foreach (MessageItem item in items)
{
item.ReadAddOn(reader);
}
}
}
}
internal Strings(Script script, ScriptBlock block, AssetLoader loader)
: base(script, block)
{
Codex <string> list = new Codex <string>();
Values = list;
while (loader.Position < block.EndOffset)
{
list.Add(loader.Reader.ReadStringz(Encoding.ASCII));
}
}
internal Locals(Script script, ScriptBlock block, AssetLoader loader)
: base(script, block)
{
Codex <ushort> values = new Codex <ushort>(block.ContentSize / 2);
Values = values;
for (int index = 0; index < block.ContentSize / 2; index++)
{
values.Add(loader.Reader.ReadUInt16());
}
}
protected virtual void OnSelected(int gx, int gy, int idx, RuneCodexEntry entry)
{
if (DoubleClicked && Codex.Recall(User, entry, true))
{
Minimized = true;
Refresh(true);
return;
}
Refresh(true);
}
Lover(Stream stream, LoverDirection direction, ByteOrder defaultByteOrder, Encoding encoding, bool keepOpen = false)
{
this.direction = direction;
Combinator = IsLoading ? LoaderCombinator : SaverCombinator;
this.stream = stream;
DefaultByteOrder = defaultByteOrder;
Encoding = encoding;
KeepOpen = keepOpen;
if (IsLoading)
SectionsMutable = new Codex<LoverSection>();
}
public LuaFunction(BinaryReader reader, LuaModule module)
{
Module = module;
Source = module.ReadString(reader);
LineDefined = module.ReadInt(reader);
UpValueCount = reader.ReadByte();
ParameterCount = reader.ReadByte();
HasVariableArguments = reader.ReadByte() != 0;
MaxStackSize = reader.ReadByte();
var lineInfoCount = module.ReadInt(reader);
LineInfo = new Codex<int>(reader.ReadArrayInt32(lineInfoCount));
var localVariableCount = module.ReadInt(reader);
LuaLocalVariable[] localVariables = new LuaLocalVariable[localVariableCount];
for (int index = 0; index < localVariableCount; index++)
localVariables[index] = new LuaLocalVariable(reader, this);
LocalVariables = new Codex<LuaLocalVariable>(localVariables);
var upValueCount = module.ReadInt(reader);
string[] upValues = new string[upValueCount];
for (int index = 0; index < upValueCount; index++)
upValues[index] = module.ReadString(reader);
UpValues = new Codex<string>(upValues);
var constantCount = module.ReadInt(reader);
Codex<object> constants = new Codex<object>(constantCount);
Constants = constants;
for (int index = 0; index < constantCount; index++) {
LuaType type = (LuaType)reader.ReadByte();
switch (type) {
case LuaType.Nil: break;
case LuaType.Boolean: constants.Add(reader.ReadByte() != 0); break;
case LuaType.Number: constants.Add(module.ReadNumber(reader)); break;
case LuaType.String: constants.Add(module.ReadString(reader)); break;
default: throw new NotSupportedException();
}
}
var functionCount = module.ReadInt(reader);
LuaFunction[] functions = new LuaFunction[functionCount];
for (int index = 0; index < functionCount; index++)
functions[index] = new LuaFunction(reader, index, this);
Closures = new Codex<LuaFunction>(functions);
var codeCount = module.ReadInt(reader);
LuaInstruction[] code = new LuaInstruction[codeCount];
for (int index = 0; index < codeCount; index++)
code[index] = new LuaInstruction(this, module.ReadInstructionCode(reader));
Instructions = new Codex<LuaInstruction>(code);
}
internal Picture(AssetLoader loader)
: base(loader)
{
BinaryReader reader = loader.Reader;
ushort check = reader.ReadUInt16();
Codex <PictureInstruction> instructions = new Codex <PictureInstruction>();
Codex <PictureCel> cels = new Codex <PictureCel>();
if (check == 0x0E) // VGA picture
{
int celCount = reader.ReadUInt16();
Unknowns.ReadInt16s(reader, 1); // 0x2A
int paletteOffset = reader.ReadInt32();
Dimensions = new Vector2i(reader.ReadUInt16(), reader.ReadUInt16());
reader.BaseStream.Position = paletteOffset;
Palette = new Palette(loader);
AddChild(Palette);
for (int celIndex = 0; celIndex < celCount; celIndex++)
{
PictureCel cel = new PictureCel(this, celIndex, loader);
cels.Add(cel);
AddChild(cel);
instructions.Add(new PictureInstruction.DrawCel(cel));
}
}
else
{
Dimensions = new Vector2i(320, 190);
reader.BaseStream.Seek(-2, SeekOrigin.Current);
byte[] data = reader.ReadBytes(checked ((int)reader.BaseStream.Length));
Stream stream = new MemoryStream(data, false);
PicturePatternFlags patternFlags = PicturePatternFlags.None;
byte patternNumber = 0;
while (true)
{
PictureInstruction instruction = PictureInstruction.ReadInstruction(stream, ref patternFlags, ref patternNumber);
instructions.Add(instruction);
if (instruction.IsQuit)
{
break;
}
}
}
Cels = cels;
Instructions = instructions;
}
Lover(Stream stream, LoverDirection direction, ByteOrder defaultByteOrder, Encoding encoding, bool keepOpen = false)
{
this.direction = direction;
Combinator = IsLoading ? LoaderCombinator : SaverCombinator;
this.stream = stream;
DefaultByteOrder = defaultByteOrder;
Encoding = encoding;
KeepOpen = keepOpen;
if (IsLoading)
{
SectionsMutable = new Codex <LoverSection>();
}
}
protected override void Awake()
{
base.Awake();
inv = GetComponent <Inventory>();
input = new InputController(sensitivity);
controller = new PlayerController(input, GetComponent <Rigidbody>(), GetComponent <GravityObject>(), GetComponent <Animator>(), GetComponent <Collider>());
cam = new PlayerCamera(input, transform, cameraOffset);
inventory = new PlayerInventory(input, cam, GetComponentInChildren <InvArm>());
interaction = new PlayerInteraction(this, input, cam, inv);
mechanics = new PlayerMechanics(this, input, interaction, toolbar);
codex = new Codex(codexParent);
}
static GameObject CreateCodexPrefab(string prefabPath)
{
GameObject codexGo = new GameObject("Codex");
Codex codex = codexGo.AddComponent <Codex>();
ReloadCreaturePool(codex);
ReloadDNAPool(codex);
UpdateCodex(codex);
GameObject prefab = PrefabUtility.CreatePrefab(prefabPath, codexGo, ReplacePrefabOptions.Default);
GameObject.DestroyImmediate(codexGo);
return(prefab);
}
public static Models.Codex Load(ulong nodeId)
{
Codex result;
if (idMap.TryGetValue(nodeId, out result))
{
return(result);
}
GomObject obj = DataObjectModel.GetObject(nodeId);
Codex cdx = new Codex();
return(Load(cdx, obj));
}
public static Models.Codex Load(string fqn)
{
Codex result;
if (nameMap.TryGetValue(fqn, out result))
{
return(result);
}
GomObject obj = DataObjectModel.GetObject(fqn);
Codex cdx = new Codex();
return(Load(cdx, obj));
}
internal Codex <MCGTable1> GetTable1Slice(int count, int offset)
{
if (offset < Table1Offset || offset + count * MCGTable1.DataSize > Table2Offset || (offset - Table1Offset) % MCGTable1.DataSize != 0)
{
throw new InvalidDataException();
}
int start = (offset - Table1Offset) / MCGTable1.DataSize;
Codex <MCGTable1> table = new Codex <MCGTable1>(count);
for (int index = 0; index < count; index++)
{
table.Add(Table1[start + index]);
}
return(table);
}
internal Message(AssetLoader loader)
: base(loader)
{
using (BinaryReader reader = loader.Reader) {
Version = (MessageVersion)reader.ReadInt32();
int fileLength, addonOffset = -1;
int count;
Codex<MessageItem> items = new Codex<MessageItem>();
Items = items;
switch (MajorVersion) {
case 3:
fileLength = reader.ReadUInt16() + 6;
count = reader.ReadUInt16();
break;
case 4:
addonOffset = reader.ReadUInt16() + 6;
Unknowns.ReadInt16s(reader, 1);
count = reader.ReadUInt16();
break;
case 5:
addonOffset = reader.ReadInt32() + 6;
count = reader.ReadUInt16();
break;
default:
throw new NotImplementedException("Unimplemented version " + Version);
}
for (int index = 0; index < count; index++) {
MessageItem item = new MessageItem(this, index, loader);
items.Add(item);
AddChild(item);
}
foreach (MessageItem item in items)
item.ReadText(reader);
if (addonOffset >= 0) {
reader.BaseStream.Position = addonOffset;
foreach (MessageItem item in items)
item.ReadAddOn(reader);
}
}
}
internal Palette(AssetLoader loader)
: base(loader)
{
BinaryReader reader = loader.Reader;
Unknowns.ReadBytes(reader, 25); // Offset 0-24
int firstIndex = reader.ReadByte(); // Offset 25-25
Unknowns.ReadBytes(reader, 3); // Offset 26-28
int count = reader.ReadUInt16(); // Offset 29-30
Unknowns.ReadBytes(reader, 1); // Offset 31-31
byte format = reader.ReadByte(); // Offset 32-32
Unknowns.ReadBytes(reader, 4); // Offset 33-36
// Offset 37
PaletteColor[] colors = new PaletteColor[count];
Colors = new ReadOnlyCollection <PaletteColor>(colors);
FlatColors = new Codex <Color>(256);
for (int index = 0; index < firstIndex; index++)
{
FlatColors.Add(Color.Purple);
}
for (int index = 0; index < count; index++)
{
PaletteColor color;
switch (format)
{
case 0: // Variable (byte used, byte red, byte green, byte blue)
color = new PaletteColor(reader.ReadByte() != 0, reader.ReadByte(), reader.ReadByte(), reader.ReadByte());
break;
case 1: // Constant (byte red, byte green, byte blue)
color = new PaletteColor(reader.ReadByte(), reader.ReadByte(), reader.ReadByte());
break;
default:
throw new NotImplementedException();
}
colors[index] = color;
FlatColors.Add(color);
}
PaletteAsset = new PaletteAsset(Manager, Name ?? "Palette", FlatColors);
}
internal ModelMesh(FolderAsset folder, int index, AssetLoader loader)
: base(folder, index, loader)
{
var reader = loader.Reader;
Unknowns.ReadInt32s(reader, 1); // 1?
MaterialIndex = reader.ReadInt32();
reader.RequireZeroes(4 * 2);
Unknowns.ReadInt32s(reader, 1); // 0 or 1, seems to be material-related but is not transparency; second seems bones-related
int boneCount = reader.ReadInt32();
reader.RequireZeroes(4 * 1);
int boneIndicesOffset = reader.ReadInt32();
PartCount = reader.ReadInt32();
int partIndicesOffset = reader.ReadInt32();
reader.Require(1);
int indexOffset = reader.ReadInt32();
long reset = reader.BaseStream.Position;
reader.BaseStream.Position = boneIndicesOffset;
var bones = new Codex <ModelBone>();
Bones = bones;
for (int i = 0; i < boneCount; i++)
{
bones.Add(Model.Bones[reader.ReadInt32()]);
}
// Read the part indices.
reader.BaseStream.Position = partIndicesOffset;
int partStart = PartStartIndex;
for (int i = 0; i < PartCount; i++)
{
reader.Require(i + partStart);
}
reader.BaseStream.Position = indexOffset;
reader.Require(Index);
reader.BaseStream.Position = reset;
}
internal Effect(AssetLoader loader)
: base(loader)
{
var reader = loader.Reader;
loader.ExpectMagic(Magic);
loader.Expect(0x10000);
loader.Expect(ContentStart);
int offsetOffset = reader.ReadInt32();
int pointerCount = reader.ReadInt32();
HashSet <int> pointers = new HashSet <int>();
int functionCount = reader.ReadInt32();
HashSet <int> functions = new HashSet <int>();
loader.Position = offsetOffset;
for (int index = 0; index < pointerCount; index++)
{
pointers.Add(reader.ReadInt32());
}
for (int index = 0; index < functionCount; index++)
{
functions.Add(reader.ReadInt32());
}
loader.Position = ContentStart;
int tokenCount = (offsetOffset - ContentStart) / 4;
Tokens = new Codex <EffectToken>(tokenCount);
for (int index = 0; index < tokenCount; index++)
{
Tokens.Add(new EffectToken(reader, pointers, functions));
}
for (int index = 0; index < tokenCount; index++)
{
Tokens[index].Link(Tokens);
}
Instructions = new Codex <EffectInstruction>();
for (int index = 0; index < tokenCount;)
{
Instructions.Add(new EffectInstruction(Tokens, ref index));
}
}
internal Picture(AssetLoader loader)
: base(loader) {
BinaryReader reader = loader.Reader;
ushort check = reader.ReadUInt16();
Codex<PictureInstruction> instructions = new Codex<PictureInstruction>();
Codex<PictureCel> cels = new Codex<PictureCel>();
if (check == 0x0E) { // VGA picture
int celCount = reader.ReadUInt16();
Unknowns.ReadInt16s(reader, 1); // 0x2A
int paletteOffset = reader.ReadInt32();
Dimensions = new Vector2i(reader.ReadUInt16(), reader.ReadUInt16());
reader.BaseStream.Position = paletteOffset;
Palette = new Palette(loader);
AddChild(Palette);
for (int celIndex = 0; celIndex < celCount; celIndex++) {
PictureCel cel = new PictureCel(this, celIndex, loader);
cels.Add(cel);
AddChild(cel);
instructions.Add(new PictureInstruction.DrawCel(cel));
}
} else {
Dimensions = new Vector2i(320, 190);
reader.BaseStream.Seek(-2, SeekOrigin.Current);
byte[] data = reader.ReadBytes(checked((int)reader.BaseStream.Length));
Stream stream = new MemoryStream(data, false);
PicturePatternFlags patternFlags = PicturePatternFlags.None;
byte patternNumber = 0;
while (true) {
PictureInstruction instruction = PictureInstruction.ReadInstruction(stream, ref patternFlags, ref patternNumber);
instructions.Add(instruction);
if (instruction.IsQuit)
break;
}
}
Cels = cels;
Instructions = instructions;
}
/// <summary>Initialise the <see cref="Asset"/> loader.</summary>
/// <param name="assetManager"></param>
/// <param name="reader"></param>
/// <param name="name"></param>
/// <param name="fileManager">The <see cref="FileManager"/> to use to load any attached files. If this is <c>null</c> (the default), then the system file manager (<see cref="Glare.Assets.FileManager.System"/>) is used.</param>
/// <param name="contextResource"></param>
/// <param name="length"></param>
public AssetLoader(AssetManager assetManager, BinaryReader reader, string name, FileManager fileManager, Asset contextResource = null, long?length = null)
{
if (assetManager == null)
{
throw new ArgumentNullException("assetManager");
}
if (reader == null)
{
throw new ArgumentNullException("reader");
}
AssetManager = assetManager;
Start = reader.BaseStream.Position;
Reader = reader;
Name = name;
FileManager = fileManager ?? FileManager.System;
Context = contextResource;
Length = length.HasValue ? length.Value : reader.BaseStream.Length;
Errors = new Codex <AssetLoadError>();
}
internal ViewAnimation(View view, AssetLoader loader)
: base(loader)
{
BinaryReader reader = loader.Reader;
View = view;
var cells = new Codex <ViewCell>();
Cells = cells;
DataOffset = (ushort)reader.BaseStream.Position;
var count = reader.ReadUInt16();
Unknowns.ReadInt16s(reader, 1);
for (int index = 0; index < count; index++)
{
reader.BaseStream.Position = DataOffset + 4 + index * 2;
cells.Add(view.FindCell(loader, reader.ReadUInt16()));
}
}
internal ModelMesh(FolderAsset folder, int index, AssetLoader loader)
: base(folder, index, loader)
{
var reader = loader.Reader;
Unknowns.ReadInt32s(reader, 1); // 1?
MaterialIndex = reader.ReadInt32();
reader.RequireZeroes(4 * 2);
Unknowns.ReadInt32s(reader, 1); // 0 or 1, seems to be material-related but is not transparency; second seems bones-related
int boneCount = reader.ReadInt32();
reader.RequireZeroes(4 * 1);
int boneIndicesOffset = reader.ReadInt32();
PartCount = reader.ReadInt32();
int partIndicesOffset = reader.ReadInt32();
reader.Require(1);
int indexOffset = reader.ReadInt32();
long reset = reader.BaseStream.Position;
reader.BaseStream.Position = boneIndicesOffset;
var bones = new Codex<ModelBone>();
Bones = bones;
for (int i = 0; i < boneCount; i++)
bones.Add(Model.Bones[reader.ReadInt32()]);
// Read the part indices.
reader.BaseStream.Position = partIndicesOffset;
int partStart = PartStartIndex;
for (int i = 0; i < PartCount; i++)
reader.Require(i + partStart);
reader.BaseStream.Position = indexOffset;
reader.Require(Index);
reader.BaseStream.Position = reset;
}
internal ViewAnimation(View view, AssetLoader loader)
: base(loader)
{
BinaryReader reader = loader.Reader;
View = view;
var cells = new Codex<ViewCell>();
Cells = cells;
DataOffset = (ushort)reader.BaseStream.Position;
var count = reader.ReadUInt16();
Unknowns.ReadInt16s(reader, 1);
for (int index = 0; index < count; index++) {
reader.BaseStream.Position = DataOffset + 4 + index * 2;
cells.Add(view.FindCell(loader, reader.ReadUInt16()));
}
}
internal Rom(AssetLoader loader)
: base(loader)
{
BinaryReader reader = Reader = loader.Reader;
Codex<RomFile> files = new Codex<RomFile>();
Codex<RomFolder> folders = new Codex<RomFolder>();
Files = files;
Folders = folders;
GameTitle = Reader.ReadStringz(12, Encoding.ASCII);
GameCode = Reader.ReadStringz(4, Encoding.ASCII);
// Offset 0x10
MakerCode = Reader.ReadStringz(2, Encoding.ASCII);
UnitCode = reader.ReadByte();
DeviceCode = reader.ReadByte();
CardSizeBase = reader.ReadByte();
loader.ExpectZeroes(1, 7);
Unknowns.ReadInt32s(reader, 1); // Usually 0, Alice in Wonderland: 3
// Offset 0x20
PageSize = reader.ReadInt32(); // Usually (always?) 0x4000
Unknowns.ReadInt16s(reader, 2); // The Dark Spire: 0x800; Trauma Center: 0xF780 (-2176)
loader.Expect(0x2000000);
Unknowns.ReadInt32s(reader, 1); // The Dark Spire: 0x9BEF8; Trauma Center: 0x1DC518
// Offset 0x30
Unknowns.ReadInt32s(reader, 1); // Entry points? The Dark Spire: 0x152200; Trauma Center: 0x1E0600
loader.Expect(0x2380000);
loader.Expect(0x2380000);
Unknowns.ReadInt16s(reader, 1); // The Dark Spire: 0x6F28; Trauma Center: 0x6F24
loader.Expect((short)0x2);
// Offset 0x40
int fileNameTableOffset = reader.ReadInt32();
int fileNameTableSize = reader.ReadInt32();
int fileSizeTableOffset = reader.ReadInt32();
int fileSizeTableSize = reader.ReadInt32();
// Offset 0x50
Unknowns.ReadInt32s(reader, 2, "Offset and size"); // Used in The Dark Spire, zeroes in Trauma Center.
loader.ExpectZeroes(4, 2);
// Offset 0x60
Unknowns.ReadInt32s(reader, 2);
int iconAndTitleOffset = reader.ReadInt32();
Unknowns.ReadInt32s(reader, 1);
// Offset 0x70
Unknowns.ReadInt32s(reader, 2);
loader.ExpectZeroes(4, 2);
// Offset 0x80
DataLength = reader.ReadInt32();
loader.Expect(PageSize);
Unknowns.ReadInt32s(reader, 2); // The Dark Spire: 0x4B68; 0 in Trauma Center.
ReadIconAndTitle(iconAndTitleOffset);
if (fileNameTableOffset > 0) {
int folderNamesOffset = reader.ReadInt32At(fileNameTableOffset);
reader.BaseStream.Position = fileNameTableOffset;
int folderCount = folderNamesOffset / 8;
for (int index = 0; index < folderCount; index++)
folders.Add(new RomFolder(this, index, reader));
byte[] folderNames = reader.ReadBytes(fileNameTableSize - folderNamesOffset);
reader.BaseStream.Position = fileSizeTableOffset;
int fileCount = fileSizeTableSize / 8;
for (int index = 0; index < fileCount; index++)
files.Add(new RomFile(this, index, reader));
folders[0].Sort(this, "Root", folderNamesOffset, folderNames);
FolderAsset orphanedFolders = null, orphanedFiles = null;
foreach (RomFolder folder in folders) {
if (folder.Used)
continue;
if (orphanedFolders == null)
orphanedFolders = new FolderAsset(this, "Orphaned folder[s]");
folder.Sort(this, folder.Name, folderNamesOffset, folderNames);
}
foreach (RomFile file in files) {
if (file.Used)
continue;
if (orphanedFiles == null)
orphanedFiles = new FolderAsset(this, "Orphaned file[s]");
file.Sort(orphanedFiles, file.Name);
}
}
}
internal Locals(Script script, ScriptBlock block, AssetLoader loader)
: base(script, block)
{
Codex<ushort> values = new Codex<ushort>(block.ContentSize / 2);
Values = values;
for (int index = 0; index < block.ContentSize / 2; index++)
values.Add(loader.Reader.ReadUInt16());
}
internal Object(Script script, ScriptBlock block, AssetLoader loader)
: base(script, block)
{
var reader = loader.Reader;
loader.Expect((ushort)0x1234);
LocalVariableOffset = reader.ReadUInt16();
int functionSelectorListOffset = reader.ReadUInt16();
int variableSelectorCount = reader.ReadUInt16();
Codex<VariableSelector> variableSelectors = new Codex<VariableSelector>(variableSelectorCount);
Variables = variableSelectors;
for (int index = 0; index < variableSelectorCount; index++)
variableSelectors.Add(new VariableSelector(this, loader));
int functionSelectorCount = reader.ReadUInt16();
Codex<FunctionSelector> functionSelectors = new Codex<FunctionSelector>(functionSelectorCount);
Functions = functionSelectors;
for (int index = 0; index < functionSelectorCount; index++)
functionSelectors.Add(new FunctionSelector(this, loader));
loader.Expect((ushort)0);
for (int index = 0; index < functionSelectorCount; index++)
functionSelectors[index].ReadCodeOffset(loader);
loader.ExpectPosition(block.EndOffset);
}
internal Strings(Script script, ScriptBlock block, AssetLoader loader)
: base(script, block)
{
Codex<string> list = new Codex<string>();
Values = list;
while (loader.Position < block.EndOffset)
list.Add(loader.Reader.ReadStringz(Encoding.ASCII));
}
internal Unknown(Script script, ScriptBlock block, AssetLoader loader)
: base(script, block)
{
Content = new Codex<byte>(loader.Reader.ReadBytes(block.ContentSize));
}
/// <summary>Initialise the <see cref="Asset"/> loader.</summary>
/// <param name="assetManager"></param>
/// <param name="reader"></param>
/// <param name="name"></param>
/// <param name="fileManager">The <see cref="FileManager"/> to use to load any attached files. If this is <c>null</c> (the default), then the system file manager (<see cref="Glare.Assets.FileManager.System"/>) is used.</param>
/// <param name="contextResource"></param>
/// <param name="length"></param>
public AssetLoader(AssetManager assetManager, BinaryReader reader, string name, FileManager fileManager, Asset contextResource = null, long? length = null) {
if (assetManager == null)
throw new ArgumentNullException("assetManager");
if (reader == null)
throw new ArgumentNullException("reader");
AssetManager = assetManager;
Start = reader.BaseStream.Position;
Reader = reader;
Name = name;
FileManager = fileManager ?? FileManager.System;
Context = contextResource;
Length = length.HasValue ? length.Value : reader.BaseStream.Length;
Errors = new Codex<AssetLoadError>();
}
internal Package(AssetLoader loader)
: base(loader)
{
loader.MakeBigEndian();
BinaryReader reader = Reader = loader.Reader;
ushort versionMajor = reader.ReadUInt16();
ushort versionMinor = reader.ReadUInt16();
reader.RequireZeroes(4);
int stringCount = reader.ReadInt32();
Codex<PackageString> strings = new Codex<PackageString>(stringCount);
for (int index = 0; index < stringCount; index++)
strings.Add(new PackageString(this, index, reader));
Strings = strings;
int fileCount = reader.ReadInt32();
for (int index = 0; index < fileCount; index++)
new PackageFile(this, index, loader);
}
internal void ReadDetailLevels(AssetLoader loader, int dataOffset, ArrayBackedList<byte> bufferData)
{
var detailLevels = new Codex<ModelDetailLevel>();
DetailLevels = detailLevels;
for (int index = 0; index < PartCount; index++)
detailLevels.Add(new ModelDetailLevel(this, index, loader, dataOffset, bufferData));
}
internal Palette(AssetLoader loader)
: base(loader)
{
BinaryReader reader = loader.Reader;
Unknowns.ReadBytes(reader, 25); // Offset 0-24
int firstIndex = reader.ReadByte(); // Offset 25-25
Unknowns.ReadBytes(reader, 3); // Offset 26-28
int count = reader.ReadUInt16(); // Offset 29-30
Unknowns.ReadBytes(reader, 1); // Offset 31-31
byte format = reader.ReadByte(); // Offset 32-32
Unknowns.ReadBytes(reader, 4); // Offset 33-36
// Offset 37
PaletteColor[] colors = new PaletteColor[count];
Colors = new ReadOnlyCollection<PaletteColor>(colors);
FlatColors = new Codex<Color>(256);
for (int index = 0; index < firstIndex; index++)
FlatColors.Add(Color.Purple);
for (int index = 0; index < count; index++) {
PaletteColor color;
switch (format) {
case 0: // Variable (byte used, byte red, byte green, byte blue)
color = new PaletteColor(reader.ReadByte() != 0, reader.ReadByte(), reader.ReadByte(), reader.ReadByte());
break;
case 1: // Constant (byte red, byte green, byte blue)
color = new PaletteColor(reader.ReadByte(), reader.ReadByte(), reader.ReadByte());
break;
default:
throw new NotImplementedException();
}
colors[index] = color;
FlatColors.Add(color);
}
PaletteAsset = new PaletteAsset(Manager, Name ?? "Palette", FlatColors);
}
internal ModelVertexDeclaration(FolderAsset folder, int index, AssetLoader loader)
: base(folder, index, loader)
{
var reader = loader.Reader;
int count = reader.ReadInt32();
reader.RequireZeroes(4 * 2);
int offset = reader.ReadInt32();
long reset = reader.BaseStream.Position;
reader.BaseStream.Position = offset;
var blocks = new Codex<ModelVertexAttribute>();
Attributes = blocks;
for (int blockIndex = 0; blockIndex < count; blockIndex++)
blocks.Add(new ModelVertexAttribute(this, loader, blockIndex));
reader.BaseStream.Position = reset;
}
/// <summary>Initialise the results.</summary>
/// <param name="result"></param>
/// <param name="problems"></param>
public SaveCheckResult(bool result, params string[] problems)
{
Result = result;
Problems = new Codex<string>(problems);
}
