public bool FindPatterns()
{
PatternFileOffsets.Clear();
int offset = 0;
while (PhxUtil.FindBytePattern(PatternFileOffsets, SourceExeBytes, ref offset, BytePattern))
{
}
return(PatternFileOffsets.Count == 1);
}
public uint GetSuperFastHashCode()
{
var hash = TypeDesc.GetSuperFastHashCode();
var buffer = PhxUtil.GetBufferForSuperFastHash(sizeof(uint));
Bitwise.ByteSwap.ReplaceBytes(buffer, 0, (uint)ArrayLength);
hash = PhxUtil.SuperFastHash(buffer, 0, sizeof(uint), hash);
// #TODO hash the value's bytes
return(hash);
}
public override object GetObject(int id)
{
if (id.IsNone())
{
return(null);
}
if (PhxUtil.IsUndefinedReferenceHandle(id))
{
return(Phoenix.TypeExtensionsPhx.GetUndefinedObject(mUndefinedInterface, id));
}
return(base.GetObject(id));
}
public bool StreamTactic <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s
, string xmlName
, ref int dbid
, IO.TagElementNodeType xmlSource = XmlUtil.kSourceElement)
where TDoc : class
where TCursor : class
{
const Phx.DatabaseObjectKind kDbKind = Phx.DatabaseObjectKind.Tactic;
Contract.Requires(xmlSource.RequiresName() == (xmlName != XML.XmlUtil.kNoXmlName));
string id_name = null;
bool was_streamed = true;
bool to_lower = false;
if (s.IsReading)
{
was_streamed = s.StreamStringOpt(xmlName, ref id_name, to_lower, xmlSource, intern: true);
if (was_streamed)
{
id_name = System.IO.Path.GetFileNameWithoutExtension(id_name);
dbid = Database.GetId(kDbKind, id_name);
Contract.Assert(dbid.IsNotNone(), id_name);
if (PhxUtil.IsUndefinedReferenceHandle(dbid))
{
TraceUndefinedHandle(s, id_name, xmlName, dbid, kDbKind.ToString());
}
}
}
else if (s.IsWriting)
{
if (dbid.IsNone())
{
was_streamed = false;
return(was_streamed);
}
id_name = Database.GetName(kDbKind, dbid);
Contract.Assert(!string.IsNullOrEmpty(id_name));
id_name += Phx.BTacticData.kFileExt;
s.StreamStringOpt(xmlName, ref id_name, to_lower, xmlSource, intern: true);
}
return(was_streamed);
}
public int GetMemberIdOrUndefined(string memberName)
{
int id = TryGetMemberIdOrUndefined(memberName);
if (id.IsNone())
{
InitializeUndefined();
id = mUndefined.Count;
mUndefined.Add(memberName);
id = PhxUtil.GetUndefinedReferenceHandle(id);
}
return(id);
}
public int TryGetMemberIdOrUndefined(string memberName)
{
int id = TryGetMemberId(memberName);
if (id.IsNone() && MemberUndefinedCount != 0)
{
id = mUndefined.FindIndex(str => PhxUtil.StrEqualsIgnoreCase(str, memberName));
if (id.IsNotNone())
{
id = PhxUtil.GetUndefinedReferenceHandle(id);
}
}
return(id);
}
public string GetMemberNameOrUndefined(int memberId)
{
string name;
if (PhxUtil.IsUndefinedReferenceHandle(memberId))
{
Contract.Assert(mUndefined != null);
name = mUndefined[PhxUtil.GetUndefinedReferenceDataIndex(memberId)];
}
else
{
name = GetMemberName(memberId);
}
return(name);
}
void StreamTacticsAsync(ref bool r, FA mode)
{
var tactics = Database.Tactics;
var tasks = new List <Task <bool> >(tactics.Count);
var task_exceptions = new List <Exception>(tactics.Count);
foreach (var tactic in tactics)
{
if (mode == FA.Read)
{
if (tactic.SourceXmlFile != null)
{
continue;
}
tactic.SourceXmlFile = Phx.BTacticData.CreateFileInfo(mode, tactic.Name);
}
else if (mode == FA.Write)
{
Contract.Assert(tactic.SourceXmlFile != null, tactic.Name);
}
var engine = this.GameEngine;
if (mode == FA.Read)
{
engine.UpdateFileLoadStatus(tactic.SourceXmlFile, Engine.XmlFileLoadState.Loading);
}
var arg = tactic;
var task = Task <bool> .Factory.StartNew((state) =>
{
var _tactic = state as Phx.BTacticData;
return(TryStreamData(_tactic.SourceXmlFile, mode, StreamTactic, _tactic, Phx.BTacticData.kFileExt));
}, arg);
tasks.Add(task);
}
PhxUtil.UpdateResultWithTaskResults(ref r, tasks, task_exceptions);
if (!r)
{
Debug.Trace.XML.TraceData(System.Diagnostics.TraceEventType.Error, TypeExtensions.kNone,
"Failed to " + mode + " tactics",
task_exceptions.ToAggregateExceptionOrNull().GetOnlyExceptionOrAllWhenAggregate());
}
}
public uint GetSuperFastHashCode()
{
var buffer = PhxUtil.GetBufferForSuperFastHash(sizeof(uint));
uint hash;
Bitwise.ByteSwap.ReplaceBytes(buffer, 0, (uint)Type);
hash = PhxUtil.SuperFastHash(buffer, 0, sizeof(uint));
Bitwise.ByteSwap.ReplaceBytes(buffer, 0, (ushort)Size);
hash = PhxUtil.SuperFastHash(buffer, 0, sizeof(ushort), hash);
Bitwise.ByteSwap.ReplaceBytes(buffer, 0, (ushort)Alignment);
hash = PhxUtil.SuperFastHash(buffer, 0, sizeof(ushort), hash);
buffer[0] = Flags;
hash = PhxUtil.SuperFastHash(buffer, 0, sizeof(byte), hash);
return hash;
}
public int CompareTo(BLeaderSupportPower other)
{
if (IconLocation != other.IconLocation)
{
IconLocation.CompareTo(other.IconLocation);
}
if (TechPrereqID != other.TechPrereqID)
{
TechPrereqID.CompareTo(other.TechPrereqID);
}
if (SupportPowerIDs.Count != other.SupportPowerIDs.Count)
{
SupportPowerIDs.Count.CompareTo(other.SupportPowerIDs.Count);
}
int a_hash = PhxUtil.CalculateHashCodeForDBIDs(SupportPowerIDs);
int b_hash = PhxUtil.CalculateHashCodeForDBIDs(other.SupportPowerIDs);
return(a_hash.CompareTo(b_hash));
}
protected static void TraceUndefinedHandle <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s, string name,
string xmlName,
int id, string kind)
where TDoc : class
where TCursor : class
{
Contract.Assert(s.IsReading);
var line_info = Text.TextLineInfo.Empty;
var cursor_name = "<unknown element>";
var text_stream = s as IO.TagElementTextStream <TDoc, TCursor>;
if (text_stream != null)
{
cursor_name = text_stream.CursorName;
line_info = text_stream.TryGetLastReadLineInfo();
}
Debug.Trace.XML.TraceEvent(System.Diagnostics.TraceEventType.Warning, TypeExtensions.kNone,
"{0} ({1}): Generated UndefinedHandle for '{2}.{3}' ({4}). {5}={6}",
s.StreamName, Text.TextLineInfo.ToString(line_info, verboseString: true),
cursor_name, xmlName ?? "InnerText",
kind, name, PhxUtil.GetUndefinedReferenceDataIndex(id).ToString());
}
public bool StreamDBID <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
string xmlName, ref int dbid,
Phx.DatabaseObjectKind kind,
bool isOptional = true, IO.TagElementNodeType xmlSource = XmlUtil.kSourceElement)
where TDoc : class
where TCursor : class
{
Contract.Requires(xmlSource.RequiresName() == (xmlName != XML.XmlUtil.kNoXmlName));
string id_name = null;
bool was_streamed = true;
bool to_lower = ToLowerName(kind);
if (s.IsReading)
{
if (isOptional)
{
was_streamed = s.StreamStringOpt(xmlName, ref id_name, to_lower, xmlSource, intern: true);
}
else
{
s.StreamString(xmlName, ref id_name, to_lower, xmlSource, intern: true);
}
if (was_streamed)
{
dbid = Database.GetId(kind, id_name);
Contract.Assert(dbid.IsNotNone());
if (PhxUtil.IsUndefinedReferenceHandle(dbid))
{
TraceUndefinedHandle(s, id_name, xmlName, dbid, kind.ToString());
}
}
else
{
dbid = TypeExtensions.kNone;
}
}
else if (s.IsWriting)
{
if (dbid.IsNone())
{
was_streamed = false;
return(was_streamed);
}
id_name = Database.GetName(kind, dbid);
Contract.Assert(!string.IsNullOrEmpty(id_name));
if (isOptional)
{
s.StreamStringOpt(xmlName, ref id_name, to_lower, xmlSource, intern: true);
}
else
{
s.StreamString(xmlName, ref id_name, to_lower, xmlSource, intern: true);
}
}
return(was_streamed);
}
public virtual int TryGetMemberId(string memberName)
{
return(mList.FindIndex(n => PhxUtil.StrEqualsIgnoreCase(n, memberName)));
}
public bool StreamCreatorToolCommandLine(IO.EndianStream s, ref string value)
{
return(PhxUtil.StreamPointerizedCString(s, ref CreatorToolCommandLine, ref value));
}
public bool StreamSourceFileNamee(IO.EndianStream s, ref string value)
{
return(PhxUtil.StreamPointerizedCString(s, ref SourceFileName, ref value));
}
public bool StreamTagUserName(IO.EndianStream s, ref string value)
{
return(PhxUtil.StreamPointerizedCString(s, ref TagUserNameOffset, ref value));
}
public int TryGetMemberId(string memberName)
{
return(Array.FindIndex(kNames, n => PhxUtil.StrEqualsIgnoreCase(n, memberName)));
}
public bool UpdateResultWithTaskResults(ref bool r)
{
PhxUtil.UpdateResultWithTaskResults(ref r, Tasks, TaskExceptions);
return(r);
}
