| public static ToInt32 ( byte value, int startIndex ) : int | ||
| value | byte | |
| startIndex | int | |
| return | int | |
public static MidiData parse(FileStream input_file_stream)
{
var input_binary_reader = new BinaryReader(input_file_stream);
HeaderChunk header_chunk;
ushort number_of_tracks;
{
var header_chunk_ID = stringEncoder.GetString(input_binary_reader.ReadBytes(4));
var header_chunk_size = BitConverter.ToInt32(input_binary_reader.ReadBytes(4).Reverse().ToArray <byte>(), 0);
var header_chunk_data = input_binary_reader.ReadBytes(header_chunk_size);
var format_type = BitConverter.ToUInt16(header_chunk_data.Take(2).Reverse().ToArray <byte>(), 0);
number_of_tracks = BitConverter.ToUInt16(header_chunk_data.Skip(2).Take(2).Reverse().ToArray <byte>(), 0);
var time_division = BitConverter.ToUInt16(header_chunk_data.Skip(4).Take(2).Reverse().ToArray <byte>(), 0);
header_chunk = new HeaderChunk(format_type, time_division);
}
var tracks =
Enumerable.Range(0, number_of_tracks)
.Select(track_number =>
{
var track_chunk_ID = stringEncoder.GetString(input_binary_reader.ReadBytes(4));
var track_chunk_size = BitConverter.ToInt32(input_binary_reader.ReadBytes(4).Reverse().ToArray <byte>(), 0);
var track_chunk_data = input_binary_reader.ReadBytes(track_chunk_size);
return(Tuple.Create(track_chunk_size, track_chunk_data));
}).ToList()
.Select(raw_track => new TrackChunk(parse_events(raw_track.Item2, raw_track.Item1)));
return(new MidiData(header_chunk, tracks));
}
public void Randomize(double num)
{
int num1 = _seed;
int num2 = !BitConverter.IsLittleEndian ? BitConverter.ToInt32(BitConverter.GetBytes(num), 0) : BitConverter.ToInt32(BitConverter.GetBytes(num), 4);
int num3 = (num2 & (int)ushort.MaxValue ^ num2 >> 16) << 8;
int num4 = num1 & -16776961 | num3;
_seed = num4;
}
public void Randomize()
{
System.DateTime now = System.DateTime.Now;
float timer = (float)checked ((60 * now.Hour + now.Minute) * 60 + now.Second) + (float)now.Millisecond / 1000f;
int num1 = _seed;
int num2 = BitConverter.ToInt32(BitConverter.GetBytes(timer), 0);
int num3 = (num2 & (int)ushort.MaxValue ^ num2 >> 16) << 8;
int num4 = num1 & -16776961 | num3;
_seed = num4;
}
private static void TransferHeaders(Socket socket, int txDataLen, out int rxDataLen)
{
socket.Blocking = true;
socket.Send(BitConverter.GetBytes(txDataLen));
byte[] buf4 = new byte[4];
int len = socket.Receive(buf4);
if (len != 4)
{
throw new ApplicationException("Incomplete header received, len=" + len);
}
rxDataLen = BitConverter.ToInt32(buf4, 0);
}
public static RpcLog Deserialize(SelfDecoder.BinaryLog source)
{
var log = new RpcLog();
log.Type = (Shared.RpcCalls)source.LogData[0];
var buffer = new byte[4];
Buffer.BlockCopy(source.LogData, 1, buffer, 0, 4);
log.GameCode = BitConverter.ToInt32(buffer, 0);
Buffer.BlockCopy(source.LogData, 5, buffer, 0, 4);
log.IpAddress = new IPAddress(buffer).ToString();
buffer = new byte[source.LogData.Length - 9];
Buffer.BlockCopy(source.LogData, 9, buffer, 0, buffer.Length);
log.RpcData = buffer;
return(log);
}
public float VBNext(float num)
{
int num1 = _seed;
if ((double)num != 0.0)
{
if ((double)num < 0.0)
{
long num2 = (long)BitConverter.ToInt32(BitConverter.GetBytes(num), 0) & (long)uint.MaxValue;
num1 = checked ((int)(num2 + (num2 >> 24) & 16777215L));
}
num1 = checked ((int)((long)num1 * 1140671485L + 12820163L & 16777215L));
}
_seed = num1;
return((float)num1 / 1.677722E+07f);
}
public DataPage(byte[] page)
{
_byteIterator = 0;
Records = new List <Record> {
Capacity = Static.GetRecordsPerPage()
};
UsedSpace = BC.ToInt32(page, _byteIterator);
_byteIterator += sizeof(int);
for (var i = 0; i < UsedSpace; i++)
{
var key = BC.ToUInt32(page, _byteIterator);
_byteIterator += sizeof(uint);
var radius = BC.ToDouble(page, _byteIterator);
_byteIterator += sizeof(double);
var angle = BC.ToInt16(page, _byteIterator);
_byteIterator += sizeof(short);
Records.Add(new Record(key, radius, angle));
}
}
private void _ReadEmblemFullInfo()
{
//loop here in case it runs this too early and reads 0 max emblems because it's not initialized in the game yet
int tries = 0, maxEmblems = 0, maxExtra = 0;
do
{
//read the number of emblems loaded into the game
byte[] maxEmblemsBuffer = new byte[4];
byte[] maxExtraBuffer = new byte[4];
ReadProcessMemory(gameProc.Handle, MAX_EMBLEMS_ADDRESS, maxEmblemsBuffer, 4, IntPtr.Zero);
ReadProcessMemory(gameProc.Handle, MAX_EXTRA_EMBLEMS_ADDRESS, maxExtraBuffer, 4, IntPtr.Zero);
maxEmblems = BC.ToInt32(maxEmblemsBuffer, 0);
maxExtra = BC.ToInt32(maxExtraBuffer, 0);
if (maxEmblems + maxExtra != 0)
{
break;
}
Thread.Sleep(2000);
tries++;
}while (tries < 5);
Emblems = new Emblem[maxEmblems];
ExtraEmblems = new ExtraEmblem[maxExtra];
byte[] currentEmblem = new byte[128]; //size of 1 emblem object in memory
int address = EMBLEMS_ADDRESS;
for (int i = 0; i < Emblems.Length; i++)
{
ReadProcessMemory(gameProc.Handle, address, currentEmblem, currentEmblem.Length, IntPtr.Zero);
//WriteProcessMemory(gameProc.Handle, address + 4, new byte[1] { 1 }, 1, IntPtr.Zero); //for the fun stuff
Emblems[i] = new Emblem()
{
type = currentEmblem[0],
tag = BC.ToInt16(currentEmblem, 2),
level = BC.ToInt16(currentEmblem, 4),
sprite = Convert.ToChar(currentEmblem[6]),
color = BC.ToUInt16(currentEmblem, 8),
var = BC.ToInt32(currentEmblem, 12),
hint = Encoding.ASCII.GetString(currentEmblem, 16, 110),
collected = currentEmblem[126]
};
address += 128;
}
currentEmblem = new byte[68]; //size of 1 extra emblem object in memory
address = EXTRA_EMBLEMS_ADDRESS;
for (int i = 0; i < ExtraEmblems.Length; i++)
{
ReadProcessMemory(gameProc.Handle, address, currentEmblem, currentEmblem.Length, IntPtr.Zero);
ExtraEmblems[i] = new ExtraEmblem()
{
name = Encoding.ASCII.GetString(currentEmblem, 0, 20),
description = Encoding.ASCII.GetString(currentEmblem, 20, 40),
conditionset = currentEmblem[60],
showconditionset = currentEmblem[61],
sprite = Convert.ToChar(currentEmblem[62]),
color = BC.ToUInt16(currentEmblem, 64),
collected = currentEmblem[66],
};
address += 68;
}
if (!(previousEmblems.SequenceEqual(Emblems) && previousExtraEmblems.SequenceEqual(ExtraEmblems)))
{
EmblemsChangedEvent(this, EmblemsChangedEventArgs.FullInfo);
}
previousEmblems = (Emblem[])Emblems.Clone();
previousExtraEmblems = (ExtraEmblem[])ExtraEmblems.Clone();
}
/// <summary>
/// Wrapper for <see cref="BitConverter.ToInt32">BitConverter.ToInt32</see>
/// To automatically check for system endianness.
/// </summary>
/// <param name="value"></param>
/// <param name="startIndex"></param>
/// <returns></returns>
public static int ToInt32(byte[] value, int startIndex = 0)
{
return(BitConverter.IsLittleEndian
? BitConverter.ToInt32(value.Reverse().ToArray(), 0)
: BitConverter.ToInt32(value, 0));
}
public static int ToInt32(ReadOnlySpan <byte> value) => Converter.ToInt32(value);
