public byte[] GetBytes(MemoryRule rule)
{
var intPtr = new IntPtr(_baseMemoryOffset + rule.MemoryOffset64);
var bytes = _process.ReadArray <byte>(intPtr, rule.NumBytes);
return(bytes);
}
private RuleMemoryContainer buildRuleMemory(MemoryRule rule)
{
object data = "-";
var dataFromRule = _processManager.GetDataFromRule(rule);
return(new RuleMemoryContainer(rule, dataFromRule ?? data, _processManager.BaseMemoryOffset + rule.MemoryOffset64));
}
private void OnLog(MemoryRule rule, string user)
{
if (!rule.Log)
{
return;
}
var message = $"{user} changed '{rule.Description}'";
LogOutput?.Invoke(this, new LogMessageEventArgs(message));
}
public RuleMemoryContainer(MemoryRule rule, object data, long actualMemoryPos)
{
MemoryRule = rule;
Description = rule.Description;
MemoryOffset64 = rule.MemoryOffset64;
MemPos = actualMemoryPos.ToString("X");
NumBytes = rule.NumBytes;
DataType = rule.DataType;
Data = data;
}
private bool isBytesChangedAccordingToRule(byte[] bytes, MemoryRule rule, out IChangedDataContainer changedBytes)
{
if (rule.DataType == DataType.Decimal || rule.DataType == DataType.SignedInteger || rule.DataType == DataType.UnsignedInteger)
{
return(isNumberChangedAccordingToRule(bytes, rule, out changedBytes));
}
if (rule.DataType == DataType.Data)
{
return(isDataChangedAccordingToRule(bytes, rule, out changedBytes));
}
changedBytes = null;
return(false);
}
private bool isDataChangedAccordingToRule(byte[] bytes, MemoryRule rule, out IChangedDataContainer changedBytes)
{
ISet <long> changedBytesSet = new HashSet <long>();
var count = bytes.LongLength;
var sendAll = rule.TransferType == TransferType.AllBytes;
for (long i = 0; i < count; ++i)
{
if (rule.Bytes[i] != bytes[i])
{
if (rule.ChangeTrigger == ChangeTrigger.AnyChange ||
rule.ChangeTrigger == ChangeTrigger.FlagOn && (rule.Bytes[i] | bytes[i]) != rule.Bytes[i] ||
rule.ChangeTrigger == ChangeTrigger.FlagOff && (rule.Bytes[i] & bytes[i]) != rule.Bytes[i] ||
rule.ChangeTrigger == ChangeTrigger.Increase && rule.NumBytes == 1 && bytes[i] > rule.Bytes[i] ||
rule.ChangeTrigger == ChangeTrigger.Decrease && rule.NumBytes == 1 && bytes[i] < rule.Bytes[i])
{
changedBytesSet.Add(i);
if (sendAll)
{
break;
}
}
}
}
if (changedBytesSet.Count > 0)
{
if (sendAll)
{
changedBytes = new BytesContainer(bytes, rule.MemoryOffset64);
}
else
{
changedBytes = BytesDifferenceContainer.ChangedBytesFromIndexSet(rule.MemoryOffset64, changedBytesSet, bytes);
}
return(true);
}
else
{
changedBytes = null;
return(false);
}
}
public object GetDataFromRule(MemoryRule rule)
{
var bytes = GetBytes(rule);
object data = null;
if (rule.DataType == DataType.Data)
{
if (rule.NumBytes == 1)
{
data = bytes[0];
}
else
{
data = bytes;
}
}
else if (rule.DataType == DataType.Decimal)
{
if (rule.NumBytes == 4)
{
data = ByteParser.ParseFloat(bytes, rule.Endianness);
}
if (rule.NumBytes == 8)
{
data = ByteParser.ParseDouble(bytes, rule.Endianness);
}
}
else if (rule.DataType == DataType.SignedInteger)
{
if (rule.NumBytes == 1)
{
data = (sbyte)bytes[0];
}
if (rule.NumBytes == 2)
{
data = ByteParser.ParseShort(bytes, rule.Endianness);
}
if (rule.NumBytes == 4)
{
data = ByteParser.ParseInt(bytes, rule.Endianness);
}
if (rule.NumBytes == 8)
{
data = ByteParser.ParseLong(bytes, rule.Endianness);
}
}
else if (rule.DataType == DataType.UnsignedInteger)
{
if (rule.NumBytes == 1)
{
data = bytes[0];
}
if (rule.NumBytes == 2)
{
data = ByteParser.ParseUnsignedShort(bytes, rule.Endianness);
}
if (rule.NumBytes == 4)
{
data = ByteParser.ParseUnsignedInt(bytes, rule.Endianness);
}
if (rule.NumBytes == 8)
{
data = ByteParser.ParseUnsignedLong(bytes, rule.Endianness);
}
}
if (data == null)
{
throw new Exception("Could not parse data from rule");
}
return(data);
}
private bool isNumberChangedAccordingToRule(byte[] bytes, MemoryRule rule, out IChangedDataContainer changedBytes)
{
byte[] diff = null;
bool numbersChanged = false;
if (rule.DataType == DataType.Decimal)
{
if (bytes.Length == 4)
{
var ov = ByteParser.ParseFloat(rule.Bytes, rule.Endianness);
var nv = ByteParser.ParseFloat(bytes, rule.Endianness);
diff = BitConverter.GetBytes(nv - ov);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
else if (bytes.Length == 8)
{
var ov = ByteParser.ParseDouble(rule.Bytes, rule.Endianness);
var nv = ByteParser.ParseDouble(bytes, rule.Endianness);
diff = BitConverter.GetBytes(nv - ov);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
else
{
throw new Exception("Can not parse decimal. Expected 4 or 8 bytes");
}
}
else if (rule.DataType == DataType.SignedInteger || rule.DataType == DataType.UnsignedInteger)
{
bool signed = rule.DataType == DataType.SignedInteger;
if (bytes.Length == 1)
{
if (signed)
{
var ov = (sbyte)rule.Bytes[0];
var nv = (sbyte)bytes[0];
diff = BitConverter.GetBytes(nv - ov);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
else
{
var ov = rule.Bytes[0];
var nv = bytes[0];
diff = BitConverter.GetBytes(nv - ov);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
}
else if (bytes.Length == 2)
{
if (signed)
{
var ov = ByteParser.ParseShort(rule.Bytes, rule.Endianness);
var nv = ByteParser.ParseShort(bytes, rule.Endianness);
diff = BitConverter.GetBytes(nv - ov);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
else
{
var ov = ByteParser.ParseUnsignedShort(rule.Bytes, rule.Endianness);
var nv = ByteParser.ParseUnsignedShort(bytes, rule.Endianness);
diff = BitConverter.GetBytes(nv - ov);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
}
else if (bytes.Length == 4)
{
if (signed)
{
var ov = ByteParser.ParseInt(rule.Bytes, rule.Endianness);
var nv = ByteParser.ParseInt(bytes, rule.Endianness);
diff = BitConverter.GetBytes(nv - ov);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
else
{
var ov = ByteParser.ParseUnsignedInt(rule.Bytes, rule.Endianness);
var nv = ByteParser.ParseUnsignedInt(bytes, rule.Endianness);
long diff2 = (long)nv - (long)ov;
diff = BitConverter.GetBytes((int)diff2);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
}
else if (bytes.Length == 8)
{
if (signed)
{
var ov = ByteParser.ParseLong(rule.Bytes, rule.Endianness);
var nv = ByteParser.ParseLong(bytes, rule.Endianness);
long diff2 = (long)nv - (long)ov;
diff = BitConverter.GetBytes((int)diff2);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
else
{
var ov = ByteParser.ParseUnsignedLong(rule.Bytes, rule.Endianness);
var nv = ByteParser.ParseUnsignedLong(bytes, rule.Endianness);
long diff2 = (long)nv - (long)ov;
diff = BitConverter.GetBytes((int)diff2);
numbersChanged = (rule.ChangeTrigger == ChangeTrigger.AnyChange && !ov.Equals(nv) ||
rule.ChangeTrigger == ChangeTrigger.Decrease && ov > nv ||
rule.ChangeTrigger == ChangeTrigger.Increase && ov < nv);
}
}
else
{
throw new Exception("Can not parse number. Expected 1, 2, 4 or 8 bytes");
}
}
if (numbersChanged)
{
if (rule.TransferType == TransferType.AllBytes)
{
changedBytes = new BytesContainer(bytes, rule.MemoryOffset64);
return(true);
}
else
{
changedBytes = new NumberDifferenceContainer(diff, rule.MemoryOffset64);
return(true);
}
}
changedBytes = null;
return(false);
}
private byte[] bytesFromStringForRule(MemoryRule rule, string valuestring)
{
if (rule.DataType == DataType.Data)
{
//Can only convert a string to a single byte value
if (rule.NumBytes == 1)
{
byte b;
if (byte.TryParse(valuestring, out b))
{
return new byte[] { b }
}
;
}
}
else if (rule.DataType == DataType.Decimal)
{
if (rule.NumBytes == 4)
{
float f;
if (float.TryParse(valuestring.Replace(",", "."), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out f))
{
return(BitConverter.GetBytes(f));
}
}
else if (rule.NumBytes == 8)
{
double d;
if (double.TryParse(valuestring.Replace(",", "."), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out d))
{
return(BitConverter.GetBytes(d));
}
}
}
else if (rule.DataType == DataType.SignedInteger)
{
if (rule.NumBytes == 1)
{
sbyte b;
if (sbyte.TryParse(valuestring, out b))
{
return new byte[] { (byte)b }
}
;
}
else if (rule.NumBytes == 2)
{
short s;
if (short.TryParse(valuestring, out s))
{
return(BitConverter.GetBytes(s));
}
}
else if (rule.NumBytes == 4)
{
int i;
if (int.TryParse(valuestring, out i))
{
return(BitConverter.GetBytes(i));
}
}
else if (rule.NumBytes == 8)
{
long l;
if (long.TryParse(valuestring, out l))
{
return(BitConverter.GetBytes(l));
}
}
}
else if (rule.DataType == DataType.UnsignedInteger)
{
if (rule.NumBytes == 1)
{
byte b;
if (byte.TryParse(valuestring, out b))
{
return new byte[] { b }
}
;
}
else if (rule.NumBytes == 2)
{
ushort s;
if (ushort.TryParse(valuestring, out s))
{
return(BitConverter.GetBytes(s));
}
}
else if (rule.NumBytes == 4)
{
uint i;
if (uint.TryParse(valuestring, out i))
{
return(BitConverter.GetBytes(i));
}
}
else if (rule.NumBytes == 8)
{
ulong l;
if (ulong.TryParse(valuestring, out l))
{
return(BitConverter.GetBytes(l));
}
}
}
return(null);
}
