public General(HiToTextEntry entry)
{
m_format = string.Join("|", entry.Header.Fields);
m_gamesSupported = string.Join(",", entry.Header.Games);
foreach(HiToTextEntryHeaderName name in entry.Header.Extensions)
m_extensionsRequired += name.Value + ",";
m_extensionsRequired = m_extensionsRequired.TrimEnd(new char[] { ',' });
tParams = GetTextParameters(entry);
switchMaps = GetSwitchMaps(entry);
hiscoreData = new HiscoreData(entry);
listOfSetMappings = SetupMappings(entry);
}
//TODO: Try to make this method more modular.
public List<DisplayData> GetDisplay(TextParams tParams, Dictionary<string, OneToManyMap<byte[], string>> switchMaps)
{
List<DisplayData> display = new List<DisplayData>();
int displayedEntries = -1;
if (_entry.DisplayStructure.NumOfDisplayedEntriesSpecified)
displayedEntries = Convert.ToInt32(_entry.DisplayStructure.NumOfDisplayedEntries);
foreach (HiToTextEntryDisplayStructureFieldName fieldName in _entry.DisplayStructure.FieldName)
{
DisplayData toDisplay = null;
HTTF.ConvertByteArrayToString cbas = null;
string methodName = fieldName.ConversionType.ToUpper();
if (fieldName.ConversionType.ToUpper().IndexOf('(') >= 0)
methodName = fieldName.ConversionType.ToUpper().Substring(0, fieldName.ConversionType.ToUpper().IndexOf('('));
switch (methodName)
{
case "CANNEDDISPLAY.ASCENDINGFROM1":
toDisplay = new DisplayData(null, DisplayData.CannedDisplay.AscendingFrom1);
break;
case "CANNEDDISPLAY.ASCENDINGFROM1ENDINGINTOTAL":
toDisplay = new DisplayData(null, DisplayData.CannedDisplay.AscendingFrom1EndingInTotal);
break;
case "NAME":
if (fieldName.CustomName != null && !fieldName.CustomName.Equals(string.Empty))
{
MethodInfo[] mInfos =
typeof(HiToStr).GetMethods(BindingFlags.Public | BindingFlags.Static);
for (int i = 0; i < mInfos.Length; i++)
{
if (mInfos[i].Name.ToUpper().Equals(fieldName.CustomName.ToUpper()))
{
cbas = (HTTF.ConvertByteArrayToString)mInfos[i].Invoke(
null,
new object[] { tParams });
break;
}
}
}
else
cbas = HiToStr.ConvertName(tParams);
break;
case "STANDARD":
cbas = HiToStr.Standard;
break;
case "REVERSED":
cbas = HiToStr.Reversed;
break;
case "HEX":
cbas = HiToStr.Hex;
break;
case "HEXREVERSED":
cbas = HiToStr.HexReversed;
break;
case "BCD":
cbas = HiToStr.BCD;
break;
case "BCDREVERSED":
cbas = HiToStr.BCDReversed;
break;
case "SWITCH":
cbas = HiToStr.ConvertSwitch(switchMaps[fieldName.Name]);
break;
case "TWOTOTHREEENCODING":
cbas = HiToStr.TwoToThreeEncoding(
tParams,
Convert.ToInt32(fieldName.ConversionType.Substring(fieldName.ConversionType.IndexOf('(') + 1,
fieldName.ConversionType.IndexOf(')') - (fieldName.ConversionType.IndexOf('(') + 1)).Trim()));
break;
default:
MethodInfo[] methodInfos = typeof(HiToStr).GetMethods(
BindingFlags.Public | BindingFlags.Static);
for (int i = 0; i < methodInfos.Length; i++)
{
if (methodInfos[i].Name.ToUpper().Equals(methodName))
{
cbas = (HTTF.ConvertByteArrayToString)Delegate.CreateDelegate(
typeof(HTTF.ConvertByteArrayToString), methodInfos[i]);
break;
}
}
//Will look for custom ByteArrayToInts that already exist and just tostring them, if we
//still don't have a cbas.
if (cbas == null)
{
methodInfos = typeof(HTTF.ByteArrayToInt).GetMethods(
BindingFlags.Public | BindingFlags.Static);
for (int i = 0; i < methodInfos.Length; i++)
{
if (methodInfos[i].Name.ToUpper().Equals(methodName))
{
BAI bai = (BAI)Delegate.CreateDelegate(typeof(BAI), methodInfos[i]);
cbas = delegate(byte[] score) { return bai(score).ToString(); };
break;
}
}
}
//ConvertByteArraysToStrings
break;
}
if (fieldName.Operator != null && !fieldName.Operator.Equals(string.Empty))
{
switch (fieldName.Operator.Substring(0, 1))
{
case "*":
cbas = HiToStr.MultiplyDisplayed(cbas, Convert.ToInt32(fieldName.Operator.Substring(1)));
break;
case "+":
cbas = HiToStr.AddToDisplayed(cbas, Convert.ToInt32(fieldName.Operator.Substring(1)));
break;
}
}
if (toDisplay == null)
{
string reg = string.Empty;
string[] fns =
fieldName.Name.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (fns.Length > 1)
CreateNewField(fns, fieldName.ConversionType);
if (displayedEntries == -1)
{
if (fns.Length > 1)
toDisplay = new DisplayData(new Regex("^" + fieldName.ConversionType + ".*$"), cbas);
else
toDisplay = new DisplayData(new Regex("^" + fieldName.Name + ".*$"), cbas);
}
else
{
for (int i = 1; i <= displayedEntries; i++)
{
if (fns.Length > 1)
reg += "|^" + fieldName.ConversionType + i.ToString() + "$";
else
reg += "|^" + fieldName.Name + i.ToString() + "$";
}
toDisplay = new DisplayData(new Regex(reg.Substring(1)), cbas);
}
}
display.Add(toDisplay);
}
return display;
}
public static ConvertValueToByteArray astdelux(string data, TextDecodingParameters tParams, string fName)
{
//fName is not used here, but is the default custom name.
string[] sVals = data.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
int score = Convert.ToInt32(sVals[0]);
string name = sVals[1];
byte checksum8 = 0x00;
byte[] datascore =
ConvertData(score, 3, HiConvert.IntToByteArrayHex, HiConvert.ReverseByteArray)(sVals[0]);
byte[] dataname = ConvertName(tParams)(sVals[1]);
for (int i = 0; i < datascore.Length; i++)
checksum8 += datascore[i];
for (int i = 0; i < dataname.Length; i++)
checksum8 += dataname[i];
return delegate(string d) { return new byte[] { checksum8 }; };
}
public static ConvertValueToByteArray apb(string data, TextDecodingParameters tParams, string fName)
{
byte[] dataname = ConvertName(tParams)(data);
switch (fName.ToUpper())
{ //For a given name section, return a delegate which returns the byte-rep of the char it corresponds to, or a byte-rep of ' '
case "FIRSTNAME":
return delegate(string d) { return ((data.Length > 0) ? new byte[] { dataname[0] } : StringToByte(" ", tParams)); };
case "MIDDLENAME":
return delegate(string d) { return ((data.Length > 1) ? new byte[] { dataname[1] } : StringToByte(" ", tParams)); };
case "LASTNAME":
return delegate(string d) { return ((data.Length > 2) ? new byte[] { dataname[2] } : StringToByte(" ", tParams)); };
}
return delegate(string d) { return new byte[] { 0041 }; };
}
public static ConvertByteArrayToString TwoToThreeEncoding(TextDecodingParameters decodingParameters, int numberOfCharacters)
{
return delegate(byte[] data)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < data.Length; i++)
sb.Append(data[i].ToString("X2"));
string name = sb.ToString();
int val = System.Convert.ToInt32(name, 16);
int everySecond = numberOfCharacters;
int everyFirst = everySecond * everySecond;
byte[] decodedData = new byte[3];
decodedData[0] = (byte)(System.Convert.ToInt32((val / everyFirst).ToString("X2"), 16) + 64);
int restOfLastTwo = val - ((val / everyFirst) * everyFirst);
decodedData[1] = (byte)(System.Convert.ToInt32((restOfLastTwo / everySecond).ToString("X2"), 16) + 64);
int last = restOfLastTwo - ((restOfLastTwo / everySecond) * everySecond);
decodedData[2] = (byte)(System.Convert.ToInt32(last.ToString("X2"), 16) + 64);
return ByteToString(decodedData, decodingParameters);
};
}
public static string ByteToString(byte[] data, TextDecodingParameters tParams)
{
StringBuilder sb = new StringBuilder();
for (int i = tParams.ByteStart; i < data.Length; i = i + tParams.ByteSkipAmount)
{
bool keyFound = false;
//Needs to be first, as it can be ASCII standard and some special mappings.
#region SPECIAL MAPPING
if ((tParams.Format & StringFormatFlag.NeedsSpecialMapping) == StringFormatFlag.NeedsSpecialMapping)
{
if (tParams.SpecialMapping.ContainsMany(data[i]))
{
sb.Append(tParams.SpecialMapping.FindOne(data[i]));
keyFound = true;
}
}
#endregion
#region ASCII STANDARD
if (!keyFound)
{
if ((tParams.Format & StringFormatFlag.ASCIIStandard) == StringFormatFlag.ASCIIStandard)
{
sb.Append((char)(int)data[i]);
keyFound = true;
}
}
#endregion
#region ASCII UPPERCASE
if (!keyFound)
{
if ((tParams.Format & StringFormatFlag.ASCIIUpper) == StringFormatFlag.ASCIIUpper)
{
foreach (Offset o in tParams.Offsets)
{
if (o.Flag.Equals(Offset.FlagOffsets.Upper))
{
if (Convert.ToInt32(data[i]) >= o.ByteOffset && Convert.ToInt32(data[i]) <= (o.ByteOffset + (26 * o.SkipModifier)))
{
sb.Append(((char)(((((int)data[i]) / o.SkipModifier) + 65) - o.ByteOffset)));
keyFound = true;
break;
}
}
}
}
}
#endregion
#region ASCII LOWERCASE
if (!keyFound)
{
if ((tParams.Format & StringFormatFlag.ASCIILower) == StringFormatFlag.ASCIILower)
{
foreach (Offset o in tParams.Offsets)
{
if (o.Flag.Equals(Offset.FlagOffsets.Lower))
{
if (Convert.ToInt32(data[i]) >= o.ByteOffset && Convert.ToInt32(data[i]) <= (o.ByteOffset + (26 * o.SkipModifier)))
{
sb.Append(((char)(((((int)data[i]) / o.SkipModifier) + 71) - o.ByteOffset)));
keyFound = true;
break;
}
}
}
}
}
#endregion
#region ASCII NUMBERS
if (!keyFound)
{
if ((tParams.Format & StringFormatFlag.ASCIINumbers) == StringFormatFlag.ASCIINumbers)
{
foreach (Offset o in tParams.Offsets)
{
if (o.Flag.Equals(Offset.FlagOffsets.Numbers))
{
if (Convert.ToInt32(data[i]) >= o.ByteOffset && Convert.ToInt32(data[i]) <= (o.ByteOffset + (10 * o.SkipModifier)))
{
sb.Append(((char)(((((int)data[i]) / o.SkipModifier) + 48) - o.ByteOffset)));
keyFound = true;
break;
}
}
}
}
}
#endregion
if (!keyFound)
throw new Exception("Error: \"0x" + data[i].ToString("X2") + "\" not found in ByteToString setup.");
}
return sb.ToString();
}
public static ConvertByteArrayToString ConvertName(TextDecodingParameters decodingParameters, WrapperByteArray internalFunction)
{
return delegate(byte[] data) { return ByteToString(internalFunction(data), decodingParameters); };
}
//For converting names.
public static ConvertByteArrayToString ConvertName(TextDecodingParameters decodingParameters)
{
return delegate(byte[] data) { return ByteToString(data, decodingParameters); };
}
public static ConvertByteArrayToString cclimber(TextDecodingParameters decodingParameters)
{
return delegate(byte[] data)
{
if (IsNichibutsu(data))
return "Nichibutsu";
else
return ByteToString(data, decodingParameters);
};
}
public static byte[] StringToByte(string str, TextDecodingParameters tParams)
{
byte[] data = new byte[str.Length * tParams.ByteSkipAmount];
for (int i = 0; i < data.Length; i++)
data[i] = tParams.ByteSkipData;
for (int i = 0; i < str.Length; i++)
{
bool keyFound = false;
//Needs to be first, as it can be ASCII standard and some special mappings.
#region SPECIAL MAPPING
if ((tParams.Format & StringFormatFlag.NeedsSpecialMapping) == StringFormatFlag.NeedsSpecialMapping)
{
if (tParams.SpecialMapping.ContainsOne(str[i]))
{
data[(i * tParams.ByteSkipAmount) + tParams.ByteStart] = tParams.SpecialMapping.FindMany(str[i]);
keyFound = true;
}
}
#endregion
#region ASCII STANDARD
if (!keyFound)
{
if ((tParams.Format & StringFormatFlag.ASCIIStandard) == StringFormatFlag.ASCIIStandard)
{
data[(i * tParams.ByteSkipAmount) + tParams.ByteStart] = (byte)((int)str[i]);
keyFound = true;
}
}
#endregion
#region ASCII UPPERCASE
if (!keyFound)
{
if ((tParams.Format & StringFormatFlag.ASCIIUpper) == StringFormatFlag.ASCIIUpper)
{
foreach (Offset o in tParams.Offsets)
{
if (o.Flag.Equals(Offset.FlagOffsets.Upper))
{
if (str[i] >= 'A' && str[i] <= 'Z')
{
data[(i * tParams.ByteSkipAmount) + tParams.ByteStart] = (byte)(((((int)str[i]) - 65) + o.ByteOffset) * o.SkipModifier);
keyFound = true;
break;
}
}
}
}
}
#endregion
#region ASCII LOWERCASE
if (!keyFound)
{
if ((tParams.Format & StringFormatFlag.ASCIILower) == StringFormatFlag.ASCIILower)
{
foreach (Offset o in tParams.Offsets)
{
if (o.Flag.Equals(Offset.FlagOffsets.Lower))
{
if (str[i] >= 'a' && str[i] <= 'z')
{
data[(i * tParams.ByteSkipAmount) + tParams.ByteStart] = (byte)(((((int)str[i]) - 71) + o.ByteOffset) * o.SkipModifier);
keyFound = true;
break;
}
}
}
}
}
#endregion
#region ASCII NUMBERS
if (!keyFound)
{
if ((tParams.Format & StringFormatFlag.ASCIINumbers) == StringFormatFlag.ASCIINumbers)
{
foreach (Offset o in tParams.Offsets)
{
if (o.Flag.Equals(Offset.FlagOffsets.Numbers))
{
if (str[i] >= '0' && str[i] <= '9')
{
data[(i * tParams.ByteSkipAmount) + tParams.ByteStart] = (byte)(((((int)str[i]) - 48) + o.ByteOffset) * o.SkipModifier);
keyFound = true;
break;
}
}
}
}
}
#endregion
if (!keyFound)
throw new Exception("Error: \"" + str[i].ToString() + "\" not found in StringToByte setup.");
}
return data;
}
public static ConvertValueToByteArray ConvertName(TextDecodingParameters decodingParameters, WrapperByteArray externalFunction)
{
return delegate(string str) { return externalFunction(StringToByte(str, decodingParameters)); };
}
//For names.
public static ConvertValueToByteArray ConvertName(TextDecodingParameters decodingParameters)
{
return delegate(string str) { return StringToByte(str, decodingParameters); };
}
private TextParams GetTextParameters(HiToTextEntry entry)
{
TextParams tParams = new TextParams();
if (entry.Header.TextParameters == null)
return tParams;
tParams.Format = GetFormat(entry);
if (entry.Header.TextParameters.ByteSkipAmountSpecified)
tParams.ByteSkipAmount = entry.Header.TextParameters.ByteSkipAmount;
if (entry.Header.TextParameters.ByteStartSpecified)
tParams.ByteStart = entry.Header.TextParameters.ByteStart;
if (entry.Header.TextParameters.ByteSkipData == null)
tParams.ByteSkipData = 0x00;
else
{
string sBSD = entry.Header.TextParameters.ByteSkipData;
if (sBSD.Substring(0, 2).Equals("0x"))
sBSD = sBSD.Substring(2);
if (!sBSD.Equals(string.Empty))
{
try
{
tParams.ByteSkipData = HiConvert.IntToByteArrayHexAsHex(Convert.ToInt32(sBSD), 1)[0];
}
catch { }
}
}
if (entry.Header.TextParameters.Offsets != null)
{
foreach (HiToTextEntryHeaderTextParametersOffsetsOffset o in entry.Header.TextParameters.Offsets.Offset)
{
Offset.FlagOffsets offsetFlag = GetOffsetFlag(o.Type);
string sByte = o.StartByte;
if (sByte.Substring(0, 2).Equals("0x"))
sByte = sByte.Substring(2);
int skipMod = 1;
if (o.SkipModifierSpecified)
skipMod = Convert.ToInt32(o.SkipModifier);
tParams.AddOffset(new Offset(
HiConvert.ByteArrayHexAsHexToInt(HiConvert.HexStringToByteArray(sByte)), skipMod, offsetFlag));
}
}
if (entry.Header.TextParameters.SpecialMapping != null)
{
foreach (HiToTextEntryHeaderTextParametersSpecialMappingMap map in entry.Header.TextParameters.SpecialMapping.Map)
{
char c = map.Char[0];
string sByte = map.Byte;
if (sByte.Substring(0, 2).Equals("0x"))
sByte = sByte.Substring(2);
byte b = HiConvert.HexStringToByteArray(sByte)[0];
tParams.AddMapping(c, b);
}
}
return tParams;
}
private VBA GetCustomName(string gName, TextDecodingParameters tParams, string data, string fName)
{
MethodInfo[] mInfos = typeof(HTTF.ConvertValuesToBytes).GetMethods(
BindingFlags.Public | BindingFlags.Static);
for (int i = 0; i < mInfos.Length; i++)
{
if (mInfos[i].Name.ToUpper().Equals(gName.ToUpper()))
return (VBA)mInfos[i].Invoke(null, new object[] { data, tParams, fName });
}
return null;
}
public static ConvertValueToByteArray apb(string data, TextDecodingParameters tParams, string fName)
{
byte[] dataname = ConvertName(tParams)(data);
switch (fName.ToUpper())
{
case "FIRSTNAME":
return delegate(string d) { return new byte[] { dataname[0] }; };
case "MIDDLENAME":
return delegate(string d) { return new byte[] { dataname[1] }; };
case "LASTNAME":
return delegate(string d) { return new byte[] { dataname[2] }; };
}
return delegate(string d) { return new byte[] { 0 }; };
}
