Update coding style.

Magnum's type names are fine, but I'd rather limit what depends on
Magnum as much as possible. Vector types are still allowed, though. No
way I'll write my own.

src/Logger/Logger.cpp

@@ -25,8 +25,6 @@ using Utility::Debug;
 using Utility::Warning;
 using Utility::Error;
 
-using namespace Magnum;
-
 Logger&
 Logger::instance() {
     static Logger logger;
@@ -89,7 +87,7 @@ Logger::log(EntryType type, StringView location, StringView message) {
 
     d << "["_s << Debug::nospace << location << Debug::nospace << "]";
 
-    for(UnsignedInt i = 0; i < _indentLevel; i++) {
+    for(auto i = 0u; i < _indentLevel; i++) {
         d << Debug::nospace << "    "_s << Debug::nospace;
     }
 

src/Logger/Logger.h

@@ -27,8 +27,6 @@
 #include <Corrade/Containers/ArrayView.h>
 #include <Corrade/Utility/Format.h>
 
-#include <Magnum/Types.h>
-
 #include "EntryType.h"
 
 using namespace Corrade;
@@ -37,8 +35,6 @@ using Containers::ArrayView;
 using Containers::String;
 using Containers::StringView;
 
-using namespace Magnum;
-
 using namespace Containers::Literals;
 
 class Logger {
@@ -68,7 +64,7 @@ class Logger {
         std::ofstream _logFile;
         #endif
 
-        UnsignedInt _indentLevel = 0;
+        std::uint32_t _indentLevel = 0;
 
         std::mutex _logMutex{};
 };

src/Maps/Accessories.h

@@ -16,15 +16,14 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+#include <cstdint>
+
 #include <map>
 
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 using namespace Corrade;
 using namespace Containers::Literals;
-using namespace Magnum;
 
 enum AccessorySize {
     S,
@@ -38,7 +37,7 @@ struct AccessoryData{
     AccessorySize size = AccessorySize::S;
 };
 
-static const std::map<Int, AccessoryData> accessories {
+static const std::map<std::int32_t, AccessoryData> accessories {
     // region Primitives
     {1,  {"Cube"_s,           AccessorySize::S}},
     {2,  {"Pentagon"_s,       AccessorySize::S}},

src/Maps/ArmourSets.h

@@ -16,22 +16,21 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+#include <cstdint>
+
 #include <map>
 
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 using namespace Corrade;
 using namespace Containers::Literals;
-using namespace Magnum;
 
 struct ArmourSet {
     Containers::StringView name;
     bool neck_compatible;
 };
 
-static const std::map<Int, ArmourSet> armour_sets {
+static const std::map<std::int32_t, ArmourSet> armour_sets {
     {-1, {"<unequipped>"_s,      true}},
     {0,  {"Vanguard"_s,          true}},
     {1,  {"Assault Mk.I"_s,      true}},

src/Maps/LastMissionId.h

@@ -20,13 +20,10 @@
 
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 using namespace Corrade;
 using namespace Containers::Literals;
-using namespace Magnum;
 
-static const std::map<Int, Containers::StringView> mission_id_map {{
+static const std::map<std::int32_t, Containers::StringView> mission_id_map {{
     // Story missions
     {0x0064, "Mission 1 - Training"_s},
     {0x0065, "Mission 2 - Patrol Operation"_s},

src/Maps/StoryProgress.h

@@ -19,14 +19,11 @@
 #include <Corrade/Containers/Array.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 using namespace Corrade;
 using namespace Containers::Literals;
-using namespace Magnum;
 
 struct StoryProgressPoint {
-    Int id;
+    std::int32_t id;
     Containers::StringView chapter;
     Containers::StringView point;
     Containers::StringView after = nullptr;

src/Maps/StyleNames.h

@@ -16,17 +16,16 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+#include <cstdint>
+
 #include <map>
 
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Magnum.h>
-
 using namespace Corrade;
 using namespace Containers::Literals;
-using namespace Magnum;
 
-extern const std::map<Int, Containers::StringView> style_names
+extern const std::map<std::int32_t, Containers::StringView> style_names
 #ifdef STYLENAMES_DEFINITION
 {
     {0,  "Custom Style 1"_s},

src/Maps/WeaponParts.h

@@ -15,19 +15,18 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+#include <cstdint>
+
 #include <map>
 
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 using namespace Corrade;
-using namespace Magnum;
 
 using namespace Containers::Literals;
 
 // region Melee
-static const std::map<Int, Containers::StringView> melee_grips {
+static const std::map<std::int32_t, Containers::StringView> melee_grips {
     {0, "Combat Grip (1H)"_s},
     {1, "Knuckle Guard Grip (1H)"_s},
     {2, "Dual Guard Grip (1H)"_s},
@@ -78,7 +77,7 @@ static const std::map<Int, Containers::StringView> melee_grips {
     {2404, "Arched Twin Blade (2H)"_s},
 };
 
-static const std::map<Int, Containers::StringView> melee_assaulters {
+static const std::map<std::int32_t, Containers::StringView> melee_assaulters {
     {0,  "Long Metal Blade"_s},
     {1,  "Long Assault Blade"_s},
     {2,  "Long Fin Blade"_s},
@@ -172,7 +171,7 @@ static const std::map<Int, Containers::StringView> melee_assaulters {
 // endregion
 
 // region Shields
-static const std::map<Int, Containers::StringView> shield_handles {
+static const std::map<std::int32_t, Containers::StringView> shield_handles {
     {0,  "Balanced Handle"_s},
     {1,  "Expanded Handle"_s},
     {2,  "Lowguard Handle"_s},
@@ -191,7 +190,7 @@ static const std::map<Int, Containers::StringView> shield_handles {
     {101, "Star Handle"_s},
 };
 
-static const std::map<Int, Containers::StringView> shield_shells {
+static const std::map<std::int32_t, Containers::StringView> shield_shells {
     {0,  "Balanced Shell"_s},
     {1,  "Compass Shell"_s},
     {2,  "Uppoint Shell"_s},
@@ -212,7 +211,7 @@ static const std::map<Int, Containers::StringView> shield_shells {
 // endregion
 
 // region Bullet Shooters
-static const std::map<Int, Containers::StringView> bshooter_triggers {
+static const std::map<std::int32_t, Containers::StringView> bshooter_triggers {
     {0,  "BL-Combat Trigger (1H)"_s},
     {1,  "Light Machine Trigger (1H)"_s},
     {2,  "Tactical Trigger (1H)"_s},
@@ -230,7 +229,7 @@ static const std::map<Int, Containers::StringView> bshooter_triggers {
     {199, "2H Base Trigger (2H)"_s},
 };
 
-static const std::map<Int, Containers::StringView> bshooter_barrels {
+static const std::map<std::int32_t, Containers::StringView> bshooter_barrels {
     {0,  "BL-Combat Barrel (1 shot)"_s},
     {1,  "Shock Absorb Barrel (1 shot) (Motion)"_s},
     {2,  "Muzzlemod Barrel (1 shot)"_s},
@@ -267,7 +266,7 @@ static const std::map<Int, Containers::StringView> bshooter_barrels {
 // endregion
 
 //region Energy Shooters
-static const std::map<Int, Containers::StringView> eshooter_triggers {
+static const std::map<std::int32_t, Containers::StringView> eshooter_triggers {
     {0,  "EN-Rifle Trigger (1H)"_s},
     {1,  "Underarm Trigger (1H)"_s},
     {2,  "EN-Inverted Trigger (1H)"_s},
@@ -285,7 +284,7 @@ static const std::map<Int, Containers::StringView> eshooter_triggers {
     {199, "2H Base EnTrigger (2H)"_s},
 };
 
-static const std::map<Int, Containers::StringView> eshooter_busters {
+static const std::map<std::int32_t, Containers::StringView> eshooter_busters {
     {0,  "EN-Combat Buster (1 shot)"_s},
     {1,  "Delta Cycler (1 shot) (Motion)"_s},
     {2,  "EN-Longbarrel Buster (1 shot)"_s},
@@ -321,7 +320,7 @@ static const std::map<Int, Containers::StringView> eshooter_busters {
 // endregion
 
 // region Bullet Launchers
-static const std::map<Int, Containers::StringView> blauncher_pods {
+static const std::map<std::int32_t, Containers::StringView> blauncher_pods {
     {0,  "BL-Delta Pack Launcher (Missile x12)"_s},
     {1,  "BL-Twin Pack Launcher (Missile x12)"_s},
     {2,  "Detector Launcher (Missile x12)"_s},
@@ -351,7 +350,7 @@ static const std::map<Int, Containers::StringView> blauncher_pods {
     {399, "C Base Pod (Cluster x40)"_s},
 };
 
-static const std::map<Int, Containers::StringView> blauncher_projectiles {
+static const std::map<std::int32_t, Containers::StringView> blauncher_projectiles {
     {0, "Flathead Missile"_s},
     {1, "Warhead Missile"_s},
     {2, "Pointhead Missile"_s},
@@ -361,7 +360,7 @@ static const std::map<Int, Containers::StringView> blauncher_projectiles {
 // endregion
 
 // region Energy Launchers
-static const std::map<Int, Containers::StringView> elauncher_generators {
+static const std::map<std::int32_t, Containers::StringView> elauncher_generators {
     {0,  "Fly Unit"_s},
     {1,  "Assault Unit (Motion)"_s},
     {2,  "Falcon Unit"_s},
@@ -393,7 +392,7 @@ static const std::map<Int, Containers::StringView> elauncher_generators {
     {99, "Base Generator"},
 };
 
-static const std::map<Int, Containers::StringView> elauncher_pods {
+static const std::map<std::int32_t, Containers::StringView> elauncher_pods {
     {0,  "EN-Dual Claw Launcher (Echo) (Motion)"_s},
     {1,  "EN-Assault Launcher (Echo)"_s},
     {2,  "EN-Tactical Launcher (Echo)"_s},

src/Mass/Accessory.h

@@ -25,9 +25,9 @@ using namespace Corrade;
 using namespace Magnum;
 
 struct Accessory {
-    Int attachIndex = -1;
+    std::int32_t attachIndex = -1;
-    Int id = -1;
+    std::int32_t id = -1;
-    Containers::StaticArray<2, Int> styles{ValueInit};
+    Containers::StaticArray<2, std::int32_t> styles{ValueInit};
     Vector3 relativePosition{0.0f};
     Vector3 relativePositionOffset{0.0f};
     Vector3 relativeRotation{0.0f};

src/Mass/ArmourPart.h

@@ -19,13 +19,10 @@
 #include <Corrade/Containers/Array.h>
 #include <Corrade/Containers/StaticArray.h>
 
-#include <Magnum/Types.h>
-
 #include "Decal.h"
 #include "Accessory.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 enum class ArmourSlot {
     #define c(enumerator, enumstr, name) enumerator,
@@ -35,8 +32,8 @@ enum class ArmourSlot {
 
 struct ArmourPart {
     ArmourSlot slot = ArmourSlot::Face;
-    Int id = 0;
+    std::int32_t id = 0;
-    Containers::StaticArray<4, Int> styles{ValueInit};
+    Containers::StaticArray<4, std::int32_t> styles{ValueInit};
     Containers::Array<Decal> decals;
     Containers::Array<Accessory> accessories;
 };

src/Mass/CustomStyle.h

@@ -28,13 +28,13 @@ using namespace Magnum;
 struct CustomStyle {
     Containers::String name;
     Color4 colour{0.0f};
-    Float metallic = 0.5f;
+    float metallic = 0.5f;
-    Float gloss = 0.5f;
+    float gloss = 0.5f;
     bool glow = false;
 
-    Int patternId = 0;
+    std::int32_t patternId = 0;
-    Float opacity = 0.5f;
+    float opacity = 0.5f;
     Vector2 offset{0.5f};
-    Float rotation = 0.0f;
+    float rotation = 0.0f;
-    Float scale = 0.5f;
+    float scale = 0.5f;
 };

src/Mass/Decal.h

@@ -19,18 +19,19 @@
 #include <Magnum/Magnum.h>
 #include <Magnum/Math/Color.h>
 #include <Magnum/Math/Vector2.h>
+#include <Magnum/Math/Vector3.h>
 
 using namespace Magnum;
 
 struct Decal {
-    Int id = -1;
+    std::int32_t id = -1;
     Color4 colour{0.0f};
     Vector3 position{0.0f};
     Vector3 uAxis{0.0f};
     Vector3 vAxis{0.0f};
     Vector2 offset{0.5f};
-    Float scale = 0.5f;
+    float scale = 0.5f;
-    Float rotation = 0.0f;
+    float rotation = 0.0f;
     bool flip = false;
     bool wrap = false;
 };

src/Mass/Joints.h

@@ -16,17 +16,13 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-#include <Magnum/Types.h>
-
-using namespace Magnum;
-
 struct Joints {
-    Float neck      = 0.0f;
+    float neck      = 0.0f;
-    Float body      = 0.0f;
+    float body      = 0.0f;
-    Float shoulders = 0.0f;
+    float shoulders = 0.0f;
-    Float hips      = 0.0f;
+    float hips      = 0.0f;
-    Float upperArms = 0.0f;
+    float upperArms = 0.0f;
-    Float lowerArms = 0.0f;
+    float lowerArms = 0.0f;
-    Float upperLegs = 0.0f;
+    float upperLegs = 0.0f;
-    Float lowerLegs = 0.0f;
+    float lowerLegs = 0.0f;
 };

src/Mass/Mass.cpp

@@ -308,32 +308,32 @@ Mass::getTuning() {
     }
 }
 
-Int&
+std::int32_t&
 Mass::engine() {
     return _tuning.engineId;
 }
 
-Containers::ArrayView<Int>
+Containers::ArrayView<std::int32_t>
 Mass::gears() {
     return _tuning.gearIds;
 }
 
-Int&
+std::int32_t&
 Mass::os() {
     return _tuning.osId;
 }
 
-Containers::ArrayView<Int>
+Containers::ArrayView<std::int32_t>
 Mass::modules() {
     return _tuning.moduleIds;
 }
 
-Int&
+std::int32_t&
 Mass::architecture() {
     return _tuning.archId;
 }
 
-Containers::ArrayView<Int>
+Containers::ArrayView<std::int32_t>
 Mass::techs() {
     return _tuning.techIds;
 }
@@ -365,8 +365,9 @@ Mass::updateAccount(Containers::StringView new_account) {
 }
 
 void
-Mass::getTuningCategory(Containers::StringView big_node_prop_name, Int& big_node_id,
+Mass::getTuningCategory(Containers::StringView big_node_prop_name, std::int32_t& big_node_id,
-                        Containers::StringView small_nodes_prop_name, Containers::ArrayView<Int> small_nodes_ids)
+                        Containers::StringView small_nodes_prop_name,
+                        Containers::ArrayView<std::int32_t> small_nodes_ids)
 {
     LOG_INFO_FORMAT("Getting tuning data ({}, {}).", big_node_prop_name, small_nodes_prop_name);
 
@@ -392,7 +393,7 @@ Mass::getTuningCategory(Containers::StringView big_node_prop_name, Int& big_node
         return;
     }
 
-    for(UnsignedInt i = 0; i < small_nodes_ids.size(); i++) {
+    for(std::uint32_t i = 0; i < small_nodes_ids.size(); i++) {
         auto small_node_id = node_ids->at<IntProperty>(i);
         CORRADE_INTERNAL_ASSERT(small_node_id);
         small_nodes_ids[i] = small_node_id->value;

src/Mass/Mass.h

@@ -64,7 +64,7 @@ class Mass {
         Containers::StringView name();
         bool setName(Containers::StringView new_name);
 
-        enum class State : UnsignedByte {
+        enum class State: std::uint8_t {
             Empty, Invalid, Valid
         };
 
@@ -77,7 +77,7 @@ class Mass {
         void getJointSliders();
         bool writeJointSliders();
 
-        Containers::ArrayView<Int> frameStyles();
+        Containers::ArrayView<std::int32_t> frameStyles();
         void getFrameStyles();
         bool writeFrameStyles();
 
@@ -87,7 +87,7 @@ class Mass {
 
         Containers::ArrayView<CustomStyle> frameCustomStyles();
         void getFrameCustomStyles();
-        bool writeFrameCustomStyle(UnsignedLong index);
+        bool writeFrameCustomStyle(std::size_t index);
 
         Containers::ArrayView<ArmourPart> armourParts();
         void getArmourParts();
@@ -100,7 +100,7 @@ class Mass {
 
         Containers::ArrayView<CustomStyle> armourCustomStyles();
         void getArmourCustomStyles();
-        bool writeArmourCustomStyle(UnsignedLong index);
+        bool writeArmourCustomStyle(std::size_t index);
 
         Containers::ArrayView<Weapon> meleeWeapons();
         void getMeleeWeapons();
@@ -128,25 +128,25 @@ class Mass {
 
         Containers::ArrayView<CustomStyle> globalStyles();
         void getGlobalStyles();
-        bool writeGlobalStyle(UnsignedLong index);
+        bool writeGlobalStyle(std::size_t index);
 
         void getTuning();
 
-        Int& engine();
+        std::int32_t& engine();
-        Containers::ArrayView<Int> gears();
+        Containers::ArrayView<std::int32_t> gears();
 
-        Int& os();
+        std::int32_t& os();
-        Containers::ArrayView<Int> modules();
+        Containers::ArrayView<std::int32_t> modules();
 
-        Int& architecture();
+        std::int32_t& architecture();
-        Containers::ArrayView<Int> techs();
+        Containers::ArrayView<std::int32_t> techs();
 
         Containers::StringView account();
         bool updateAccount(Containers::StringView new_account);
 
     private:
         void getCustomStyles(Containers::ArrayView<CustomStyle> styles, ArrayProperty* style_array);
-        bool writeCustomStyle(const CustomStyle& style, UnsignedLong index, ArrayProperty* style_array);
+        bool writeCustomStyle(const CustomStyle& style, std::size_t index, ArrayProperty* style_array);
 
         void getDecals(Containers::ArrayView<Decal> decals, ArrayProperty* decal_array);
         void writeDecals(Containers::ArrayView<Decal> decals, ArrayProperty* decal_array);
@@ -157,8 +157,9 @@ class Mass {
         void getWeaponType(Containers::StringView prop_name, Containers::ArrayView<Weapon> weapon_array);
         bool writeWeaponType(Containers::StringView prop_name, Containers::ArrayView<Weapon> weapon_array);
 
-        void getTuningCategory(Containers::StringView big_node_prop_name, Int& big_node_id,
+        void getTuningCategory(Containers::StringView big_node_prop_name, std::int32_t& big_node_id,
-                               Containers::StringView small_nodes_prop_name, Containers::ArrayView<Int> small_nodes_ids);
+                               Containers::StringView small_nodes_prop_name,
+                               Containers::ArrayView<std::int32_t> small_nodes_ids);
 
         Containers::Optional<UESaveFile> _mass;
 
@@ -174,7 +175,7 @@ class Mass {
 
         struct {
             Joints joints{};
-            Containers::StaticArray<4, Int> styles{ValueInit};
+            Containers::StaticArray<4, std::int32_t> styles{ValueInit};
             Color4 eyeFlare{0.0f};
             Containers::StaticArray<16, CustomStyle> customStyles;
         } _frame;
@@ -198,14 +199,14 @@ class Mass {
         Containers::Array<CustomStyle> _globalStyles;
 
         struct {
-            Int engineId;
+            std::int32_t engineId;
-            Containers::StaticArray<7, Int> gearIds;
+            Containers::StaticArray<7, std::int32_t> gearIds;
 
-            Int osId;
+            std::int32_t osId;
-            Containers::StaticArray<7, Int> moduleIds;
+            Containers::StaticArray<7, std::int32_t> moduleIds;
 
-            Int archId;
+            std::int32_t archId;
-            Containers::StaticArray<7, Int> techIds;
+            Containers::StaticArray<7, std::int32_t> techIds;
         } _tuning;
 
         Containers::String _account;

src/Mass/Mass_Armour.cpp

@@ -59,7 +59,7 @@ Mass::getArmourParts() {
         return;
     }
 
-    for(UnsignedInt i = 0; i < armour_array->items.size(); i++) {
+    for(std::uint32_t i = 0; i < armour_array->items.size(); i++) {
         auto part_prop = armour_array->at<GenericStructProperty>(i);
         auto& part = _armour.parts[i];
 
@@ -89,7 +89,7 @@ Mass::getArmourParts() {
             return;
         }
 
-        for(UnsignedInt j = 0; j < part_styles->items.size(); j++) {
+        for(std::uint32_t j = 0; j < part_styles->items.size(); j++) {
             part.styles[j] = part_styles->at<IntProperty>(j)->value;
         }
 
@@ -152,7 +152,7 @@ Mass::writeArmourPart(ArmourSlot slot) {
 
     GenericStructProperty* part_prop = nullptr;
 
-    for(UnsignedInt i = 0; i < armour_array->items.size(); i++) {
+    for(std::uint32_t i = 0; i < armour_array->items.size(); i++) {
         part_prop = armour_array->at<GenericStructProperty>(i);
         if(slot_str == part_prop->at<ByteProperty>(MASS_ARMOUR_SLOT)->enumValue) {
             break;
@@ -178,7 +178,7 @@ Mass::writeArmourPart(ArmourSlot slot) {
     part_prop->at<IntProperty>(MASS_ARMOUR_ID)->value = part.id;
 
     auto part_styles = part_prop->at<ArrayProperty>(MASS_ARMOUR_STYLES);
-    for(UnsignedInt i = 0; i < part.styles.size(); i++) {
+    for(std::uint32_t i = 0; i < part.styles.size(); i++) {
         part_styles->at<IntProperty>(i)->value = part.styles[i];
     }
 
@@ -238,7 +238,7 @@ Mass::getBulletLauncherAttachments() {
     if(attach_array->items.size() == _weapons.bulletLaunchers.size() &&
        attach_array->items.size() == _armour.blAttachment.size())
     {
-        for(UnsignedInt i = 0; i < attach_array->items.size(); i++) {
+        for(std::uint32_t i = 0; i < attach_array->items.size(); i++) {
             auto attachment_prop = attach_array->at<GenericStructProperty>(i);
             auto& attachment = _armour.blAttachment[i];
 
@@ -313,7 +313,7 @@ Mass::writeBulletLauncherAttachments() {
     if(attach_array->items.size() == _weapons.bulletLaunchers.size() &&
        attach_array->items.size() == _armour.blAttachment.size())
     {
-        for(UnsignedInt i = 0; i < attach_array->items.size(); i++) {
+        for(std::uint32_t i = 0; i < attach_array->items.size(); i++) {
             auto attachment_prop = attach_array->at<GenericStructProperty>(i);
             auto& attachment = _armour.blAttachment[i];
 
@@ -414,7 +414,7 @@ Mass::getArmourCustomStyles() {
 }
 
 bool
-Mass::writeArmourCustomStyle(UnsignedLong index) {
+Mass::writeArmourCustomStyle(std::size_t index) {
     LOG_INFO_FORMAT("Writing custom armour style {}.", index);
 
     if(index > _armour.customStyles.size()) {

src/Mass/Mass_DecalsAccessories.cpp

@@ -31,7 +31,7 @@ using namespace Containers::Literals;
 
 void
 Mass::getDecals(Containers::ArrayView<Decal> decals, ArrayProperty* decal_array) {
-    for(UnsignedInt i = 0; i < decal_array->items.size(); i++) {
+    for(std::uint32_t i = 0; i < decal_array->items.size(); i++) {
         auto decal_prop = decal_array->at<GenericStructProperty>(i);
         CORRADE_INTERNAL_ASSERT(decal_prop);
         auto& decal = decals[i];
@@ -56,7 +56,7 @@ Mass::getDecals(Containers::ArrayView<Decal> decals, ArrayProperty* decal_array)
 
 void
 Mass::writeDecals(Containers::ArrayView<Decal> decals, ArrayProperty* decal_array) {
-    for(UnsignedInt i = 0; i < decal_array->items.size(); i++) {
+    for(std::uint32_t i = 0; i < decal_array->items.size(); i++) {
         auto decal_prop = decal_array->at<GenericStructProperty>(i);
         CORRADE_INTERNAL_ASSERT(decal_prop);
         auto& decal = decals[i];
@@ -91,7 +91,7 @@ Mass::writeDecals(Containers::ArrayView<Decal> decals, ArrayProperty* decal_arra
 
 void
 Mass::getAccessories(Containers::ArrayView<Accessory> accessories, ArrayProperty* accessory_array) {
-    for(UnsignedInt i = 0; i < accessory_array->items.size(); i++) {
+    for(std::uint32_t i = 0; i < accessory_array->items.size(); i++) {
         auto acc_prop = accessory_array->at<GenericStructProperty>(i);
         CORRADE_INTERNAL_ASSERT(acc_prop);
         auto& accessory = accessories[i];
@@ -99,7 +99,7 @@ Mass::getAccessories(Containers::ArrayView<Accessory> accessories, ArrayProperty
         accessory.attachIndex = acc_prop->at<IntProperty>(MASS_ACCESSORY_ATTACH_INDEX)->value;
         accessory.id = acc_prop->at<IntProperty>(MASS_ACCESSORY_ID)->value;
         auto acc_styles = acc_prop->at<ArrayProperty>(MASS_ACCESSORY_STYLES);
-        for(UnsignedInt j = 0; j < acc_styles->items.size(); j++) {
+        for(std::uint32_t j = 0; j < acc_styles->items.size(); j++) {
             accessory.styles[j] = acc_styles->at<IntProperty>(j)->value;
         }
         auto rel_pos_prop = acc_prop->at<VectorStructProperty>(MASS_ACCESSORY_RELPOS);
@@ -117,7 +117,7 @@ Mass::getAccessories(Containers::ArrayView<Accessory> accessories, ArrayProperty
 
 void
 Mass::writeAccessories(Containers::ArrayView<Accessory> accessories, ArrayProperty* accs_array) {
-    for(UnsignedInt i = 0; i < accs_array->items.size(); i++) {
+    for(std::uint32_t i = 0; i < accs_array->items.size(); i++) {
         auto acc_prop = accs_array->at<GenericStructProperty>(i);
         CORRADE_INTERNAL_ASSERT(acc_prop);
         auto& accessory = accessories[i];
@@ -125,7 +125,7 @@ Mass::writeAccessories(Containers::ArrayView<Accessory> accessories, ArrayProper
         acc_prop->at<IntProperty>(MASS_ACCESSORY_ATTACH_INDEX)->value = accessory.attachIndex;
         acc_prop->at<IntProperty>(MASS_ACCESSORY_ID)->value = accessory.id;
         auto acc_styles = acc_prop->at<ArrayProperty>(MASS_ACCESSORY_STYLES);
-        for(UnsignedInt j = 0; j < acc_styles->items.size(); j++) {
+        for(std::uint32_t j = 0; j < acc_styles->items.size(); j++) {
             acc_styles->at<IntProperty>(j)->value = accessory.styles[j];
         }
         auto rel_pos_prop = acc_prop->at<VectorStructProperty>(MASS_ACCESSORY_RELPOS);

src/Mass/Mass_Frame.cpp

@@ -184,7 +184,7 @@ Mass::writeJointSliders() {
     return true;
 }
 
-Containers::ArrayView<Int>
+Containers::ArrayView<std::int32_t>
 Mass::frameStyles() {
     return _frame.styles;
 }
@@ -221,7 +221,7 @@ Mass::getFrameStyles() {
         return;
     }
 
-    for(UnsignedInt i = 0; i < frame_styles->items.size(); i++) {
+    for(std::uint32_t i = 0; i < frame_styles->items.size(); i++) {
         _frame.styles[i] = frame_styles->at<IntProperty>(i)->value;
     }
 }
@@ -254,7 +254,7 @@ Mass::writeFrameStyles() {
         return false;
     }
 
-    for(UnsignedInt i = 0; i < frame_styles->items.size(); i++) {
+    for(std::uint32_t i = 0; i < frame_styles->items.size(); i++) {
         frame_styles->at<IntProperty>(i)->value = _frame.styles[i];
     }
 
@@ -374,7 +374,7 @@ Mass::getFrameCustomStyles() {
 }
 
 bool
-Mass::writeFrameCustomStyle(UnsignedLong index) {
+Mass::writeFrameCustomStyle(std::size_t index) {
     LOG_INFO_FORMAT("Writing frame custom style number {}.", index);
 
     if(index > _frame.customStyles.size()) {

src/Mass/Mass_Styles.cpp

@@ -58,7 +58,7 @@ Mass::getGlobalStyles() {
 }
 
 bool
-Mass::writeGlobalStyle(UnsignedLong index) {
+Mass::writeGlobalStyle(std::size_t index) {
     LOG_INFO_FORMAT("Writing global style number {}.", index);
 
     if(index > _globalStyles.size()) {
@@ -88,7 +88,7 @@ Mass::writeGlobalStyle(UnsignedLong index) {
 
 void
 Mass::getCustomStyles(Containers::ArrayView<CustomStyle> styles, ArrayProperty* style_array) {
-    for(UnsignedInt i = 0; i < style_array->items.size(); i++) {
+    for(std::uint32_t i = 0; i < style_array->items.size(); i++) {
         auto style_prop = style_array->at<GenericStructProperty>(i);
         auto& style = styles[i];
 
@@ -111,7 +111,7 @@ Mass::getCustomStyles(Containers::ArrayView<CustomStyle> styles, ArrayProperty*
 }
 
 bool
-Mass::writeCustomStyle(const CustomStyle& style, UnsignedLong index, ArrayProperty* style_array) {
+Mass::writeCustomStyle(const CustomStyle& style, std::size_t index, ArrayProperty* style_array) {
     if(!style_array) {
         _lastError = "style_array is null."_s;
         LOG_ERROR(_lastError);

src/Mass/Mass_Weapons.cpp

@@ -153,7 +153,7 @@ Mass::getWeaponType(Containers::StringView prop_name, Containers::ArrayView<Weap
         return;
     }
 
-    for(UnsignedInt i = 0; i < weapon_array.size(); i++) {
+    for(std::uint32_t i = 0; i < weapon_array.size(); i++) {
         auto weapon_prop = prop->at<GenericStructProperty>(i);
         auto& weapon = weapon_array[i];
 
@@ -171,14 +171,14 @@ Mass::getWeaponType(Containers::StringView prop_name, Containers::ArrayView<Weap
         auto parts_prop = weapon_prop->at<ArrayProperty>(MASS_WEAPON_ELEMENT);
         weapon.parts = Containers::Array<WeaponPart>{ValueInit, parts_prop->items.size()};
 
-        for(UnsignedInt j = 0; j < parts_prop->items.size(); j++) {
+        for(std::uint32_t j = 0; j < parts_prop->items.size(); j++) {
             auto part_prop = parts_prop->at<GenericStructProperty>(j);
             auto& part = weapon.parts[j];
 
             part.id = part_prop->at<IntProperty>(MASS_WEAPON_PART_ID)->value;
 
             auto part_styles = part_prop->at<ArrayProperty>(MASS_WEAPON_PART_STYLES);
-            for(UnsignedInt k = 0; k < part_styles->items.size(); k++) {
+            for(std::uint32_t k = 0; k < part_styles->items.size(); k++) {
                 part.styles[k] = part_styles->at<IntProperty>(k)->value;
             }
 
@@ -268,7 +268,7 @@ Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayView<We
         return false;
     }
 
-    for(UnsignedInt i = 0; i < weapon_array.size(); i++) {
+    for(std::uint32_t i = 0; i < weapon_array.size(); i++) {
         auto weapon_prop = prop->at<GenericStructProperty>(i);
         auto& weapon = weapon_array[i];
 
@@ -292,14 +292,14 @@ Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayView<We
             return false;
         }
 
-        for(UnsignedInt j = 0; j < parts_prop->items.size(); j++) {
+        for(std::uint32_t j = 0; j < parts_prop->items.size(); j++) {
             auto part_prop = parts_prop->at<GenericStructProperty>(j);
             auto& part = weapon.parts[j];
 
             part_prop->at<IntProperty>(MASS_WEAPON_PART_ID)->value = part.id;
 
             auto part_styles = part_prop->at<ArrayProperty>(MASS_WEAPON_PART_STYLES);
-            for(UnsignedInt k = 0; k < part_styles->items.size(); k++) {
+            for(std::uint32_t k = 0; k < part_styles->items.size(); k++) {
                 part_styles->at<IntProperty>(k)->value = part.styles[k];
             }
 
@@ -338,7 +338,7 @@ Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayView<We
             return false;
         }
 
-        for(UnsignedInt j = 0; j < weapon.customStyles.size(); j++) {
+        for(std::uint32_t j = 0; j < weapon.customStyles.size(); j++) {
             writeCustomStyle(weapon.customStyles[j], j, custom_styles);
         }
 

src/Mass/Weapon.cpp

@@ -20,7 +20,7 @@ Weapon::Weapon(const Weapon& other) {
     name = other.name;
     type = other.type;
     parts = Containers::Array<WeaponPart>{other.parts.size()};
-    for(UnsignedInt i = 0; i < parts.size(); i++) {
+    for(std::uint32_t i = 0; i < parts.size(); i++) {
         parts[i] = other.parts[i];
     }
     customStyles = other.customStyles;
@@ -35,7 +35,7 @@ Weapon& Weapon::operator=(const Weapon& other) {
     name = other.name;
     type = other.type;
     parts = Containers::Array<WeaponPart>{other.parts.size()};
-    for(UnsignedInt i = 0; i < parts.size(); i++) {
+    for(std::uint32_t i = 0; i < parts.size(); i++) {
         parts[i] = other.parts[i];
     }
     customStyles = other.customStyles;

src/Mass/WeaponPart.h

@@ -19,13 +19,10 @@
 #include <Corrade/Containers/Array.h>
 #include <Corrade/Containers/StaticArray.h>
 
-#include <Magnum/Types.h>
-
 #include "Decal.h"
 #include "Accessory.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 struct WeaponPart {
     WeaponPart() = default;
@@ -34,11 +31,11 @@ struct WeaponPart {
         id = other.id;
         styles = other.styles;
         decals = Containers::Array<Decal>{other.decals.size()};
-        for(UnsignedInt i = 0; i < decals.size(); i++) {
+        for(auto i = 0u; i < decals.size(); i++) {
             decals[i] = other.decals[i];
         }
         accessories = Containers::Array<Accessory>{other.accessories.size()};
-        for(UnsignedInt i = 0; i < accessories.size(); i++) {
+        for(auto i = 0u; i < accessories.size(); i++) {
             accessories[i] = other.accessories[i];
         }
     }
@@ -46,11 +43,11 @@ struct WeaponPart {
         id = other.id;
         styles = other.styles;
         decals = Containers::Array<Decal>{other.decals.size()};
-        for(UnsignedInt i = 0; i < decals.size(); i++) {
+        for(auto i = 0u; i < decals.size(); i++) {
             decals[i] = other.decals[i];
         }
         accessories = Containers::Array<Accessory>{other.accessories.size()};
-        for(UnsignedInt i = 0; i < accessories.size(); i++) {
+        for(auto i = 0u; i < accessories.size(); i++) {
             accessories[i] = other.accessories[i];
         }
         return *this;
@@ -59,8 +56,8 @@ struct WeaponPart {
     WeaponPart(WeaponPart&& other) = default;
     WeaponPart& operator=(WeaponPart&& other) = default;
 
-    Int id = 0;
+    std::int32_t id = 0;
-    Containers::StaticArray<4, Int> styles{ValueInit};
+    Containers::StaticArray<4, std::int32_t> styles{ValueInit};
     Containers::Array<Decal> decals{};
     Containers::Array<Accessory> accessories{};
 };

src/MassManager/MassManager.cpp

@@ -30,7 +30,7 @@ MassManager::MassManager(Containers::StringView save_path, Containers::StringVie
     _saveDirectory{save_path}, _account{account}, _demo{demo}, _stagingAreaDirectory{staging_dir}
 {
     Containers::String mass_filename = "";
-    for(UnsignedInt i = 0; i < _hangars.size(); i++) {
+    for(std::uint32_t i = 0; i < _hangars.size(); i++) {
         mass_filename = Utility::Path::join(_saveDirectory,
                                             Utility::format("{}Unit{:.2d}{}.sav", demo ? "Demo"_s : ""_s, i, _account));
         new(&_hangars[i]) Mass{mass_filename};
@@ -45,12 +45,12 @@ MassManager::lastError() {
 }
 
 Mass&
-MassManager::hangar(Int hangar) {
+MassManager::hangar(std::int32_t hangar) {
     return _hangars[hangar];
 }
 
 void
-MassManager::refreshHangar(Int hangar) {
+MassManager::refreshHangar(std::int32_t hangar) {
     if(hangar < 0 || hangar >= 32) {
         _lastError = "Hangar index out of range.";
         LOG_ERROR(_lastError);
@@ -64,7 +64,7 @@ MassManager::refreshHangar(Int hangar) {
 }
 
 bool
-MassManager::importMass(Containers::StringView staged_fn, Int hangar) {
+MassManager::importMass(Containers::StringView staged_fn, std::int32_t hangar) {
     if(hangar < 0 || hangar >= 32) {
         _lastError = "Hangar index out of range.";
         LOG_ERROR(_lastError);
@@ -107,7 +107,7 @@ MassManager::importMass(Containers::StringView staged_fn, Int hangar) {
 }
 
 bool
-MassManager::exportMass(Int hangar) {
+MassManager::exportMass(std::int32_t hangar) {
     if(hangar < 0 || hangar >= 32) {
         _lastError = "Hangar index out of range."_s;
         LOG_ERROR(_lastError);
@@ -134,7 +134,7 @@ MassManager::exportMass(Int hangar) {
 }
 
 bool
-MassManager::moveMass(Int source, Int destination) {
+MassManager::moveMass(std::int32_t source, std::int32_t destination) {
     if(source < 0 || source >= 32) {
         _lastError = "Source hangar index out of range."_s;
         LOG_ERROR(_lastError);
@@ -172,7 +172,7 @@ MassManager::moveMass(Int source, Int destination) {
 }
 
 bool
-MassManager::deleteMass(Int hangar) {
+MassManager::deleteMass(std::int32_t hangar) {
     if(hangar < 0 || hangar >= 32) {
         _lastError = "Hangar index out of range."_s;
         LOG_ERROR(_lastError);

src/Profile/Profile.cpp

@@ -189,24 +189,24 @@ Profile::renameCompany(Containers::StringView new_name) {
     return true;
 }
 
-Int
+std::int32_t
 Profile::activeFrameSlot() const {
     return _activeFrameSlot;
 }
 
-Int
+std::int32_t
 Profile::credits() const {
     return _credits;
 }
 
 bool
-Profile::setCredits(Int amount) {
+Profile::setCredits(std::int32_t amount) {
     auto credits_prop = _profile.at<IntProperty>(PROFILE_CREDITS);
 
     if(!credits_prop) {
         credits_prop = new IntProperty;
         credits_prop->name.emplace("Credit"_s);
-        credits_prop->valueLength = sizeof(Int);
+        credits_prop->valueLength = sizeof(std::int32_t);
         _profile.appendProperty(IntProperty::ptr{credits_prop});
     }
 
@@ -220,19 +220,19 @@ Profile::setCredits(Int amount) {
     return true;
 }
 
-Int
+std::int32_t
 Profile::storyProgress() const {
     return _storyProgress;
 }
 
 bool
-Profile::setStoryProgress(Int progress) {
+Profile::setStoryProgress(std::int32_t progress) {
     auto story_progress_prop = _profile.at<IntProperty>("StoryProgress"_s);
 
     if(!story_progress_prop) {
         story_progress_prop = new IntProperty;
         story_progress_prop->name.emplace("StoryProgress"_s);
-        story_progress_prop->valueLength = sizeof(Int);
+        story_progress_prop->valueLength = sizeof(std::int32_t);
         _profile.appendProperty(IntProperty::ptr{story_progress_prop});
     }
 
@@ -246,252 +246,252 @@ Profile::setStoryProgress(Int progress) {
     return true;
 }
 
-Int
+std::int32_t
 Profile::lastMissionId() const {
     return _lastMissionId;
 }
 
-Int
+std::int32_t
 Profile::verseSteel() const {
     return _verseSteel;
 }
 
 bool
-Profile::setVerseSteel(Int amount) {
+Profile::setVerseSteel(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, VerseSteel, amount);
 }
 
-Int
+std::int32_t
 Profile::undinium() const {
     return _undinium;
 }
 
 bool
-Profile::setUndinium(Int amount) {
+Profile::setUndinium(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Undinium, amount);
 }
 
-Int
+std::int32_t
 Profile::necriumAlloy() const {
     return _necriumAlloy;
 }
 
 bool
-Profile::setNecriumAlloy(Int amount) {
+Profile::setNecriumAlloy(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, NecriumAlloy, amount);
 }
 
-Int
+std::int32_t
 Profile::lunarite() const {
     return _lunarite;
 }
 
 bool
-Profile::setLunarite(Int amount) {
+Profile::setLunarite(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Lunarite, amount);
 }
 
-Int
+std::int32_t
 Profile::asterite() const {
     return _asterite;
 }
 
 bool
-Profile::setAsterite(Int amount) {
+Profile::setAsterite(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Asterite, amount);
 }
 
-Int
+std::int32_t
 Profile::halliteFragma() const {
     return _halliteFragma;
 }
 
 bool
-Profile::setHalliteFragma(Int amount) {
+Profile::setHalliteFragma(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, HalliteFragma, amount);
 }
 
-Int
+std::int32_t
 Profile::ednil() const {
     return _ednil;
 }
 
 bool
-Profile::setEdnil(Int amount) {
+Profile::setEdnil(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Ednil, amount);
 }
 
-Int
+std::int32_t
 Profile::nuflalt() const {
     return _nuflalt;
 }
 
 bool
-Profile::setNuflalt(Int amount) {
+Profile::setNuflalt(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Nuflalt, amount);
 }
 
-Int
+std::int32_t
 Profile::aurelene() const {
     return _aurelene;
 }
 
 bool
-Profile::setAurelene(Int amount) {
+Profile::setAurelene(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Aurelene, amount);
 }
 
-Int
+std::int32_t
 Profile::soldus() const {
     return _soldus;
 }
 
 bool
-Profile::setSoldus(Int amount) {
+Profile::setSoldus(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Soldus, amount);
 }
 
-Int
+std::int32_t
 Profile::synthesisedN() const {
     return _synthesisedN;
 }
 
 bool
-Profile::setSynthesisedN(Int amount) {
+Profile::setSynthesisedN(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, SynthesisedN, amount);
 }
 
-Int
+std::int32_t
 Profile::nanoc() const {
     return _nanoc;
 }
 
 bool
-Profile::setNanoc(Int amount) {
+Profile::setNanoc(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Nanoc, amount);
 }
 
-Int
+std::int32_t
 Profile::alcarbonite() const {
     return _alcarbonite;
 }
 
 bool
-Profile::setAlcarbonite(Int amount) {
+Profile::setAlcarbonite(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Alcarbonite, amount);
 }
 
-Int
+std::int32_t
 Profile::keriphene() const {
     return _keriphene;
 }
 
 bool
-Profile::setKeriphene(Int amount) {
+Profile::setKeriphene(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Keriphene, amount);
 }
 
-Int
+std::int32_t
 Profile::nitinolCM() const {
     return _nitinolCM;
 }
 
 bool
-Profile::setNitinolCM(Int amount) {
+Profile::setNitinolCM(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, NitinolCM, amount);
 }
 
-Int
+std::int32_t
 Profile::quarkium() const {
     return _quarkium;
 }
 
 bool
-Profile::setQuarkium(Int amount) {
+Profile::setQuarkium(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Quarkium, amount);
 }
 
-Int
+std::int32_t
 Profile::alterene() const {
     return _alterene;
 }
 
 bool
-Profile::setAlterene(Int amount) {
+Profile::setAlterene(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Alterene, amount);
 }
 
-Int
+std::int32_t
 Profile::cosmium() const {
     return _cosmium;
 }
 
 bool
-Profile::setCosmium(Int amount) {
+Profile::setCosmium(std::int32_t amount) {
     return setResource(PROFILE_MATERIAL, Cosmium, amount);
 }
 
-Int
+std::int32_t
 Profile::mixedComposition() const {
     return _mixedComposition;
 }
 
 bool
-Profile::setMixedComposition(Int amount) {
+Profile::setMixedComposition(std::int32_t amount) {
     return setResource(PROFILE_QUARK_DATA, MixedComposition, amount);
 }
 
-Int
+std::int32_t
 Profile::voidResidue() const {
     return _voidResidue;
 }
 
 bool
-Profile::setVoidResidue(Int amount) {
+Profile::setVoidResidue(std::int32_t amount) {
     return setResource(PROFILE_QUARK_DATA, VoidResidue, amount);
 }
 
-Int
+std::int32_t
 Profile::muscularConstruction() const {
     return _muscularConstruction;
 }
 
 bool
-Profile::setMuscularConstruction(Int amount) {
+Profile::setMuscularConstruction(std::int32_t amount) {
     return setResource(PROFILE_QUARK_DATA, MuscularConstruction, amount);
 }
 
-Int
+std::int32_t
 Profile::mineralExoskeletology() const {
     return _mineralExoskeletology;
 }
 
 bool
-Profile::setMineralExoskeletology(Int amount) {
+Profile::setMineralExoskeletology(std::int32_t amount) {
     return setResource(PROFILE_QUARK_DATA, MineralExoskeletology, amount);
 }
 
-Int
+std::int32_t
 Profile::carbonisedSkin() const {
     return _carbonisedSkin;
 }
 
 bool
-Profile::setCarbonisedSkin(Int amount) {
+Profile::setCarbonisedSkin(std::int32_t amount) {
     return setResource(PROFILE_QUARK_DATA, CarbonisedSkin, amount);
 }
 
-Int
+std::int32_t
 Profile::isolatedVoidParticle() const {
     return _isolatedVoidParticle;
 }
 
 bool
-Profile::setIsolatedVoidParticle(Int amount) {
+Profile::setIsolatedVoidParticle(std::int32_t amount) {
     return setResource(PROFILE_QUARK_DATA, IsolatedVoidParticle, amount);
 }
 
-Int
+std::int32_t
 Profile::getResource(Containers::StringView container, MaterialID id) {
     auto mats_prop = _profile.at<ArrayProperty>(container);
 
@@ -509,7 +509,7 @@ Profile::getResource(Containers::StringView container, MaterialID id) {
 }
 
 bool
-Profile::setResource(Containers::StringView container, MaterialID id, Int amount) {
+Profile::setResource(Containers::StringView container, MaterialID id, std::int32_t amount) {
     auto mats_prop = _profile.at<ArrayProperty>(container);
 
     if(!mats_prop) {

src/Profile/Profile.h

@@ -19,16 +19,13 @@
 #include <Corrade/Containers/String.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Magnum.h>
-
 #include "../UESaveFile/UESaveFile.h"
 
 #include "ResourceIDs.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
-enum class ProfileType : UnsignedByte {
+enum class ProfileType: std::uint8_t {
     Demo,
     FullGame
 };
@@ -37,14 +34,14 @@ class Profile {
     public:
         explicit Profile(Containers::StringView path);
 
-        auto valid() const -> bool;
+        bool valid() const;
 
         auto lastError() const -> Containers::StringView;
 
         auto filename() const -> Containers::StringView;
 
-        auto type() const -> ProfileType;
+        ProfileType type() const;
-        auto isDemo() const -> bool;
+        bool isDemo() const;
 
         auto account() const -> Containers::StringView;
 
@@ -53,91 +50,91 @@ class Profile {
         auto companyName() const -> Containers::StringView;
         bool renameCompany(Containers::StringView new_name);
 
-        auto activeFrameSlot() const -> Int;
+        std::int32_t activeFrameSlot() const;
 
-        auto credits() const -> Int;
+        std::int32_t credits() const;
-        bool setCredits(Int credits);
+        bool setCredits(std::int32_t credits);
 
-        auto storyProgress() const -> Int;
+        std::int32_t storyProgress() const;
-        bool setStoryProgress(Int progress);
+        bool setStoryProgress(std::int32_t progress);
 
-        auto lastMissionId() const -> Int;
+        std::int32_t lastMissionId() const;
 
-        auto verseSteel() const -> Int;
+        std::int32_t verseSteel() const;
-        bool setVerseSteel(Int amount);
+        bool setVerseSteel(std::int32_t amount);
 
-        auto undinium() const -> Int;
+        std::int32_t undinium() const;
-        bool setUndinium(Int amount);
+        bool setUndinium(std::int32_t amount);
 
-        auto necriumAlloy() const -> Int;
+        std::int32_t necriumAlloy() const;
-        bool setNecriumAlloy(Int amount);
+        bool setNecriumAlloy(std::int32_t amount);
 
-        auto lunarite() const -> Int;
+        std::int32_t lunarite() const;
-        bool setLunarite(Int amount);
+        bool setLunarite(std::int32_t amount);
 
-        auto asterite() const -> Int;
+        std::int32_t asterite() const;
-        bool setAsterite(Int amount);
+        bool setAsterite(std::int32_t amount);
 
-        Int halliteFragma() const;
+        std::int32_t halliteFragma() const;
-        bool setHalliteFragma(Int amount);
+        bool setHalliteFragma(std::int32_t amount);
 
-        auto ednil() const -> Int;
+        std::int32_t ednil() const;
-        bool setEdnil(Int amount);
+        bool setEdnil(std::int32_t amount);
 
-        auto nuflalt() const -> Int;
+        std::int32_t nuflalt() const;
-        bool setNuflalt(Int amount);
+        bool setNuflalt(std::int32_t amount);
 
-        auto aurelene() const -> Int;
+        std::int32_t aurelene() const;
-        bool setAurelene(Int amount);
+        bool setAurelene(std::int32_t amount);
 
-        auto soldus() const -> Int;
+        std::int32_t soldus() const;
-        bool setSoldus(Int amount);
+        bool setSoldus(std::int32_t amount);
 
-        auto synthesisedN() const -> Int;
+        std::int32_t synthesisedN() const;
-        bool setSynthesisedN(Int amount);
+        bool setSynthesisedN(std::int32_t amount);
 
-        Int nanoc() const;
+        std::int32_t nanoc() const;
-        bool setNanoc(Int amount);
+        bool setNanoc(std::int32_t amount);
 
-        auto alcarbonite() const -> Int;
+        std::int32_t alcarbonite() const;
-        bool setAlcarbonite(Int amount);
+        bool setAlcarbonite(std::int32_t amount);
 
-        auto keriphene() const -> Int;
+        std::int32_t keriphene() const;
-        bool setKeriphene(Int amount);
+        bool setKeriphene(std::int32_t amount);
 
-        auto nitinolCM() const -> Int;
+        std::int32_t nitinolCM() const;
-        bool setNitinolCM(Int amount);
+        bool setNitinolCM(std::int32_t amount);
 
-        auto quarkium() const -> Int;
+        std::int32_t quarkium() const;
-        bool setQuarkium(Int amount);
+        bool setQuarkium(std::int32_t amount);
 
-        auto alterene() const -> Int;
+        std::int32_t alterene() const;
-        bool setAlterene(Int amount);
+        bool setAlterene(std::int32_t amount);
 
-        Int cosmium() const;
+        std::int32_t cosmium() const;
-        bool setCosmium(Int amount);
+        bool setCosmium(std::int32_t amount);
 
-        auto mixedComposition() const -> Int;
+        std::int32_t mixedComposition() const;
-        bool setMixedComposition(Int amount);
+        bool setMixedComposition(std::int32_t amount);
 
-        auto voidResidue() const -> Int;
+        std::int32_t voidResidue() const;
-        bool setVoidResidue(Int amount);
+        bool setVoidResidue(std::int32_t amount);
 
-        auto muscularConstruction() const -> Int;
+        std::int32_t muscularConstruction() const;
-        bool setMuscularConstruction(Int amount);
+        bool setMuscularConstruction(std::int32_t amount);
 
-        auto mineralExoskeletology() const -> Int;
+        std::int32_t mineralExoskeletology() const;
-        bool setMineralExoskeletology(Int amount);
+        bool setMineralExoskeletology(std::int32_t amount);
 
-        auto carbonisedSkin() const -> Int;
+        std::int32_t carbonisedSkin() const;
-        bool setCarbonisedSkin(Int amount);
+        bool setCarbonisedSkin(std::int32_t amount);
 
-        Int isolatedVoidParticle() const;
+        std::int32_t isolatedVoidParticle() const;
-        bool setIsolatedVoidParticle(Int amount);
+        bool setIsolatedVoidParticle(std::int32_t amount);
 
     private:
-        Int getResource(Containers::StringView container, MaterialID id);
+        std::int32_t getResource(Containers::StringView container, MaterialID id);
-        bool setResource(Containers::StringView container, MaterialID id, Int amount);
+        bool setResource(Containers::StringView container, MaterialID id, std::int32_t amount);
 
         Containers::String _filename;
 
@@ -146,38 +143,38 @@ class Profile {
         UESaveFile _profile;
 
         Containers::String _name;
-        Int _activeFrameSlot = 0;
+        std::int32_t _activeFrameSlot = 0;
-        Int _credits         = 0;
+        std::int32_t _credits         = 0;
-        Int _storyProgress   = 0;
+        std::int32_t _storyProgress   = 0;
-        Int _lastMissionId   = 0;
+        std::int32_t _lastMissionId   = 0;
 
-        Int _verseSteel    = 0;
+        std::int32_t _verseSteel    = 0;
-        Int _undinium      = 0;
+        std::int32_t _undinium      = 0;
-        Int _necriumAlloy  = 0;
+        std::int32_t _necriumAlloy  = 0;
-        Int _lunarite      = 0;
+        std::int32_t _lunarite      = 0;
-        Int _asterite      = 0;
+        std::int32_t _asterite      = 0;
-        Int _halliteFragma = 0;
+        std::int32_t _halliteFragma = 0;
 
-        Int _ednil        = 0;
+        std::int32_t _ednil        = 0;
-        Int _nuflalt      = 0;
+        std::int32_t _nuflalt      = 0;
-        Int _aurelene     = 0;
+        std::int32_t _aurelene     = 0;
-        Int _soldus       = 0;
+        std::int32_t _soldus       = 0;
-        Int _synthesisedN = 0;
+        std::int32_t _synthesisedN = 0;
-        Int _nanoc        = 0;
+        std::int32_t _nanoc        = 0;
 
-        Int _alcarbonite = 0;
+        std::int32_t _alcarbonite = 0;
-        Int _keriphene   = 0;
+        std::int32_t _keriphene   = 0;
-        Int _nitinolCM   = 0;
+        std::int32_t _nitinolCM   = 0;
-        Int _quarkium    = 0;
+        std::int32_t _quarkium    = 0;
-        Int _alterene    = 0;
+        std::int32_t _alterene    = 0;
-        Int _cosmium     = 0;
+        std::int32_t _cosmium     = 0;
 
-        Int _mixedComposition      = 0;
+        std::int32_t _mixedComposition      = 0;
-        Int _voidResidue           = 0;
+        std::int32_t _voidResidue           = 0;
-        Int _muscularConstruction  = 0;
+        std::int32_t _muscularConstruction  = 0;
-        Int _mineralExoskeletology = 0;
+        std::int32_t _mineralExoskeletology = 0;
-        Int _carbonisedSkin        = 0;
+        std::int32_t _carbonisedSkin        = 0;
-        Int _isolatedVoidParticle  = 0;
+        std::int32_t _isolatedVoidParticle  = 0;
 
         Containers::String _account;
 

src/Profile/ResourceIDs.h

@@ -16,11 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-#include <Magnum/Types.h>
+enum MaterialID : std::int32_t {
-
-using namespace Magnum;
-
-enum MaterialID : Int {
     VerseSteel    = 0xC3500,
     Undinium      = 0xC3501,
     NecriumAlloy  = 0xC3502,

src/ProfileManager/ProfileManager.cpp

@@ -114,7 +114,7 @@ ProfileManager::deleteProfile(std::size_t index, bool delete_builds) {
     }
 
     if(delete_builds) {
-        for(UnsignedByte i = 0; i < 32; ++i) {
+        for(std::uint8_t i = 0; i < 32; ++i) {
             auto filename = Utility::format("{}Unit{:.2d}{}.sav",
                                             _profiles[index].type() == ProfileType::Demo ? "Demo": "",
                                             i, _profiles[index].account());
@@ -176,7 +176,7 @@ ProfileManager::backupProfile(std::size_t index, bool backup_builds) {
     zip_set_archive_comment(zip, comment.data(), comment.size());
 
     if(backup_builds) {
-        for(UnsignedByte i = 0; i < 32; ++i) {
+        for(std::uint8_t i = 0; i < 32; ++i) {
             auto build_filename = Utility::format("{}Unit{:.2d}{}.sav",
                                                   profile.isDemo() ? "Demo"_s : ""_s, i,
                                                   profile.account());
@@ -247,7 +247,7 @@ ProfileManager::refreshBackups() {
 
         Containers::ScopeGuard guard{zip, zip_close};
 
-        Long num_entries = zip_get_num_entries(zip, ZIP_FL_UNCHANGED);
+        auto num_entries = zip_get_num_entries(zip, ZIP_FL_UNCHANGED);
 
         if(num_entries == 0) {
             continue;
@@ -291,7 +291,7 @@ ProfileManager::refreshBackups() {
 
         arrayReserve(backup.includedFiles, num_entries);
 
-        for(Long i = 0; i < num_entries; i++) {
+        for(auto i = 0; i < num_entries; i++) {
             arrayAppend(backup.includedFiles, InPlaceInit, zip_get_name(zip, i, ZIP_FL_UNCHANGED));
         }
 
@@ -358,7 +358,7 @@ ProfileManager::restoreBackup(std::size_t index) {
 
         Containers::StaticArray<8192, char> buf{ValueInit};
 
-        Long bytes_read = 0;
+        auto bytes_read = 0l;
         while((bytes_read = zip_fread(zf, buf.data(), buf.size())) > 0) {
             if(std::fwrite(buf.data(), sizeof(char), bytes_read, out) < static_cast<std::size_t>(bytes_read)) {
                 _lastError = Utility::format(error_format.data(), file, "not enough bytes written.");

src/ProfileManager/ProfileManager.h

@@ -16,6 +16,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+#include <cstdint>
+
 #include <string>
 
 #include <Corrade/Containers/Array.h>
@@ -30,12 +32,12 @@ struct Backup {
     Containers::String company;
     ProfileType type;
     struct {
-        int year;
+        std::int32_t year;
-        int month;
+        std::int32_t month;
-        int day;
+        std::int32_t day;
-        int hour;
+        std::int32_t hour;
-        int minute;
+        std::int32_t minute;
-        int second;
+        std::int32_t second;
     } timestamp;
     Containers::Array<Containers::String> includedFiles;
 };

src/SaveTool/SaveTool.cpp

@@ -58,8 +58,6 @@ SaveTool::SaveTool(const Arguments& arguments):
     LOG_INFO("Configuring OpenGL renderer.");
     GL::Renderer::enable(GL::Renderer::Feature::Blending);
     GL::Renderer::enable(GL::Renderer::Feature::ScissorTest);
-    GL::Renderer::disable(GL::Renderer::Feature::FaceCulling);
-    GL::Renderer::disable(GL::Renderer::Feature::DepthTest);
     GL::Renderer::setBlendFunction(GL::Renderer::BlendFunction::SourceAlpha,
                                    GL::Renderer::BlendFunction::OneMinusSourceAlpha);
     GL::Renderer::setBlendEquation(GL::Renderer::BlendEquation::Add,
@@ -79,7 +77,7 @@ SaveTool::SaveTool(const Arguments& arguments):
     #endif
 
     LOG_INFO("Registering custom events.");
-    if((_initEventId = SDL_RegisterEvents(3)) == UnsignedInt(-1)) {
+    if((_initEventId = SDL_RegisterEvents(3)) == std::uint32_t(-1)) {
         SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error",
                                  "SDL_RegisterEvents() failed in SaveTool::SaveTool(). Exiting...", window());
         exit(EXIT_FAILURE);
@@ -116,7 +114,7 @@ SaveTool::SaveTool(const Arguments& arguments):
 
     checkGameState();
     _gameCheckTimerId = SDL_AddTimer(2000,
-                                     [](UnsignedInt interval, void* param)->UnsignedInt{
+                                     [](std::uint32_t interval, void* param)->std::uint32_t{
                                          static_cast<SaveTool*>(param)->checkGameState();
                                          return interval;
                                      }, this);
@@ -405,13 +403,13 @@ SaveTool::drawGameState() {
 }
 
 void
-SaveTool::drawHelpMarker(Containers::StringView text, Float wrap_pos) {
+SaveTool::drawHelpMarker(Containers::StringView text, float wrap_pos) {
     ImGui::TextUnformatted(ICON_FA_QUESTION_CIRCLE);
     drawTooltip(text, wrap_pos);
 }
 
 void
-SaveTool::drawTooltip(Containers::StringView text, Float wrap_pos) {
+SaveTool::drawTooltip(Containers::StringView text, float wrap_pos) {
     if(ImGui::IsItemHovered()){
         ImGui::BeginTooltip();
         if(wrap_pos > 0.0f) {

src/SaveTool/SaveTool.h

@@ -77,20 +77,20 @@ class SaveTool: public Platform::Sdl2Application, public efsw::FileWatchListener
 
         void anyEvent(SDL_Event& event) override;
 
-        enum InitStatus: Int {
+        enum InitStatus: std::int32_t {
             InitSuccess,
             ProfileManagerFailure
         };
         void initEvent(SDL_Event& event);
 
-        enum UpdateCheckStatus : Int {
+        enum UpdateCheckStatus : std::int32_t {
             CurlInitFailed = 0,
             CurlError      = 1,
             CurlTimeout    = 2,
         };
         void updateCheckEvent(SDL_Event& event);
 
-        enum FileEventType: Int {
+        enum FileEventType: std::int32_t {
             FileAdded    = efsw::Action::Add,
             FileDeleted  = efsw::Action::Delete,
             FileModified = efsw::Action::Modified,
@@ -126,8 +126,8 @@ class SaveTool: public Platform::Sdl2Application, public efsw::FileWatchListener
         void drawGeneralInfo();
         void drawResearchInventory();
         template<typename Getter, typename Setter>
-        void drawMaterialRow(Containers::StringView name, Int tier, Getter getter, Setter setter);
+        void drawMaterialRow(Containers::StringView name, std::int32_t tier, Getter getter, Setter setter);
-        void drawUnavailableMaterialRow(Containers::StringView name, Int tier);
+        void drawUnavailableMaterialRow(Containers::StringView name, std::int32_t tier);
         void drawMassManager();
         ImGuiID drawDeleteMassPopup(int mass_index);
         ImGuiID drawDeleteStagedMassPopup(Containers::StringView filename);
@@ -148,7 +148,7 @@ class SaveTool: public Platform::Sdl2Application, public efsw::FileWatchListener
         void drawTuning();
         void drawDecalEditor(Decal& decal);
         void drawAccessoryEditor(Accessory& accessory, Containers::ArrayView<CustomStyle> style_view);
-        Containers::StringView getStyleName(Int id, Containers::ArrayView<CustomStyle> view);
+        Containers::StringView getStyleName(std::int32_t id, Containers::ArrayView<CustomStyle> view);
 
         enum DCSResult {
             DCS_Fail,
@@ -161,8 +161,8 @@ class SaveTool: public Platform::Sdl2Application, public efsw::FileWatchListener
         void drawGameState();
 
         // Convenience wrappers over ImGui stuff
-        void drawHelpMarker(Containers::StringView text, Float wrap_pos = 0.0f);
+        void drawHelpMarker(Containers::StringView text, float wrap_pos = 0.0f);
-        void drawTooltip(Containers::StringView text, Float wrap_pos = 0.0f);
+        void drawTooltip(Containers::StringView text, float wrap_pos = 0.0f);
         bool drawCheckbox(Containers::StringView label, bool value);
 
         template<typename Functor, typename... Args>
@@ -222,9 +222,9 @@ class SaveTool: public Platform::Sdl2Application, public efsw::FileWatchListener
         std::thread _initThread;
         std::thread _updateThread;
 
-        UnsignedInt _initEventId;
+        std::uint32_t _initEventId;
-        UnsignedInt _updateEventId;
+        std::uint32_t _updateEventId;
-        UnsignedInt _fileEventId;
+        std::uint32_t _fileEventId;
 
         Containers::String _lastError;
 
@@ -240,7 +240,7 @@ class SaveTool: public Platform::Sdl2Application, public efsw::FileWatchListener
         //Containers::String _weaponsDir;
         //Containers::String _stylesDir;
 
-        enum class GameState : UnsignedByte {
+        enum class GameState : std::uint8_t {
             Unknown, NotRunning, Running
         } _gameState{GameState::Unknown};
 
@@ -270,12 +270,12 @@ class SaveTool: public Platform::Sdl2Application, public efsw::FileWatchListener
         bool _jointsDirty{false};
         bool _stylesDirty{false};
         bool _eyeFlareDirty{false};
-        Containers::StaticArray<38, Int> _selectedArmourDecals{ValueInit};
+        Containers::StaticArray<38, std::int32_t> _selectedArmourDecals{ValueInit};
-        Containers::StaticArray<38, Int> _selectedArmourAccessories{ValueInit};
+        Containers::StaticArray<38, std::int32_t> _selectedArmourAccessories{ValueInit};
-        Int _selectedBLPlacement{0};
+        std::int32_t _selectedBLPlacement{0};
-        Int _selectedWeaponPart{0};
+        std::int32_t _selectedWeaponPart{0};
-        Int _selectedWeaponDecal{0};
+        std::int32_t _selectedWeaponDecal{0};
-        Int _selectedWeaponAccessory{0};
+        std::int32_t _selectedWeaponAccessory{0};
         bool _meleeDirty{false};
         bool _shieldsDirty{false};
         bool _bShootersDirty{false};

src/SaveTool/SaveTool_FileWatcher.cpp

@@ -73,8 +73,8 @@ SaveTool::fileUpdateEvent(SDL_Event& event) {
 
     Containers::String old_filename;
 
-    Int index = 0;
+    std::int32_t index = 0;
-    Int old_index = 0;
+    std::int32_t old_index = 0;
     bool is_current_profile = filename == _currentProfile->filename();
     bool is_unit = filename.hasPrefix(_currentProfile->isDemo() ? "DemoUnit"_s : "Unit"_s);
     if(is_unit) {

src/SaveTool/SaveTool_Initialisation.cpp

@@ -73,7 +73,7 @@ SaveTool::initialiseGui() {
     font_config.FontDataOwnedByAtlas = false;
     std::strcpy(font_config.Name, "Source Sans Pro");
     io.Fonts->AddFontFromMemoryTTF(const_cast<char*>(reg_font.data()), int(reg_font.size()),
-                                   20.0f * Float(framebufferSize().x()) / size.x(), &font_config);
+                                   20.0f * float(framebufferSize().x()) / size.x(), &font_config);
 
     auto icon_font = _rs.getRaw(FONT_ICON_FILE_NAME_FAS);
     static const ImWchar icon_range[] = { ICON_MIN_FA, ICON_MAX_FA, 0 };
@@ -84,12 +84,12 @@ SaveTool::initialiseGui() {
     icon_config.OversampleH = icon_config.OversampleV = 1;
     icon_config.GlyphMinAdvanceX = 18.0f;
     io.Fonts->AddFontFromMemoryTTF(const_cast<char*>(icon_font.data()), int(icon_font.size()),
-                                   16.0f * Float(framebufferSize().x()) / size.x(), &icon_config, icon_range);
+                                   16.0f * float(framebufferSize().x()) / size.x(), &icon_config, icon_range);
 
     auto brand_font = _rs.getRaw(FONT_ICON_FILE_NAME_FAB);
     static const ImWchar brand_range[] = { ICON_MIN_FAB, ICON_MAX_FAB, 0 };
     io.Fonts->AddFontFromMemoryTTF(const_cast<char*>(brand_font.data()), int(brand_font.size()),
-                                   16.0f * Float(framebufferSize().x()) / size.x(), &icon_config, brand_range);
+                                   16.0f * float(framebufferSize().x()) / size.x(), &icon_config, brand_range);
 
     auto mono_font = _rs.getRaw("SourceCodePro-Regular.ttf"_s);
     ImVector<ImWchar> range;
@@ -98,7 +98,7 @@ SaveTool::initialiseGui() {
     builder.AddChar(u'š'); // This allows displaying Vladimír Vondruš' name in Corrade's and Magnum's licences.
     builder.BuildRanges(&range);
     io.Fonts->AddFontFromMemoryTTF(const_cast<char*>(mono_font.data()), int(mono_font.size()),
-                                   18.0f * Float(framebufferSize().x()) / size.x(), &font_config, range.Data);
+                                   18.0f * float(framebufferSize().x()) / size.x(), &font_config, range.Data);
 
     _imgui = ImGuiIntegration::Context(*ImGui::GetCurrentContext(), windowSize());
 

src/SaveTool/SaveTool_MainManager.cpp

@@ -31,7 +31,7 @@
 void
 SaveTool::drawManager() {
     ImGui::SetNextWindowPos({0.0f, ImGui::GetItemRectSize().y}, ImGuiCond_Always);
-    ImGui::SetNextWindowSize({Float(windowSize().x()), Float(windowSize().y()) - ImGui::GetItemRectSize().y},
+    ImGui::SetNextWindowSize({float(windowSize().x()), float(windowSize().y()) - ImGui::GetItemRectSize().y},
                              ImGuiCond_Always);
     if(!ImGui::Begin("##MainWindow", nullptr,
                      ImGuiWindowFlags_NoDecoration|ImGuiWindowFlags_NoMove|
@@ -210,7 +210,7 @@ SaveTool::drawGeneralInfo() {
     drawTooltip("This is the last mission selected in the mission selection screen, not the last mission played.",
                 float(windowSize().x()) * 0.35f);
 
-    const Float footer_height_to_reserve = ImGui::GetStyle().ItemSpacing.y + ImGui::GetFrameHeightWithSpacing();
+    const float footer_height_to_reserve = ImGui::GetStyle().ItemSpacing.y + ImGui::GetFrameHeightWithSpacing();
     ImGui::Dummy({ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y - footer_height_to_reserve});
 
     ImGui::Separator();
@@ -235,7 +235,7 @@ SaveTool::drawGeneralInfo() {
 
     ImGui::SameLine();
 
-    static Int credits;
+    static std::int32_t credits;
     if(drawUnsafeWidget([]{ return ImGui::Button("Edit credits"); })) {
         credits = _currentProfile->credits();
         ImGui::OpenPopup("int_edit");
@@ -302,22 +302,22 @@ SaveTool::drawResearchInventory() {
 
         drawMaterialRow("Verse steel", 1,
                         [this]{ return _currentProfile->verseSteel(); },
-                        [this](Int amount){ return _currentProfile->setVerseSteel(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setVerseSteel(amount); });
         drawMaterialRow("Undinium", 2,
                         [this]{ return _currentProfile->undinium(); },
-                        [this](Int amount){ return _currentProfile->setUndinium(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setUndinium(amount); });
         drawMaterialRow("Necrium alloy", 3,
                         [this]{ return _currentProfile->necriumAlloy(); },
-                        [this](Int amount){ return _currentProfile->setNecriumAlloy(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setNecriumAlloy(amount); });
         drawMaterialRow("Lunarite", 4,
                         [this]{ return _currentProfile->lunarite(); },
-                        [this](Int amount){ return _currentProfile->setLunarite(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setLunarite(amount); });
         drawMaterialRow("Asterite", 5,
                         [this]{ return _currentProfile->asterite(); },
-                        [this](Int amount){ return _currentProfile->setAsterite(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setAsterite(amount); });
         drawMaterialRow("Hallite fragma", 6,
                         [this]{ return _currentProfile->halliteFragma(); },
-                        [this](Int amount){ return _currentProfile->setHalliteFragma(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setHalliteFragma(amount); });
         drawUnavailableMaterialRow("Unnoctinium", 7);
 
         ImGui::TableNextRow(ImGuiTableRowFlags_Headers);
@@ -326,22 +326,22 @@ SaveTool::drawResearchInventory() {
 
         drawMaterialRow("Ednil", 1,
                         [this]{ return _currentProfile->ednil(); },
-                        [this](Int amount){ return _currentProfile->setEdnil(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setEdnil(amount); });
         drawMaterialRow("Nuflalt", 2,
                         [this]{ return _currentProfile->nuflalt(); },
-                        [this](Int amount){ return _currentProfile->setNuflalt(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setNuflalt(amount); });
         drawMaterialRow("Aurelene", 3,
                         [this]{ return _currentProfile->aurelene(); },
-                        [this](Int amount){ return _currentProfile->setAurelene(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setAurelene(amount); });
         drawMaterialRow("Soldus", 4,
                         [this]{ return _currentProfile->soldus(); },
-                        [this](Int amount){ return _currentProfile->setSoldus(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setSoldus(amount); });
         drawMaterialRow("Synthesized N", 5,
                         [this]{ return _currentProfile->synthesisedN(); },
-                        [this](Int amount){ return _currentProfile->setSynthesisedN(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setSynthesisedN(amount); });
         drawMaterialRow("Nanoc", 6,
                         [this]{ return _currentProfile->nanoc(); },
-                        [this](Int amount){ return _currentProfile->setNanoc(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setNanoc(amount); });
         drawUnavailableMaterialRow("Abyssillite", 7);
 
         ImGui::TableNextRow(ImGuiTableRowFlags_Headers);
@@ -350,22 +350,22 @@ SaveTool::drawResearchInventory() {
 
         drawMaterialRow("Alcarbonite", 1,
                         [this]{ return _currentProfile->alcarbonite(); },
-                        [this](Int amount){ return _currentProfile->setAlcarbonite(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setAlcarbonite(amount); });
         drawMaterialRow("Keripehene", 2,
                         [this]{ return _currentProfile->keriphene(); },
-                        [this](Int amount){ return _currentProfile->setKeriphene(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setKeriphene(amount); });
         drawMaterialRow("Nitinol-CM", 3,
                         [this]{ return _currentProfile->nitinolCM(); },
-                        [this](Int amount){ return _currentProfile->setNitinolCM(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setNitinolCM(amount); });
         drawMaterialRow("Quarkium", 4,
                         [this]{ return _currentProfile->quarkium(); },
-                        [this](Int amount){ return _currentProfile->setQuarkium(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setQuarkium(amount); });
         drawMaterialRow("Alterene", 5,
                         [this]{ return _currentProfile->alterene(); },
-                        [this](Int amount){ return _currentProfile->setAlterene(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setAlterene(amount); });
         drawMaterialRow("Cosmium", 6,
                         [this]{ return _currentProfile->cosmium(); },
-                        [this](Int amount){ return _currentProfile->setCosmium(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setCosmium(amount); });
         drawUnavailableMaterialRow("Purified quarkium", 7);
 
         ImGui::TableNextRow(ImGuiTableRowFlags_Headers);
@@ -374,22 +374,22 @@ SaveTool::drawResearchInventory() {
 
         drawMaterialRow("Mixed composition", 1,
                         [this]{ return _currentProfile->mixedComposition(); },
-                        [this](Int amount){ return _currentProfile->setMixedComposition(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setMixedComposition(amount); });
         drawMaterialRow("Void residue", 2,
                         [this]{ return _currentProfile->voidResidue(); },
-                        [this](Int amount){ return _currentProfile->setVoidResidue(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setVoidResidue(amount); });
         drawMaterialRow("Muscular construction", 3,
                         [this]{ return _currentProfile->muscularConstruction(); },
-                        [this](Int amount){ return _currentProfile->setMuscularConstruction(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setMuscularConstruction(amount); });
         drawMaterialRow("Mineral exoskeletology", 4,
                         [this]{ return _currentProfile->mineralExoskeletology(); },
-                        [this](Int amount){ return _currentProfile->setMineralExoskeletology(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setMineralExoskeletology(amount); });
         drawMaterialRow("Carbonized skin", 5,
                         [this]{ return _currentProfile->carbonisedSkin(); },
-                        [this](Int amount){ return _currentProfile->setCarbonisedSkin(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setCarbonisedSkin(amount); });
         drawMaterialRow("Isolated void particle", 6,
                         [this]{ return _currentProfile->isolatedVoidParticle(); },
-                        [this](Int amount){ return _currentProfile->setIsolatedVoidParticle(amount); });
+                        [this](std::int32_t amount){ return _currentProfile->setIsolatedVoidParticle(amount); });
         drawUnavailableMaterialRow("Weaponised physiology", 7);
 
         ImGui::EndTable();
@@ -398,9 +398,9 @@ SaveTool::drawResearchInventory() {
 
 template<typename Getter, typename Setter>
 void
-SaveTool::drawMaterialRow(Containers::StringView name, Int tier, Getter getter, Setter setter) {
+SaveTool::drawMaterialRow(Containers::StringView name, std::int32_t tier, Getter getter, Setter setter) {
-    static_assert(std::is_same<decltype(getter()), Int>::value, "getter doesn't return an Int, and/or doesn't take zero arguments.");
+    static_assert(std::is_same<decltype(getter()), std::int32_t>::value, "getter doesn't return an std::int32_t, and/or doesn't take zero arguments.");
-    static_assert(std::is_same<decltype(setter(0)), bool>::value, "setter doesn't return a bool, and/or doesn't take a single Int as an argument.");
+    static_assert(std::is_same<decltype(setter(0)), bool>::value, "setter doesn't return a bool, and/or doesn't take a single std::int32_t as an argument.");
 
     ImGui::TableNextRow();
     ImGui::TableSetColumnIndex(0);
@@ -413,7 +413,7 @@ SaveTool::drawMaterialRow(Containers::StringView name, Int tier, Getter getter,
         if(conf().cheatMode()) {
             ImGui::TableSetColumnIndex(3);
             ImGui::PushID(name.data());
-            static Int var = 0;
+            static std::int32_t var = 0;
             if(drawUnsafeWidget(ImGui::SmallButton, ICON_FA_EDIT)) {
                 (var) = getter();
                 ImGui::OpenPopup("int_edit");
@@ -433,7 +433,7 @@ SaveTool::drawMaterialRow(Containers::StringView name, Int tier, Getter getter,
 }
 
 void
-SaveTool::drawUnavailableMaterialRow(Containers::StringView name, Int tier) {
+SaveTool::drawUnavailableMaterialRow(Containers::StringView name, std::int32_t tier) {
     ImGui::TableNextRow();
     ImGui::TableSetColumnIndex(0);
     ImGui::Text("T%i", tier);

src/SaveTool/SaveTool_MassViewer.cpp

@@ -38,7 +38,7 @@ SaveTool::drawMassViewer() {
     }
 
     ImGui::SetNextWindowPos({0.0f, ImGui::GetItemRectSize().y}, ImGuiCond_Always);
-    ImGui::SetNextWindowSize({Float(windowSize().x()), Float(windowSize().y()) - ImGui::GetItemRectSize().y},
+    ImGui::SetNextWindowSize({float(windowSize().x()), float(windowSize().y()) - ImGui::GetItemRectSize().y},
                              ImGuiCond_Always);
     if(!ImGui::Begin("##MassViewer", nullptr,
                      ImGuiWindowFlags_NoDecoration|ImGuiWindowFlags_NoMove|
@@ -86,8 +86,8 @@ SaveTool::drawMassViewer() {
                     _jointsDirty = false;
                     _stylesDirty = false;
                     _eyeFlareDirty = false;
-                    _selectedArmourDecals = Containers::StaticArray<38, Int>{ValueInit};
+                    _selectedArmourDecals = Containers::StaticArray<38, std::int32_t>{ValueInit};
-                    _selectedArmourAccessories = Containers::StaticArray<38, Int>{ValueInit};
+                    _selectedArmourAccessories = Containers::StaticArray<38, std::int32_t>{ValueInit};
                     _selectedBLPlacement = 0;
                     _selectedWeaponPart = 0;
                     _selectedWeaponDecal = 0;
@@ -168,7 +168,7 @@ SaveTool::drawGlobalStyles() {
 
     ImGui::TextWrapped("In-game values are multiplied by 100. For example, 0.500 here is equal to 50 in-game.");
 
-    for(UnsignedInt i = 0; i < _currentMass->globalStyles().size(); i++) {
+    for(std::uint32_t i = 0; i < _currentMass->globalStyles().size(); i++) {
         ImGui::PushID(int(i));
         DCSResult result;
         result = drawCustomStyle(_currentMass->globalStyles()[i]);
@@ -225,7 +225,7 @@ SaveTool::drawTuning() {
         ImGui::TableNextColumn();
         ImGui::TextUnformatted("Gears");
 
-        for(UnsignedInt i = 0; i < _currentMass->gears().size(); i++) {
+        for(std::uint32_t i = 0; i < _currentMass->gears().size(); i++) {
             ImGui::TableNextRow();
             ImGui::TableNextColumn();
             ImGui::Text("%i", _currentMass->gears()[i]);
@@ -251,7 +251,7 @@ SaveTool::drawTuning() {
         ImGui::TableNextColumn();
         ImGui::TextUnformatted("Modules");
 
-        for(UnsignedInt i = 0; i < _currentMass->modules().size(); i++) {
+        for(std::uint32_t i = 0; i < _currentMass->modules().size(); i++) {
             ImGui::TableNextRow();
             ImGui::TableNextColumn();
             ImGui::Text("%i", _currentMass->modules()[i]);
@@ -277,7 +277,7 @@ SaveTool::drawTuning() {
         ImGui::TableNextColumn();
         ImGui::TextUnformatted("Techs");
 
-        for(UnsignedInt i = 0; i < _currentMass->techs().size(); i++) {
+        for(std::uint32_t i = 0; i < _currentMass->techs().size(); i++) {
             ImGui::TableNextRow();
             ImGui::TableNextColumn();
             ImGui::Text("%i", _currentMass->techs()[i]);
@@ -515,7 +515,7 @@ SaveTool::drawAccessoryEditor(Accessory& accessory, Containers::ArrayView<Custom
 
     ImGui::SameLine();
 
-    static Int tab = 0;
+    static std::int32_t tab = 0;
     static Containers::Optional<AccessorySize> size = Containers::NullOpt;
     if(ImGui::SmallButton("Change")) {
         ImGui::OpenPopup("##AccessoryPopup");
@@ -539,7 +539,7 @@ SaveTool::drawAccessoryEditor(Accessory& accessory, Containers::ArrayView<Custom
             "L",
             "XL"
         };
-        static const Float selectable_width = 90.0f;
+        static const float selectable_width = 90.0f;
 
         ImGui::PushStyleVar(ImGuiStyleVar_SelectableTextAlign, {0.5f, 0.0f});
         if(ImGui::Selectable("Primitives", tab == 0, ImGuiSelectableFlags_DontClosePopups, {selectable_width, 0.0f})) {
@@ -740,7 +740,7 @@ SaveTool::drawAccessoryEditor(Accessory& accessory, Containers::ArrayView<Custom
 }
 
 Containers::StringView
-SaveTool::getStyleName(Int id, Containers::ArrayView<CustomStyle> view) {
+SaveTool::getStyleName(std::int32_t id, Containers::ArrayView<CustomStyle> view) {
     if(id >= 0 && id <= 15) {
         return view[id].name;
     }

src/SaveTool/SaveTool_MassViewer_Armour.cpp

@@ -43,7 +43,7 @@ SaveTool::drawArmour() {
         #undef c
     };
 
-    for(UnsignedInt i = 0; i < _currentMass->armourParts().size(); i++) {
+    for(std::uint32_t i = 0; i < _currentMass->armourParts().size(); i++) {
         ImGui::PushID(int(i));
 
         auto& part = _currentMass->armourParts()[i];
@@ -53,10 +53,10 @@ SaveTool::drawArmour() {
         std::memset(header, '\0', 129);
 
         if(armour_sets.find(part.id) != armour_sets.cend()) {
-            std::snprintf(header, 128, "%s: %s###%u", slot_labels[UnsignedInt(part.slot)].data(), armour_sets.at(part.id).name.data(), UnsignedInt(part.slot));
+            std::snprintf(header, 128, "%s: %s###%u", slot_labels[std::uint32_t(part.slot)].data(), armour_sets.at(part.id).name.data(), std::uint32_t(part.slot));
         }
         else {
-            std::snprintf(header, 128, "%s: %i###%u", slot_labels[UnsignedInt(part.slot)].data(), part.id, UnsignedInt(part.slot));
+            std::snprintf(header, 128, "%s: %i###%u", slot_labels[std::uint32_t(part.slot)].data(), part.id, std::uint32_t(part.slot));
         }
 
         if(ImGui::CollapsingHeader(header)) {
@@ -64,7 +64,7 @@ SaveTool::drawArmour() {
 
             ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x * 0.491f);
             if(ImGui::BeginListBox("##ChangePart")) {
-                if(std::strncmp("Neck", slot_labels[UnsignedInt(part.slot)].data(), 4) != 0) {
+                if(std::strncmp("Neck", slot_labels[std::uint32_t(part.slot)].data(), 4) != 0) {
                     for(auto& set : armour_sets) {
                         if(ImGui::Selectable(set.second.name.data(), set.first == part.id, ImGuiSelectableFlags_SpanAvailWidth)) {
                             part.id = set.first;
@@ -97,7 +97,7 @@ SaveTool::drawArmour() {
 
             ImGui::TextUnformatted("Styles:");
 
-            for(Int j = 0; j < 4; j++) {
+            for(std::int32_t j = 0; j < 4; j++) {
                 drawAlignedText("Slot %d:", j + 1);
 
                 ImGui::SameLine();
@@ -125,7 +125,7 @@ SaveTool::drawArmour() {
             ImGui::PushID("Decal");
 
             drawAlignedText("Showing/editing decal");
-            for(UnsignedInt j = 0; j < part.decals.size(); j++) {
+            for(std::uint32_t j = 0; j < part.decals.size(); j++) {
                 ImGui::SameLine();
                 ImGui::RadioButton(std::to_string(j + 1).c_str(), &_selectedArmourDecals[i], int(j));
             }
@@ -140,7 +140,7 @@ SaveTool::drawArmour() {
                 ImGui::PushID("Accessory");
 
                 drawAlignedText("Showing/editing accessory");
-                for(UnsignedInt j = 0; j < part.accessories.size(); j++) {
+                for(std::uint32_t j = 0; j < part.accessories.size(); j++) {
                     ImGui::SameLine();
                     ImGui::RadioButton(std::string{char(65 + j)}.c_str(), &_selectedArmourAccessories[i], int(j));
                 }
@@ -200,9 +200,9 @@ SaveTool::drawArmour() {
 
         drawAlignedText("Socket:");
         ImGui::SameLine();
-        if(ImGui::BeginCombo("##Socket", socket_labels[UnsignedInt(placement.socket)].data())) {
+        if(ImGui::BeginCombo("##Socket", socket_labels[std::uint32_t(placement.socket)].data())) {
-            for(UnsignedInt i = 0; i < (sizeof(socket_labels) / sizeof(socket_labels[0])); i++) {
+            for(std::uint32_t i = 0; i < (sizeof(socket_labels) / sizeof(socket_labels[0])); i++) {
-                if(ImGui::Selectable(socket_labels[i].data(), i == UnsignedInt(placement.socket), ImGuiSelectableFlags_SpanAvailWidth)) {
+                if(ImGui::Selectable(socket_labels[i].data(), i == std::uint32_t(placement.socket), ImGuiSelectableFlags_SpanAvailWidth)) {
                     placement.socket = static_cast<BulletLauncherSocket>(i);
                 }
             }
@@ -302,7 +302,7 @@ SaveTool::drawCustomArmourStyles() {
 
     ImGui::TextWrapped("In-game values are multiplied by 100. For example, 0.500 here is equal to 50 in-game.");
 
-    for(UnsignedInt i = 0; i < _currentMass->armourCustomStyles().size(); i++) {
+    for(std::uint32_t i = 0; i < _currentMass->armourCustomStyles().size(); i++) {
         ImGui::PushID(int(i));
         DCSResult result;
         result = drawCustomStyle(_currentMass->armourCustomStyles()[i]);

src/SaveTool/SaveTool_MassViewer_Frame.cpp

@@ -202,7 +202,7 @@ SaveTool::drawFrameStyles() {
         return;
     }
 
-    for(Int i = 0; i < 4; i++) {
+    for(std::int32_t i = 0; i < 4; i++) {
         drawAlignedText("Slot %d:", i + 1);
 
         ImGui::SameLine();
@@ -294,7 +294,7 @@ SaveTool::drawCustomFrameStyles() {
 
     ImGui::TextWrapped("In-game values are multiplied by 100. For example, 0.500 here is equal to 50 in-game.");
 
-    for(UnsignedInt i = 0; i < _currentMass->frameCustomStyles().size(); i++) {
+    for(std::uint32_t i = 0; i < _currentMass->frameCustomStyles().size(); i++) {
         ImGui::PushID(int(i));
         DCSResult result;
         result = drawCustomStyle(_currentMass->frameCustomStyles()[i]);

src/SaveTool/SaveTool_MassViewer_Weapons.cpp

@@ -28,7 +28,7 @@ SaveTool::drawWeapons() {
         return;
     }
 
-    const Float footer_height_to_reserve = ImGui::GetStyle().ItemSpacing.y + ImGui::GetFrameHeightWithSpacing();
+    const float footer_height_to_reserve = ImGui::GetStyle().ItemSpacing.y + ImGui::GetFrameHeightWithSpacing();
 
     ImGui::BeginGroup();
 
@@ -265,7 +265,7 @@ SaveTool::drawWeaponCategory(Containers::StringView name, Containers::ArrayView<
 
     ImGui::PushID(payload_type.data());
 
-    for(UnsignedInt i = 0; i < weapons_view.size(); i++) {
+    for(std::uint32_t i = 0; i < weapons_view.size(); i++) {
         auto& weapon = weapons_view[i];
 
         ImGui::TableNextRow();
@@ -277,7 +277,7 @@ SaveTool::drawWeaponCategory(Containers::StringView name, Containers::ArrayView<
             _currentWeapon = &weapon;
         }
         if(ImGui::BeginDragDropSource()) {
-            ImGui::SetDragDropPayload(payload_type.data(), &i, sizeof(UnsignedInt));
+            ImGui::SetDragDropPayload(payload_type.data(), &i, sizeof(std::uint32_t));
             if(ImGui::GetIO().KeyCtrl) {
                 ImGui::Text("%s %i - %s (copy)", payload_tooltip.data(), i + 1, weapon.name.data());
             }
@@ -331,7 +331,7 @@ SaveTool::drawWeaponEditor(Weapon& weapon) {
         #undef c
     };
 
-    drawAlignedText("%s: %s", labels[UnsignedInt(weapon.type)].data(), weapon.name.data());
+    drawAlignedText("%s: %s", labels[std::uint32_t(weapon.type)].data(), weapon.name.data());
 
     ImGui::SameLine();
 
@@ -428,8 +428,8 @@ SaveTool::drawWeaponEditor(Weapon& weapon) {
 
     if(ImGui::CollapsingHeader("Weapon parts")) {
         drawAlignedText("Viewing/editing part:");
-        for(Int i = 0; UnsignedLong(i) < weapon.parts.size(); i++) {
+        for(std::int32_t i = 0; std::size_t(i) < weapon.parts.size(); i++) {
-            if(UnsignedLong(_selectedWeaponPart) >= weapon.parts.size()) {
+            if(std::size_t(_selectedWeaponPart) >= weapon.parts.size()) {
                 _selectedWeaponPart = 0;
             }
             ImGui::SameLine();
@@ -438,7 +438,7 @@ SaveTool::drawWeaponEditor(Weapon& weapon) {
 
         auto& part = weapon.parts[_selectedWeaponPart];
 
-        const auto* map = [this, &weapon]()-> const std::map<Int, Containers::StringView>* {
+        const auto* map = [this, &weapon]()-> const std::map<std::int32_t, Containers::StringView>* {
             switch(weapon.type) {
                 case WeaponType::Melee:
                     return _selectedWeaponPart == 0 ? &melee_grips : &melee_assaulters;
@@ -511,7 +511,7 @@ SaveTool::drawWeaponEditor(Weapon& weapon) {
         if(ImGui::BeginChild("##PartDetails", {0.0f, 0.0f}, true)) {
             ImGui::TextUnformatted("Styles:");
 
-            for(Int i = 0; i < 4; i++) {
+            for(std::int32_t i = 0; i < 4; i++) {
                 drawAlignedText("Slot %d:", i + 1);
 
                 ImGui::SameLine();
@@ -537,7 +537,7 @@ SaveTool::drawWeaponEditor(Weapon& weapon) {
             ImGui::PushID("Decal");
 
             drawAlignedText("Showing/editing decal");
-            for(UnsignedLong i = 0; i < part.decals.size(); i++) {
+            for(std::size_t i = 0; i < part.decals.size(); i++) {
                 ImGui::SameLine();
                 ImGui::RadioButton(std::to_string(i + 1).c_str(), &_selectedWeaponDecal, int(i));
             }
@@ -552,7 +552,7 @@ SaveTool::drawWeaponEditor(Weapon& weapon) {
                 ImGui::PushID("Accessory");
 
                 drawAlignedText("Showing/editing accessory");
-                for(UnsignedLong i = 0; i < part.accessories.size(); i++) {
+                for(std::size_t i = 0; i < part.accessories.size(); i++) {
                     ImGui::SameLine();
                     ImGui::RadioButton(std::string{char(65 + i)}.c_str(), &_selectedWeaponAccessory, int(i));
                 }

src/SaveTool/SaveTool_UpdateChecker.cpp

@@ -73,10 +73,10 @@ SaveTool::updateCheckEvent(SDL_Event& event) {
                 prerelease = true;
             }
         }
-        Int fullVersion;
+        std::int32_t fullVersion;
-        Int major = 0;
+        std::int32_t major = 0;
-        Int minor = 0;
+        std::int32_t minor = 0;
-        Int patch = 0;
+        std::int32_t patch = 0;
         bool prerelease = false;
 
         bool operator==(const Version& other) const {
@@ -161,7 +161,7 @@ SaveTool::checkForUpdates() {
         if(code == CURLE_OK) {
             long status = 0;
             curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &status);
-            event.user.code = Int(status);
+            event.user.code = std::int32_t(status);
             event.user.data1 = response_body.release();
         }
         else if(code == CURLE_OPERATION_TIMEDOUT) {

src/SaveTool/SaveTool_drawMainMenu.cpp

@@ -113,7 +113,7 @@ SaveTool::drawMainMenu() {
             ImGui::SameLine();
             ImGui::AlignTextToFramePadding();
             drawHelpMarker("This gives access to save edition features that can be considered cheats.",
-                           Float(windowSize().x()) * 0.4f);
+                           float(windowSize().x()) * 0.4f);
 
             if(drawCheckbox("Advanced mode", conf().advancedMode())) {
                 conf().setAdvancedMode(!conf().advancedMode());
@@ -121,7 +121,7 @@ SaveTool::drawMainMenu() {
             ImGui::SameLine();
             ImGui::AlignTextToFramePadding();
             drawHelpMarker("This gives access to editing values that have unknown purposes or are undocumented.",
-                           Float(windowSize().x()) * 0.4f);
+                           float(windowSize().x()) * 0.4f);
 
             if(drawCheckbox("Check for updates on startup", conf().checkUpdatesOnStartup())) {
                 conf().setCheckUpdatesOnStartup(!conf().checkUpdatesOnStartup());

src/ToastQueue/ToastQueue.cpp

@@ -26,15 +26,15 @@
 
 using namespace Containers::Literals;
 
-constexpr UnsignedInt success_colour = 0xff67d23bu;
+constexpr std::uint32_t success_colour = 0xff67d23bu;
-constexpr UnsignedInt info_colour    = 0xffcc832fu;
+constexpr std::uint32_t info_colour    = 0xffcc832fu;
-constexpr UnsignedInt warning_colour = 0xff2fcfc7u;
+constexpr std::uint32_t warning_colour = 0xff2fcfc7u;
-constexpr UnsignedInt error_colour   = 0xff3134cdu;
+constexpr std::uint32_t error_colour   = 0xff3134cdu;
 
-constexpr UnsignedInt fade_time = 150;
+constexpr std::uint32_t fade_time = 150;
-constexpr Float base_opacity = 1.0f;
+constexpr float base_opacity = 1.0f;
 constexpr Vector2 padding{20.0f, 20.0f};
-constexpr Float toast_spacing = 10.0f;
+constexpr float toast_spacing = 10.0f;
 
 Toast::Toast(Type type, Containers::StringView message, std::chrono::milliseconds timeout):
     _type{type},
@@ -42,7 +42,7 @@ Toast::Toast(Type type, Containers::StringView message, std::chrono::millisecond
     _timeout{timeout},
     _creationTime{std::chrono::steady_clock::now()}
 {
-    _phaseTrack = Animation::Track<UnsignedInt, Phase>{{
+    _phaseTrack = Animation::Track<std::uint32_t, Phase>{{
         {0,                                 Phase::FadeIn},
         {fade_time,                         Phase::Wait},
         {fade_time + timeout.count(),       Phase::FadeOut},
@@ -80,16 +80,16 @@ Toast::phase() {
     return _phaseTrack.at(elapsedTime().count());
 }
 
-Float
+float
 Toast::opacity() {
     Phase phase = this->phase();
-    Long elapsed_time = elapsedTime().count();
+    std::int64_t elapsed_time = elapsedTime().count();
 
     if(phase == Phase::FadeIn) {
-        return Float(elapsed_time) / Float(fade_time);
+        return float(elapsed_time) / float(fade_time);
     }
     else if(phase == Phase::FadeOut) {
-        return 1.0f - ((Float(elapsed_time) - Float(fade_time) - Float(_timeout.count())) / Float(fade_time));
+        return 1.0f - ((float(elapsed_time) - float(fade_time) - float(_timeout.count())) / float(fade_time));
     }
 
     return 1.0f;
@@ -107,9 +107,9 @@ ToastQueue::addToast(Toast::Type type, Containers::StringView message, std::chro
 
 void
 ToastQueue::draw(Vector2i viewport_size) {
-    Float height = 0.0f;
+    float height = 0.0f;
 
-    for(UnsignedInt i = 0; i < _toasts.size(); i++) {
+    for(std::uint32_t i = 0; i < _toasts.size(); i++) {
         Toast* current = &_toasts[i];
 
         if(current->phase() == Toast::Phase::TimedOut) {
@@ -119,11 +119,12 @@ ToastQueue::draw(Vector2i viewport_size) {
 
         Containers::String win_id = Utility::format("##Toast{}", i);
 
-        Float opacity = base_opacity * current->opacity();
+        float opacity = base_opacity * current->opacity();
 
         ImGui::PushStyleVar(ImGuiStyleVar_Alpha, opacity);
 
-        ImGui::SetNextWindowPos({viewport_size.x() - padding.x(), viewport_size.y() - padding.y() - height}, ImGuiCond_Always, {1.0f, 1.0f});
+        ImGui::SetNextWindowPos({float(viewport_size.x()) - padding.x(), float(viewport_size.y()) - padding.y() - height},
+                                ImGuiCond_Always, {1.0f, 1.0f});
         if(ImGui::Begin(win_id.data(), nullptr,
                         ImGuiWindowFlags_AlwaysAutoResize|ImGuiWindowFlags_NoDecoration|
                         ImGuiWindowFlags_NoInputs|ImGuiWindowFlags_NoNav|ImGuiWindowFlags_NoFocusOnAppearing))
@@ -168,6 +169,6 @@ ToastQueue::draw(Vector2i viewport_size) {
 }
 
 void
-ToastQueue::removeToast(Long index) {
+ToastQueue::removeToast(std::int64_t index) {
     _toasts.erase(_toasts.begin() + index);
 }

src/ToastQueue/ToastQueue.h

@@ -29,11 +29,11 @@ using namespace Magnum;
 
 class Toast {
     public:
-        enum class Type : UnsignedByte {
+        enum class Type: std::uint8_t {
             Default, Success, Info, Warning, Error
         };
 
-        enum class Phase : UnsignedByte {
+        enum class Phase: std::uint8_t {
             FadeIn, Wait, FadeOut, TimedOut
         };
 
@@ -58,14 +58,14 @@ class Toast {
 
         Phase phase();
 
-        Float opacity();
+        float opacity();
 
     private:
         Type _type{Type::Default};
         Containers::String _message;
         std::chrono::milliseconds _timeout;
         std::chrono::steady_clock::time_point _creationTime;
-        Animation::Track<UnsignedInt, Phase> _phaseTrack;
+        Animation::Track<std::uint32_t, Phase> _phaseTrack;
 };
 
 class ToastQueue {
@@ -78,7 +78,7 @@ class ToastQueue {
         void draw(Vector2i viewport_size);
 
     private:
-        void removeToast(Long index);
+        void removeToast(std::int64_t index);
 
         std::vector<Toast> _toasts;
 };

src/UESaveFile/BinaryReader.cpp

@@ -45,13 +45,13 @@ BinaryReader::eof() {
     return std::feof(_file) != 0;
 }
 
-Long
+std::int64_t
 BinaryReader::position() {
     return _ftelli64(_file);
 }
 
 bool
-BinaryReader::seek(Long position) {
+BinaryReader::seek(std::int64_t position) {
     return _fseeki64(_file, position, SEEK_SET) == 0;
 }
 
@@ -67,53 +67,53 @@ BinaryReader::readChar(char& value) {
 }
 
 bool
-BinaryReader::readByte(Byte& value) {
+BinaryReader::readInt8(std::int8_t& value) {
-    return std::fread(&value, sizeof(Byte), 1, _file) == 1;
+    return std::fread(&value, sizeof(std::int8_t), 1, _file) == 1;
 }
 
 bool
-BinaryReader::readUnsignedByte(UnsignedByte& value) {
+BinaryReader::readUint8(std::uint8_t& value) {
-    return std::fread(&value, sizeof(UnsignedByte), 1, _file) == 1;
+    return std::fread(&value, sizeof(std::uint8_t), 1, _file) == 1;
 }
 
 bool
-BinaryReader::readShort(Short& value) {
+BinaryReader::readInt16(std::int16_t& value) {
-    return std::fread(&value, sizeof(Short), 1, _file) == 1;
+    return std::fread(&value, sizeof(std::int16_t), 1, _file) == 1;
 }
 
 bool
-BinaryReader::readUnsignedShort(UnsignedShort& value) {
+BinaryReader::readUint16(std::uint16_t& value) {
-    return std::fread(&value, sizeof(UnsignedShort), 1, _file) == 1;
+    return std::fread(&value, sizeof(std::uint16_t), 1, _file) == 1;
 }
 
 bool
-BinaryReader::readInt(Int& value) {
+BinaryReader::readInt32(std::int32_t& value) {
-    return std::fread(&value, sizeof(Int), 1, _file) == 1;
+    return std::fread(&value, sizeof(std::int32_t), 1, _file) == 1;
 }
 
 bool
-BinaryReader::readUnsignedInt(UnsignedInt& value) {
+BinaryReader::readUint32(std::uint32_t& value) {
-    return std::fread(&value, sizeof(UnsignedInt), 1, _file) == 1;
+    return std::fread(&value, sizeof(std::uint32_t), 1, _file) == 1;
 }
 
 bool
-BinaryReader::readLong(Long& value) {
+BinaryReader::readInt64(std::int64_t& value) {
-    return std::fread(&value, sizeof(Long), 1, _file) == 1;
+    return std::fread(&value, sizeof(std::int64_t), 1, _file) == 1;
 }
 
 bool
-BinaryReader::readUnsignedLong(UnsignedLong& value) {
+BinaryReader::readUint64(std::uint64_t& value) {
-    return std::fread(&value, sizeof(UnsignedLong), 1, _file) == 1;
+    return std::fread(&value, sizeof(std::uint64_t), 1, _file) == 1;
 }
 
 bool
-BinaryReader::readFloat(Float& value) {
+BinaryReader::readFloat(float& value) {
-    return std::fread(&value, sizeof(Float), 1, _file) == 1;
+    return std::fread(&value, sizeof(float), 1, _file) == 1;
 }
 
 bool
-BinaryReader::readDouble(Double& value) {
+BinaryReader::readDouble(double& value) {
-    return std::fread(&value, sizeof(Double), 1, _file) == 1;
+    return std::fread(&value, sizeof(double), 1, _file) == 1;
 }
 
 bool
@@ -127,8 +127,8 @@ BinaryReader::readArray(Containers::Array<char>& array, std::size_t count) {
 
 bool
 BinaryReader::readUEString(Containers::String& str) {
-    UnsignedInt length = 0;
+    std::uint32_t length = 0;
-    if(!readUnsignedInt(length) || length == 0) {
+    if(!readUint32(length) || length == 0) {
         return false;
     }
 
@@ -137,9 +137,9 @@ BinaryReader::readUEString(Containers::String& str) {
     return std::fread(str.data(), sizeof(char), length, _file) == length;
 }
 
-Int
+std::int32_t
 BinaryReader::peekChar() {
-    Int c;
+    std::int32_t c;
     c = std::fgetc(_file);
     std::ungetc(c, _file);
     return c;

src/UESaveFile/BinaryReader.h

@@ -16,16 +16,14 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+#include <cstdint>
 #include <cstdio>
 
 #include <Corrade/Containers/Containers.h>
 #include <Corrade/Containers/StaticArray.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 using namespace Corrade;
-using namespace Magnum;
 
 class BinaryReader {
     public:
@@ -34,23 +32,23 @@ class BinaryReader {
 
         bool open();
         bool eof();
-        Long position();
+        std::int64_t position();
 
-        bool seek(Long position);
+        bool seek(std::int64_t position);
 
         void closeFile();
 
         bool readChar(char& value);
-        bool readByte(Byte& value);
+        bool readInt8(std::int8_t& value);
-        bool readUnsignedByte(UnsignedByte& value);
+        bool readUint8(std::uint8_t& value);
-        bool readShort(Short& value);
+        bool readInt16(std::int16_t& value);
-        bool readUnsignedShort(UnsignedShort& value);
+        bool readUint16(std::uint16_t& value);
-        bool readInt(Int& value);
+        bool readInt32(std::int32_t& value);
-        bool readUnsignedInt(UnsignedInt& value);
+        bool readUint32(std::uint32_t& value);
-        bool readLong(Long& value);
+        bool readInt64(std::int64_t& value);
-        bool readUnsignedLong(UnsignedLong& value);
+        bool readUint64(std::uint64_t& value);
-        bool readFloat(Float& value);
+        bool readFloat(float& value);
-        bool readDouble(Double& value);
+        bool readDouble(double& value);
         bool readArray(Containers::Array<char>& array, std::size_t count);
 
         template<typename T>
@@ -65,7 +63,7 @@ class BinaryReader {
 
         bool readUEString(Containers::String& str);
 
-        Int peekChar();
+        std::int32_t peekChar();
 
     private:
         std::FILE* _file = nullptr;

src/UESaveFile/BinaryWriter.cpp

@@ -45,7 +45,7 @@ BinaryWriter::closeFile() {
     _file = nullptr;
 }
 
-Long
+std::int64_t
 BinaryWriter::position() {
     return _ftelli64(_file);
 }
@@ -55,7 +55,7 @@ BinaryWriter::array() const {
     return _data;
 }
 
-UnsignedLong
+std::size_t
 BinaryWriter::arrayPosition() const {
     return _index;
 }
@@ -75,53 +75,53 @@ BinaryWriter::writeChar(char value) {
 }
 
 bool
-BinaryWriter::writeByte(Byte value) {
+BinaryWriter::writeInt8(std::int8_t value) {
-    return std::fwrite(&value, sizeof(Byte), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(std::int8_t), 1, _file) == 1;
 }
 
 bool
-BinaryWriter::writeUnsignedByte(UnsignedByte value) {
+BinaryWriter::writeUint8(std::uint8_t value) {
-    return std::fwrite(&value, sizeof(UnsignedByte), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(std::uint8_t), 1, _file) == 1;
 }
 
 bool
-BinaryWriter::writeShort(Short value) {
+BinaryWriter::writeInt16(std::int16_t value) {
-    return std::fwrite(&value, sizeof(Short), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(std::int16_t), 1, _file) == 1;
 }
 
 bool
-BinaryWriter::writeUnsignedShort(UnsignedShort value) {
+BinaryWriter::writeUint16(std::uint16_t value) {
-    return std::fwrite(&value, sizeof(UnsignedShort), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(std::uint16_t), 1, _file) == 1;
 }
 
 bool
-BinaryWriter::writeInt(Int value) {
+BinaryWriter::writeInt32(std::int32_t value) {
-    return std::fwrite(&value, sizeof(Int), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(std::int32_t), 1, _file) == 1;
 }
 
 bool
-BinaryWriter::writeUnsignedInt(UnsignedInt value) {
+BinaryWriter::writeUint32(std::uint32_t value) {
-    return std::fwrite(&value, sizeof(UnsignedInt), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(std::uint32_t), 1, _file) == 1;
 }
 
 bool
-BinaryWriter::writeLong(Long value) {
+BinaryWriter::writeInt64(std::int64_t value) {
-    return std::fwrite(&value, sizeof(Long), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(std::int64_t), 1, _file) == 1;
 }
 
 bool
-BinaryWriter::writeUnsignedLong(UnsignedLong value) {
+BinaryWriter::writeUint64(std::uint64_t value) {
-    return std::fwrite(&value, sizeof(UnsignedLong), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(std::uint64_t), 1, _file) == 1;
 }
 
 bool
-BinaryWriter::writeFloat(Float value) {
+BinaryWriter::writeFloat(float value) {
-    return std::fwrite(&value, sizeof(Float), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(float), 1, _file) == 1;
 }
 
 bool
-BinaryWriter::writeDouble(Double value) {
+BinaryWriter::writeDouble(double value) {
-    return std::fwrite(&value, sizeof(Double), 1, _file) == 1;
+    return std::fwrite(&value, sizeof(double), 1, _file) == 1;
 }
 
 bool
@@ -140,7 +140,7 @@ BinaryWriter::writeUEString(Containers::StringView str) {
         return false;
     }
 
-    writeUnsignedInt(static_cast<UnsignedInt>(str.size()) + 1);
+    writeUint32(static_cast<std::uint32_t>(str.size()) + 1);
 
     if(str.size() > 0) {
         std::size_t count = std::fwrite(str.data(), sizeof(char), str.size(), _file);
@@ -151,9 +151,9 @@ BinaryWriter::writeUEString(Containers::StringView str) {
     return writeChar('\0');
 }
 
-UnsignedLong
+std::size_t
 BinaryWriter::writeUEStringToArray(Containers::StringView value) {
-    return writeValueToArray<UnsignedInt>(UnsignedInt(value.size()) + 1u) +
+    return writeValueToArray<std::uint32_t>(std::uint32_t(value.size()) + 1u) +
            writeDataToArray(Containers::ArrayView<const char>{value}) +
            writeValueToArray<char>('\0');
 }

src/UESaveFile/BinaryWriter.h

@@ -16,6 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+#include <cstdint>
 #include <cstdio>
 
 #include <Corrade/Containers/ArrayView.h>
@@ -23,10 +24,7 @@
 #include <Corrade/Containers/StaticArray.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 using namespace Corrade;
-using namespace Magnum;
 
 class BinaryWriter {
     public:
@@ -43,23 +41,23 @@ class BinaryWriter {
 
         void closeFile();
 
-        Long position();
+        std::int64_t position();
 
         Containers::ArrayView<const char> array() const;
-        UnsignedLong arrayPosition() const;
+        std::size_t arrayPosition() const;
         bool flushToFile();
 
-        bool writeByte(Byte value);
         bool writeChar(char value);
-        bool writeUnsignedByte(UnsignedByte value);
+        bool writeInt8(std::int8_t value);
-        bool writeShort(Short value);
+        bool writeUint8(std::uint8_t value);
-        bool writeUnsignedShort(UnsignedShort value);
+        bool writeInt16(std::int16_t value);
-        bool writeInt(Int value);
+        bool writeUint16(std::uint16_t value);
-        bool writeUnsignedInt(UnsignedInt value);
+        bool writeInt32(std::int32_t value);
-        bool writeLong(Long value);
+        bool writeUint32(std::uint32_t value);
-        bool writeUnsignedLong(UnsignedLong value);
+        bool writeInt64(std::int64_t value);
-        bool writeFloat(Float value);
+        bool writeUint64(std::uint64_t value);
-        bool writeDouble(Double value);
+        bool writeFloat(float value);
+        bool writeDouble(double value);
         bool writeArray(Containers::ArrayView<const char> array);
         template<std::size_t size>
         bool writeString(const char(&str)[size]) {
@@ -74,30 +72,30 @@ class BinaryWriter {
         bool writeUEString(Containers::StringView str);
 
         template<typename T, typename U = std::conditional_t<std::is_trivially_copyable<T>::value, T, T&>>
-        UnsignedLong writeValueToArray(U value) {
+        std::size_t writeValueToArray(U value) {
             Containers::ArrayView<T> view{&value, 1};
             return writeDataToArray(view);
         }
 
-        UnsignedLong writeUEStringToArray(Containers::StringView value);
+        std::size_t writeUEStringToArray(Containers::StringView value);
 
         template<typename T>
-        void writeValueToArrayAt(T& value, UnsignedLong position) {
+        void writeValueToArrayAt(T& value, std::size_t position) {
             Containers::ArrayView<T> view{&value, 1};
             writeDataToArrayAt(view, position);
         }
 
         template<typename T>
-        UnsignedLong writeDataToArray(Containers::ArrayView<T> view) {
+        std::size_t writeDataToArray(Containers::ArrayView<T> view) {
             arrayAppend(_data, Containers::arrayCast<const char>(view));
             _index += sizeof(T) * view.size();
             return sizeof(T) * view.size();
         }
 
         template<typename T>
-        void writeDataToArrayAt(Containers::ArrayView<T> view, UnsignedLong position) {
+        void writeDataToArrayAt(Containers::ArrayView<T> view, std::size_t position) {
             auto casted_view = Containers::arrayCast<const char>(view);
-            for(UnsignedLong i = 0; i < casted_view.size(); i++) {
+            for(std::size_t i = 0; i < casted_view.size(); i++) {
                 _data[position + i] = casted_view[i];
             }
         }
@@ -106,5 +104,5 @@ class BinaryWriter {
         FILE* _file = nullptr;
 
         Containers::Array<char> _data;
-        UnsignedLong _index = 0;
+        std::size_t _index = 0;
 };

src/UESaveFile/PropertySerialiser.cpp

@@ -93,8 +93,8 @@ PropertySerialiser::read(BinaryReader& reader) {
         return nullptr;
     }
 
-    UnsignedLong value_length;
+    std::size_t value_length;
-    if(!reader.readUnsignedLong(value_length)) {
+    if(!reader.readUint64(value_length)) {
         return nullptr;
     }
 
@@ -102,7 +102,7 @@ PropertySerialiser::read(BinaryReader& reader) {
 }
 
 UnrealPropertyBase::ptr
-PropertySerialiser::readItem(BinaryReader& reader, Containers::String type, UnsignedLong value_length,
+PropertySerialiser::readItem(BinaryReader& reader, Containers::String type, std::size_t value_length,
                              Containers::String name)
 {
     if(reader.peekChar() < 0 || reader.eof()) {
@@ -113,7 +113,7 @@ PropertySerialiser::readItem(BinaryReader& reader, Containers::String type, Unsi
 }
 
 Containers::Array<UnrealPropertyBase::ptr>
-PropertySerialiser::readSet(BinaryReader& reader, Containers::StringView item_type, UnsignedInt count) {
+PropertySerialiser::readSet(BinaryReader& reader, Containers::StringView item_type, std::uint32_t count) {
     if(reader.peekChar() < 0 || reader.eof()) {
         return nullptr;
     }
@@ -133,8 +133,8 @@ PropertySerialiser::readSet(BinaryReader& reader, Containers::StringView item_ty
             return nullptr;
         }
 
-        UnsignedLong value_length;
+        std::size_t value_length;
-        if(!reader.readUnsignedLong(value_length)) {
+        if(!reader.readUint64(value_length)) {
             return nullptr;
         }
 
@@ -147,8 +147,8 @@ PropertySerialiser::readSet(BinaryReader& reader, Containers::StringView item_ty
         }
     }
     else {
-        for(UnsignedInt i = 0; i < count; i++) {
+        for(std::uint32_t i = 0; i < count; i++) {
-            auto item = readItem(reader, item_type, UnsignedLong(-1), "");
+            auto item = readItem(reader, item_type, std::size_t(-1), "");
             arrayAppend(array, std::move(item));
         }
     }
@@ -157,7 +157,7 @@ PropertySerialiser::readSet(BinaryReader& reader, Containers::StringView item_ty
 }
 
 UnrealPropertyBase::ptr
-PropertySerialiser::deserialise(Containers::String name, Containers::String type, UnsignedLong value_length,
+PropertySerialiser::deserialise(Containers::String name, Containers::String type, std::size_t value_length,
                                 BinaryReader& reader)
 {
     UnrealPropertyBase::ptr prop;
@@ -181,7 +181,7 @@ PropertySerialiser::deserialise(Containers::String name, Containers::String type
 }
 
 bool PropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, Containers::StringView item_type,
-                                   UnsignedLong& bytes_written, BinaryWriter& writer)
+                                   std::size_t& bytes_written, BinaryWriter& writer)
 {
     auto serialiser = getSerialiser(item_type);
     if(!serialiser) {
@@ -191,7 +191,7 @@ bool PropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, Containers::St
 }
 
 bool
-PropertySerialiser::write(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer) {
+PropertySerialiser::write(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer) {
     if(prop->name == "None" && prop->propertyType == "NoneProperty" && dynamic_cast<NoneProperty*>(prop.get())) {
         bytes_written += writer.writeUEStringToArray(*prop->name);
         return true;
@@ -200,10 +200,10 @@ PropertySerialiser::write(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_wri
     bytes_written += writer.writeUEStringToArray(*prop->name);
     bytes_written += writer.writeUEStringToArray(prop->propertyType);
 
-    UnsignedLong value_length = 0;
+    std::size_t value_length = 0;
-    UnsignedLong vl_position = writer.arrayPosition();
+    std::size_t vl_position = writer.arrayPosition();
 
-    bytes_written += writer.writeValueToArray<UnsignedLong>(value_length);
+    bytes_written += writer.writeValueToArray<std::size_t>(value_length);
 
     bool ret = serialise(prop, prop->propertyType, value_length, writer);
 
@@ -216,7 +216,7 @@ PropertySerialiser::write(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_wri
 
 bool
 PropertySerialiser::writeItem(UnrealPropertyBase::ptr& prop, Containers::StringView item_type,
-                              UnsignedLong& bytes_written, BinaryWriter& writer)
+                              std::size_t& bytes_written, BinaryWriter& writer)
 {
     if(prop->name == "None" && prop->propertyType == "NoneProperty" && dynamic_cast<NoneProperty*>(prop.get())) {
         bytes_written += writer.writeUEStringToArray(*prop->name);
@@ -227,7 +227,7 @@ PropertySerialiser::writeItem(UnrealPropertyBase::ptr& prop, Containers::StringV
 }
 
 bool PropertySerialiser::writeSet(Containers::ArrayView<UnrealPropertyBase::ptr> props,
-                                  Containers::StringView item_type, UnsignedLong& bytes_written, BinaryWriter& writer)
+                                  Containers::StringView item_type, std::size_t& bytes_written, BinaryWriter& writer)
 {
     auto serialiser = getCollectionSerialiser(item_type);
     if(serialiser) {

src/UESaveFile/PropertySerialiser.h

@@ -35,20 +35,20 @@ class PropertySerialiser {
         static PropertySerialiser& instance();
 
         UnrealPropertyBase::ptr read(BinaryReader& reader);
-        UnrealPropertyBase::ptr readItem(BinaryReader& reader, Containers::String type, UnsignedLong value_length,
+        UnrealPropertyBase::ptr readItem(BinaryReader& reader, Containers::String type, std::size_t value_length,
                                          Containers::String name);
         Containers::Array<UnrealPropertyBase::ptr> readSet(BinaryReader& reader, Containers::StringView item_type,
-                                                           UnsignedInt count);
+                                                           std::uint32_t count);
-        UnrealPropertyBase::ptr deserialise(Containers::String name, Containers::String type, UnsignedLong value_length,
+        UnrealPropertyBase::ptr deserialise(Containers::String name, Containers::String type, std::size_t value_length,
                                             BinaryReader& reader);
 
-        bool serialise(UnrealPropertyBase::ptr& prop, Containers::StringView item_type, UnsignedLong& bytes_written,
+        bool serialise(UnrealPropertyBase::ptr& prop, Containers::StringView item_type, std::size_t& bytes_written,
                        BinaryWriter& writer);
-        bool write(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer);
+        bool write(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer);
-        bool writeItem(UnrealPropertyBase::ptr& prop, Containers::StringView item_type, UnsignedLong& bytes_written,
+        bool writeItem(UnrealPropertyBase::ptr& prop, Containers::StringView item_type, std::size_t& bytes_written,
                        BinaryWriter& writer);
         bool writeSet(Containers::ArrayView<UnrealPropertyBase::ptr> props, Containers::StringView item_type,
-                      UnsignedLong& bytes_written, BinaryWriter& writer);
+                      std::size_t& bytes_written, BinaryWriter& writer);
 
     private:
         PropertySerialiser();

src/UESaveFile/Serialisers/AbstractUnrealCollectionPropertySerialiser.h

@@ -21,12 +21,9 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "../Types/UnrealPropertyBase.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 class BinaryReader;
 class BinaryWriter;
@@ -44,9 +41,9 @@ class AbstractUnrealCollectionPropertySerialiser {
         virtual StringArrayView types() = 0;
 
         virtual PropertyArray deserialise(Containers::StringView name, Containers::StringView type,
-                                          UnsignedLong value_length, UnsignedInt count, BinaryReader& reader,
+                                          std::size_t value_length, std::uint32_t count, BinaryReader& reader,
                                           PropertySerialiser& serialiser) = 0;
 
-        virtual auto serialise(Containers::ArrayView<UnrealPropertyBase::ptr> props, Containers::StringView item_type,
+        virtual bool serialise(Containers::ArrayView<UnrealPropertyBase::ptr> props, Containers::StringView item_type,
-                               UnsignedLong& bytes_written, BinaryWriter& writer, PropertySerialiser& serialiser) -> bool = 0;
+                               std::size_t& bytes_written, BinaryWriter& writer, PropertySerialiser& serialiser) = 0;
 };

src/UESaveFile/Serialisers/AbstractUnrealPropertySerialiser.h

@@ -20,12 +20,9 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "../Types/UnrealPropertyBase.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 class BinaryReader;
 class BinaryWriter;
@@ -42,9 +39,9 @@ class AbstractUnrealPropertySerialiser {
         virtual StringArrayView types() = 0;
 
         virtual UnrealPropertyBase::ptr deserialise(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) = 0;
 
-        virtual bool serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        virtual bool serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) = 0;
 };

src/UESaveFile/Serialisers/AbstractUnrealStructSerialiser.h

@@ -21,12 +21,9 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "../Types/UnrealPropertyBase.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 class BinaryReader;
 class BinaryWriter;
@@ -41,6 +38,5 @@ class AbstractUnrealStructSerialiser {
 
         virtual UnrealPropertyBase::ptr deserialise(BinaryReader& reader) = 0;
 
-        virtual bool serialise(UnrealPropertyBase::ptr& structProp, BinaryWriter& writer,
+        virtual bool serialise(UnrealPropertyBase::ptr& structProp, BinaryWriter& writer, std::size_t& bytes_written) = 0;
-                               UnsignedLong& bytes_written) = 0;
 };

src/UESaveFile/Serialisers/ArrayPropertySerialiser.cpp

@@ -25,7 +25,7 @@
 
 UnrealPropertyBase::ptr
 ArrayPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                             UnsignedLong value_length, BinaryReader& reader,
+                                             std::size_t value_length, BinaryReader& reader,
                                              PropertySerialiser& serialiser)
 {
     Containers::String item_type;
@@ -40,8 +40,8 @@ ArrayPropertySerialiser::deserialiseProperty(Containers::StringView name, Contai
         return nullptr;
     }
 
-    UnsignedInt item_count;
+    std::uint32_t item_count;
-    if(!reader.readUnsignedInt(item_count)) {
+    if(!reader.readUint32(item_count)) {
         LOG_ERROR_FORMAT("Couldn't read array property {}'s item count.", name);
         return nullptr;
     }
@@ -54,7 +54,7 @@ ArrayPropertySerialiser::deserialiseProperty(Containers::StringView name, Contai
 }
 
 bool
-ArrayPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+ArrayPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                            BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto array_prop = dynamic_cast<ArrayProperty*>(prop.get());
@@ -65,10 +65,10 @@ ArrayPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Unsign
 
     writer.writeUEStringToArray(array_prop->itemType);
     writer.writeValueToArray<char>('\0');
-    bytes_written += writer.writeValueToArray<UnsignedInt>(UnsignedInt(array_prop->items.size()));
+    bytes_written += writer.writeValueToArray<std::uint32_t>(std::uint32_t(array_prop->items.size()));
 
-    UnsignedLong start_pos = writer.arrayPosition();
+    std::size_t start_pos = writer.arrayPosition();
-    UnsignedLong dummy_bytes_written = 0;
+    std::size_t dummy_bytes_written = 0;
     bool ret = serialiser.writeSet(array_prop->items, array_prop->itemType, dummy_bytes_written, writer);
     bytes_written += writer.arrayPosition() - start_pos;
 

src/UESaveFile/Serialisers/ArrayPropertySerialiser.h

@@ -18,14 +18,11 @@
 
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "UnrealPropertySerialiser.h"
 
 #include "../Types/ArrayProperty.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 class ArrayPropertySerialiser : public UnrealPropertySerialiser<ArrayProperty> {
     public:
@@ -33,8 +30,8 @@ class ArrayPropertySerialiser : public UnrealPropertySerialiser<ArrayProperty> {
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/BoolPropertySerialiser.cpp

@@ -28,7 +28,7 @@ BoolPropertySerialiser::types() {
 }
 
 UnrealPropertyBase::ptr
-BoolPropertySerialiser::deserialise(Containers::StringView name, Containers::StringView type, UnsignedLong value_length,
+BoolPropertySerialiser::deserialise(Containers::StringView name, Containers::StringView type, std::size_t value_length,
                                     BinaryReader& reader, PropertySerialiser& serialiser)
 {
     if(value_length != 0) {
@@ -36,8 +36,8 @@ BoolPropertySerialiser::deserialise(Containers::StringView name, Containers::Str
         return nullptr;
     }
 
-    Short value;
+    std::int16_t value;
-    if(!reader.readShort(value)) {
+    if(!reader.readInt16(value)) {
         LOG_ERROR_FORMAT("Couldn't read bool property {}'s value.", name);
         return nullptr;
     }
@@ -54,7 +54,7 @@ BoolPropertySerialiser::deserialise(Containers::StringView name, Containers::Str
 }
 
 bool
-BoolPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+BoolPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                   PropertySerialiser& serialiser)
 {
     auto bool_prop = dynamic_cast<BoolProperty*>(prop.get());
@@ -63,7 +63,7 @@ BoolPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& b
         return false;
     }
 
-    writer.writeValueToArray<Short>(Short(bool_prop->value));
+    writer.writeValueToArray<std::int16_t>(std::int16_t(bool_prop->value));
 
     return true;
 }

src/UESaveFile/Serialisers/BoolPropertySerialiser.h

@@ -32,9 +32,9 @@ class BoolPropertySerialiser : public AbstractUnrealPropertySerialiser {
         StringArrayView types() override;
 
         UnrealPropertyBase::ptr deserialise(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser) override;
 
-        bool serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                        PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/BytePropertySerialiser.cpp

@@ -28,12 +28,12 @@ BytePropertySerialiser::types() {
 }
 
 UnrealPropertyBase::ptr
-BytePropertySerialiser::deserialise(Containers::StringView name, Containers::StringView type, UnsignedLong value_length,
+BytePropertySerialiser::deserialise(Containers::StringView name, Containers::StringView type, std::size_t value_length,
                                     BinaryReader& reader, PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<ByteProperty>();
 
-    if(value_length != UnsignedLong(-1)) {
+    if(value_length != std::size_t(-1)) {
         if(!reader.readUEString(prop->enumType)) {
             LOG_ERROR_FORMAT("Couldn't read byte property {}'s enum type.", name);
             return nullptr;
@@ -53,8 +53,8 @@ BytePropertySerialiser::deserialise(Containers::StringView name, Containers::Str
 
     prop->valueLength = value_length;
 
-    //UnsignedInt count = 0;
+    //std::uint32_t count = 0;
-    //if(!reader.readUnsignedInt(count)) {
+    //if(!reader.readstd::uint32_t(count)) {
     //    return nullptr;
     //}
 
@@ -66,7 +66,7 @@ BytePropertySerialiser::deserialise(Containers::StringView name, Containers::Str
 }
 
 bool
-BytePropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+BytePropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                   PropertySerialiser& serialiser)
 {
     auto byte_prop = dynamic_cast<ByteProperty*>(prop.get());
@@ -76,10 +76,10 @@ BytePropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& b
     }
 
     //writer.writeValueToArray<char>('\0');
-    //bytes_written += writer.writeValueToArray<UnsignedInt>(byte_prop->value.size());
+    //bytes_written += writer.writeValueToArray<std::uint32_t>(byte_prop->value.size());
     //bytes_written += writer.writeDataToArray<char>(byte_prop->value);
 
-    if(byte_prop->valueLength != UnsignedLong(-1)) {
+    if(byte_prop->valueLength != std::size_t(-1)) {
         writer.writeUEStringToArray(byte_prop->enumType);
         writer.writeValueToArray<char>('\0');
     }

src/UESaveFile/Serialisers/BytePropertySerialiser.h

@@ -30,9 +30,9 @@ class BytePropertySerialiser : public AbstractUnrealPropertySerialiser {
         StringArrayView types() override;
 
         UnrealPropertyBase::ptr deserialise(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser) override;
 
-        bool serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                        PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/ColourPropertySerialiser.cpp

@@ -22,7 +22,7 @@
 
 UnrealPropertyBase::ptr
 ColourPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                              UnsignedLong value_length, BinaryReader& reader,
+                                              std::size_t value_length, BinaryReader& reader,
                                               PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<ColourStructProperty>();
@@ -38,7 +38,7 @@ ColourPropertySerialiser::deserialiseProperty(Containers::StringView name, Conta
 }
 
 bool
-ColourPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+ColourPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                             BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto colour_prop = dynamic_cast<ColourStructProperty*>(prop.get());
@@ -47,10 +47,10 @@ ColourPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Unsig
         return false;
     }
 
-    bytes_written += writer.writeValueToArray<Float>(colour_prop->r) +
+    bytes_written += writer.writeValueToArray<float>(colour_prop->r) +
-                     writer.writeValueToArray<Float>(colour_prop->g) +
+                     writer.writeValueToArray<float>(colour_prop->g) +
-                     writer.writeValueToArray<Float>(colour_prop->b) +
+                     writer.writeValueToArray<float>(colour_prop->b) +
-                     writer.writeValueToArray<Float>(colour_prop->a);
+                     writer.writeValueToArray<float>(colour_prop->a);
 
     return true;
 }

src/UESaveFile/Serialisers/ColourPropertySerialiser.h

@@ -30,8 +30,8 @@ class ColourPropertySerialiser : public UnrealPropertySerialiser<ColourStructPro
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/DateTimePropertySerialiser.cpp

@@ -22,12 +22,12 @@
 
 UnrealPropertyBase::ptr
 DateTimePropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                UnsignedLong value_length, BinaryReader& reader,
+                                                std::size_t value_length, BinaryReader& reader,
                                                 PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<DateTimeStructProperty>();
 
-    if(!reader.readUnsignedLong(prop->timestamp)) {
+    if(!reader.readInt64(prop->timestamp)) {
         LOG_ERROR_FORMAT("Couldn't read date/time property {}'s value.", name);
         return nullptr;
     }
@@ -36,7 +36,7 @@ DateTimePropertySerialiser::deserialiseProperty(Containers::StringView name, Con
 }
 
 bool
-DateTimePropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+DateTimePropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                               BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto dt_prop = dynamic_cast<DateTimeStructProperty*>(prop.get());
@@ -45,7 +45,7 @@ DateTimePropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Uns
         return false;
     }
 
-    bytes_written += writer.writeValueToArray<UnsignedLong>(dt_prop->timestamp);
+    bytes_written += writer.writeValueToArray<std::int64_t>(dt_prop->timestamp);
 
     return true;
 }

src/UESaveFile/Serialisers/DateTimePropertySerialiser.h

@@ -28,8 +28,8 @@ class DateTimePropertySerialiser : public UnrealPropertySerialiser<DateTimeStruc
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/EnumPropertySerialiser.cpp

@@ -28,7 +28,7 @@ EnumPropertySerialiser::types() {
 }
 
 UnrealPropertyBase::ptr
-EnumPropertySerialiser::deserialise(Containers::StringView name, Containers::StringView type, UnsignedLong value_length,
+EnumPropertySerialiser::deserialise(Containers::StringView name, Containers::StringView type, std::size_t value_length,
                                     BinaryReader& reader, PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<EnumProperty>();
@@ -53,7 +53,7 @@ EnumPropertySerialiser::deserialise(Containers::StringView name, Containers::Str
 }
 
 bool
-EnumPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+EnumPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                   PropertySerialiser& serialiser)
 {
     auto enum_prop = dynamic_cast<EnumProperty*>(prop.get());

src/UESaveFile/Serialisers/EnumPropertySerialiser.h

@@ -30,9 +30,9 @@ class EnumPropertySerialiser : public AbstractUnrealPropertySerialiser {
         StringArrayView types() override;
 
         UnrealPropertyBase::ptr deserialise(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser) override;
 
-        bool serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                        PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/FloatPropertySerialiser.cpp

@@ -29,7 +29,7 @@ FloatPropertySerialiser::types() {
 
 UnrealPropertyBase::ptr
 FloatPropertySerialiser::deserialise(Containers::StringView name, Containers::StringView type,
-                                     UnsignedLong value_length, BinaryReader& reader, PropertySerialiser& serialiser)
+                                     std::size_t value_length, BinaryReader& reader, PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<FloatProperty>();
 
@@ -48,7 +48,7 @@ FloatPropertySerialiser::deserialise(Containers::StringView name, Containers::St
 }
 
 bool
-FloatPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+FloatPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                    PropertySerialiser& serialiser)
 {
     auto float_prop = dynamic_cast<FloatProperty*>(prop.get());
@@ -58,7 +58,7 @@ FloatPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong&
     }
 
     writer.writeValueToArray<char>('\0');
-    bytes_written += writer.writeValueToArray<Float>(float_prop->value);
+    bytes_written += writer.writeValueToArray<float>(float_prop->value);
 
     return true;
 }

src/UESaveFile/Serialisers/FloatPropertySerialiser.h

@@ -30,9 +30,9 @@ class FloatPropertySerialiser : public AbstractUnrealPropertySerialiser {
         StringArrayView types() override;
 
         UnrealPropertyBase::ptr deserialise(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser) override;
 
-        bool serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                        PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/GuidPropertySerialiser.cpp

@@ -24,7 +24,7 @@ using namespace Containers::Literals;
 
 UnrealPropertyBase::ptr
 GuidPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<GuidStructProperty>();
@@ -38,7 +38,7 @@ GuidPropertySerialiser::deserialiseProperty(Containers::StringView name, Contain
 }
 
 bool
-GuidPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+GuidPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                           BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto guid_prop = dynamic_cast<GuidStructProperty*>(prop.get());

src/UESaveFile/Serialisers/GuidPropertySerialiser.h

@@ -28,8 +28,8 @@ class GuidPropertySerialiser : public UnrealPropertySerialiser<GuidStructPropert
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/IntPropertySerialiser.cpp

@@ -22,18 +22,18 @@
 
 UnrealPropertyBase::ptr
 IntPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                           UnsignedLong value_length, BinaryReader& reader,
+                                           std::size_t value_length, BinaryReader& reader,
                                            PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<IntProperty>();
 
-    if(value_length == UnsignedLong(-1)) {
+    if(value_length == std::size_t(-1)) {
-        if(!reader.readInt(prop->value)) {
+        if(!reader.readInt32(prop->value)) {
             LOG_ERROR("Couldn't read int property's value.");
             return nullptr;
         }
 
-        prop->valueLength = UnsignedLong(-1);
+        prop->valueLength = std::size_t(-1);
         return prop;
     }
 
@@ -43,7 +43,7 @@ IntPropertySerialiser::deserialiseProperty(Containers::StringView name, Containe
         return nullptr;
     }
 
-    if(!reader.readInt(prop->value)) {
+    if(!reader.readInt32(prop->value)) {
         LOG_ERROR_FORMAT("Couldn't read int property {}'s value.", name);
         return nullptr;
     }
@@ -54,7 +54,7 @@ IntPropertySerialiser::deserialiseProperty(Containers::StringView name, Containe
 }
 
 bool
-IntPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+IntPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                          BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto int_prop = dynamic_cast<IntProperty*>(prop.get());
@@ -63,11 +63,11 @@ IntPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Unsigned
         return false;
     }
 
-    if(prop->valueLength != UnsignedLong(-1)) {
+    if(prop->valueLength != std::size_t(-1)) {
         writer.writeValueToArray<char>('\0');
     }
 
-    bytes_written += writer.writeValueToArray<Int>(int_prop->value);
+    bytes_written += writer.writeValueToArray<std::int32_t>(int_prop->value);
 
     return true;
 }

src/UESaveFile/Serialisers/IntPropertySerialiser.h

@@ -28,8 +28,8 @@ class IntPropertySerialiser : public UnrealPropertySerialiser<IntProperty> {
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/MapPropertySerialiser.cpp

@@ -26,7 +26,7 @@ using namespace Containers::Literals;
 
 UnrealPropertyBase::ptr
 MapPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                           UnsignedLong value_length, BinaryReader& reader,
+                                           std::size_t value_length, BinaryReader& reader,
                                            PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<MapProperty>();
@@ -47,14 +47,14 @@ MapPropertySerialiser::deserialiseProperty(Containers::StringView name, Containe
         return nullptr;
     }
 
-    UnsignedInt null;
+    std::uint32_t null;
-    if(!reader.readUnsignedInt(null) || null != 0u) {
+    if(!reader.readUint32(null) || null != 0u) {
         LOG_ERROR_FORMAT("Couldn't read a null int in map property {}.", name);
         return nullptr;
     }
 
-    UnsignedInt count;
+    std::uint32_t count;
-    if(!reader.readUnsignedInt(count)) {
+    if(!reader.readUint32(count)) {
         LOG_ERROR_FORMAT("Couldn't read map property {}'s item count.", name);
         return nullptr;
     }
@@ -64,7 +64,7 @@ MapPropertySerialiser::deserialiseProperty(Containers::StringView name, Containe
 
     arrayReserve(prop->map, count);
 
-    for(UnsignedInt i = 0; i < count; i++) {
+    for(std::uint32_t i = 0; i < count; i++) {
         MapProperty::KeyValuePair pair;
 
         if(prop->keyType == "IntProperty"_s || prop->keyType == "StrProperty"_s) {
@@ -109,7 +109,7 @@ MapPropertySerialiser::deserialiseProperty(Containers::StringView name, Containe
 }
 
 bool
-MapPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+MapPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                          BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto map_prop = dynamic_cast<MapProperty*>(prop.get());
@@ -122,12 +122,12 @@ MapPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Unsigned
     writer.writeUEStringToArray(map_prop->valueType);
     writer.writeValueToArray<char>('\0');
 
-    UnsignedLong value_start = writer.arrayPosition();
+    std::size_t value_start = writer.arrayPosition();
-    writer.writeValueToArray<UnsignedInt>(0u);
+    writer.writeValueToArray<std::uint32_t>(0u);
 
-    writer.writeValueToArray<UnsignedInt>(UnsignedInt(map_prop->map.size()));
+    writer.writeValueToArray<std::uint32_t>(std::uint32_t(map_prop->map.size()));
 
-    UnsignedLong dummy_bytes_written = 0;
+    std::size_t dummy_bytes_written = 0;
     for(auto& pair : map_prop->map) {
         if(!serialiser.writeItem(pair.key, map_prop->keyType, dummy_bytes_written, writer)) {
             LOG_ERROR("Couldn't write a key.");

src/UESaveFile/Serialisers/MapPropertySerialiser.h

@@ -28,8 +28,8 @@ class MapPropertySerialiser : public UnrealPropertySerialiser<MapProperty> {
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/ResourcePropertySerialiser.cpp

@@ -27,7 +27,7 @@ using namespace Containers::Literals;
 
 UnrealPropertyBase::ptr
 ResourcePropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                UnsignedLong value_length, BinaryReader& reader,
+                                                std::size_t value_length, BinaryReader& reader,
                                                 PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<ResourceItemValue>();
@@ -79,7 +79,7 @@ ResourcePropertySerialiser::deserialiseProperty(Containers::StringView name, Con
 }
 
 bool
-ResourcePropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+ResourcePropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                               BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto res_prop = dynamic_cast<ResourceItemValue*>(prop.get());
@@ -90,15 +90,15 @@ ResourcePropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Uns
 
     bytes_written += writer.writeUEStringToArray("ID_4_AAE08F17428E229EC7A2209F51081A21"_s) +
                      writer.writeUEStringToArray("IntProperty"_s) +
-                     writer.writeValueToArray<UnsignedLong>(4ull) +
+                     writer.writeValueToArray<std::size_t>(4ull) +
                      writer.writeValueToArray<char>('\0') +
-                     writer.writeValueToArray<Int>(res_prop->id);
+                     writer.writeValueToArray<std::int32_t>(res_prop->id);
 
     bytes_written += writer.writeUEStringToArray("Quantity_3_560F09B5485C365D3041888910019CE3"_s) +
                      writer.writeUEStringToArray("IntProperty"_s) +
-                     writer.writeValueToArray<UnsignedLong>(4ull) +
+                     writer.writeValueToArray<std::size_t>(4ull) +
                      writer.writeValueToArray<char>('\0') +
-                     writer.writeValueToArray<Int>(res_prop->quantity);
+                     writer.writeValueToArray<std::int32_t>(res_prop->quantity);
 
     bytes_written += writer.writeUEStringToArray("None"_s);
 

src/UESaveFile/Serialisers/ResourcePropertySerialiser.h

@@ -28,8 +28,8 @@ class ResourcePropertySerialiser : public UnrealPropertySerialiser<ResourceItemV
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/RotatorPropertySerialiser.cpp

@@ -22,7 +22,7 @@
 
 UnrealPropertyBase::ptr
 RotatorPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                               UnsignedLong value_length, BinaryReader& reader,
+                                               std::size_t value_length, BinaryReader& reader,
                                                PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<RotatorStructProperty>();
@@ -36,7 +36,7 @@ RotatorPropertySerialiser::deserialiseProperty(Containers::StringView name, Cont
 }
 
 bool
-RotatorPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+RotatorPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                              BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto rotator = dynamic_cast<RotatorStructProperty*>(prop.get());
@@ -45,8 +45,8 @@ RotatorPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Unsi
         return false;
     }
 
-    bytes_written += writer.writeValueToArray<Float>(rotator->x) + writer.writeValueToArray<Float>(rotator->y) +
+    bytes_written += writer.writeValueToArray<float>(rotator->x) + writer.writeValueToArray<float>(rotator->y) +
-                     writer.writeValueToArray<Float>(rotator->z);
+                     writer.writeValueToArray<float>(rotator->z);
 
     return true;
 }

src/UESaveFile/Serialisers/RotatorPropertySerialiser.h

@@ -28,8 +28,8 @@ class RotatorPropertySerialiser : public UnrealPropertySerialiser<RotatorStructP
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/SetPropertySerialiser.cpp

@@ -23,7 +23,7 @@
 
 UnrealPropertyBase::ptr
 SetPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                           UnsignedLong value_length, BinaryReader& reader,
+                                           std::size_t value_length, BinaryReader& reader,
                                            PropertySerialiser& serialiser)
 {
     Containers::String item_type;
@@ -38,14 +38,14 @@ SetPropertySerialiser::deserialiseProperty(Containers::StringView name, Containe
         return nullptr;
     }
 
-    UnsignedInt four_bytes;
+    std::uint32_t four_bytes;
-    if(!reader.readUnsignedInt(four_bytes) || four_bytes != 0u) {
+    if(!reader.readUint32(four_bytes) || four_bytes != 0u) {
         LOG_ERROR_FORMAT("Couldn't read four null bytes in set property {}.", name);
         return nullptr;
     }
 
-    UnsignedInt item_count;
+    std::uint32_t item_count;
-    if(!reader.readUnsignedInt(item_count)) {
+    if(!reader.readUint32(item_count)) {
         LOG_ERROR_FORMAT("Couldn't read set property {}'s item count.", name);
         return nullptr;
     }
@@ -58,7 +58,7 @@ SetPropertySerialiser::deserialiseProperty(Containers::StringView name, Containe
 }
 
 bool
-SetPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+SetPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                          BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto set_prop = dynamic_cast<SetProperty*>(prop.get());
@@ -70,11 +70,11 @@ SetPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Unsigned
     writer.writeUEStringToArray(set_prop->itemType);
     writer.writeValueToArray<char>('\0');
 
-    bytes_written += writer.writeValueToArray<UnsignedInt>(0u);
+    bytes_written += writer.writeValueToArray<std::uint32_t>(0u);
-    bytes_written += writer.writeValueToArray<UnsignedInt>(UnsignedInt(set_prop->items.size()));
+    bytes_written += writer.writeValueToArray<std::uint32_t>(std::uint32_t(set_prop->items.size()));
 
-    UnsignedLong start_pos = writer.arrayPosition();
+    std::size_t start_pos = writer.arrayPosition();
-    UnsignedLong dummy_bytes_written = 0;
+    std::size_t dummy_bytes_written = 0;
     serialiser.writeSet(set_prop->items, set_prop->itemType, dummy_bytes_written, writer);
     bytes_written += writer.arrayPosition() - start_pos;
 

src/UESaveFile/Serialisers/SetPropertySerialiser.h

@@ -28,8 +28,8 @@ class SetPropertySerialiser : public UnrealPropertySerialiser<SetProperty> {
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/StringPropertySerialiser.cpp

@@ -31,11 +31,11 @@ StringPropertySerialiser::types() {
 
 UnrealPropertyBase::ptr
 StringPropertySerialiser::deserialise(Containers::StringView name, Containers::StringView type,
-                                      UnsignedLong value_length, BinaryReader& reader, PropertySerialiser& serialiser)
+                                      std::size_t value_length, BinaryReader& reader, PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<StringProperty>(type);
 
-    if(value_length != UnsignedLong(-1)) {
+    if(value_length != std::size_t(-1)) {
         char terminator;
         if(!reader.readChar(terminator) || terminator != '\0') {
             LOG_ERROR_FORMAT("Couldn't read a null byte in string property {}.", name);
@@ -54,7 +54,7 @@ StringPropertySerialiser::deserialise(Containers::StringView name, Containers::S
 }
 
 bool
-StringPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+StringPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                     PropertySerialiser& serialiser)
 {
     auto str_prop = dynamic_cast<StringProperty*>(prop.get());
@@ -63,7 +63,7 @@ StringPropertySerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong&
         return false;
     }
 
-    if(str_prop->valueLength != UnsignedLong(-1)) {
+    if(str_prop->valueLength != std::size_t(-1)) {
         writer.writeValueToArray<char>('\0');
     }
 

src/UESaveFile/Serialisers/StringPropertySerialiser.h

@@ -30,9 +30,9 @@ class StringPropertySerialiser : public AbstractUnrealPropertySerialiser {
         StringArrayView types() override;
 
         UnrealPropertyBase::ptr deserialise(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser) override;
 
-        bool serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                        PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/StructSerialiser.cpp

@@ -33,8 +33,8 @@ StructSerialiser::types() {
 }
 
 Containers::Array<UnrealPropertyBase::ptr>
-StructSerialiser::deserialise(Containers::StringView name, Containers::StringView type, UnsignedLong value_length,
+StructSerialiser::deserialise(Containers::StringView name, Containers::StringView type, std::size_t value_length,
-                              UnsignedInt count, BinaryReader& reader, PropertySerialiser& serialiser)
+                              std::uint32_t count, BinaryReader& reader, PropertySerialiser& serialiser)
 {
     Containers::String item_type;
     if(!reader.readUEString(item_type)) {
@@ -62,10 +62,10 @@ StructSerialiser::deserialise(Containers::StringView name, Containers::StringVie
         prop->structGuid = std::move(guid);
     }
     else {
-        for(UnsignedInt i = 0; i < count; i++) {
+        for(std::uint32_t i = 0; i < count; i++) {
             auto prop = Containers::pointer<UnrealPropertyBase>();
 
-            prop = serialiser.readItem(reader, item_type, UnsignedLong(-1), name);
+            prop = serialiser.readItem(reader, item_type, std::size_t(-1), name);
 
             if(!prop) {
                 prop = readStructValue(name, item_type, value_length, reader, serialiser);
@@ -86,7 +86,7 @@ StructSerialiser::deserialise(Containers::StringView name, Containers::StringVie
 }
 
 UnrealPropertyBase::ptr
-StructSerialiser::deserialise(Containers::StringView name, Containers::StringView type, UnsignedLong value_length,
+StructSerialiser::deserialise(Containers::StringView name, Containers::StringView type, std::size_t value_length,
                               BinaryReader& reader, PropertySerialiser& serialiser)
 {
     Containers::String item_type;
@@ -125,12 +125,12 @@ StructSerialiser::deserialise(Containers::StringView name, Containers::StringVie
 
 bool
 StructSerialiser::serialise(Containers::ArrayView<UnrealPropertyBase::ptr> props, Containers::StringView item_type,
-                            UnsignedLong& bytes_written, BinaryWriter& writer, PropertySerialiser& serialiser)
+                            std::size_t& bytes_written, BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     bytes_written += writer.writeUEStringToArray(*(props.front()->name));
     bytes_written += writer.writeUEStringToArray(item_type);
-    UnsignedLong vl_pos = writer.arrayPosition();
+    std::size_t vl_pos = writer.arrayPosition();
-    bytes_written += writer.writeValueToArray<UnsignedLong>(0ull);
+    bytes_written += writer.writeValueToArray<std::size_t>(0ull);
 
     auto struct_prop = dynamic_cast<StructProperty*>(props.front().get());
     if(!struct_prop) {
@@ -142,9 +142,9 @@ StructSerialiser::serialise(Containers::ArrayView<UnrealPropertyBase::ptr> props
     bytes_written += writer.writeDataToArray(arrayView(struct_prop->structGuid));
     bytes_written += writer.writeValueToArray<char>('\0');
 
-    UnsignedLong vl_start = writer.arrayPosition();
+    std::size_t vl_start = writer.arrayPosition();
 
-    UnsignedLong bytes_written_here = 0;
+    std::size_t bytes_written_here = 0;
     for(auto& prop : props) {
         struct_prop = dynamic_cast<StructProperty*>(prop.get());
         if(!struct_prop) {
@@ -160,7 +160,7 @@ StructSerialiser::serialise(Containers::ArrayView<UnrealPropertyBase::ptr> props
         }
     }
 
-    UnsignedLong vl_stop = writer.arrayPosition() - vl_start;
+    std::size_t vl_stop = writer.arrayPosition() - vl_start;
     writer.writeValueToArrayAt(vl_stop, vl_pos);
     bytes_written += vl_stop;
 
@@ -168,7 +168,7 @@ StructSerialiser::serialise(Containers::ArrayView<UnrealPropertyBase::ptr> props
 }
 
 bool
-StructSerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+StructSerialiser::serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                             PropertySerialiser& serialiser)
 {
     auto struct_prop = dynamic_cast<StructProperty*>(prop.get());
@@ -182,8 +182,8 @@ StructSerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_w
     writer.writeValueToArray<char>('\0');
 
     if(!serialiser.writeItem(prop, struct_prop->structType, bytes_written, writer)) {
-        UnsignedLong dummy_bytes_written = 0;
+        std::size_t dummy_bytes_written = 0;
-        UnsignedLong vl_start = writer.arrayPosition();
+        std::size_t vl_start = writer.arrayPosition();
         if(!writeStructValue(struct_prop, dummy_bytes_written, writer, serialiser)) {
             LOG_ERROR("Couldn't write the struct value.");
             return false;
@@ -195,7 +195,7 @@ StructSerialiser::serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_w
 }
 
 StructProperty::ptr
-StructSerialiser::readStructValue(Containers::StringView name, Containers::StringView type, UnsignedLong value_length,
+StructSerialiser::readStructValue(Containers::StringView name, Containers::StringView type, std::size_t value_length,
                                   BinaryReader& reader, PropertySerialiser& serialiser)
 {
     auto st_prop = Containers::pointer<GenericStructProperty>();
@@ -219,7 +219,7 @@ StructSerialiser::readStructValue(Containers::StringView name, Containers::Strin
 }
 
 bool
-StructSerialiser::writeStructValue(StructProperty* prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+StructSerialiser::writeStructValue(StructProperty* prop, std::size_t& bytes_written, BinaryWriter& writer,
                                    PropertySerialiser& serialiser)
 {
     auto struct_prop = dynamic_cast<GenericStructProperty*>(prop);

src/UESaveFile/Serialisers/StructSerialiser.h

@@ -31,21 +31,21 @@ class StructSerialiser : public AbstractUnrealPropertySerialiser, public Abstrac
 
         StringArrayView types() override;
 
-        PropertyArray deserialise(Containers::StringView name, Containers::StringView type, UnsignedLong value_length,
+        PropertyArray deserialise(Containers::StringView name, Containers::StringView type, std::size_t value_length,
-                                  UnsignedInt count, BinaryReader& reader, PropertySerialiser& serialiser) override;
+                                  std::uint32_t count, BinaryReader& reader, PropertySerialiser& serialiser) override;
         UnrealPropertyBase::ptr deserialise(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser) override;
 
-        bool serialise(PropertyArrayView props, Containers::StringView item_type, UnsignedLong& bytes_written,
+        bool serialise(PropertyArrayView props, Containers::StringView item_type, std::size_t& bytes_written,
                        BinaryWriter& writer, PropertySerialiser& serialiser) override;
-        bool serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                        PropertySerialiser& serialiser) override;
 
     private:
         StructProperty::ptr readStructValue(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser);
-        bool writeStructValue(StructProperty* prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool writeStructValue(StructProperty* prop, std::size_t& bytes_written, BinaryWriter& writer,
                               PropertySerialiser& serialiser);
 } ;

src/UESaveFile/Serialisers/TextPropertySerialiser.cpp

@@ -23,12 +23,12 @@
 
 UnrealPropertyBase::ptr
 TextPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<TextProperty>();
 
-    Long start_position = reader.position();
+    auto start_position = reader.position();
 
     char terminator;
     if(!reader.readChar(terminator) || terminator != '\0') {
@@ -62,7 +62,7 @@ TextPropertySerialiser::deserialiseProperty(Containers::StringView name, Contain
         arrayAppend(prop->data, std::move(str));
 
         interval = reader.position() - start_position;
-    } while(UnsignedLong(interval) < value_length);
+    } while(std::size_t(interval) < value_length);
 
     prop->value = prop->data.back();
 
@@ -70,7 +70,7 @@ TextPropertySerialiser::deserialiseProperty(Containers::StringView name, Contain
 }
 
 bool
-TextPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+TextPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                           BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto text_prop = dynamic_cast<TextProperty*>(prop.get());

src/UESaveFile/Serialisers/TextPropertySerialiser.h

@@ -28,8 +28,8 @@ class TextPropertySerialiser : public UnrealPropertySerialiser<TextProperty> {
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/UnrealPropertySerialiser.h

@@ -50,13 +50,13 @@ class UnrealPropertySerialiser : public AbstractUnrealPropertySerialiser {
         }
 
         UnrealPropertyBase::ptr deserialise(Containers::StringView name, Containers::StringView type,
-                                            UnsignedLong value_length, BinaryReader& reader,
+                                            std::size_t value_length, BinaryReader& reader,
                                             PropertySerialiser& serialiser) override
         {
             return deserialiseProperty(name, type, value_length, reader, serialiser);
         }
 
-        bool serialise(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialise(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                        PropertySerialiser& serialiser) override
         {
             return serialiseProperty(prop, bytes_written, writer, serialiser);
@@ -64,9 +64,9 @@ class UnrealPropertySerialiser : public AbstractUnrealPropertySerialiser {
 
     private:
         virtual UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                            UnsignedLong value_length, BinaryReader& reader,
+                                                            std::size_t value_length, BinaryReader& reader,
                                                             PropertySerialiser& serialiser) = 0;
 
-        virtual bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        virtual bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                        PropertySerialiser& serialiser) = 0;
 };

src/UESaveFile/Serialisers/Vector2DPropertySerialiser.cpp

@@ -22,7 +22,7 @@
 
 UnrealPropertyBase::ptr
 Vector2DPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                UnsignedLong value_length, BinaryReader& reader,
+                                                std::size_t value_length, BinaryReader& reader,
                                                 PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<Vector2DStructProperty>();
@@ -36,7 +36,7 @@ Vector2DPropertySerialiser::deserialiseProperty(Containers::StringView name, Con
 }
 
 bool
-Vector2DPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+Vector2DPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                               BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto vector = dynamic_cast<Vector2DStructProperty*>(prop.get());
@@ -45,7 +45,7 @@ Vector2DPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Uns
         return false;
     }
 
-    bytes_written += writer.writeValueToArray<Float>(vector->x) + writer.writeValueToArray<Float>(vector->y);
+    bytes_written += writer.writeValueToArray<float>(vector->x) + writer.writeValueToArray<float>(vector->y);
 
     return true;
 }

src/UESaveFile/Serialisers/Vector2DPropertySerialiser.h

@@ -28,8 +28,8 @@ class Vector2DPropertySerialiser : public UnrealPropertySerialiser<Vector2DStruc
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Serialisers/VectorPropertySerialiser.cpp

@@ -22,7 +22,7 @@
 
 UnrealPropertyBase::ptr
 VectorPropertySerialiser::deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                              UnsignedLong value_length, BinaryReader& reader,
+                                              std::size_t value_length, BinaryReader& reader,
                                               PropertySerialiser& serialiser)
 {
     auto prop = Containers::pointer<VectorStructProperty>();
@@ -36,7 +36,7 @@ VectorPropertySerialiser::deserialiseProperty(Containers::StringView name, Conta
 }
 
 bool
-VectorPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written,
+VectorPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written,
                                             BinaryWriter& writer, PropertySerialiser& serialiser)
 {
     auto vector = dynamic_cast<VectorStructProperty*>(prop.get());
@@ -45,8 +45,8 @@ VectorPropertySerialiser::serialiseProperty(UnrealPropertyBase::ptr& prop, Unsig
         return false;
     }
 
-    bytes_written += writer.writeValueToArray<Float>(vector->x) + writer.writeValueToArray<Float>(vector->y) +
+    bytes_written += writer.writeValueToArray<float>(vector->x) + writer.writeValueToArray<float>(vector->y) +
-                     writer.writeValueToArray<Float>(vector->z);
+                     writer.writeValueToArray<float>(vector->z);
 
     return true;
 }

src/UESaveFile/Serialisers/VectorPropertySerialiser.h

@@ -28,8 +28,8 @@ class VectorPropertySerialiser : public UnrealPropertySerialiser<VectorStructPro
 
     private:
         UnrealPropertyBase::ptr deserialiseProperty(Containers::StringView name, Containers::StringView type,
-                                                    UnsignedLong value_length, BinaryReader& reader,
+                                                    std::size_t value_length, BinaryReader& reader,
                                                     PropertySerialiser& serialiser) override;
-        bool serialiseProperty(UnrealPropertyBase::ptr& prop, UnsignedLong& bytes_written, BinaryWriter& writer,
+        bool serialiseProperty(UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryWriter& writer,
                                PropertySerialiser& serialiser) override;
 };

src/UESaveFile/Types/ColourStructProperty.h

@@ -29,5 +29,5 @@ struct ColourStructProperty : public StructProperty {
         using namespace Containers::Literals;
         structType = "LinearColor"_s;
     }
-    Float r = 0.0f, g = 0.0f, b = 0.0f, a = 0.0f;
+    float r = 0.0f, g = 0.0f, b = 0.0f, a = 0.0f;
 };

src/UESaveFile/Types/DateTimeStructProperty.h

@@ -19,12 +19,9 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "StructProperty.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 struct DateTimeStructProperty : public StructProperty {
     using ptr = Containers::Pointer<DateTimeStructProperty>;
@@ -34,5 +31,5 @@ struct DateTimeStructProperty : public StructProperty {
         structType = "DateTime"_s;
     }
 
-    UnsignedLong timestamp = 0;
+    std::int64_t timestamp = 0;
 };

src/UESaveFile/Types/FloatProperty.h

@@ -19,14 +19,11 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "UnrealProperty.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
-struct FloatProperty : public UnrealProperty<Float> {
+struct FloatProperty : public UnrealProperty<float> {
     using ptr = Containers::Pointer<FloatProperty>;
 
     FloatProperty() {

src/UESaveFile/Types/IntProperty.h

@@ -23,7 +23,7 @@
 
 using namespace Corrade;
 
-struct IntProperty : public UnrealProperty<Int> {
+struct IntProperty : public UnrealProperty<std::int32_t> {
     using ptr = Containers::Pointer<IntProperty>;
 
     IntProperty() {

src/UESaveFile/Types/ResourceItemValue.h

@@ -19,12 +19,9 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "StructProperty.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 struct ResourceItemValue : public StructProperty {
     using ptr = Containers::Pointer<ResourceItemValue>;
@@ -32,8 +29,12 @@ struct ResourceItemValue : public StructProperty {
     ResourceItemValue() {
         using namespace Containers::Literals;
         structType = "sttResourceItemValue"_s;
-        structGuid = Containers::StaticArray<16, char>{'\xB7', '\xA7', '\x77', '\xAB', '\xD3', '\x1B', '\xA6', '\x43', '\xAF', '\x42', '\xE5', '\x9E', '\xBF', '\xFD', '\x37', '\x55'};
+        structGuid = Containers::StaticArray<16, char>{
+            '\xB7', '\xA7', '\x77', '\xAB', '\xD3', '\x1B', '\xA6', '\x43',
+            '\xAF', '\x42', '\xE5', '\x9E', '\xBF', '\xFD', '\x37', '\x55'
+        };
     }
 
-    Int id = 0, quantity = 0;
+    std::int32_t id = 0;
+    std::int32_t quantity = 0;
 };

src/UESaveFile/Types/RotatorStructProperty.h

@@ -19,12 +19,9 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "StructProperty.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 struct RotatorStructProperty : public StructProperty {
     using ptr = Containers::Pointer<RotatorStructProperty>;
@@ -34,5 +31,5 @@ struct RotatorStructProperty : public StructProperty {
         structType = "Rotator"_s;
     }
 
-    Float x = 0.0f, y = 0.0f, z = 0.0f;
+    float x = 0.0f, y = 0.0f, z = 0.0f;
 };

src/UESaveFile/Types/UnrealPropertyBase.h

@@ -16,14 +16,13 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+#include <cstdint>
+
 #include <Corrade/Containers/Optional.h>
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/String.h>
 
-#include <Magnum/Types.h>
-
 using namespace Corrade;
-using namespace Magnum;
 
 struct UnrealPropertyBase {
     using ptr = Containers::Pointer<UnrealPropertyBase>;
@@ -32,5 +31,5 @@ struct UnrealPropertyBase {
 
     Containers::Optional<Containers::String> name = Containers::NullOpt;
     Containers::String propertyType;
-    UnsignedLong valueLength = 0;
+    std::size_t valueLength = 0;
 };

src/UESaveFile/Types/Vector2DStructProperty.h

@@ -19,12 +19,9 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "StructProperty.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 struct Vector2DStructProperty : public StructProperty {
     using ptr = Containers::Pointer<Vector2DStructProperty>;
@@ -34,5 +31,5 @@ struct Vector2DStructProperty : public StructProperty {
         structType = "Vector2D"_s;
     }
 
-    Float x = 0.0f, y = 0.0f;
+    float x = 0.0f, y = 0.0f;
 };

src/UESaveFile/Types/VectorStructProperty.h

@@ -19,12 +19,9 @@
 #include <Corrade/Containers/Pointer.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Types.h>
-
 #include "StructProperty.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 struct VectorStructProperty : public StructProperty {
     using ptr = Containers::Pointer<VectorStructProperty>;
@@ -34,5 +31,5 @@ struct VectorStructProperty : public StructProperty {
         structType = "Vector"_s;
     }
 
-    Float x = 0.0f, y = 0.0f, z = 0.0f;
+    float x = 0.0f, y = 0.0f, z = 0.0f;
 };

src/UESaveFile/UESaveFile.cpp

@@ -93,12 +93,12 @@ UESaveFile::saveToFile() {
     }
 
     if(!writer.writeArray(arrayView(_magicBytes)) ||
-       !writer.writeUnsignedInt(_saveVersion)           ||
+       !writer.writeUint32(_saveVersion)          ||
-       !writer.writeUnsignedInt(_packageVersion)        ||
+       !writer.writeUint32(_packageVersion)       ||
-       !writer.writeUnsignedShort(_engineVersion.major) ||
+       !writer.writeUint16(_engineVersion.major)  ||
-       !writer.writeUnsignedShort(_engineVersion.minor) ||
+       !writer.writeUint16(_engineVersion.minor)  ||
-       !writer.writeUnsignedShort(_engineVersion.patch) ||
+       !writer.writeUint16(_engineVersion.patch)  ||
-       !writer.writeUnsignedInt(_engineVersion.build)   ||
+       !writer.writeUint32(_engineVersion.build)  ||
        !writer.writeUEString(_engineVersion.buildId))
     {
         _lastError = "Couldn't write the header."_s;
@@ -106,17 +106,17 @@ UESaveFile::saveToFile() {
         return false;
     }
 
-    if(!writer.writeUnsignedInt(_customFormatVersion) ||
+    if(!writer.writeUint32(_customFormatVersion) ||
-       !writer.writeUnsignedInt(_customFormatData.size()))
+       !writer.writeUint32(_customFormatData.size()))
     {
         _lastError = "Couldn't write the custom format data."_s;
         LOG_ERROR(_lastError);
         return false;
     }
 
-    for(UnsignedLong i = 0; i < _customFormatData.size(); i++) {
+    for(std::size_t i = 0; i < _customFormatData.size(); i++) {
         if(!writer.writeStaticArray(Containers::StaticArrayView<16, const char>{_customFormatData[i].id}) ||
-           !writer.writeUnsignedInt(_customFormatData[i].value))
+           !writer.writeUint32(_customFormatData[i].value))
         {
             _lastError = "Couldn't write the custom format data."_s;
             LOG_ERROR(_lastError);
@@ -131,7 +131,7 @@ UESaveFile::saveToFile() {
     }
 
     for(auto& prop : _properties) {
-        UnsignedLong bytes_written = 0;
+        std::size_t bytes_written = 0;
         if(!_propSerialiser->write(prop, bytes_written, writer)) {
             _lastError = "Couldn't write the property "_s + *prop->name + " to the array."_s;
             LOG_ERROR(_lastError);
@@ -145,7 +145,7 @@ UESaveFile::saveToFile() {
         }
     }
 
-    writer.writeUnsignedInt(0);
+    writer.writeUint32(0u);
 
     writer.closeFile();
 
@@ -197,12 +197,12 @@ UESaveFile::loadData() {
         return;
     }
 
-    if(!reader.readUnsignedInt(_saveVersion)           ||
+    if(!reader.readUint32(_saveVersion)         ||
-       !reader.readUnsignedInt(_packageVersion)        ||
+       !reader.readUint32(_packageVersion)      ||
-       !reader.readUnsignedShort(_engineVersion.major) ||
+       !reader.readUint16(_engineVersion.major) ||
-       !reader.readUnsignedShort(_engineVersion.minor) ||
+       !reader.readUint16(_engineVersion.minor) ||
-       !reader.readUnsignedShort(_engineVersion.patch) ||
+       !reader.readUint16(_engineVersion.patch) ||
-       !reader.readUnsignedInt(_engineVersion.build)   ||
+       !reader.readUint32(_engineVersion.build) ||
        !reader.readUEString(_engineVersion.buildId))
     {
         _lastError = "Couldn't read version data.";
@@ -210,15 +210,15 @@ UESaveFile::loadData() {
         return;
     }
 
-    if(!reader.readUnsignedInt(_customFormatVersion)) {
+    if(!reader.readUint32(_customFormatVersion)) {
         _lastError = "Couldn't read the custom format version.";
         LOG_ERROR(_lastError);
         return;
     }
 
-    UnsignedInt custom_format_data_size = 0;
+    std::uint32_t custom_format_data_size = 0;
 
-    if(!reader.readUnsignedInt(custom_format_data_size)) {
+    if(!reader.readUint32(custom_format_data_size)) {
         _lastError = "Couldn't read the custom format data size.";
         LOG_ERROR(_lastError);
         return;
@@ -226,11 +226,11 @@ UESaveFile::loadData() {
 
     _customFormatData = Containers::Array<CustomFormatDataEntry>{custom_format_data_size};
 
-    for(UnsignedInt i = 0; i < custom_format_data_size; i++) {
+    for(std::uint32_t i = 0; i < custom_format_data_size; i++) {
         CustomFormatDataEntry entry;
 
         if(!reader.readStaticArray(entry.id) ||
-           !reader.readInt(entry.value))
+           !reader.readInt32(entry.value))
         {
             _lastError = "Couldn't read the custom format data";
             LOG_ERROR(_lastError);

src/UESaveFile/UESaveFile.h

@@ -23,14 +23,11 @@
 #include <Corrade/Containers/String.h>
 #include <Corrade/Containers/StringView.h>
 
-#include <Magnum/Magnum.h>
-
 #include "Types/UnrealPropertyBase.h"
 
 #include "PropertySerialiser.h"
 
 using namespace Corrade;
-using namespace Magnum;
 
 class UESaveFile {
     public:
@@ -72,20 +69,20 @@ class UESaveFile {
 
         Containers::StaticArray<4, char> _magicBytes{'G', 'V', 'A', 'S'};
 
-        UnsignedInt _saveVersion = 0;
+        std::uint32_t _saveVersion = 0;
-        UnsignedInt _packageVersion = 0;
+        std::uint32_t _packageVersion = 0;
         struct {
-            UnsignedShort      major = 0;
+            std::uint16_t      major = 0;
-            UnsignedShort      minor = 0;
+            std::uint16_t      minor = 0;
-            UnsignedShort      patch = 0;
+            std::uint16_t      patch = 0;
-            UnsignedInt        build = 0;
+            std::uint32_t      build = 0;
             Containers::String buildId;
         } _engineVersion;
 
-        UnsignedInt _customFormatVersion = 0;
+        std::uint32_t _customFormatVersion = 0;
         struct CustomFormatDataEntry {
             Containers::StaticArray<16, char> id;
-            Int value = 0;
+            std::int32_t value = 0;
         };
         Containers::Array<CustomFormatDataEntry> _customFormatData;
 

src/Utilities/Crc32.h

@@ -16,35 +16,22 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+#include <cstdint>
+
 #include <Corrade/Containers/ArrayView.h>
 #include <Corrade/Containers/StaticArray.h>
 
-#include <Magnum/Types.h>
-
 using namespace Corrade;
-using namespace Magnum;
 
-struct Crc32 {
+namespace Crc32 {
-    static const Containers::StaticArray<256, UnsignedInt> table;
 
-    static auto update(UnsignedInt initial, Containers::ArrayView<const void> data) -> UnsignedInt {
+std::uint32_t update(std::uint32_t initial, Containers::ArrayView<const void> data) {
-        UnsignedInt c = initial ^ 0xFFFFFFFF;
+    static const auto table = []{
-        auto u = Containers::arrayCast<const UnsignedByte>(data);
+        std::uint32_t polynomial = 0xEDB88320u;
+        Containers::StaticArray<256, std::uint32_t> temp{ValueInit};
 
-        for(std::size_t i = 0; i < data.size(); ++i) {
+        for(std::uint32_t i = 0; i < 256; i++) {
-            c = table[(c ^ u[i]) & 0xFF] ^ (c >> 8);
+            std::uint32_t c = i;
-        }
-
-        return c ^ 0xFFFFFFFF;
-    }
-};
-
-const Containers::StaticArray<256, UnsignedInt> Crc32::table = []{
-    UnsignedInt polynomial = 0xEDB88320u;
-    Containers::StaticArray<256, UnsignedInt> temp{ValueInit};
-
-    for(UnsignedInt i = 0; i < 256; i++) {
-        UnsignedInt c = i;
 
             for(std::size_t j = 0; j < 8; j++) {
                 if(c & 1) {
@@ -60,3 +47,16 @@ const Containers::StaticArray<256, UnsignedInt> Crc32::table = []{
 
         return temp;
     }();
+
+    std::uint32_t c = initial ^ 0xFFFFFFFF;
+
+    auto u = Containers::arrayCast<const std::uint8_t>(data);
+
+    for(std::size_t i = 0; i < data.size(); ++i) {
+        c = table[(c ^ u[i]) & 0xFF] ^ (c >> 8);
+    }
+
+    return c ^ 0xFFFFFFFF;
+}
+
+} // Crc32

src/main.cpp

@@ -81,7 +81,7 @@ int main(int argc, char** argv) {
     }
 
     SaveTool app({argc, argv});
-    Int result = app.exec();
+    int result = app.exec();
 
     ReleaseMutex(mutex_handle);