public static string RegionDirectory(string region_name) { FormatX.GetInt32(region_name, "L{X}R#", out int area); string loc = region_name.Substring(region_name.Length - 1, 1); return($"Location{area.ToString()}\\Region{loc.ToUpper()}"); }
/// <summary> /// Disperses all settings from the rim string passed. /// </summary> /// <param name="rim">Rim string to be dispersed.</param> /// <param name="brand">Brand of the rim.</param> /// <param name="style">Style of the rim brand.</param> /// <param name="size">Size of the rim brand.</param> /// <param name="max">Max outer size of the rim brand.</param> private void DisperseRimSettings(string rim) { bool potentialspi = false; if (rim.EndsWith("_SPI")) { potentialspi = true; rim = rim.Substring(0, rim.Length - 4); } this._rim_brand = FormatX.GetString(rim, "{X}_STYLE##_##_##"); if (!FormatX.GetByte(rim, this._rim_brand + "_STYLE{X}_##_##", out byte thisstyle)) { thisstyle = 1; } if (!FormatX.GetByte(rim, this._rim_brand + "_STYLE##_{X}_##", out byte thissize)) { thissize = 18; } if (!FormatX.GetByte(rim, this._rim_brand + "_STYLE##_##_{X}", out byte thismax)) { thismax = 24; } this._rim_style = thisstyle; this._rim_size = thissize; this._rim_outer_max = thismax; this._is_spinning_rim = potentialspi ? eBoolean.True : eBoolean.False; }
/// <summary> /// Gets pearl window tint string from a string passed. /// </summary> /// <param name="tint">String to get pearl window tint from.</param> /// <returns>Pearl tint string if was resolved, null otherwise.</returns> public static void GetWindowTintString(string tint) { try { if (!tint.StartsWith("WINDSHIELD_TINT")) { return; } if (!int.TryParse(tint.Substring(17, 1), out int level)) { return; } if (level == 3) { string color = FormatX.GetString(tint, "WINDSHIELD_TINT_L3_{X}"); string var1 = "WINDSHIELD_TINT_L3_PEARL_" + color; string var2 = "WINDSHIELD_TINT_L3_PEARL " + color; Map.WindowTintMap.Add(var1); Map.WindowTintMap.Add(var2); Bin.Hash(var1); Bin.Hash(var2); return; } else if (!Map.WindowTintMap.Contains(tint)) { Map.WindowTintMap.Add(tint); } } catch (Exception) { } }
/// <summary> /// Gets blue parameter of a hexadecimal color passed. /// </summary> /// <param name="color">Hexadecimal color passed.</param> /// <returns>Blue parameter as a byte.</returns> public static byte GetBlue(string color) { try { string hex = FormatX.GetString(color, "0xABCDEF{XX}"); return(Convert.ToByte(hex, 16)); } catch (Exception) { return(0); } }
public static bool CareerStageCollectionName(string CName) { if (!CName.StartsWith("STAGE_")) { return(false); } string index = FormatX.GetString(CName, "STAGE_{X}"); return(byte.TryParse(index, out byte _)); }
public unsafe void Assemble(byte *byteptr_t) { FormatX.GetByte(this._collection_name, "STAGE_{X}", out byte stage); *byteptr_t = stage; *(byteptr_t + 0x01) = this.NumberOfSponsorsToChoose; *(short *)(byteptr_t + 0x02) = this.OutrunCashValue; *(short *)(byteptr_t + 0x04) = this.Unknown0x04; *(short *)(byteptr_t + 0x06) = this.Unknown0x06; *(uint *)(byteptr_t + 0x08) = Bin.SmartHash(this._stage_sponsor1); *(uint *)(byteptr_t + 0x0C) = Bin.SmartHash(this._stage_sponsor2); *(uint *)(byteptr_t + 0x10) = Bin.SmartHash(this._stage_sponsor3); *(uint *)(byteptr_t + 0x14) = Bin.SmartHash(this._stage_sponsor4); *(uint *)(byteptr_t + 0x18) = Bin.SmartHash(this._stage_sponsor5); *(short *)(byteptr_t + 0x1C) = this.AttribSponsor1; *(short *)(byteptr_t + 0x1E) = this.AttribSponsor2; *(short *)(byteptr_t + 0x20) = this.AttribSponsor3; *(short *)(byteptr_t + 0x22) = this.AttribSponsor4; *(short *)(byteptr_t + 0x24) = this.AttribSponsor5; *(short *)(byteptr_t + 0x26) = this.Unknown0x26; *(uint *)(byteptr_t + 0x28) = Bin.SmartHash(this._last_stage_event); *(byteptr_t + 0x2C) = this.Unknown0x2C; *(byteptr_t + 0x2D) = this.Unknown0x2D; *(byteptr_t + 0x2E) = this.Unknown0x2E; *(byteptr_t + 0x2F) = this.Unknown0x2F; *(byteptr_t + 0x30) = this.MaxCircuitsShownOnMap; *(byteptr_t + 0x31) = this.MaxDragsShownOnMap; *(byteptr_t + 0x32) = this.MaxStreetXShownOnMap; *(byteptr_t + 0x33) = this.MaxDriftsShownOnMap; *(byteptr_t + 0x34) = this.MaxSprintsShownOnMap; *(byteptr_t + 0x35) = this.Unknown0x35; *(byteptr_t + 0x36) = this.Unknown0x36; *(byteptr_t + 0x37) = this.Unknown0x37; *(byteptr_t + 0x38) = this.Unknown0x38; *(byteptr_t + 0x39) = this.Unknown0x39; *(byteptr_t + 0x3A) = this.Unknown0x3A; *(byteptr_t + 0x3B) = this.Unknown0x3B; *(byteptr_t + 0x3C) = this.Unknown0x3C; *(byteptr_t + 0x3D) = this.Unknown0x3D; *(byteptr_t + 0x3E) = this.Unknown0x3E; *(byteptr_t + 0x3F) = this.Unknown0x3F; *(byteptr_t + 0x40) = this.MaxOutrunEvents; *(byteptr_t + 0x41) = this.Unknown0x41; *(byteptr_t + 0x42) = this.Unknown0x42; *(byteptr_t + 0x43) = this.Unknown0x43; *(float *)(byteptr_t + 0x44) = this.Unknown0x44; *(float *)(byteptr_t + 0x48) = this.Unknown0x48; *(float *)(byteptr_t + 0x4C) = this.Unknown0x4C; }
/// <summary> /// Disassembles frontend group array into separate properties. /// </summary> /// <param name="byteptr_t">Pointer to the frontend group array.</param> protected override unsafe void Disassemble(byte[] data) { this._DATA = new byte[data.Length]; Buffer.BlockCopy(data, 0, this._DATA, 0, data.Length); fixed(byte *byteptr_t = &this._DATA[0]) { this.Size = *(uint *)(byteptr_t + 4); // For some reason HUFF compression has the same ID as FEng files if (*(uint *)(byteptr_t + 8) == 0x46465548) { this.Destroy = true; return; } // Read CollectionName this.CollectionName = ScriptX.NullTerminatedString(byteptr_t + 0x30, this._DATA.Length - 0x30); if (this.CollectionName.EndsWith(".fng")) { this.CollectionName = FormatX.GetString(this.CollectionName, "{X}.fng"); } for (uint offset = 0x30; offset < this._DATA.Length; offset += 4) { byte b1 = *(byteptr_t + offset); byte b2 = *(byteptr_t + offset + 1); byte b3 = *(byteptr_t + offset + 2); byte b4 = *(byteptr_t + offset + 3); // SAT, SAD, SA(0x90) or 1111 if ((b1 == 'S' && b2 == 'A') || (b1 == 0xFF && b2 == 0xFF && b3 == 0xFF && b4 == 0xFF)) { uint Blue = *(uint *)(byteptr_t + offset + 4); uint Green = *(uint *)(byteptr_t + offset + 8); uint Red = *(uint *)(byteptr_t + offset + 12); uint Alpha = *(uint *)(byteptr_t + offset + 16); // If it is a color, add to the list if (Resolve.IsColor(Alpha, Red, Green, Blue)) { var TempColor = new FEngColor(this); TempColor.Offset = offset; TempColor.Alpha = (byte)Alpha; TempColor.Red = (byte)Red; TempColor.Green = (byte)Green; TempColor.Blue = (byte)Blue; this._colorinfo.Add(TempColor); } offset += 0x14; } } } }
public static bool TrackCollectionName(string CName) { // Allowed format: Track_#, where # is ushort if (!CName.StartsWith("Track_")) { return(false); } if (!FormatX.GetInt32(CName, "Track_{X}", out int result)) { return(false); } return(result <= ushort.MaxValue); }
public static bool BankTriggerCollectionName(string CName) { if (CName.Length != 15) { return(false); } if (!CName.StartsWith("BANK_TRIGGER_")) { return(false); } string index = FormatX.GetString(CName, "BANK_TRIGGER_{X}"); return(byte.TryParse(index, out byte _)); }
/// <summary> /// Sets first valid rim outer max radius based on current brand and style. /// </summary> private void SetValidRimSize() { string rim = $"{this._rim_brand}_STYLE{this._rim_style:00}"; foreach (var str in Map.RimBrands) { if (str.StartsWith(rim)) { if (FormatX.GetByte(str, rim + "_{X}_##", out byte radius)) { this._rim_size = radius; } } } }
/// <summary> /// Sets first valid rim outer max radius based on current brand, style and size. /// </summary> private void SetValidRimOuterMax() { string rim = $"{this._rim_brand}_STYLE{this._rim_style:00}_{this._rim_size}_"; foreach (var str in Map.RimBrands) { if (str.StartsWith(rim)) { if (FormatX.GetByte(str, rim + "{X}", out byte radius)) { this._rim_outer_max = radius; return; } } } }
/// <summary> /// Checks if a value passed is a valid rim size in terms of current /// brand and style. /// </summary> /// <param name="value">Rim size value to check.</param> /// <returns>True if value passed is valid, false otherwise.</returns> private bool IsValidRimSize(byte value) { string rim = $"{this._rim_brand}_STYLE{this._rim_style:00}_"; foreach (var str in Map.RimBrands) { if (str.StartsWith(rim)) { if (!FormatX.GetByte(str, rim + "{X}_##", out byte radius)) { continue; } if (value == radius) { return(true); } } } return(false); }
public static bool TrackRegionName(string region_name) { // Allowed format: L#R&, where # = int number, & = ascii char if (!region_name.StartsWith("L")) { return(false); } if (region_name.Substring(region_name.Length - 2, 1) != "R") { return(false); } if ((byte)region_name[region_name.Length - 1] > sbyte.MaxValue) { return(false); } if (!FormatX.GetInt32(region_name, "L{X}R#", out int result)) { return(false); } return(true); }
public static bool PartUnlockableCollectionName(string CName) { if (CName.Length != 10) { return(false); } if (!CName.StartsWith("CARPART_")) { return(false); } string index = FormatX.GetString(CName, "CARPART_{X}"); if (ConvertX.ToInt32(index) == 0) { return(false); } else { return(true); } }
/// <summary> /// Gets index from "Color[#]" string. /// </summary> /// <param name="field">String from which get the index.</param> /// <returns>Integer value of the index of the color.</returns> public static int GetIndex(string field) { int result = -1; if (!field.StartsWith("Color[")) { return(-1); } if (!field.EndsWith("]")) { return(-1); } try { string str = FormatX.GetString(field, "Color[{X}]"); if (!int.TryParse(str, out result)) { return(-1); } } catch { } return(result); }
public string EndTagToStartTag(string tag) { return(FormatX.GetString(tag, "/{X}")); }
private static string ExecuteUpdateFNG(BasicBase db, string node, string field, string value) { if (!db.TryGetCollection(node, FNGroups, out var collection)) { return($"Collection {node} does not exist in root {FNGroups}."); } if (!(collection is FNGroup fng)) { return($"Collection {node} is not a {FNGroups} collection."); } if (!SAT.CanBeColor(value)) { return($"Value {value} is not an 8-digit hexadecimal color-type."); } var color = new FEngColor(null); color.Alpha = SAT.GetAlpha(value); color.Red = SAT.GetRed(value); color.Green = SAT.GetGreen(value); color.Blue = SAT.GetBlue(value); if (field.StartsWith("ReplaceSame")) { if (field.StartsWith("ReplaceSameNoAlpha[") && field.EndsWith("]")) { if (FormatX.GetInt32(field, "ReplaceSameNoAlpha[{X}]", out int index)) { fng.TrySetSame(index, color, true); } else { return($"Unable to get color index from field named {field}."); } } else if (field.StartsWith("ReplaceSameWithAlpha[") && field.EndsWith("]")) { if (FormatX.GetInt32(field, "ReplaceSameWithAlpha[{X}]", out int index)) { fng.TrySetSame(index, color, false); } else { return($"Unable to get color index from field named {field}."); } } else { return($"Incorrect passed parameter named {field}."); } } else if (field == "ReplaceAllNoAlpha") { fng.TrySetAll(color, true); } else if (field == "ReplaceAllWithAlpha") { fng.TrySetAll(color, false); } else { int index = SAT.GetIndex(field); if (index >= fng.InfoLength || index == -1) { return($"Field named {field} does not exist."); } fng.TrySetOne(index, color); } return(null); }
public static string TrackDirectory(string region_name, string CName) { FormatX.GetInt32(region_name, "L{X}R#", out int area); return($"Location{area.ToString()}\\{CName}"); }
/// <summary> /// Loads Wheels files and reads its rim brand strings /// </summary> /// <param name="Wheels_dir">Directory of the game.</param> /// <param name="db">Database of classes.</param> /// <returns>True if success.</returns> public static unsafe bool LoadWheels(string Wheels_dir) { Wheels_dir += @"\CARS\WHEELS"; if (!Directory.Exists(Wheels_dir)) { if (Process.MessageShow) { MessageBox.Show(@"Directory CARS\WHEELS does not exist.", "Failure"); } else { Console.WriteLine(@"Directory CARS\WHEELS does not exist."); } return(false); } var files = Directory.GetFiles(Wheels_dir); if (files == null || files.Length == 0) { if (Process.MessageShow) { MessageBox.Show(@"Directory CARS\WHEELS is empty.", "Failure"); } else { Console.WriteLine(@"Directory CARS\WHEELS is empty."); } return(false); } foreach (var file in files) { string ext = Path.GetExtension(file).ToUpper(); if (!Path.GetFileName(file).StartsWith("GEOMETRY_") || (Path.GetExtension(file).ToUpper() != ".BIN")) { continue; } try { using (var br = new BinaryReader(File.Open(file, FileMode.Open, FileAccess.Read))) { if (br.ReadUInt32() != 0x80134000) { continue; // if not a wheels file } br.BaseStream.Position += 4; // skip size while (br.BaseStream.Position < br.BaseStream.Length) { uint ID = br.ReadUInt32(); int size = br.ReadInt32(); int off = (int)br.BaseStream.Position; if (ID != 0x80134010) { br.ReadBytes(size); continue; } while ((int)br.BaseStream.Position < off + size) { ID = br.ReadUInt32(); size = br.ReadInt32(); if (ID == 0x00134011) { break; } } if (ID != 0x00134011) { continue; } br.BaseStream.Position += 0xA4; string rim = ScriptX.NullTerminatedString(br); br.BaseStream.Position -= 0xB0 + rim.Length + 1; rim = FormatX.GetString(rim, "{X}_X"); if (!Map.RimBrands.Contains(rim)) { Map.RimBrands.Add(rim); } br.ReadBytes(br.ReadInt32()); } } } catch (Exception e) { while (e.InnerException != null) { e = e.InnerException; } if (Process.MessageShow) { MessageBox.Show(e.Message, "Failure"); } else { Console.WriteLine(e.Message); } return(false); } } foreach (var rim in Map.RimBrands) { Bin.Hash(rim); } return(true); }