private string GetText(int offset, int length)
{
byte *start = Pointers.Add(_blockStart, offset);
byte *end = Pointers.Add(_blockStart, offset + length);
return(Conversion.UTF8ToString(start, end));
}
public SignSpawner(int offset)
{
ObjectDP = new DeepPointer(PtrDB.DP_SignSpawner).ModifyOffset(4, offset);
Pointers.Add("Speed", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x248), IntPtr.Zero));
Pointers.Add("SpawnDelay", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x24C), IntPtr.Zero));
Pointers.Add("DelayOnStart", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x250), IntPtr.Zero));
}
private byte[] ReadData(IntPtr pHCIPacket, Structs.HCI_Packet hciPacket, int len)
{
byte[] data = GetBufferOfAtLeast(len);
var pData = Pointers.Add(pHCIPacket, OffsetOfData);
Marshal.Copy(pData, data, 0, len);
return(data);
}
public JumpPad(int offset)
{
ObjectDP = new DeepPointer(PtrDB.DP_JumpPad).ModifyOffset(2, offset);
// Pointers
Pointers.Add("Speed", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x248), IntPtr.Zero));
Pointers.Add("Rotation", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x230, 0x1C0), IntPtr.Zero));
}
public TomLaser(int offset)
{
ObjectDP = new DeepPointer(PtrDB.DP_Tom_Laser).ModifyOffset(5, offset);
// pointers
Pointers.Add("Pos", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x11C), IntPtr.Zero));
Pointers.Add("VerticalAngle", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x128), IntPtr.Zero));
Pointers.Add("Rotation", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x1A0), IntPtr.Zero));
}
public UplinkSlowmo(int firstOffset, int secondOffset, int thirdOffet)
{
ObjectDP = new DeepPointer(PtrDB.DP_UplinkSlowmo).ModifyOffset(1, firstOffset).ModifyOffset(4, secondOffset).ModifyOffset(6, thirdOffet);
// add pointers
Pointers.Add("TimeMultiplier", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x8), IntPtr.Zero));
Pointers.Add("MidCurveTime", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x20), IntPtr.Zero));
Pointers.Add("TotalTime", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x3C), IntPtr.Zero));
}
//base + 98 + <firstOffset> + 128 + A8 + <secondOffset> + XXX
public ToggleableFan(int firstOffset, int secondOffset)
{
ObjectDP = new DeepPointer(PtrDB.DP_ToggleableFan).ModifyOffset(1, firstOffset).ModifyOffset(4, secondOffset);
// Add pointers
Pointers.Add("FanSpeed", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2E0), IntPtr.Zero));
Pointers.Add("HackedFanSpeed", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2E8), IntPtr.Zero));
Pointers.Add("HackedDuration", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2EC), IntPtr.Zero));
}
//0x045A3C20, 0x98, <firstOffset>, 0x128, 0xA8, <secondOffset>
public UplinkJump(int firstOffset, int secondOffset)
{
ObjectDP = new DeepPointer(PtrDB.DP_UplinkJump).ModifyOffset(1, firstOffset).ModifyOffset(4, secondOffset);
// add pointers
Pointers.Add("TimeToActivate", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x234), IntPtr.Zero));
Pointers.Add("JumpMultiplier", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x280), IntPtr.Zero));
Pointers.Add("JumpForwardMultiplier", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x284), IntPtr.Zero));
Pointers.Add("JumpGravity", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x288), IntPtr.Zero)); // 6 by default, 2x from basic value ingame
}
// base, 0x98, firstOffset, 0x128, 0xA8, secondOffset
public Billboard(int firstOffset, int secondOffset)
{
ObjectDP = new DeepPointer(PtrDB.DP_Billboard).ModifyOffset(1, firstOffset).ModifyOffset(4, secondOffset);
// Pointers
Pointers.Add("Time1", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2C8), IntPtr.Zero));
Pointers.Add("Angle1", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2CC), IntPtr.Zero));
Pointers.Add("Time2", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2C0), IntPtr.Zero));
Pointers.Add("Angle2", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2D4), IntPtr.Zero));
}
public void AddPointer()
{
WorldPointer p = new WorldPointer()
{
X = 8,
Y = 0x16,
LevelGuid = Guid.Empty
};
Pointers.Add(p);
}
public void AddPointer()
{
LevelPointer p = new LevelPointer()
{
ExitType = 0,
XExit = 0,
XEnter = 0,
YExit = 0,
YEnter = 0,
LevelGuid = Guid.Empty
};
Pointers.Add(p);
}
private string GetText(int offset, int length)
{
byte *start = Pointers.Add(_blockStart, offset * _characterSize);
byte *end = Pointers.Add(_blockStart, (offset + length) * _characterSize);
if (_characterSize == 1)
{
return(Conversion.Utf8ToString(start, end));
}
else
{
return(Conversion.Utf16ToString(start, end));
}
}
private void SetForKey(string key, string id)
{
switch (key)
{
case Constants.PointersNames.ACCOUNT_PUBKEY:
if (!id.StartsWith(Constants.ApiIdentifiers.ACCOUNT_PUBKEY))
{
throw new ArgumentException("Invalid Account Public Key");
}
break;
case Constants.PointersNames.CONTRACT_PUBKEY:
if (!id.StartsWith(Constants.ApiIdentifiers.CONTRACT_PUBKEY))
{
throw new ArgumentException("Invalid Contract Public Key");
}
break;
case Constants.PointersNames.ORACLE_PUBKEY:
if (!id.StartsWith(Constants.ApiIdentifiers.ORACLE_PUBKEY))
{
throw new ArgumentException("Invalid Oracle Public Key");
}
break;
case Constants.PointersNames.CHANNEL:
if (!id.StartsWith(Constants.ApiIdentifiers.ORACLE_PUBKEY))
{
throw new ArgumentException("Invalid Channel");
}
break;
default:
throw new ArgumentException("Invalid Id");
}
NamePointer p = PointerForKey(key);
if (p == null)
{
p = new NamePointer {
Key = key
};
Pointers.Add(p);
}
if (p.Id != id)
{
p.Id = id;
}
}
/// <summary>
/// Adds a pointer from the given source offset to the given destination offset.
/// </summary>
/// <param name="src">The pointer source offset.</param>
/// <param name="dst">The pointer destination offset.</param>
/// <param name="isVlt">Whether the pointer is a VLT pointer.</param>
/// <exception cref="Exception">if a duplicate pointer is added</exception>
public void AddPointer(long src, long dst, bool isVlt)
{
Debug.Assert(src != 0);
var pointer = new VltPointer
{
Type = isVlt ? VltPointerType.Vlt : VltPointerType.Bin,
FixUpOffset = (uint)src,
Destination = (uint)dst
};
if (!Pointers.Add(pointer))
{
throw new Exception("Duplicate pointer added?");
}
}
internal ServiceRecord BuildRecord(Structs.SDP_Service_Attribute_Response_Data attrRsp) //ORIG
{
int sizeofAttrData = Marshal.SizeOf(typeof(Structs.SDP_Service_Attribute_Value_Data));
var attrList = new List <ServiceAttribute>();
IntPtr pCur = attrRsp.pSDP_Service_Attribute_Value_Data;
for (int curAttr = 0; curAttr < attrRsp.Number_Attribute_Values; ++curAttr)
{
var attr = BuildAttribute(pCur);
attrList.Add(attr);
// Next
pCur = Pointers.Add(pCur, sizeofAttrData);
}//for
var r = new ServiceRecord(attrList);
return(r);
}
public void AddPointer(long address)
{
Pointer pointer = null;
foreach (Pointer p in Pointers)
{
if (p.AddressLong == address)
{
pointer = p;
break;
}
}
if (pointer == null)
{
Pointers.Add(new Pointer(address));
}
}
//////////////////////////////
/////////CONSTRUCTORS/////////
//////////////////////////////
//public SoftwareComponent(string name, List<AssemblyPointer> assemblies)
//{
// if (assemblies == null || string.IsNullOrEmpty(name))
// throw new ArgumentNullException();
// else if (assemblies.Count == 0)
// throw new ArgumentException();
// Name = name;
// Color = Color.Black;
// foreach (AssemblyPointer pointer in assemblies)
// {
// Pointers.Add(pointer);
// }
//}
public SoftwareComponent(string name, IEnumerable <AssemblyPointer> assemblies, Color color)
{
if (assemblies == null || string.IsNullOrEmpty(name))
{
throw new ArgumentNullException();
}
else if (assemblies.Count() == 0)
{
throw new ArgumentException();
}
Name = name;
Color = color;
foreach (AssemblyPointer pointer in assemblies)
{
Pointers.Add(pointer);
}
}
/// <summary>
/// Update the gauge range.
/// </summary>
private void UpdateGauge()
{
Pointers.Clear();
var ranges = new ObservableCollection <Pointer>();
double rangeStart = 0;
// var items = selectedCalorieItems;
var proteinRange = new RangePointer();
for (int i = 0; i < SelectedCalorieItems.Count; i++)
{
RangePointer range = new RangePointer()
{
RangeStart = rangeStart,
Value = rangeStart + SelectedCalorieItems[i].Quantity,
Offset = 0.9,
Thickness = 12,
EnableAnimation = false,
Color = Color.FromHex(SelectedCalorieItems[i].Indicator)
};
if (SelectedCalorieItems[i].Nutrient == "Protein")
{
range.Offset = 0.93;
range.Thickness = 18;
range.RangeStart -= 3;
range.Value += 3;
range.RangeCap = RangeCap.Both;
proteinRange = range;
}
else
{
ranges.Add(range);
}
rangeStart += SelectedCalorieItems[i].Quantity;
}
ScaleEndValue = rangeStart;
Pointers = ranges;
Pointers.Add(proteinRange);
}
internal List <ServiceRecord> BuildRecordList(IntPtr pSSSARD)
{
var sizeofSSARD = Marshal.SizeOf(typeof(Structs.SDP_Service_Attribute_Response_Data));
var rList = new List <ServiceRecord>();
var svcSrchAttrRsp = (Structs.SDP_Response_Data__SDP_Service_Search_Attribute_Response_Data)
Marshal.PtrToStructure(pSSSARD, typeof(Structs.SDP_Response_Data__SDP_Service_Search_Attribute_Response_Data));
IntPtr pCur = svcSrchAttrRsp.pSDP_Service_Attribute_Response_Data;
Debug.WriteLine(string.Format(CultureInfo.InvariantCulture,
"BuildRecordList Number_Service_Records: {0}",
svcSrchAttrRsp.Number_Service_Records));
for (int i = 0; i < svcSrchAttrRsp.Number_Service_Records; ++i)
{
var curSR = BuildRecord(pCur);
rList.Add(curSR);
//next SR
pCur = Pointers.Add(pCur, sizeofSSARD);
}//for
return(rList);
}
private static IntPtr CopyArrayToHGlobal <T>(T[] arr, List <IntPtr> toFree)
where T : struct
{
// NETCF P/Invoke doesn't support marshalling an array of structs
// so we have to marshal it ourselves.
var so = Marshal.SizeOf(typeof(T));
var p = Marshal.AllocHGlobal(so * arr.Length);
toFree.Add(p);
var pCur = p;
for (int i = 0; i < arr.Length; ++i)
{
Marshal.StructureToPtr(arr[i], pCur, false);
pCur = Pointers.Add(pCur, so);
}
#if DEBUG
var pEnd = Pointers.Add(p, (so * arr.Length));
Debug.Assert(pCur == pEnd);
#endif
return(p);
}
//public SoftwareComponent(string name, List<AssemblyPointer> assemblies, List<SoftwareComponent> subcomponents)
//{
// if (assemblies == null || string.IsNullOrEmpty(name) || subcomponents == null)
// throw new ArgumentNullException();
// else if (assemblies.Count == 0 && subcomponents.Count == 0)
// throw new ArgumentException();
// Name = name;
// Color = Color.Black;
// foreach (AssemblyPointer pointer in assemblies)
// {
// Pointers.Add(pointer);
// }
// foreach (SoftwareComponent subcomponent in subcomponents)
// {
// AddSubcomponent(subcomponent);
// }
//}
public SoftwareComponent(string name, List <AssemblyPointer> assemblies, Color color, List <SoftwareComponent> subcomponents)
{
if (assemblies == null || string.IsNullOrEmpty(name) || subcomponents == null)
{
throw new ArgumentNullException();
}
else if (assemblies.Count == 0 && subcomponents.Count == 0)
{
throw new ArgumentException();
}
Name = name;
Color = color;
foreach (AssemblyPointer pointer in assemblies)
{
Pointers.Add(pointer);
}
foreach (SoftwareComponent subcomponent in subcomponents)
{
AddSubcomponent(subcomponent);
}
}
//TODO: Find out why objects are being added twice
public void Add(long id)
{
Pointers.Add(id);
BuildCollection();
}
public bool Load(string filename)
{
XDocument xDoc;
string[] levelData = null;
string[] compressData = null;
SpriteData.Clear();
Pointers.Clear();
try
{
xDoc = XDocument.Load(filename);
}
catch
{
return(false);
}
XElement level = xDoc.Element("level");
foreach (var a in level.Attributes())
{
switch (a.Name.LocalName)
{
case "layout":
LevelLayout = (LevelLayout)Enum.Parse(typeof(LevelLayout), a.Value, true);
break;
case "guid":
Guid = a.Value.ToGuid();
break;
case "type":
Type = a.Value.ToInt();
break;
case "clearvalue":
ClearValue = a.Value.ToInt();
break;
case "graphicsbank":
GraphicsBank = a.Value.ToInt();
break;
case "music":
Music = a.Value.ToInt();
break;
case "length":
Length = a.Value.ToInt();
break;
case "time":
Time = a.Value.ToInt();
break;
case "xstart":
XStart = a.Value.ToInt();
break;
case "ystart":
YStart = a.Value.ToInt();
break;
case "invincibleenemies":
InvincibleEnemies = a.Value.ToBoolean();
break;
case "vineblocked":
VineBlocked = a.Value.ToBoolean();
break;
case "paletteeffect":
PaletteEffect = a.Value.ToInt();
break;
case "palette":
Palette = a.Value.ToInt();
break;
case "scrolltype":
ScrollType = a.Value.ToInt();
break;
case "animationtype":
AnimationType = a.Value.ToInt();
break;
case "startaction":
StartAction = a.Value.ToInt();
break;
case "leveldata":
levelData = a.Value.Split(',');
break;
case "compresseddata":
compressData = a.Value.Split(',');
break;
case "challengeleveltype":
ChallengeType = a.Value.ToInt();
break;
case "specialleveltype":
SpecialLevelType = a.Value.ToInt();
break;
case "misc1":
MiscByte1 = a.Value.ToInt();
break;
case "misc2":
MiscByte2 = a.Value.ToInt();
break;
case "misc3":
MiscByte3 = a.Value.ToInt();
break;
case "tempprojeffects":
ProjectileBlocksTemporary = a.Value.ToBoolean();
break;
case "rhythm":
RhythmPlatforms = a.Value.ToBoolean();
break;
case "dpadtiles":
DpadTiles = a.Value.ToBoolean();
break;
}
}
int xPointer = 0, yPointer = 0;
int[] tileCount = new int[256];
foreach (var c in levelData)
{
LevelData[xPointer, yPointer] = (byte)c.ToInt();
tileCount[c.ToInt()]++;
xPointer++;
if (xPointer >= Width)
{
xPointer = 0;
yPointer++;
if (yPointer > Height)
{
break;
}
}
}
int highestTileCount = -1;
for (int i = 0; i < 256; i++)
{
if (tileCount[i] > highestTileCount)
{
highestTileCount = MostCommonTile = i;
}
}
foreach (var x in level.Elements())
{
switch (x.Name.LocalName)
{
case "spritedata":
foreach (var spr in x.Elements("sprite"))
{
Sprite s = new Sprite();
s.LoadFromElement(spr);
SpriteData.Add(s);
}
break;
case "pointers":
foreach (var ptr in x.Elements("pointer"))
{
LevelPointer p = new LevelPointer();
p.LoadFromElement(ptr);
Pointers.Add(p);
}
break;
case "settings":
Settings.LoadFromElement(x);
break;
}
}
return(true);
}
/// <summary>
/// Create a stream over the underlying memory content.
/// </summary>
public unsafe Stream CreateSteam()
{
return(new UnmanagedMemoryStream(
Pointers.Add(_block.DangerousGetHandle(), _contentsOffset),
_contentsLength));
}
private ServiceElement BuildElement(IntPtr pElemData)
{
var elemData = (Structs.SDP_Data_Element)Marshal.PtrToStructure(
pElemData, typeof(Structs.SDP_Data_Element));
var sizeofElemData = Marshal.SizeOf(typeof(Structs.SDP_Data_Element));
//
ElementTypeDescriptor etd; SizeIndex sizeIndex;
Map(elemData.SDP_Data_Element_Type, out etd, out sizeIndex);
//
const int OffsetOf_FakeAtUnionPosition = 8;
#if !NETCF
var dbgOffset = Marshal.OffsetOf(typeof(Structs.SDP_Data_Element), "FakeAtUnionPosition");
Debug.Assert(new IntPtr(OffsetOf_FakeAtUnionPosition) == dbgOffset,
"OffsetOf_FakeAtUnionPosition but: " + dbgOffset);
#endif
IntPtr pDataInStruct = Pointers.Add(pElemData, OffsetOf_FakeAtUnionPosition);
IntPtr pArrElements = Marshal.ReadIntPtr(pDataInStruct);
if (etd == ElementTypeDescriptor.ElementSequence ||
etd == ElementTypeDescriptor.ElementAlternative)
{
var list = new List <ServiceElement>();
var pCur = pArrElements;
for (int i = 0; i < elemData.SDP_Data_Element_Length; ++i)
{
var e = BuildElement(pCur);
list.Add(e);
// Next
pCur = Pointers.Add(pCur, sizeofElemData);
}//for
#if DEBUG
ElementTypeDescriptor cover;
if (etd == ElementTypeDescriptor.ElementAlternative)
{
cover = etd; //COVERAGE
}
else
{
cover = etd; //COVERAGE
}
#endif
return(new ServiceElement(
etd == ElementTypeDescriptor.ElementSequence
? ElementType.ElementSequence
: ElementType.ElementAlternative,
list));
}
else
{
byte[] buf = new byte[elemData.SDP_Data_Element_Length];
IntPtr pData;
if (etd == ElementTypeDescriptor.TextString ||
etd == ElementTypeDescriptor.Url)
{
pData = pArrElements;
}
else
{
pData = pDataInStruct;
}
Marshal.Copy(pData, buf, 0, buf.Length);
int readLen = buf.Length;
var elem = _parser.ParseContent(false, true,
buf, 0, buf.Length, ref readLen,
etd, sizeIndex, buf.Length, 0);
return(elem);
}
}
public bool Load(string filename)
{
string[] compressData = null;
string[] levelData = null;
XDocument xDoc;
try
{
xDoc = XDocument.Load(filename);
}
catch
{
return(false);
}
XElement world = xDoc.Element("world");
foreach (var a in world.Attributes())
{
switch (a.Name.LocalName)
{
case "guid":
Guid = a.Value.ToGuid();
break;
case "graphicsbank":
GraphicsBank = a.Value.ToInt();
break;
case "music":
Music = a.Value.ToInt();
break;
case "length":
Length = a.Value.ToInt();
break;
case "palette":
Palette = a.Value.ToInt();
break;
case "compresseddata":
compressData = a.Value.Split(',');
break;
case "worlddata":
levelData = a.Value.Split(',');
break;
}
}
int xPointer = 0, yPointer = 0;
foreach (var c in levelData)
{
LevelData[xPointer, yPointer] = (byte)c.ToInt();
xPointer++;
if (xPointer >= Width)
{
xPointer = 0;
yPointer++;
if (yPointer > Height)
{
break;
}
}
}
SpriteData.Clear();
Pointers.Clear();
foreach (var x in world.Elements())
{
switch (x.Name.LocalName)
{
case "spritedata":
foreach (var spr in x.Elements("sprite"))
{
Sprite s = new Sprite();
s.LoadFromElement(spr);
SpriteData.Add(s);
}
break;
case "pointers":
foreach (var ptr in x.Elements("pointer"))
{
WorldPointer p = new WorldPointer();
p.LoadFromElement(ptr);
Pointers.Add(p);
}
break;
case "settings":
Settings.LoadFromElement(x);
break;
}
}
return(true);
}
private void AddPointers()
{
// Add points
Pointers.Add("Duration", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x238), IntPtr.Zero));
Pointers.Add("MaxAttacks", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x270), IntPtr.Zero));
}
//base, 0x98, firstOffset, 0x128, 0xA8, secondOffset,
public ShurikenTarget(int firstOffset, int secondOffset)
{
ObjectDP = new DeepPointer(PtrDB.DP_ShurikenTarget).ModifyOffset(1, firstOffset).ModifyOffset(4, secondOffset);
// Add pointers
Pointers.Add("HitsNeeded", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x224), IntPtr.Zero));
}