private byte _expMultiplier; // Exp 0B:1x, ..., 64:10x
public Challenge(Settings settings)
{
_serverFlags = 0x50;
if (settings.IsPvP)
{
_serverFlags |= 0x80;
}
if (settings.SpiritBonus)
{
_serverFlags |= 0x08;
}
if (settings.DropBonus)
{
_serverFlags |= 0x04;
}
if (settings.MoneyBonus)
{
_serverFlags |= 0x02;
}
Random random = new Random();
_key = new byte[8];
random.NextBytes(_key);
_clientSignature = HexParser.GetBytes(settings.ClientSignature);
_clientSignatureLength = (byte)_clientSignature.Length;
_expMultiplier = (byte)(settings.ExpMultiplier * 10);
}
public static void Write(string hexFileName)
{
HexParser hexParser = new HexParser(hexFileName);
hexParser.StartReading();
int pageSize = 32;
HexRecord record = hexParser.ReadLine();
byte[] data = new byte[pageSize];
int totalWritten = 0;
Commander cmd = new Commander();
try
{
FileStream usb = cmd.GetUSB();
byte[] nill = new byte[100];
// usb.Read(nill, 0, 100);
}
catch
{
}
if (cmd.BeginProgramming())
{
cmd.ChipErase();
while (record.Type != HexRecord.EOF)
{
switch (record.Type)
{
case HexRecord.DataType:
for (int i = 0; i < record.Length; i++)
{
if (totalWritten == pageSize || (((record.FullAddress + i) / (2 * pageSize)) != (cmd.Address / pageSize)))
{
cmd.Write(data, totalWritten);
cmd.Address = (int)(cmd.Address) + (totalWritten / 2);
totalWritten = 0;
}
data[totalWritten++] = record.Data[i];
}
break;
case HexRecord.ExtendedLinearAddressRecord:
case HexRecord.ExtendedSegmentAddress:
throw new Exception("Not Supporte Yet");
}
record = hexParser.ReadLine();
}
if (totalWritten != 0)
cmd.Write(data, totalWritten);
}
cmd.Dispose();
hexParser.Dispose();
}
private void daqUpdateFileChooser_Click(object sender, EventArgs e)
{
var openFile = new OpenFileDialog();
openFile.AutoUpgradeEnabled = true;
openFile.DefaultExt = "hex";
openFile.Filter = "Hex memory files (*.hex)|*.hex";
openFile.SupportMultiDottedExtensions = true;
openFile.Multiselect = false;
if (DialogResult.OK != openFile.ShowDialog())
{
return;
}
var fileInfo = new FileInfo(openFile.FileName);
try {
_patchData = HexParser.ParseToMemoryRegions(
new StreamReader(
File.OpenRead(fileInfo.FullName)
)
);
daqFileLabel.Text = String.Concat("Loaded: ", fileInfo.Name);
beginDaqUpdate.Enabled = true;
}
catch (Exception ex) {
daqFileLabel.Text = String.Concat("Load error: ", ex.ToString());
Log.Error("DAQ firmware load error.", ex);
beginDaqUpdate.Enabled = false;
}
}
public void ParseLongData()
{
var line = ":1000080009002C2083160313861283120313861605";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal(16, parsed.ByteCount);
Assert.Equal(8, parsed.Address);
Assert.Equal(RecordType.Data, parsed.RecordType);
Assert.Equal(0x00, parsed.Instructions[0].FirstByte);
Assert.Equal(0x09, parsed.Instructions[0].SecondByte);
Assert.Equal(0x20, parsed.Instructions[1].FirstByte);
Assert.Equal(0x2C, parsed.Instructions[1].SecondByte);
Assert.Equal(0x16, parsed.Instructions[2].FirstByte);
Assert.Equal(0x83, parsed.Instructions[2].SecondByte);
Assert.Equal(0x13, parsed.Instructions[3].FirstByte);
Assert.Equal(0x03, parsed.Instructions[3].SecondByte);
Assert.Equal(0x12, parsed.Instructions[4].FirstByte);
Assert.Equal(0x86, parsed.Instructions[4].SecondByte);
Assert.Equal(0x12, parsed.Instructions[5].FirstByte);
Assert.Equal(0x83, parsed.Instructions[5].SecondByte);
Assert.Equal(0x13, parsed.Instructions[6].FirstByte);
Assert.Equal(0x03, parsed.Instructions[6].SecondByte);
Assert.Equal(0x16, parsed.Instructions[7].FirstByte);
Assert.Equal(0x86, parsed.Instructions[7].SecondByte);
}
public void TestMinusHexToLong()
{
var hex = "-F";
var x = hex;
var s = '+';
if (x[0] == '-' || x[0] == '+')
{
s = x[0];
x = x.Remove(0, 1);
}
var y = Hex.Decode($"{"".PadRight(16 - x.Length, '0')}{x}");
if (BitConverter.IsLittleEndian)
{
Array.Reverse(y);
}
var y1 = BitConverter.ToInt64(y, 0);
if (s == '-')
{
y1 = 0 - y1;
}
var a = -15L;
Assert.AreEqual(a, y1);
Assert.AreEqual(a, HexParser.HexStringToLong(hex));
Assert.AreEqual(8, y.Length);
}
private object ParseMatch(HexParser hexParser, Match match)
{
if (match.Value == "+")
{
return(MathOperator.PLUS);
}
if (match.Value == "-")
{
return(MathOperator.MINUS);
}
if (match.Value == "*")
{
return(MathOperator.TIMES);
}
if (match.Value == "/")
{
return(MathOperator.DIVIDED_BY);
}
if (hexParser.TryByteParse(match.Value, out var hexByte))
{
return(hexByte);
}
if (hexParser.TryUShortParse(match.Value, out var hexWord))
{
return(hexWord);
}
if (int.TryParse(match.Value, out var parsedInt))
{
return(parsedInt);
}
return(match.Value);
}
public void ParseORGDirective()
{
var line = ":020000040000FA";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal("ORG 0x0000", parsed.ToString());
}
public void ParseData5()
{
var line = ":02400E008C3FE5";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal("__CONFIG 0x3F8C", parsed.ToString());
}
public void ParseGotoInstruction()
{
var line = ":020000000528D1";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.IsType(typeof(Goto), parsed.Instructions[0]);
}
public void ParseEnd()
{
var line = ":00000001FF";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal("END", parsed.ToString());
}
public void ReturnsBcfInstructionString()
{
var line = ":1000080009002C2083160313861283120313861605";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal("BCF STATUS, RP1", parsed.Instructions[3].ToString());
}
public void ReturnsGotoInstructionString()
{
var line = ":020000000528D1";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal("GOTO 0x05", parsed.Instructions[0].ToString());
}
public void ParseBcfInstruction()
{
var line = ":1000080009002C2083160313861283120313861605";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.IsType(typeof(Bcf), parsed.Instructions[3]);
}
public void ParseAddress()
{
var line = ":020000000528D1";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal(0, parsed.Address);
}
public void ReturnsCallInstructionString()
{
var line = ":1000080009002C2083160313861283120313861605";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal("CALL 0x2C", parsed.Instructions[1].ToString());
}
public void ReturnsRetfieInstructionString()
{
var line = ":1000080009002C2083160313861283120313861605";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal("RETFIE", parsed.Instructions[0].ToString());
}
public void ParseChecksum()
{
var line = ":020000000528D1";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal(0xD1, parsed.Checksum);
}
public void ParseRecordType()
{
var line = ":020000000528D1";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal(RecordType.Data, parsed.RecordType);
}
public void ParseByteCount()
{
var line = ":020000000528D1";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal(2, parsed.ByteCount);
}
public static bool Verify(string hexFileName)
{
HexParser hexParser = new HexParser(hexFileName);
hexParser.StartReading();
int pageSize = 32;
HexRecord record = hexParser.ReadLine();
byte[] data = new byte[pageSize];
Commander cmd = new Commander();
try
{
FileStream usb = cmd.GetUSB();
byte[] nill = new byte[100];
// usb.Read(nill, 0, 100);
}
catch
{
}
bool success = true;
if (cmd.BeginProgramming())
{
while (record.Type != HexRecord.EOF && success)
{
switch (record.Type)
{
case HexRecord.DataType:
cmd.Address = record.Address / 2;
cmd.Read(data, record.Length);
for (int i = 0; i < record.Length; i++)
{
if (data[i] != record.Data[i])
{
success = false;
break;
}
}
break;
case HexRecord.ExtendedLinearAddressRecord:
case HexRecord.ExtendedSegmentAddress:
throw new Exception("Not Supporte Yet");
}
record = hexParser.ReadLine();
}
}
cmd.Dispose();
hexParser.Dispose();
return(success);
}
public CalculatedImmediateOperand(string calculatedImmediate, HexParser hexParser)
{
//Regex that groups operators as separate matches from non-operators
var _regex = new Regex(@"([\+\-\*\/]|[^[\+\-\*\/]*)", RegexOptions.IgnoreCase);
Clauses = (from Match match in _regex.Matches(calculatedImmediate)
where !string.IsNullOrEmpty(match.Value)
select ParseMatch(hexParser, match)).ToList();
}
public void ParseInstructionBytes()
{
var line = ":020000000528D1";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
Assert.Equal(0x28, parsed.Instructions[0].FirstByte);
Assert.Equal(0x05, parsed.Instructions[0].SecondByte);
}
public static bool Verify(string hexFileName)
{
HexParser hexParser = new HexParser(hexFileName);
hexParser.StartReading();
int pageSize = 32;
HexRecord record = hexParser.ReadLine();
byte[] data = new byte[pageSize];
Commander cmd = new Commander();
try
{
FileStream usb = cmd.GetUSB();
byte[] nill = new byte[100];
// usb.Read(nill, 0, 100);
}
catch
{
}
bool success = true;
if (cmd.BeginProgramming())
{
while (record.Type != HexRecord.EOF && success)
{
switch (record.Type)
{
case HexRecord.DataType:
cmd.Address = record.Address / 2;
cmd.Read(data, record.Length);
for (int i = 0; i < record.Length; i++)
{
if (data[i] != record.Data[i])
{
success = false;
break;
}
}
break;
case HexRecord.ExtendedLinearAddressRecord:
case HexRecord.ExtendedSegmentAddress:
throw new Exception("Not Supporte Yet");
}
record = hexParser.ReadLine();
}
}
cmd.Dispose();
hexParser.Dispose();
return success;
}
public void ParseData4()
{
var line = ":0A003000850090308B0064001B284F";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
var asm = @"MOVWF 0x05
MOVLW 0x90
MOVWF 0x0B
CLRWDT
GOTO 0x1B";
Assert.Equal(asm, parsed.ToString());
}
public void ParseData()
{
var hex = @":020000001228C4
:08000800A000030E8312A10009";
var parser = new HexParser();
var parsed = parser.ParseLines(hex.Split(new[] { "\r\n" }, System.StringSplitOptions.RemoveEmptyEntries));
var asm = @"GOTO 0x12
MOVWF 0x20
SWAPF STATUS, W
BCF STATUS, RP0
MOVWF 0x21";
Assert.Equal(asm, parsed.ToString());
}
public void CalculatedImmediateOperandTests_DecimalMinusHex()
{
var sourceOperand = "10-20h";
var expected = new List <object>()
{
(byte)10,
MathOperator.MINUS,
(byte)0x20
};
var parser = new HexParser(string.Empty, "h");
var operand = new CalculatedImmediateOperand(sourceOperand, parser);
CollectionAssert.AreEquivalent(expected, operand.Clauses);
Assert.AreEqual("10-32", operand.DisplayValue);
}
public void CalculatedImmediateOperandTests_DecimalPlusDecimal()
{
var sourceOperand = "4+8";
var expected = new List <object>()
{
(byte)4,
MathOperator.PLUS,
(byte)8
};
var parser = new HexParser();
var operand = new CalculatedImmediateOperand(sourceOperand, parser);
CollectionAssert.AreEquivalent(expected, operand.Clauses);
Assert.AreEqual(sourceOperand, operand.DisplayValue);
}
public void CalculatedImmediateOperandTests_LabelTimesDecimal()
{
var sourceOperand = "score*8";
var expected = new List <object>()
{
"score",
MathOperator.TIMES,
(byte)8
};
var parser = new HexParser();
var operand = new CalculatedImmediateOperand(sourceOperand, parser);
CollectionAssert.AreEquivalent(expected, operand.Clauses);
Assert.AreEqual(sourceOperand, operand.DisplayValue);
}
public void ParseData2()
{
var line = ":100010008B1C0D288B1005168516210E8300A00E53";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
var asm = @"BTFSS INTCON, INTF
GOTO 0x0D
BCF INTCON, INTF
BSF PORTA, RA4
BSF PORTA, RA5
SWAPF 0x21, W
MOVWF 0x03
SWAPF 0x20, W";
Assert.Equal(asm, parsed.ToString());
}
public void ParseDataAndReturnsTheSourceCode()
{
var line = ":1000080009002C2083160313861283120313861605";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
var asm = @"RETFIE
CALL 0x2C
BSF STATUS, RP0
BCF STATUS, RP1
BCF PORTB, RB5
BCF STATUS, RP0
BCF STATUS, RP1
BSF PORTB, RB5";
Assert.Equal(asm, parsed.ToString());
}
public void ParseData3()
{
var line = ":10002000200E09008316BF3081000F308500831237";
var parser = new HexParser();
var parsed = parser.ParseLine(line);
var asm = @"SWAPF 0x20, W
RETFIE
BSF STATUS, RP0
MOVLW 0xBF
MOVWF 0x01
MOVLW 0x0F
MOVWF 0x05
BCF STATUS, RP0";
Assert.Equal(asm, parsed.ToString());
}
public static string ReplaceEscapedValues(string text)
{
var matcher = new Matcher();
if (matcher.IsMatch(text, "'`x_' /(['0-9a-f_']+)"))
{
for (var i = 0; i < matcher.MatchCount; i++)
{
matcher[i] = getCharFromInt(HexParser.GetNumber(matcher[i, 1]));
}
text = matcher.ToString();
}
if (matcher.IsMatch(text, "'`o_' /(['0-7_']+)"))
{
for (var i = 0; i < matcher.MatchCount; i++)
{
matcher[i] = getCharFromInt(OctParser.GetNumber(matcher[i, 1]));
}
text = matcher.ToString();
}
if (matcher.IsMatch(text, "'`b_' /(['01_']+)"))
{
for (var i = 0; i < matcher.MatchCount; i++)
{
matcher[i] = getCharFromInt(BinParser.GetNumber(matcher[i, 1]));
}
text = matcher.ToString();
}
if (matcher.IsMatch(text, "'`' /(['0-9_']+)"))
{
for (var i = 0; i < matcher.MatchCount; i++)
{
matcher[i] = getCharFromInt(matcher[i, 1].Replace("_", "").ToInt());
}
text = matcher.ToString();
}
return(text);
}
