private bool ProcessObject(Table table, SaveReader reader, DatumIndex index, uint size, long offset) { if (!index.IsValid) { _objects.Add(null); return(true); } // Read the ObjectEntry and seek to the object's file offset ObjectEntry entry = new ObjectEntry(index, reader); long fileOffset = entry.ObjectAddress - table.Address + _entryTableOffset; reader.SeekTo(fileOffset); // Construct a specialized GameObject class depending on the tag group GameObject obj; switch (entry.TagGroup) { case TagGroup.Bipd: obj = new BipedObject(entry, reader); break; case TagGroup.Weap: obj = new WeaponObject(entry, reader); break; default: obj = new GameObject(entry, reader); break; } _objects.Add(obj); return(true); }
private static void DumpCharacterData(SaveReader saveData) { lock (outputLock) { sw.WriteLine(GetCharacterCSVData(saveData)); } }
/// <summary> /// Reads data from a SaveReader. Override this in a derived class to read object-specific data. /// </summary> /// <param name="reader">The SaveReader to read from. No guarantees can be made about its ending offset.</param> /// <param name="baseOffset">The offset of the start of the object data.</param> protected virtual void ReadFrom(SaveReader reader, long baseOffset) { _tag = DatumIndex.ReadFrom(reader); reader.SeekTo(baseOffset + StrengthInfoOffset); // Using the default Master Chief values is kind of hackish, // but at the same time it would be overkill to have a huge DB of original health/shield values. _healthInfo = new HealthInfo(reader, DefaultChiefHealthModifier, DefaultChiefShieldModifier); reader.SeekTo(baseOffset + PositionOffset1); _position.X = reader.ReadFloat(); _position.Y = reader.ReadFloat(); _position.Z = reader.ReadFloat(); reader.SeekTo(baseOffset + PositionOffset2); _unkPosition.X = reader.ReadFloat(); _unkPosition.Y = reader.ReadFloat(); _unkPosition.Z = reader.ReadFloat(); _unkPosition = Vector3.Subtract(_unkPosition, _position); reader.SeekTo(baseOffset + CarryInfoOffset); _nextCarriedIndex = DatumIndex.ReadFrom(reader); _firstCarriedIndex = DatumIndex.ReadFrom(reader); _carrierIndex = DatumIndex.ReadFrom(reader); }
/// <summary> /// Constructs a HealthInfo object, reading strength data from a SaveReader. /// </summary> /// <param name="reader">The SaveReader to read from.</param> /// <param name="defaultHealthModifier">The default health modifier that this object should use</param> /// <param name="defaultShieldModifier">The default shield modifier that this object should use</param> public HealthInfo(SaveReader reader, float defaultHealthModifier, float defaultShieldModifier, float customInfinity = float.NaN) { _customInvincibility = customInfinity; _healthModifier = reader.ReadFloat(); _shieldModifier = reader.ReadFloat(); //System.Diagnostics.Debug.WriteLine("{0:F} {1:F}", _healthModifier, _shieldModifier); // Keep backups of the values so that invincibility can be disabled // However, if a value is already NaN (invincible), we have to resort to the default value that was passed in. if (float.IsNaN(_healthModifier) || float.IsPositiveInfinity(_healthModifier) || _healthModifier == customInfinity) { _oldHealthModifier = defaultHealthModifier; } else { _oldHealthModifier = _healthModifier; } if (float.IsNaN(_shieldModifier) || float.IsPositiveInfinity(_shieldModifier) || _shieldModifier == customInfinity) { _oldShieldModifier = defaultShieldModifier; } else { _oldShieldModifier = _shieldModifier; } }
public ObjectEntry(DatumIndex index, SaveReader reader) { _index = index; _flags = reader.ReadByte(); _tagGroup = (TagGroup)reader.ReadByte(); reader.Skip(4); _chunkOffset = reader.ReadUInt32(); }
public BipedObject(ObjectEntry entry, SaveReader reader) : base(entry, reader) { if (entry.TagGroup != HCEX.TagGroup.Bipd) { throw new ArgumentException("Cannot construct a BipedObject from a non-Bipd object entry"); } }
protected override void ReadFrom(SaveReader reader, long baseOffset) { base.ReadFrom(reader, baseOffset); reader.SeekTo(baseOffset + AmmoOffset); _remainingAmmo = reader.ReadInt16(); _clipAmmo = reader.ReadInt16(); }
public WeaponObject(ObjectEntry entry, SaveReader reader) : base(entry, reader) { if (entry.TagGroup != Halo3ODST.TagGroup.Weap) { throw new ArgumentException("Cannot construct a WeaponObject from a non-Weap object entry"); } }
private void ClearPlayerData() { playerData = null; itemToEdit = null; RefreshCharacter(); RefreshInventory(); RefreshItemEditor(); }
/// <summary> /// Constructs a new ObjectEntry, reading it from a SaveReader. /// </summary> /// <param name="index">The object's datum index.</param> /// <param name="reader">The SaveReader to read from. It should point to the section of the table entry after the salt.</param> public ObjectEntry(DatumIndex index, SaveReader reader) { _index = index; _flags = reader.ReadByte(); _tagGroup = (TagGroup)reader.ReadByte(); reader.Skip(2); // Unknown value _chunkSize = reader.ReadUInt16(); _chunkAddress = reader.ReadUInt32(); }
public void TestHeaderDecrypt() { var h = SaveReader.GetSaveFileHeader((byte[])Header00C_3.Clone(), 3); h.Magic.Should().Be(0xC63E569C); h.EncryptedEntrySize.Should().Be(0x70840); h.DecryptedEntrySize.Should().Be(0x70810); h.SizeMaybe.Should().Be(0x30); }
/// <summary> /// Constructs a new Table and reads the header. /// </summary> /// <param name="reader"> /// The SaveReader to read from. It should be positioned at the start of the table header. /// When the function finishes, it will point to the first entry in the entry list (see the HeaderSize constant). /// </param> public Table(SaveReader reader) { _name = reader.ReadAscii(0x1E); reader.Skip(2); _entryCount = reader.ReadUInt32(); _entrySize = reader.ReadUInt32(); reader.Skip(0x28); _tableSizeWHeader = reader.ReadUInt32(); _tmpTableStartOffset = reader.Position; }
public void DumpSaveNames() { var arr = SaveReader.SaveFileNames; for (int i = 0; i < arr.Count; i++) { var index = SaveReader.GetIndex(arr[i]); index.Should().Be(i); } }
public void TestEntryDecrypt() { var e = SaveReader.GetSaveFileEntry((byte[])Entry000_0.Clone(), 0, 0); e.Magic.Should().Be(0x9B7A0B7C); e.AdlerChecksum.Should().Be(Adler32.ComputeChecksum(e.Data)); e.Crc32Checksum.Should().Be(Crc32.ComputeChecksum(e.Data)); e.DataSize.Should().Be(e.Data.Length); e.DataSizeDuplicate.Should().Be(e.Data.Length); }
/// <summary> /// Constructs a new GameObject based off of an ObjectEntry and data read from a SaveReader. /// </summary> /// <param name="entry">The ObjectEntry that corresponds to this object.</param> /// <param name="reader">The SaveRead to read from. It should be positioned at the start of the object data, after the link data.</param> public GameObject(ObjectEntry entry, SaveReader reader) { _entry = entry; // Read data long baseOffset = reader.Position; _streamOffset = baseOffset; ReadFrom(reader, baseOffset); }
public ActionResult <Response> Post(IFormFile file, string type) { byte[] data; try { using (var fs = file.OpenReadStream()) { data = new byte[fs.Length]; fs.Read(data, 0, (int)fs.Length); } } catch (Exception e) { return(new ErrorResponse(ErrorCode.INTERNAL_ERROR, e.Message, e.ToString())); } string errorMessage = ""; try { switch (type) { case null: goto default; case "charinfo": var charinfo = new CharInfo(); charinfo.Read(data); return(new SuccessResponse(charinfo)); case "charsave": var charsave = new SaveReader("1.13c"); charsave.Read(data); var charsaveResponse = new CharSaveResponse(charsave); return(new SuccessResponse(charsaveResponse)); case "charitem": var charitem = Item.NewItem(data); var charitemResponse = new CharItemResponse(charitem); return(new SuccessResponse(charitemResponse)); default: return(new ErrorResponse(ErrorCode.MISS_PARAM, "Type parameter is empty (allowed: charinfo, charsave, charitem)")); } } catch (EndOfStreamException e3) { return(new ErrorResponse(ErrorCode.NOT_SUPPORTED, e3.Message, file.Name)); } catch (Exception e3) { errorMessage += "\n\n" + e3.ToString(); } return(new ErrorResponse(ErrorCode.BAD_DATA, "Bad file format. Only charinfo, charsave and charitem are allowed.", errorMessage)); }
private bool ProcessPlayer(Table table, SaveReader reader, DatumIndex index, uint size, long offset) { if (!index.IsValid) { return(true); } ReadPlayerInfo(reader, offset); return(false); }
public Form1() { InitializeComponent(); _dirsReader = new DirsReader(); _saveReader = new SaveReader(_dirsReader.Find("Saves")); foreach (var item in _saveReader.values) { NumericUpDown nums = (NumericUpDown)Controls.Find(item.Item1, true)[0]; nums.Value = item.Item2; } }
public void UseClick(BodyState BodyData) { if (!BodyData.isLocked) { sm.saveState.bodyID = BodyData.id; SaveReader.bodyIndex = BodyData.id; sm.Save(); SaveReader.Load(); mm.UpdateMarket(); } }
public void UseClick(GunState GunData) { if (!GunData.isLocked) { sm.saveState.gunID = GunData.id; SaveReader.gunIndex = GunData.id; sm.Save(); SaveReader.Load(); mm.UpdateMarket(); } }
public void ErrorOnTruncatedHeader() { var reader = new StringReader("|MxDz;"); var buildHeaderReader = new SaveReader(reader); var exception = Assert.Throws <Exception>(() => { var buildHeader = buildHeaderReader.Read(); }); Assert.Equal("The header was truncated", exception.Message); }
private void Awake() { Instance = this; guns = Resources.LoadAll <GunState>("DataFiles/Guns"); bodies = Resources.LoadAll <BodyState>("DataFiles/Bodies"); Load(); SaveReader.LoadGun(guns); SaveReader.LoadBody(bodies); SaveReader.Load(saveState); DontDestroyOnLoad(gameObject); }
private void ReadPlayerInfo(SaveReader reader, long baseOffset) { reader.SeekTo(baseOffset + PlayerBipedOffset); _bipedIndex = DatumIndex.ReadFrom(reader); reader.Seek(baseOffset + 0x50, System.IO.SeekOrigin.Begin); _gamertag = reader.ReadUTF16(); reader.Seek(baseOffset + 0x86, System.IO.SeekOrigin.Begin); _serviceTag = reader.ReadUTF16(); }
public void Save() { if (PlayerPrefs.HasKey("Save")) { saveState = SaveReader.ReturnSave(); } FillItem(); PlayerPrefs.SetString("Save", SaveHelper.Serialize <SaveState>(saveState)); PlayerPrefs.SetString("Gun", SaveHelper.Serialize <bool[]>(gun)); PlayerPrefs.SetString("Body", SaveHelper.Serialize <bool[]>(body)); }
void GetReferencesFromScene() { flowchart = GameObject.FindObjectOfType <Flowchart>(); flowchartTransVar = flowchart.GetVariable <TransformVariable>("thisTrans"); gameSaver = GameObject.FindObjectOfType <GameSaver>(); gameLoader = GameObject.FindObjectOfType <GameLoader>(); saveManager = GameObject.FindObjectOfType <SaveManager>(); saveReader = saveManager.SaveReader; someInt = flowchart.GetVariable <IntegerVariable>("someInt"); GetRefsToGameObjects(); }
public void ErrorOnInvalidStart() { var reader = new StringReader("MxDz;"); var buildHeaderReader = new SaveReader(reader); var exception = Assert.Throws <Exception>(() => { var buildHeader = buildHeaderReader.Read(); }); Assert.Equal("The header is missing", exception.Message); }
public void BuyClick(GunState GunData, int index) { if (SaveReader.money >= GunData.cost && GunData.isLocked) { sm.guns[index].isLocked = false; GunData.isLocked = false; SaveReader.money -= GunData.cost; sm.Save(); SaveReader.Load(); mm.UpdateMarket(); } }
public void BuyClick(BodyState BodyData, int index) { if (SaveReader.money >= BodyData.cost && BodyData.isLocked) { sm.bodies[index].isLocked = false; BodyData.isLocked = false; SaveReader.money -= BodyData.cost; sm.Save(); SaveReader.Load(); mm.UpdateMarket(); } }
private bool ProcessPlayer(Table table, SaveReader reader, DatumIndex index, uint size, long offset) { if (!index.IsValid) { return(true); } ReadPlayerInfo(reader, offset); // Return false, we only need the first active entry return(false); }
/// <summary> /// Constructs a new Player object containing player information. /// </summary> /// <param name="reader">The SaveReader to read from. It must be positioned at the start of the players table.</param> /// <param name="objectResolver">The IDatumIndexResolver to use to resolve object indices.</param> public Player(SaveReader reader, IDatumIndexResolver <GameObject> objectResolver) { // Read the first entry from the players table Table playerTable = new Table(reader); if (playerTable.Name != "players") { throw new ArgumentException("Player info must be read from the \"players\" table. The save file may be corrupt."); } playerTable.ReadEntries(reader, ProcessPlayer); _biped = objectResolver.ResolveIndex(_bipedIndex) as BipedObject; }