MassBuilderSaveTool/src/GameObjects/Mass_Weapons.cpp

// MassBuilderSaveTool
// Copyright (C) 2021-2024 Guillaume Jacquemin
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// 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 "MassPropertyNames.h"
#include "../Logger/Logger.h"
#include "../Gvas/Types/ArrayProperty.h"
#include "../Gvas/Types/BoolProperty.h"
#include "../Gvas/Types/ByteProperty.h"
#include "../Gvas/Types/ColourStructProperty.h"
#include "../Gvas/Types/GenericStructProperty.h"
#include "../Gvas/Types/IntProperty.h"
#include "../Gvas/Types/StringProperty.h"

#include "Mass.h"

using namespace Containers::Literals;

namespace mbst { namespace GameObjects {

Containers::ArrayView<Weapon>
Mass::meleeWeapons() {
    return _weapons.melee;
}

void
Mass::getMeleeWeapons() {
    LOG_INFO("Getting melee weapons.");
    getWeaponType(MASS_WEAPONS_MELEE, _weapons.melee);
}

bool
Mass::writeMeleeWeapons() {
    LOG_INFO("Writing melee weapons.");
    return writeWeaponType(MASS_WEAPONS_MELEE, _weapons.melee);
}

Containers::ArrayView<Weapon>
Mass::shields() {
    return _weapons.shields;
}

void
Mass::getShields() {
    LOG_INFO("Getting shields.");
    getWeaponType(MASS_WEAPONS_SHIELD, _weapons.shields);
}

bool
Mass::writeShields() {
    LOG_INFO("Writing shields.");
    return writeWeaponType(MASS_WEAPONS_SHIELD, _weapons.shields);
}

Containers::ArrayView<Weapon>
Mass::bulletShooters() {
    return _weapons.bulletShooters;
}

void
Mass::getBulletShooters() {
    LOG_INFO("Getting bullet shooters.");
    getWeaponType(MASS_WEAPONS_BSHOOTER, _weapons.bulletShooters);
}

bool
Mass::writeBulletShooters() {
    LOG_INFO("Writing bullet shooters.");
    return writeWeaponType(MASS_WEAPONS_BSHOOTER, _weapons.bulletShooters);
}

Containers::ArrayView<Weapon>
Mass::energyShooters() {
    return _weapons.energyShooters;
}

void
Mass::getEnergyShooters() {
    LOG_INFO("Getting energy shooters.");
    getWeaponType(MASS_WEAPONS_ESHOOTER, _weapons.energyShooters);
}

bool
Mass::writeEnergyShooters() {
    LOG_INFO("Writing energy shooters.");
    return writeWeaponType(MASS_WEAPONS_ESHOOTER, _weapons.energyShooters);
}

Containers::ArrayView<Weapon>
Mass::bulletLaunchers() {
    return _weapons.bulletLaunchers;
}

void
Mass::getBulletLaunchers() {
    LOG_INFO("Getting bullet launchers.");
    getWeaponType(MASS_WEAPONS_BLAUNCHER, _weapons.bulletLaunchers);
}

bool
Mass::writeBulletLaunchers() {
    LOG_INFO("Writing bullet launchers.");
    return writeWeaponType(MASS_WEAPONS_BLAUNCHER, _weapons.bulletLaunchers);
}

Containers::ArrayView<Weapon>
Mass::energyLaunchers() {
    return _weapons.energyLaunchers;
}

void
Mass::getEnergyLaunchers() {
    LOG_INFO("Getting energy launchers.");
    getWeaponType(MASS_WEAPONS_ELAUNCHER, _weapons.energyLaunchers);
}

bool
Mass::writeEnergyLaunchers() {
    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<Gvas::Types::GenericStructProperty>(MASS_UNIT_DATA);
    if(!unit_data) {
        LOG_ERROR_FORMAT("Couldn't find {} in {}.", MASS_UNIT_DATA, _filename);
        _state = State::Invalid;
        return;
    }

    auto prop = unit_data->at<Gvas::Types::ArrayProperty>(prop_name);
    if(!prop) {
        LOG_ERROR_FORMAT("Couldn't find {} in {}.", prop_name, _filename);
        _state = State::Invalid;
        return;
    }

    if(prop->items.size() != weapon_array.size()) {
        LOG_ERROR_FORMAT("Weapon arrays are not of the same size. Expected {}, got {} instead.",
                         weapon_array.size(), prop->items.size());
        _state = State::Invalid;
        return;
    }

    for(std::uint32_t i = 0; i < weapon_array.size(); i++) {
        auto weapon_prop = prop->at<Gvas::Types::GenericStructProperty>(i);
        auto& weapon = weapon_array[i];

        weapon.name = weapon_prop->at<Gvas::Types::StringProperty>(MASS_WEAPON_NAME)->value;
        auto& weapon_type = weapon_prop->at<Gvas::Types::ByteProperty>(MASS_WEAPON_TYPE)->enumValue;
        #define c(enumerator, strenum, name) if(weapon_type == (strenum)) { weapon.type = Weapon::Type::enumerator; } else
        #include "../Maps/WeaponTypes.hpp"
        #undef c
        {
            LOG_ERROR_FORMAT("Invalid weapon type {} in {}.", weapon_type, _filename);
            _state = State::Invalid;
            return;
        }

        auto parts_prop = weapon_prop->at<Gvas::Types::ArrayProperty>(MASS_WEAPON_ELEMENT);
        weapon.parts = Containers::Array<WeaponPart>{ValueInit, parts_prop->items.size()};

        for(std::uint32_t j = 0; j < parts_prop->items.size(); j++) {
            auto part_prop = parts_prop->at<Gvas::Types::GenericStructProperty>(j);
            auto& part = weapon.parts[j];

            part.id = part_prop->at<Gvas::Types::IntProperty>(MASS_WEAPON_PART_ID)->value;

            auto part_styles = part_prop->at<Gvas::Types::ArrayProperty>(MASS_WEAPON_PART_STYLES);
            for(std::uint32_t k = 0; k < part_styles->items.size(); k++) {
                part.styles[k] = part_styles->at<Gvas::Types::IntProperty>(k)->value;
            }

            auto part_decals = part_prop->at<Gvas::Types::ArrayProperty>(MASS_WEAPON_PART_DECALS);
            if(part_decals->items.size() != part.decals.size()) {
                part.decals = Containers::Array<Decal>{part_decals->items.size()};
            }

            getDecals(part.decals, part_decals);

            auto part_accs = part_prop->at<Gvas::Types::ArrayProperty>(MASS_WEAPON_PART_ACCESSORIES);
            if(!part_accs) {
                part.accessories = Containers::Array<Accessory>{0};
                continue;
            }

            if(part_accs->items.size() != part.accessories.size()) {
                part.accessories = Containers::Array<Accessory>{part_accs->items.size()};
            }
            getAccessories(part.accessories, part_accs);
        }

        auto custom_styles = weapon_prop->at<Gvas::Types::ArrayProperty>(MASS_CUSTOM_WEAPON_STYLES);
        if(!custom_styles) {
            LOG_ERROR_FORMAT("Can't find weapon custom styles in {}", _filename);
            _state = State::Invalid;
            return;
        }

        if(custom_styles->items.size() != weapon.customStyles.size()) {
            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;
        }

        getCustomStyles(weapon.customStyles, custom_styles);

        for(auto& style : weapon.customStyles) {
            style.type = CustomStyle::Type::Weapon;
        }

        weapon.attached = weapon_prop->at<Gvas::Types::BoolProperty>(MASS_WEAPON_ATTACH)->value;
        auto& damage_type = weapon_prop->at<Gvas::Types::ByteProperty>(MASS_WEAPON_DAMAGE_TYPE)->enumValue;
        #define c(enumerator, strenum) if(damage_type == (strenum)) { weapon.damageType = Weapon::DamageType::enumerator; } else
        #include "../Maps/DamageTypes.hpp"
        #undef c
        {
            LOG_ERROR_FORMAT("Invalid damage type {} in {}.", damage_type, _filename);
            _state = State::Invalid;
            return;
        }
        weapon.dualWield = weapon_prop->at<Gvas::Types::BoolProperty>(MASS_WEAPON_DUAL_WIELD)->value;
        auto& effect_colour_mode = weapon_prop->at<Gvas::Types::ByteProperty>(MASS_WEAPON_COLOUR_EFX_MODE)->enumValue;
        #define c(enumerator, strenum) if(effect_colour_mode == (strenum)) { weapon.effectColourMode = Weapon::EffectColourMode::enumerator; } else
        #include "../Maps/EffectColourModes.hpp"
        #undef c
        {
            LOG_ERROR_FORMAT("Invalid effect colour mode {} in {}.", effect_colour_mode, _filename);
            _state = State::Invalid;
            return;
        }
        auto effect_colour = weapon_prop->at<Gvas::Types::ColourStructProperty>(MASS_WEAPON_COLOUR_EFX);
        weapon.effectColour = Color4{effect_colour->r, effect_colour->g, effect_colour->b, effect_colour->a};
    }
}

bool
Mass::writeWeaponType(Containers::StringView prop_name, Containers::ArrayView<Weapon> weapon_array) {
    auto unit_data = _mass->at<Gvas::Types::GenericStructProperty>(MASS_UNIT_DATA);
    if(!unit_data) {
        _lastError = "No unit data in "_s + _filename;
        LOG_ERROR(_lastError);
        _state = State::Invalid;
        return false;
    }

    auto prop = unit_data->at<Gvas::Types::ArrayProperty>(prop_name);
    if(!prop) {
        _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;
        return false;
    }

    for(std::uint32_t i = 0; i < weapon_array.size(); i++) {
        auto weapon_prop = prop->at<Gvas::Types::GenericStructProperty>(i);
        auto& weapon = weapon_array[i];

        weapon_prop->at<Gvas::Types::StringProperty>(MASS_WEAPON_NAME)->value = weapon.name;
        switch(weapon.type) {
            #define c(enumerator, strenum, name) case Weapon::Type::enumerator: weapon_prop->at<Gvas::Types::ByteProperty>(MASS_WEAPON_TYPE)->enumValue = strenum; break;
            #include "../Maps/WeaponTypes.hpp"
            #undef c
            default:
                _lastError = Utility::format("Invalid weapon type at index {}.", i);
                LOG_ERROR(_lastError);
                return false;
        }

        auto parts_prop = weapon_prop->at<Gvas::Types::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;
            return false;
        }

        for(std::uint32_t j = 0; j < parts_prop->items.size(); j++) {
            auto part_prop = parts_prop->at<Gvas::Types::GenericStructProperty>(j);
            auto& part = weapon.parts[j];

            part_prop->at<Gvas::Types::IntProperty>(MASS_WEAPON_PART_ID)->value = part.id;

            auto part_styles = part_prop->at<Gvas::Types::ArrayProperty>(MASS_WEAPON_PART_STYLES);
            for(std::uint32_t k = 0; k < part_styles->items.size(); k++) {
                part_styles->at<Gvas::Types::IntProperty>(k)->value = part.styles[k];
            }

            auto part_decals = part_prop->at<Gvas::Types::ArrayProperty>(MASS_WEAPON_PART_DECALS);
            writeDecals(part.decals, part_decals);

            auto part_accs = part_prop->at<Gvas::Types::ArrayProperty>(MASS_WEAPON_PART_ACCESSORIES);
            if(!part_accs) {
                continue;
            }

            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;
                return false;
            }

            writeAccessories(part.accessories, part_accs);
        }

        auto custom_styles = weapon_prop->at<Gvas::Types::ArrayProperty>(MASS_CUSTOM_WEAPON_STYLES);
        if(!custom_styles) {
            _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;
            return false;
        }

        for(std::uint32_t j = 0; j < weapon.customStyles.size(); j++) {
            writeCustomStyle(weapon.customStyles[j], j, custom_styles);
        }

        weapon_prop->at<Gvas::Types::BoolProperty>(MASS_WEAPON_ATTACH)->value = weapon.attached;
        switch(weapon.damageType) {
            #define c(enumerator, strenum) case Weapon::DamageType::enumerator: weapon_prop->at<Gvas::Types::ByteProperty>(MASS_WEAPON_DAMAGE_TYPE)->enumValue = strenum; break;
            #include "../Maps/DamageTypes.hpp"
            #undef c
            default:
                _lastError = Utility::format("Invalid damage type at index {}.", i);
                LOG_ERROR(_lastError);
                return false;
        }
        weapon_prop->at<Gvas::Types::BoolProperty>(MASS_WEAPON_DUAL_WIELD)->value = weapon.dualWield;
        switch(weapon.effectColourMode) {
            #define c(enumerator, enumstr) case Weapon::EffectColourMode::enumerator:                                                        \
                                               weapon_prop->at<Gvas::Types::ByteProperty>(MASS_WEAPON_COLOUR_EFX_MODE)->enumValue = enumstr; \
                                               break;
            #include "../Maps/EffectColourModes.hpp"
            #undef c
            default:
                _lastError = Utility::format("Invalid damage type at index {}.", i);
                LOG_ERROR(_lastError);
                return false;
        }
        auto effect_colour = weapon_prop->at<Gvas::Types::ColourStructProperty>(MASS_WEAPON_COLOUR_EFX);
        effect_colour->r = weapon.effectColour.r();
        effect_colour->g = weapon.effectColour.g();
        effect_colour->b = weapon.effectColour.b();
        effect_colour->a = weapon.effectColour.a();
    }

    if(!_mass->saveToFile()) {
        _lastError = _mass->lastError();
        return false;
    }

    return true;
}

}}