Mass: use Logger.

Oh, and some stuff didn't initially get logged, so now I can have better
insight in case of errors.

src/Mass/Mass.cpp

@@ -18,10 +18,10 @@
 
 #include <Corrade/Containers/Array.h>
 #include <Corrade/Containers/Pair.h>
-#include <Corrade/Containers/ScopeGuard.h>
 #include <Corrade/Utility/Path.h>
 
 #include "PropertyNames.h"
+#include "../Logger/Logger.h"
 #include "../UESaveFile/Types/ArrayProperty.h"
 #include "../UESaveFile/Types/BoolProperty.h"
 #include "../UESaveFile/Types/ColourStructProperty.h"
@@ -47,28 +47,28 @@ auto Mass::lastError() -> Containers::StringView {
 
 auto Mass::getNameFromFile(Containers::StringView path) -> Containers::Optional<Containers::String> {
     if(!Utility::Path::exists(path)) {
-        Utility::Error{} << path << "couldn't be found."_s;
+        LOG_ERROR_FORMAT("{} couldn't be found.", path);
         return Containers::NullOpt;
     }
 
     UESaveFile mass{path};
 
     if(!mass.valid()) {
-        Utility::Error{} << "The unit file seems to be corrupt."_s;
+        LOG_ERROR_FORMAT("{} is invalid: {}", path, mass.lastError());
         return Containers::NullOpt;
     }
 
     auto unit_data = mass.at<GenericStructProperty>(MASS_UNIT_DATA);
 
     if(!unit_data) {
-        Utility::Error{} << "Couldn't find unit data in the file."_s;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, path);
         return Containers::NullOpt;
     }
 
     auto name_prop = unit_data->at<StringProperty>(MASS_NAME);
 
     if(!name_prop) {
-        Utility::Error{} << "Couldn't find the name in the file."_s;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_NAME, path);
         return Containers::NullOpt;
     }
 
@@ -76,47 +76,53 @@ auto Mass::getNameFromFile(Containers::StringView path) -> Containers::Optional<
 }
 
 void Mass::refreshValues() {
-    Utility::Debug{} << "=Refreshing values for" << _filename << Utility::Debug::nospace << "=";
+    LOG_INFO_FORMAT("Refreshing values for {}.", _filename);
-
-    Containers::ScopeGuard guard{[]{ Utility::Error{} << "Refresh failed."; }};
 
+    LOG_INFO("Checking if file exists.");
     if(!Utility::Path::exists(Utility::Path::join(_folder, _filename))) {
-        Utility::Warning{} << _filename << "does not exist in" << _folder;
+        LOG_WARNING_FORMAT("{} doesn't exist in {}.", _filename, _folder);
         _state = State::Empty;
         return;
     }
 
     if(!_mass) {
+        LOG_INFO("Reading the GVAS save.");
         _mass.emplace(Utility::Path::join(_folder, _filename));
         if(!_mass->valid()) {
-            Utility::Error{} << _mass->lastError();
+            LOG_ERROR(_mass->lastError());
             _state = State::Invalid;
             return;
         }
     }
     else {
+        LOG_INFO("Reloading the GVAS data.");
         if(!_mass->reloadData()) {
-            Utility::Error{} << _mass->lastError();
+            LOG_ERROR(_mass->lastError());
             _state = State::Invalid;
             return;
         }
     }
 
+    LOG_INFO("Checking the save file type.");
     if(_mass->saveType() != "/Game/Core/Save/bpSaveGameUnit.bpSaveGameUnit_C"_s) {
-        Utility::Error{} << _filename << "is not a valid unit save.";
+        LOG_ERROR_FORMAT("{} is not a valid unit save.", _filename);
-    }
-
-    auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
-    if(!unit_data) {
-        Utility::Error{} << "Couldn't find unit data in" << _filename;
         _state = State::Invalid;
         return;
     }
 
+    LOG_INFO("Getting the unit data.");
+    auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
+    if(!unit_data) {
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
+        _state = State::Invalid;
+        return;
+    }
+
+    LOG_INFO("Reading the M.A.S.S. name.");
     auto name_prop = unit_data->at<StringProperty>(MASS_NAME);
 
     if(!name_prop) {
-        Utility::Error{} << "Couldn't find a M.A.S.S. name in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_NAME, _filename);
         _name = Containers::NullOpt;
         _state = State::Invalid;
         return;
@@ -199,18 +205,16 @@ void Mass::refreshValues() {
         return;
     }
 
+    LOG_INFO("Getting the associated account.");
     auto account_prop = _mass->at<StringProperty>("Account"_s);
     if(!account_prop) {
-        Utility::Error{} << "Couldn't find an account ID in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_ACCOUNT, _filename);
         _state = State::Invalid;
         return;
     }
 
     _account = account_prop->value;
 
-    guard.release();
-    guard = Containers::ScopeGuard{[]{Utility::Debug{} << "Refresh successful.";}};
-
     _state = State::Valid;
 }
 
@@ -219,6 +223,7 @@ auto Mass::filename() -> Containers::StringView {
 }
 
 auto Mass::name() -> Containers::StringView {
+    CORRADE_INTERNAL_ASSERT(_name);
     return *_name;
 }
 
@@ -228,6 +233,7 @@ auto Mass::setName(Containers::StringView new_name) -> bool {
     auto unit_data = _mass->at<GenericStructProperty>("UnitData"_s);
 
     if(!unit_data) {
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return false;
     }
@@ -235,6 +241,7 @@ auto Mass::setName(Containers::StringView new_name) -> bool {
     auto name_prop = unit_data->at<StringProperty>("Name_45_A037C5D54E53456407BDF091344529BB"_s);
 
     if(!name_prop) {
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_NAME, _filename);
         _state = State::Invalid;
         return false;
     }
@@ -275,6 +282,7 @@ void Mass::getTuning() {
     }
 
     getTuningCategory(MASS_ARCHITECT, _tuning.archId,
+                      MASS_TECHS, _tuning.techIds);
     if(_state == State::Invalid) {
         return;
     }
@@ -313,8 +321,8 @@ auto Mass::updateAccount(Containers::StringView new_account) -> bool {
 
     auto account = _mass->at<StringProperty>(MASS_ACCOUNT);
     if(!account) {
+        _lastError = "Couldn't find the " MASS_ACCOUNT " property."_s;
         _state = State::Invalid;
-        _lastError = "Couldn't find the account property."_s;
         return false;
     }
 
@@ -331,9 +339,11 @@ auto Mass::updateAccount(Containers::StringView new_account) -> bool {
 void Mass::getTuningCategory(Containers::StringView big_node_prop_name, Int& big_node_id,
                              Containers::StringView small_nodes_prop_name, Containers::ArrayView<Int> small_nodes_ids)
 {
+    LOG_INFO_FORMAT("Getting tuning data ({}, {}).", big_node_prop_name, small_nodes_prop_name);
+
     auto node_id = _mass->at<IntProperty>(big_node_prop_name);
     if(!node_id) {
-        Utility::Error{} << "Couldn't find" << big_node_prop_name << "in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", big_node_prop_name, _filename);
         _state = State::Invalid;
         return;
     }
@@ -341,13 +351,14 @@ void Mass::getTuningCategory(Containers::StringView big_node_prop_name, Int& big
 
     auto node_ids = _mass->at<ArrayProperty>(small_nodes_prop_name);
     if(!node_ids) {
-        Utility::Error{} << "Couldn't find" << small_nodes_prop_name << "in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", small_nodes_prop_name, _filename);
         _state = State::Invalid;
         return;
     }
 
     if(node_ids->items.size() != small_nodes_ids.size()) {
-        Utility::Error{} << "Node ID arrays are not of the same size. Expected" << small_nodes_ids.size() << Utility::Debug::nospace << ", got" << node_ids->items.size() << "instead.";
+        LOG_ERROR_FORMAT("Node ID arrays are not of the same size. Expected {}, got {} instead.",
+                         small_nodes_ids.size(), node_ids->items.size());
         _state = State::Invalid;
         return;
     }

src/Mass/Mass_Armour.cpp

@@ -17,6 +17,7 @@
 #include <algorithm>
 
 #include "PropertyNames.h"
+#include "../Logger/Logger.h"
 #include "../UESaveFile/Types/ArrayProperty.h"
 #include "../UESaveFile/Types/ByteProperty.h"
 #include "../UESaveFile/Types/GenericStructProperty.h"
@@ -33,22 +34,25 @@ auto Mass::armourParts() -> Containers::ArrayView<ArmourPart> {
 }
 
 void Mass::getArmourParts() {
+    LOG_INFO("Getting armour parts.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        Utility::Error{} << "Couldn't find unit data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto armour_array = unit_data->at<ArrayProperty>(MASS_ARMOUR_PARTS);
     if(!armour_array) {
-        Utility::Error{} << "Couldn't find the armour parts array in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_ARMOUR_PARTS, _filename);
         _state = State::Invalid;
         return;
     }
 
     if(armour_array->items.size() != _armour.parts.size()) {
-        Utility::Error{} << "Armour arrays are not of the same size. Expected" << _armour.parts.size() << Utility::Debug::nospace << ", got" << armour_array->items.size() << "instead.";
+        LOG_ERROR_FORMAT("Armour part arrays are not of the same size. Expected {}, got {} instead.",
+                         _armour.parts.size(), armour_array->items.size());
         _state = State::Invalid;
         return;
     }
@@ -62,21 +66,23 @@ void Mass::getArmourParts() {
         #include "../Maps/ArmourSlots.hpp"
         #undef c
         {
+            LOG_ERROR_FORMAT("Invalid armour slot enumerator {}.", armour_slot);
             _state = State::Invalid;
-            Utility::Warning{} << "Invalid armour slot enum value in getArmourParts()."_s;
+            return;
         }
 
         part.id = part_prop->at<IntProperty>(MASS_ARMOUR_ID)->value;
 
         auto part_styles = part_prop->at<ArrayProperty>(MASS_ARMOUR_STYLES);
         if(!part_styles) {
-            Utility::Error{} << "Part styles not found for part number" << i << "in" << _filename;
+            LOG_ERROR_FORMAT("Part styles not found for part number {}.", i);
             _state = State::Invalid;
             return;
         }
 
         if(part_styles->items.size() != part.styles.size()) {
-            Utility::Error{} << "Part style arrays are not of the same size. Expected" << part.styles.size() << Utility::Debug::nospace << ", got" << part_styles->items.size() << "instead.";
+            LOG_ERROR_FORMAT("Armour part style arrays are not of the same size. Expected {}, got {} instead.",
+                             part.styles.size(), part_styles->items.size());
             _state = State::Invalid;
             return;
         }
@@ -87,7 +93,7 @@ void Mass::getArmourParts() {
 
         auto decals_array = part_prop->at<ArrayProperty>(MASS_ARMOUR_DECALS);
         if(!decals_array) {
-            Utility::Error{} << "Part decals not found for part number" << i << "in" << _filename;
+            LOG_ERROR_FORMAT("Part decals not found for part number {}.", i);
             _state = State::Invalid;
             return;
         }
@@ -98,7 +104,7 @@ void Mass::getArmourParts() {
 
         auto accs_array = part_prop->at<ArrayProperty>(MASS_ARMOUR_ACCESSORIES);
         if(!accs_array) {
-            Utility::Error{} << "Part accessories not found for part number" << i << "in" << _filename;
+            LOG_WARNING_FORMAT("Part accessories not found for part number {}.", i);
             part.accessories = Containers::Array<Accessory>{};
             continue;
         }
@@ -112,11 +118,25 @@ void Mass::getArmourParts() {
 }
 
 auto Mass::writeArmourPart(ArmourSlot slot) -> bool {
+    LOG_INFO_FORMAT("Writing armour part in slot {}.", static_cast<int>(slot));
+
     auto& part = *std::find_if(_armour.parts.begin(), _armour.parts.end(), [&slot](const ArmourPart& part){ return slot == part.slot; });
 
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
+    if(!unit_data) {
+        _lastError = "Couldn't find the unit data in " + _filename + ".";
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
+        return false;
+    }
 
     auto armour_array = unit_data->at<ArrayProperty>(MASS_ARMOUR_PARTS);
+    if(!armour_array) {
+        _lastError = "Couldn't find the armour part array in " + _filename + ".";
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
+        return false;
+    }
 
     Containers::StringView slot_str = nullptr;
     switch(slot) {
@@ -148,6 +168,7 @@ auto Mass::writeArmourPart(ArmourSlot slot) -> bool {
             #include "../Maps/ArmourSlots.hpp"
             #undef c
         }
+        LOG_ERROR(_lastError);
         return false;
     }
 
@@ -183,9 +204,11 @@ auto Mass::bulletLauncherAttachments() -> Containers::ArrayView<BulletLauncherAt
 }
 
 void Mass::getBulletLauncherAttachments() {
+    LOG_INFO("Getting the bullet launcher attachment data.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        Utility::Error{} << "Couldn't find unit data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return;
     }
@@ -194,13 +217,14 @@ void Mass::getBulletLauncherAttachments() {
     auto attach_array = unit_data->at<ArrayProperty>(MASS_BL_ATTACHMENTS);
 
     if(!attach_style_prop && !attach_array) {
+        LOG_WARNING_FORMAT("No bullet launcher attachment data found in {}.", _filename);
         _armour.blAttachmentStyle = BulletLauncherAttachmentStyle::NotFound;
         return;
     }
 
     if(attach_style_prop && !attach_array) {
+        LOG_WARNING_FORMAT("No bullet launcher attachments found in {}.", _filename);
         _armour.blAttachmentStyle = BulletLauncherAttachmentStyle::NotFound;
-        Utility::Error{} << "Couldn't find bullet launcher attachments in" << _filename;
         _state = State::Invalid;
         return;
     }
@@ -217,7 +241,7 @@ void Mass::getBulletLauncherAttachments() {
             #include "../Maps/BulletLauncherSockets.hpp"
             #undef c
             {
-                Utility::Error{} << "Invalid BL attachment socket.";
+                LOG_ERROR_FORMAT("Invalid attachment socket {}.", socket);
                 _state = State::Invalid;
                 return;
             }
@@ -241,7 +265,8 @@ void Mass::getBulletLauncherAttachments() {
         #include "../Maps/BulletLauncherAttachmentStyles.hpp"
         #undef c
         {
-            Utility::Error{} << "Unknown BL attachment style enumerator.";
+            LOG_ERROR_FORMAT("Invalid attachment style {}.", attach_style);
+            _state = State::Invalid;
         }
     }
     else {
@@ -250,10 +275,13 @@ void Mass::getBulletLauncherAttachments() {
 }
 
 auto Mass::writeBulletLauncherAttachments() -> bool {
+    LOG_INFO("Writing bullet launcher attachments.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        _state = State::Invalid;
         _lastError = "No unit data in " + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
@@ -261,15 +289,17 @@ auto Mass::writeBulletLauncherAttachments() -> bool {
     auto attach_array = unit_data->at<ArrayProperty>(MASS_BL_ATTACHMENTS);
 
     if(!attach_style_prop && !attach_array) {
-        _armour.blAttachmentStyle = BulletLauncherAttachmentStyle::NotFound;
         _lastError = "No attachment properties to write to in " + _filename;
+        LOG_ERROR(_lastError);
+        _armour.blAttachmentStyle = BulletLauncherAttachmentStyle::NotFound;
         return false;
     }
 
     if(attach_style_prop && !attach_array) {
+        _lastError = "Couldn't find the attachments in " + _filename;
+        LOG_ERROR(_lastError);
         _armour.blAttachmentStyle = BulletLauncherAttachmentStyle::NotFound;
         _state = State::Invalid;
-        _lastError = "Couldn't find the attachments in " + _filename;
         return false;
     }
 
@@ -287,6 +317,7 @@ auto Mass::writeBulletLauncherAttachments() -> bool {
                 #undef c
                 default:
                     _lastError = "Invalid socket type."_s;
+                    LOG_ERROR(_lastError);
                     return false;
             }
 
@@ -330,6 +361,7 @@ auto Mass::writeBulletLauncherAttachments() -> bool {
         #undef c
         default:
             _lastError = "Unknown BL attachment style.";
+            LOG_ERROR(_lastError);
             return false;
     }
 
@@ -346,22 +378,25 @@ auto Mass::armourCustomStyles() -> Containers::ArrayView<CustomStyle> {
 }
 
 void Mass::getArmourCustomStyles() {
+    LOG_INFO("Getting the custom armour styles.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        Utility::Error{} << "Couldn't find unit data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto armour_styles = unit_data->at<ArrayProperty>(MASS_CUSTOM_ARMOUR_STYLES);
     if(!armour_styles) {
-        Utility::Error{} << "Couldn't find custom armour styles in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_CUSTOM_ARMOUR_STYLES, _filename);
         _state = State::Invalid;
         return;
     }
 
     if(armour_styles->items.size() != _armour.customStyles.size()) {
-        Utility::Error{} << "Custom armour style arrays are not of the same size. Expected" << _armour.customStyles.size() << Utility::Debug::nospace << ", got" << armour_styles->items.size() << "instead.";
+        LOG_ERROR_FORMAT("Custom armour style arrays are not of the same size. Expected {}, got {} instead.",
+                         _armour.customStyles.size(), armour_styles->items.size());
         _state = State::Invalid;
         return;
     }
@@ -370,21 +405,26 @@ void Mass::getArmourCustomStyles() {
 }
 
 auto Mass::writeArmourCustomStyle(UnsignedLong index) -> bool {
+    LOG_INFO_FORMAT("Writing custom armour style {}.", index);
+
     if(index > _armour.customStyles.size()) {
         _lastError = "Style index out of range."_s;
+        LOG_ERROR(_lastError);
         return false;
     }
 
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        _state = State::Invalid;
         _lastError = "Couldn't find unit data in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     auto armour_styles = unit_data->at<ArrayProperty>(MASS_CUSTOM_ARMOUR_STYLES);
     if(!armour_styles) {
         _lastError = "Couldn't find armour custom styles in "_s + _filename;
+        LOG_ERROR(_lastError);
         _state = State::Invalid;
         return false;
     }

src/Mass/Mass_Frame.cpp

@@ -15,6 +15,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 #include "PropertyNames.h"
+#include "../Logger/Logger.h"
 #include "../UESaveFile/Types/ArrayProperty.h"
 #include "../UESaveFile/Types/ColourStructProperty.h"
 #include "../UESaveFile/Types/FloatProperty.h"
@@ -30,16 +31,18 @@ auto Mass::jointSliders() -> Joints& {
 }
 
 void Mass::getJointSliders() {
+    LOG_INFO("Getting joint sliders.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        Utility::Error{} << "Can't find unit data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto frame_prop = unit_data->at<GenericStructProperty>(MASS_FRAME);
     if(!frame_prop) {
-        Utility::Error{} << "Can't find frame data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_FRAME, _filename);
         _state = State::Invalid;
         return;
     }
@@ -63,19 +66,22 @@ void Mass::getJointSliders() {
 }
 
 auto Mass::writeJointSliders() -> bool {
+    LOG_INFO("Writing joint sliders");
 
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        _state = State::Invalid;
         _lastError = "No unit data in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     auto frame_prop = unit_data->at<GenericStructProperty>(MASS_FRAME);
 
     if(!frame_prop) {
-        _state = State::Invalid;
         _lastError = "No frame data in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
@@ -180,29 +186,32 @@ auto Mass::frameStyles() -> Containers::ArrayView<Int> {
 }
 
 void Mass::getFrameStyles() {
+    LOG_INFO("Getting frame styles.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        Utility::Error{} << "Can't find unit data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto frame_prop = unit_data->at<GenericStructProperty>(MASS_FRAME);
     if(!frame_prop) {
-        Utility::Error{} << "Can't find frame data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_FRAME, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto frame_styles = frame_prop->at<ArrayProperty>(MASS_FRAME_STYLES);
     if(!frame_styles) {
-        Utility::Error{} << "Can't find frame styles in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_FRAME_STYLES, _filename);
         _state = State::Invalid;
         return;
     }
 
     if(frame_styles->items.size() != _frame.styles.size()) {
-        Utility::Error{} << "Frame style arrays are not of the same size. Expected" << _frame.styles.size() << Utility::Debug::nospace << ", got" << frame_styles->items.size() << "instead.";
+        LOG_ERROR_FORMAT("Frame style arrays are not of the same size. Expected {}, got {} instead.",
+                         _frame.styles.size(), frame_styles->items.size());
         _state = State::Invalid;
         return;
     }
@@ -213,24 +222,29 @@ void Mass::getFrameStyles() {
 }
 
 auto Mass::writeFrameStyles() -> bool {
+    LOG_INFO("Writing frame styles.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        _state = State::Invalid;
         _lastError = "No unit data in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     auto frame = unit_data->at<GenericStructProperty>(MASS_FRAME);
     if(!frame) {
-        _state = State::Invalid;
         _lastError = "No frame data in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     auto frame_styles = frame->at<ArrayProperty>(MASS_FRAME_STYLES);
     if(!frame_styles) {
-        _state = State::Invalid;
         _lastError = "No frame styles in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
@@ -251,23 +265,25 @@ auto Mass::eyeFlareColour() -> Color4& {
 }
 
 void Mass::getEyeFlareColour() {
+    LOG_INFO("Getting the eye flare colour.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        Utility::Error{} << "Can't find unit data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto frame_prop = unit_data->at<GenericStructProperty>(MASS_FRAME);
     if(!frame_prop) {
-        Utility::Error{} << "Can't find frame data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_FRAME, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto eye_flare_prop = frame_prop->at<ColourStructProperty>(MASS_EYE_FLARE);
     if(!eye_flare_prop) {
-        Utility::Error{} << "Can't find eye flare data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_EYE_FLARE, _filename);
         _state = State::Invalid;
         return;
     }
@@ -276,24 +292,29 @@ void Mass::getEyeFlareColour() {
 }
 
 auto Mass::writeEyeFlareColour() -> bool {
+    LOG_INFO("Writing the eye flare colour.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        _state = State::Invalid;
         _lastError = "No unit data in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     auto frame = unit_data->at<GenericStructProperty>(MASS_FRAME);
     if(!frame) {
-        _state = State::Invalid;
         _lastError = "No frame data in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     auto eye_flare_prop = frame->at<ColourStructProperty>(MASS_EYE_FLARE);
     if(!eye_flare_prop) {
-        _state = State::Invalid;
         _lastError = "No eye flare property in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
@@ -315,22 +336,25 @@ auto Mass::frameCustomStyles() -> Containers::ArrayView<CustomStyle> {
 }
 
 void Mass::getFrameCustomStyles() {
+    LOG_INFO("Getting the frame's custom styles.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        Utility::Error{} << "Can't find unit data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto frame_styles = unit_data->at<ArrayProperty>(MASS_CUSTOM_FRAME_STYLES);
     if(!frame_styles) {
-        Utility::Error{} << "Can't find frame styles in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_CUSTOM_FRAME_STYLES, _filename);
         _state = State::Invalid;
         return;
     }
 
     if(frame_styles->items.size() != _frame.customStyles.size()) {
-        Utility::Error{} << "Frame custom style arrays are not of the same size. Expected" << _frame.customStyles.size() << Utility::Debug::nospace << ", got" << frame_styles->items.size() << "instead.";
+        LOG_ERROR_FORMAT("Frame custom style arrays are not of the same size. Expected {}, got {} instead.",
+                         _frame.customStyles.size(), frame_styles->items.size());
         _state = State::Invalid;
         return;
     }
@@ -339,22 +363,27 @@ void Mass::getFrameCustomStyles() {
 }
 
 auto Mass::writeFrameCustomStyle(UnsignedLong index) -> bool {
+    LOG_INFO_FORMAT("Writing frame custom style number {}.", index);
+
     if(index > _frame.customStyles.size()) {
         _lastError = "Style index out of range."_s;
+        LOG_ERROR(_lastError);
         return false;
     }
 
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        _state = State::Invalid;
         _lastError = "No unit data in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     auto frame_styles = unit_data->at<ArrayProperty>(MASS_CUSTOM_FRAME_STYLES);
     if(!frame_styles) {
-        _state = State::Invalid;
         _lastError = "No frame styles in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 

src/Mass/Mass_Styles.cpp

@@ -15,6 +15,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 #include "PropertyNames.h"
+#include "../Logger/Logger.h"
 #include "../UESaveFile/Types/ArrayProperty.h"
 #include "../UESaveFile/Types/ColourStructProperty.h"
 #include "../UESaveFile/Types/FloatProperty.h"
@@ -31,15 +32,18 @@ auto Mass::globalStyles() -> Containers::ArrayView<CustomStyle> {
 }
 
 void Mass::getGlobalStyles() {
+    LOG_INFO("Getting global styles.");
+
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        Utility::Error{} << "Can't find unit data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto global_styles = unit_data->at<ArrayProperty>(MASS_GLOBAL_STYLES);
     if(!global_styles) {
+        LOG_WARNING_FORMAT("Couldn't find global styles in {}.", _filename);
         _globalStyles = Containers::Array<CustomStyle>{0};
         return;
     }
@@ -52,22 +56,27 @@ void Mass::getGlobalStyles() {
 }
 
 auto Mass::writeGlobalStyle(UnsignedLong index) -> bool {
+    LOG_INFO_FORMAT("Writing global style number {}.", index);
+
     if(index > _globalStyles.size()) {
         _lastError = "Global style index out of range"_s;
+        LOG_ERROR(_lastError);
         return false;
     }
 
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        _state = State::Invalid;
         _lastError = "No unit data found in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     auto global_styles = unit_data->at<ArrayProperty>(MASS_GLOBAL_STYLES);
     if(!global_styles) {
-        _state = State::Invalid;
         _lastError = "No global styles found in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
@@ -82,9 +91,9 @@ void Mass::getCustomStyles(Containers::ArrayView<CustomStyle> styles, ArrayPrope
         style.name = style_prop->at<StringProperty>(MASS_STYLE_NAME)->value;
         auto colour_prop = style_prop->at<ColourStructProperty>(MASS_STYLE_COLOUR);
         style.colour = Color4{colour_prop->r, colour_prop->g, colour_prop->b, colour_prop->a};
-        style.glow = colour_prop->a == 0.0f ? false : true;
         style.metallic = style_prop->at<FloatProperty>(MASS_STYLE_METALLIC)->value;
         style.gloss = style_prop->at<FloatProperty>(MASS_STYLE_GLOSS)->value;
+        style.glow = colour_prop->a != 0.0f;
 
         style.patternId = style_prop->at<IntProperty>(MASS_STYLE_PATTERN_ID)->value;
         style.opacity = style_prop->at<FloatProperty>(MASS_STYLE_PATTERN_OPACITY)->value;
@@ -99,13 +108,15 @@ void Mass::getCustomStyles(Containers::ArrayView<CustomStyle> styles, ArrayPrope
 
 auto Mass::writeCustomStyle(const CustomStyle& style, UnsignedLong index, ArrayProperty* style_array) -> bool {
     if(!style_array) {
-        _lastError = "Mass::setCustomStyle(): style_array is null."_s;
+        _lastError = "style_array is null."_s;
+        LOG_ERROR(_lastError);
         return false;
     }
 
     auto style_prop = style_array->at<GenericStructProperty>(index);
     if(!style_prop) {
         _lastError = "Style index is out of range in "_s + _filename;
+        LOG_ERROR(_lastError);
         return false;
     }
 

src/Mass/Mass_Weapons.cpp

@@ -14,6 +14,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 "PropertyNames.h"
+#include "../Logger/Logger.h"
 #include "../UESaveFile/Types/ArrayProperty.h"
 #include "../UESaveFile/Types/BoolProperty.h"
 #include "../UESaveFile/Types/ByteProperty.h"
@@ -31,10 +33,12 @@ auto Mass::meleeWeapons() -> Containers::ArrayView<Weapon> {
 }
 
 void Mass::getMeleeWeapons() {
+    LOG_INFO("Getting melee weapons.");
     getWeaponType(MASS_WEAPONS_MELEE, _weapons.melee);
 }
 
 auto Mass::writeMeleeWeapons() -> bool {
+    LOG_INFO("Writing melee weapons.");
     return writeWeaponType(MASS_WEAPONS_MELEE, _weapons.melee);
 }
 
@@ -43,10 +47,12 @@ auto Mass::shields() -> Containers::ArrayView<Weapon> {
 }
 
 void Mass::getShields() {
+    LOG_INFO("Getting shields.");
     getWeaponType(MASS_WEAPONS_SHIELD, _weapons.shields);
 }
 
 auto Mass::writeShields() -> bool {
+    LOG_INFO("Writing shields.");
     return writeWeaponType(MASS_WEAPONS_SHIELD, _weapons.shields);
 }
 
@@ -55,10 +61,12 @@ auto Mass::bulletShooters() -> Containers::ArrayView<Weapon> {
 }
 
 void Mass::getBulletShooters() {
+    LOG_INFO("Getting bullet shooters.");
     getWeaponType(MASS_WEAPONS_BSHOOTER, _weapons.bulletShooters);
 }
 
 auto Mass::writeBulletShooters() -> bool {
+    LOG_INFO("Writing bullet shooters.");
     return writeWeaponType(MASS_WEAPONS_BSHOOTER, _weapons.bulletShooters);
 }
 
@@ -67,10 +75,12 @@ auto Mass::energyShooters() -> Containers::ArrayView<Weapon> {
 }
 
 void Mass::getEnergyShooters() {
+    LOG_INFO("Getting energy shooters.");
     getWeaponType(MASS_WEAPONS_ESHOOTER, _weapons.energyShooters);
 }
 
 auto Mass::writeEnergyShooters() -> bool {
+    LOG_INFO("Writing energy shooters.");
     return writeWeaponType(MASS_WEAPONS_ESHOOTER, _weapons.energyShooters);
 }
 
@@ -79,10 +89,12 @@ auto Mass::bulletLaunchers() -> Containers::ArrayView<Weapon> {
 }
 
 void Mass::getBulletLaunchers() {
+    LOG_INFO("Getting bullet launchers.");
     getWeaponType(MASS_WEAPONS_BLAUNCHER, _weapons.bulletLaunchers);
 }
 
 auto Mass::writeBulletLaunchers() -> bool {
+    LOG_INFO("Writing bullet launchers.");
     return writeWeaponType(MASS_WEAPONS_BLAUNCHER, _weapons.bulletLaunchers);
 }
 
@@ -91,30 +103,33 @@ auto Mass::energyLaunchers() -> Containers::ArrayView<Weapon> {
 }
 
 void Mass::getEnergyLaunchers() {
+    LOG_INFO("Getting energy launchers.");
     getWeaponType(MASS_WEAPONS_ELAUNCHER, _weapons.energyLaunchers);
 }
 
 auto Mass::writeEnergyLaunchers() -> bool {
+    LOG_INFO("Writing energy launchers.");
     return writeWeaponType(MASS_WEAPONS_ELAUNCHER, _weapons.energyLaunchers);
 }
 
 void Mass::getWeaponType(Containers::StringView prop_name, Containers::ArrayView<Weapon> weapon_array) {
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        Utility::Error{} << "Can't find unit data in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
         _state = State::Invalid;
         return;
     }
 
     auto prop = unit_data->at<ArrayProperty>(prop_name);
     if(!prop) {
-        Utility::Error{} << "Can't find" << prop_name << "in" << _filename;
+        LOG_ERROR_FORMAT("Couldn't find {} in {}.", prop_name, _filename);
         _state = State::Invalid;
         return;
     }
 
     if(prop->items.size() != weapon_array.size()) {
-        Utility::Error{} << "Weapon arrays are not of the same size. Expected" << weapon_array.size() << Utility::Debug::nospace << ", got" << prop->items.size() << "instead.";
+        LOG_ERROR_FORMAT("Weapon arrays are not of the same size. Expected {}, got {} instead.",
+                         weapon_array.size(), prop->items.size());
         _state = State::Invalid;
         return;
     }
@@ -129,8 +144,9 @@ void Mass::getWeaponType(Containers::StringView prop_name, Containers::ArrayView
         #include "../Maps/WeaponTypes.hpp"
         #undef c
         {
+            LOG_ERROR_FORMAT("Invalid weapon type {} in {}.", weapon_type, _filename);
             _state = State::Invalid;
-            Utility::Warning{} << "Invalid weapon type enum value in getWeaponType()."_s;
+            return;
         }
 
         auto parts_prop = weapon_prop->at<ArrayProperty>(MASS_WEAPON_ELEMENT);
@@ -168,13 +184,14 @@ void Mass::getWeaponType(Containers::StringView prop_name, Containers::ArrayView
 
         auto custom_styles = weapon_prop->at<ArrayProperty>(MASS_CUSTOM_WEAPON_STYLES);
         if(!custom_styles) {
-            Utility::Error{} << "Can't find weapon custom styles in" << _filename;
+            LOG_ERROR_FORMAT("Can't find weapon custom styles in {}", _filename);
             _state = State::Invalid;
             return;
         }
 
         if(custom_styles->items.size() != weapon.customStyles.size()) {
-            Utility::Error{} << "Weapon custom style arrays are not of the same size. Expected" << weapon.customStyles.size() << Utility::Debug::nospace << ", got" << custom_styles->items.size() << "instead.";
+            LOG_ERROR_FORMAT("Custom weapon style arrays are not of the same size. Expected {}, got {} instead.",
+                             weapon.customStyles.size(), custom_styles->items.size());
             _state = State::Invalid;
             return;
         }
@@ -187,8 +204,9 @@ void Mass::getWeaponType(Containers::StringView prop_name, Containers::ArrayView
         #include "../Maps/DamageTypes.hpp"
         #undef c
         {
+            LOG_ERROR_FORMAT("Invalid damage type {} in {}.", damage_type, _filename);
             _state = State::Invalid;
-            Utility::Warning{} << "Invalid damage type enum value in getWeaponType()."_s;
+            return;
         }
         weapon.dualWield = weapon_prop->at<BoolProperty>(MASS_WEAPON_DUAL_WIELD)->value;
         auto& effect_colour_mode = weapon_prop->at<ByteProperty>(MASS_WEAPON_COLOUR_EFX_MODE)->enumValue;
@@ -196,8 +214,9 @@ void Mass::getWeaponType(Containers::StringView prop_name, Containers::ArrayView
         #include "../Maps/EffectColourModes.hpp"
         #undef c
         {
+            LOG_ERROR_FORMAT("Invalid effect colour mode {} in {}.", effect_colour_mode, _filename);
             _state = State::Invalid;
-            Utility::Warning{} << "Invalid effect colour mode in getWeaponType()."_s;
+            return;
         }
         auto effect_colour = weapon_prop->at<ColourStructProperty>(MASS_WEAPON_COLOUR_EFX);
         weapon.effectColour = Color4{effect_colour->r, effect_colour->g, effect_colour->b, effect_colour->a};
@@ -207,21 +226,25 @@ void Mass::getWeaponType(Containers::StringView prop_name, Containers::ArrayView
 auto Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayView<Weapon> weapon_array) -> bool {
     auto unit_data = _mass->at<GenericStructProperty>(MASS_UNIT_DATA);
     if(!unit_data) {
-        _state = State::Invalid;
         _lastError = "No unit data in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     auto prop = unit_data->at<ArrayProperty>(prop_name);
     if(!prop) {
-        _state = State::Invalid;
         _lastError = prop_name + " not found in "_s + _filename;
+        LOG_ERROR(_lastError);
+        _state = State::Invalid;
         return false;
     }
 
     if(prop->items.size() != weapon_array.size()) {
+        _lastError = Utility::format("Weapon arrays are not of the same size. Expected {}, got {} instead.",
+                                     weapon_array.size(), prop->items.size());
+        LOG_ERROR(_lastError);
         _state = State::Invalid;
-        _lastError = "Weapon type array size mismatch."_s;
         return false;
     }
 
@@ -235,13 +258,17 @@ auto Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayVi
             #include "../Maps/WeaponTypes.hpp"
             #undef c
             default:
-                Utility::Warning{} << "Invalid weapon type enum value in writeWeaponType()."_s;
+                _lastError = Utility::format("Invalid weapon type at index {}.", i);
+                LOG_ERROR(_lastError);
+                return false;
         }
 
         auto parts_prop = weapon_prop->at<ArrayProperty>(MASS_WEAPON_ELEMENT);
         if(parts_prop->items.size() != weapon.parts.size()) {
+            _lastError = Utility::format("Weapon part arrays are not of the same size. Expected {}, got {} instead.",
+                                         weapon.parts.size(), parts_prop->items.size());
+            LOG_ERROR(_lastError);
             _state = State::Invalid;
-            _lastError = "Weapon parts array size mismatch."_s;
             return false;
         }
 
@@ -265,8 +292,10 @@ auto Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayVi
             }
 
             if(part_accs->items.size() != part.accessories.size()) {
+                _lastError = Utility::format("Part accessory arrays are not of the same size. Expected {}, got {} instead.",
+                                             part.accessories.size(), part_accs->items.size());
+                LOG_ERROR(_lastError);
                 _state = State::Invalid;
-                _lastError = "Accessories array size mismatch."_s;
                 return false;
             }
 
@@ -275,14 +304,17 @@ auto Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayVi
 
         auto custom_styles = weapon_prop->at<ArrayProperty>(MASS_CUSTOM_WEAPON_STYLES);
         if(!custom_styles) {
-            _state = State::Invalid;
             _lastError = "No custom styles found for weapon."_s;
+            LOG_ERROR(_lastError);
+            _state = State::Invalid;
             return false;
         }
 
         if(custom_styles->items.size() != weapon.customStyles.size()) {
+            _lastError = Utility::format("Custom style arrays are not of the same size. Expected {}, got {} instead.",
+                                         weapon.customStyles.size(), custom_styles->items.size());
+            LOG_ERROR(_lastError);
             _state = State::Invalid;
-            _lastError = "Custom styles array size mismatch."_s;
             return false;
         }
 
@@ -296,7 +328,9 @@ auto Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayVi
             #include "../Maps/DamageTypes.hpp"
             #undef c
             default:
-                Utility::Warning{} << "Unknown damage type enum value in writeWeaponType()."_s;
+                _lastError = Utility::format("Invalid damage type at index {}.", i);
+                LOG_ERROR(_lastError);
+                return false;
         }
         weapon_prop->at<BoolProperty>(MASS_WEAPON_DUAL_WIELD)->value = weapon.dualWield;
         switch(weapon.effectColourMode) {
@@ -306,7 +340,9 @@ auto Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayVi
             #include "../Maps/EffectColourModes.hpp"
             #undef c
             default:
-                Utility::Warning{} << "Unknown effect colour mode in writeWeaponType()."_s;
+                _lastError = Utility::format("Invalid damage type at index {}.", i);
+                LOG_ERROR(_lastError);
+                return false;
         }
         auto effect_colour = weapon_prop->at<ColourStructProperty>(MASS_WEAPON_COLOUR_EFX);
         effect_colour->r = weapon.effectColour.r();