Mirrors/PKHeX
2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-12-26 12:23:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
PKHeX/PKHeX.Core/Saves/Substructures/Gen8/MyStatus8.cs

186 lines
5.2 KiB
C#
Raw Normal View History

Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
using System;
Add Roto Rally score, copy Jersey # to other block Closes #2635
2020-01-16 04:48:19 +00:00
using System.Text;
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
using static System.Buffers.Binary.BinaryPrimitives;
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
namespace PKHeX.Core
{
sealed sealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealedsealed
2019-10-04 02:09:02 +00:00
public sealed class MyStatus8 : SaveBlock
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
{
Minor tweaks Extract some interfaces Suppress some warning messages with commented reasons if appropriate
2020-09-09 19:47:24 +00:00
public const uint MaxWatt = 9999999;
Sword/Shield Update
2019-11-16 01:34:18 +00:00
public MyStatus8(SAV8SWSH sav, SCBlock block) : base(sav, block.Data) { }
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
Add Roto Rally score, copy Jersey # to other block Closes #2635
2020-01-16 04:48:19 +00:00
public string Number
{
get => Encoding.ASCII.GetString(Data, 0x01, 3);
set
{
for (int i = 0; i < 3; i++)
Data[0x01 + i] = (byte)(value.Length > i ? value[i] : '\0');
Extract metadata/state tracking from SaveFile obj
2020-12-05 13:36:23 +00:00
SAV.State.Edited = true;
Add Roto Rally score, copy Jersey # to other block Closes #2635
2020-01-16 04:48:19 +00:00
}
}
Add more trainer card/status fields & stats Closes #2658 ty @CanoeHope ! Mostly just serves as documentation; with the amount of fields being editable increasing, hard-coded GUI might not be optimal here. I'm thinking something like a PropertyGrid based on the selected block which will pull up the Block object if the key matches... for fields, something like a dynamically populated list or something.
2020-01-24 02:31:10 +00:00
public ulong Skin // aka the base model
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x08));
set => WriteUInt64LittleEndian(Data.AsSpan(0x08), value);
Add more trainer card/status fields & stats Closes #2658 ty @CanoeHope ! Mostly just serves as documentation; with the amount of fields being editable increasing, hard-coded GUI might not be optimal here. I'm thinking something like a PropertyGrid based on the selected block which will pull up the Block object if the key matches... for fields, something like a dynamically populated list or something.
2020-01-24 02:31:10 +00:00
}
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
public ulong Hair
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x10));
set => WriteUInt64LittleEndian(Data.AsSpan(0x10), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Brow
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x18));
set => WriteUInt64LittleEndian(Data.AsSpan(0x18), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Lashes
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x20));
set => WriteUInt64LittleEndian(Data.AsSpan(0x20), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Contacts
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x28));
set => WriteUInt64LittleEndian(Data.AsSpan(0x28), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Lips
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x30));
set => WriteUInt64LittleEndian(Data.AsSpan(0x30), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Glasses
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x38));
set => WriteUInt64LittleEndian(Data.AsSpan(0x38), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Hat
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x40));
set => WriteUInt64LittleEndian(Data.AsSpan(0x40), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Jacket
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x48));
set => WriteUInt64LittleEndian(Data.AsSpan(0x48), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Top
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x50));
set => WriteUInt64LittleEndian(Data.AsSpan(0x50), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Bag
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x58));
set => WriteUInt64LittleEndian(Data.AsSpan(0x58), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Gloves
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x60));
set => WriteUInt64LittleEndian(Data.AsSpan(0x60), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
Fix property name typo https://github.com/kwsch/PKHeX/commit/efec331741c48ab0138be3b4079ea2a7a4e27621#r36246093 ty @AnalogMan151
2019-12-03 18:39:57 +00:00
public ulong BottomOrDress
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x68));
set => WriteUInt64LittleEndian(Data.AsSpan(0x68), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Sock
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x70));
set => WriteUInt64LittleEndian(Data.AsSpan(0x70), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
public ulong Shoe
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x78));
set => WriteUInt64LittleEndian(Data.AsSpan(0x78), value);
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
}
Add more trainer card/status fields & stats Closes #2658 ty @CanoeHope ! Mostly just serves as documentation; with the amount of fields being editable increasing, hard-coded GUI might not be optimal here. I'm thinking something like a PropertyGrid based on the selected block which will pull up the Block object if the key matches... for fields, something like a dynamically populated list or something.
2020-01-24 02:31:10 +00:00
// 80 - 87
public ulong MomSkin // aka the base model
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt64LittleEndian(Data.AsSpan(0x88));
set => WriteUInt64LittleEndian(Data.AsSpan(0x88), value);
Add more trainer card/status fields & stats Closes #2658 ty @CanoeHope ! Mostly just serves as documentation; with the amount of fields being editable increasing, hard-coded GUI might not be optimal here. I'm thinking something like a PropertyGrid based on the selected block which will pull up the Block object if the key matches... for fields, something like a dynamically populated list or something.
2020-01-24 02:31:10 +00:00
}
// 8C - 9F
add some customization options in MyStatus8 (#2552)
2019-12-02 21:40:09 +00:00
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
public int TID
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt16LittleEndian(Data.AsSpan(0xA0));
set => WriteUInt16LittleEndian(Data.AsSpan(0xA0), (ushort)value);
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
public int SID
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt16LittleEndian(Data.AsSpan(0xA2));
set => WriteUInt16LittleEndian(Data.AsSpan(0xA2), (ushort)value);
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
public int Game
{
Sword/Shield Update
2019-11-16 01:34:18 +00:00
get => Data[0xA4];
set => Data[0xA4] = (byte)value;
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
public int Gender
{
Sword/Shield Update
2019-11-16 01:34:18 +00:00
get => Data[0xA5];
set => Data[0xA5] = (byte)value;
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
Sword/Shield Update
2019-11-16 01:34:18 +00:00
// A6
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
public int Language
{
Sword/Shield Update
2019-11-16 01:34:18 +00:00
get => Data[Offset + 0xA7];
Rearrange key list, add syntax sugar methods
2020-01-18 05:53:51 +00:00
set
{
Decrement runtime language if appropriate Closes #2674
2020-02-04 03:16:30 +00:00
if (value == Language)
return;
Rearrange key list, add syntax sugar methods
2020-01-18 05:53:51 +00:00
Data[Offset + 0xA7] = (byte) value;
Decrement runtime language if appropriate Closes #2674
2020-02-04 03:16:30 +00:00
// For runtime language, the game shifts all languages above Language 6 (unused) down one.
if (value >= 6)
value--;
Add missing generation to accessor type name Now matches Interface declaration style (iAccessorGenGame), and is consistently named with the other accessors already using the same naming style plus they are now ordered in the file tree :) no functional change
2020-01-24 07:22:54 +00:00
((SAV8SWSH)SAV).SetValue(SaveBlockAccessor8SWSH.KGameLanguage, (uint)value);
Rearrange key list, add syntax sugar methods
2020-01-18 05:53:51 +00:00
}
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
private Span<byte> OT_Trash =>Data.AsSpan(0xB0, 0x1A);
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
public string OT
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => SAV.GetString(OT_Trash);
set => SAV.SetString(OT_Trash, value.AsSpan(), SAV.OTLength, StringConverterOption.ClearZero);
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
Add watt in trainer data editor (#2583)
2019-12-13 00:27:01 +00:00
// D0
public uint Watt
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
get => ReadUInt32LittleEndian(Data.AsSpan(Offset + 0xD0));
Add watt in trainer data editor (#2583)
2019-12-13 00:27:01 +00:00
set
{
if (value > MaxWatt)
value = MaxWatt;
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
WriteUInt32LittleEndian(Data.AsSpan(Offset + 0xD0), value);
Add watt in trainer data editor (#2583)
2019-12-13 00:27:01 +00:00
}
}
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
Fix property name typo https://github.com/kwsch/PKHeX/commit/efec331741c48ab0138be3b4079ea2a7a4e27621#r36246093 ty @AnalogMan151
2019-12-03 18:39:57 +00:00
}
Reference in a new issue Copy permalink