From 61464651cdee047f823ebebd88f9379bbc89dd53 Mon Sep 17 00:00:00 2001 From: Phillip Stephens Date: Sat, 8 May 2021 20:14:38 -0700 Subject: [PATCH] CDamageVulnerability fixes --- Runtime/Weapon/WeaponCommon.hpp | 3 +- Runtime/World/CDamageVulnerability.cpp | 218 ++++++++++++++++--------- Runtime/World/CDamageVulnerability.hpp | 83 ++-------- 3 files changed, 150 insertions(+), 154 deletions(-) diff --git a/Runtime/Weapon/WeaponCommon.hpp b/Runtime/Weapon/WeaponCommon.hpp index 5f7a3b05c..9c4f805ca 100644 --- a/Runtime/Weapon/WeaponCommon.hpp +++ b/Runtime/Weapon/WeaponCommon.hpp @@ -32,7 +32,8 @@ enum class EWeaponType { Lava = 11, Heat = 12, Unused1 = 13, - OrangePhazon = 14 + OrangePhazon = 14, + Max = 15 }; enum class EProjectileAttrib { diff --git a/Runtime/World/CDamageVulnerability.cpp b/Runtime/World/CDamageVulnerability.cpp index 9027bacbd..495f17699 100644 --- a/Runtime/World/CDamageVulnerability.cpp +++ b/Runtime/World/CDamageVulnerability.cpp @@ -34,40 +34,46 @@ const CDamageVulnerability CDamageVulnerability::sPassThroughVulnerability( EVulnerability::PassThrough, EVulnerability::PassThrough, EVulnerability::PassThrough, EVulnerability::PassThrough, EVulnerability::PassThrough, EVulnerability::PassThrough, EVulnerability::PassThrough, EDeflectType::None); -static constexpr bool is_not_deflect_direct(EVulnerability vuln) { - return vuln != EVulnerability::Deflect && vuln != EVulnerability::DirectWeak && - vuln != EVulnerability::DirectNormal && vuln != EVulnerability::DirectImmune; +static constexpr bool is_deflect_direct(EVulnerability vuln) { + return vuln == EVulnerability::Deflect || vuln == EVulnerability::DirectWeak || + vuln == EVulnerability::DirectNormal || vuln == EVulnerability::DirectImmune; } static constexpr bool is_normal_or_weak(EVulnerability vuln) { - return vuln == EVulnerability::Normal || vuln == EVulnerability::Weak; + return vuln == EVulnerability::Weak || vuln == EVulnerability::Normal; +} +static constexpr bool is_not_deflect(EVulnerability vuln) { + return vuln != EVulnerability::Deflect; } void CDamageVulnerability::ConstructNew(CInputStream& in, int propCount) { propCount -= 3; - EVulnerability* vulns = &x0_power; - for (int i = 0; i < std::min(propCount, 15); ++i) - vulns[i] = EVulnerability(in.readUint32Big()); - if (propCount < 15) { - for (int i = propCount; i < 15; ++i) - vulns[i] = EVulnerability::Deflect; + for (int i = 0; i < std::min(propCount, 15); ++i) { + x0_normal[i] = EVulnerability(in.readUint32Big()); } - for (int i = 15; i < propCount; ++i) + if (propCount < 15) { + for (int i = propCount; i < 15; ++i) { + x0_normal[i] = EVulnerability::Deflect; + } + } + + for (int i = 15; i < propCount; ++i) { in.readUint32Big(); + } x5c_deflected = EDeflectType(in.readUint32Big()); - EVulnerability* vulns2 = &x3c_chargedPower; in.readUint32Big(); - for (int i = 0; i < 4; ++i) - vulns2[i] = EVulnerability(in.readUint32Big()); + for (int i = 0; i < 4; ++i) { + x3c_charged[i] = EVulnerability(in.readUint32Big()); + } x60_chargedDeflected = EDeflectType(in.readUint32Big()); - EVulnerability* vulns3 = &x4c_superMissile; in.readUint32Big(); - for (int i = 0; i < 4; ++i) - vulns3[i] = EVulnerability(in.readUint32Big()); + for (int i = 0; i < 4; ++i) { + x4c_combo[i] = EVulnerability(in.readUint32Big()); + } x64_comboDeflected = EDeflectType(in.readUint32Big()); } @@ -75,74 +81,105 @@ void CDamageVulnerability::ConstructNew(CInputStream& in, int propCount) { CDamageVulnerability::CDamageVulnerability(CInputStream& in) { u32 propCount = in.readUint32Big(); if (propCount == 11) { - EVulnerability* vulns = &x0_power; - for (int i = 0; i < 15; ++i) - vulns[i] = EVulnerability(in.readUint32Big()); + for (int i = 0; i < 15; ++i) { + x0_normal[i] = EVulnerability(in.readUint32Big()); + } - if (propCount == 15) + if (propCount == 15) { x5c_deflected = EDeflectType::None; - else + } else { x5c_deflected = EDeflectType(in.readUint32Big()); + } - x3c_chargedPower = x0_power; - x4c_superMissile = x0_power; - x40_chargedIce = x4_ice; - x50_iceSpreader = x4_ice; - x44_chargedWave = x8_wave; - x54_wavebuster = x8_wave; - x48_chargedPlasma = xc_plasma; - x58_flamethrower = xc_plasma; - } else + x3c_charged[0] = x0_normal[0]; + x4c_combo[0] = x0_normal[0]; + x3c_charged[1] = x0_normal[1]; + x4c_combo[1] = x0_normal[1]; + x3c_charged[2] = x0_normal[2]; + x4c_combo[2] = x0_normal[2]; + x3c_charged[3] = x0_normal[3]; + x4c_combo[3] = x0_normal[3]; + } else { ConstructNew(in, propCount); + } } EDeflectType CDamageVulnerability::GetDeflectionType(const CWeaponMode& mode) const { - if (mode.IsCharged()) + if (mode.IsCharged()) { return x60_chargedDeflected; - if (mode.IsComboed()) + } + if (mode.IsComboed()) { return x64_comboDeflected; + } return x5c_deflected; } bool CDamageVulnerability::WeaponHurts(const CWeaponMode& mode, bool ignoreDirect) const { - if (mode.GetType() == EWeaponType::None || mode.GetType() > EWeaponType::OrangePhazon) + if (mode.GetType() == EWeaponType::None || mode.GetType() > EWeaponType::OrangePhazon) { return false; - if (mode.IsInstantKill()) + } + if (mode.IsInstantKill()) { return true; + } - EVulnerability normalVuln = (&x0_power)[u32(mode.GetType())]; bool normalHurts = true; - if (ignoreDirect) { - normalHurts = is_normal_or_weak(normalVuln); - } else { - if (!is_normal_or_weak(normalVuln) && - (normalVuln != EVulnerability::DirectWeak && normalVuln != EVulnerability::DirectNormal)) + const auto vuln = x0_normal[u32(mode.GetType())]; + if (!ignoreDirect) { + bool directHurts = true; + if (!is_normal_or_weak(vuln) && vuln != EVulnerability::DirectWeak) { + directHurts = false; + } + if (!directHurts && vuln != EVulnerability::DirectNormal) { normalHurts = false; + } + } else if (!is_normal_or_weak(vuln)) { + normalHurts = false; } bool chargedHurts = true; - bool comboedHurts = true; if (mode.GetType() < EWeaponType::Bomb) { - EVulnerability chargedVuln = (&x3c_chargedPower)[u32(mode.GetType())]; - EVulnerability comboedVuln = (&x4c_superMissile)[u32(mode.GetType())]; - if (ignoreDirect) { - chargedHurts = is_normal_or_weak(chargedVuln); - comboedHurts = is_normal_or_weak(comboedVuln); - } else { - if (!is_normal_or_weak(chargedVuln) && - (chargedVuln != EVulnerability::DirectWeak && chargedVuln != EVulnerability::DirectNormal)) + const auto chargedVuln = x3c_charged[u32(mode.GetType())]; + if (!ignoreDirect) { + bool directHurts = true; + if (!is_normal_or_weak(chargedVuln) && chargedVuln != EVulnerability::DirectWeak) { + directHurts = false; + } + + if (!directHurts && chargedVuln != EVulnerability::DirectNormal) { chargedHurts = false; - if (!is_normal_or_weak(comboedVuln) && - (comboedVuln != EVulnerability::DirectWeak && comboedVuln != EVulnerability::DirectNormal)) - comboedHurts = false; + } + } else if (!is_normal_or_weak(chargedVuln)) { + chargedHurts = false; } } - if (normalHurts && !mode.IsCharged() && !mode.IsComboed()) - return true; - if (chargedHurts && mode.IsCharged()) - return true; - return comboedHurts && mode.IsComboed(); + bool comboedHurts = true; + if (mode.GetType() < EWeaponType::Bomb) { + const auto comboedVuln = x4c_combo[u32(mode.GetType())]; + if (!ignoreDirect) { + bool directHurts = true; + if (!is_normal_or_weak(comboedVuln) && comboedVuln != EVulnerability::DirectWeak) { + directHurts = false; + } + + if (!directHurts && comboedVuln != EVulnerability::DirectNormal) { + comboedHurts = false; + } + } else if (!is_normal_or_weak(comboedVuln)) { + comboedHurts = false; + } + } + + if (((!normalHurts || mode.IsCharged()) || mode.IsComboed()) && (!chargedHurts || !mode.IsCharged())) { + if (!comboedHurts) { + return false; + } + + if (!mode.IsComboed()) { + return false; + } + } + return true; } bool CDamageVulnerability::WeaponHits(const CWeaponMode& mode, bool checkDirect) const { @@ -152,39 +189,56 @@ bool CDamageVulnerability::WeaponHits(const CWeaponMode& mode, bool checkDirect) if (mode.IsInstantKill()) { return true; } - - bool normalVuln; + const auto normalVuln = x0_normal[u32(mode.GetType())]; + bool normalHits = true; if (!checkDirect) { - normalVuln = (&x0_power)[u32(mode.GetType())] != EVulnerability::Deflect; - } else { - normalVuln = is_not_deflect_direct((&x0_power)[u32(mode.GetType())]); + normalHits = is_not_deflect(normalVuln); + } else if (is_deflect_direct(normalVuln)) { + normalHits = false; } - bool chargedVuln = true; - bool comboedVuln = true; + bool chargedHits = true; if (mode.GetType() < EWeaponType::Bomb) { - const EVulnerability chargedPowerVuln = (&x3c_chargedPower)[u32(mode.GetType())]; - const EVulnerability superMissileVuln = (&x4c_superMissile)[u32(mode.GetType())]; + const auto chargedVuln = x3c_charged[u32(mode.GetType())]; if (!checkDirect) { - chargedVuln = chargedPowerVuln != EVulnerability::Deflect; - comboedVuln = superMissileVuln != EVulnerability::Deflect; + chargedHits = is_not_deflect(chargedVuln); + } else if (is_deflect_direct(normalVuln)) { + chargedHits = false; } else { - chargedVuln = is_not_deflect_direct(chargedPowerVuln); - comboedVuln = is_not_deflect_direct(superMissileVuln); + chargedHits = true; } } - if (normalVuln && !mode.IsCharged() && !mode.IsComboed()) { + bool comboedHits = true; + if (mode.GetType() < EWeaponType::Bomb) { + const auto chargedVuln = x3c_charged[u32(mode.GetType())]; + if (!checkDirect) { + comboedHits = is_not_deflect(chargedVuln); + } else if (is_deflect_direct(normalVuln)) { + comboedHits = false; + } else { + comboedHits = true; + } + } + + if (normalHits && !mode.IsCharged() && !mode.IsComboed()) { return true; } - if (chargedVuln && mode.IsCharged()) { - return true; + + if (!chargedHits || !mode.IsCharged()) { + if (comboedHits) { + return false; + } + if (!mode.IsComboed()) { + return false; + } } - return comboedVuln && mode.IsComboed(); + return true; } EVulnerability CDamageVulnerability::GetVulnerability(const CWeaponMode& mode, bool ignoreDirect) const { - if (mode.GetType() == EWeaponType::None || mode.GetType() > EWeaponType::OrangePhazon) { + const auto type = mode.GetType(); + if (type <= EWeaponType::None || type >= EWeaponType::Max) { return EVulnerability::Deflect; } @@ -192,18 +246,18 @@ EVulnerability CDamageVulnerability::GetVulnerability(const CWeaponMode& mode, b return EVulnerability::Normal; } - EVulnerability vuln = (&x0_power)[u32(mode.GetType())]; + auto vuln = x0_normal[u32(type)]; if (mode.IsCharged()) { - if (mode.GetType() < EWeaponType::Bomb) { - vuln = (&x3c_chargedPower)[u32(mode.GetType())]; + if (type < EWeaponType::Bomb) { + vuln = x3c_charged[u32(type)]; } else { vuln = EVulnerability::Normal; } } if (mode.IsComboed()) { - if (mode.GetType() < EWeaponType::Bomb) { - vuln = (&x3c_chargedPower)[u32(mode.GetType())]; + if (type < EWeaponType::Bomb) { + vuln = x4c_combo[u32(type)]; } else { vuln = EVulnerability::Normal; } @@ -216,9 +270,11 @@ EVulnerability CDamageVulnerability::GetVulnerability(const CWeaponMode& mode, b if (vuln == EVulnerability::DirectWeak) { return EVulnerability::Weak; } + if (vuln == EVulnerability::DirectNormal) { return EVulnerability::Normal; } + if (vuln == EVulnerability::DirectImmune) { return EVulnerability::Immune; } diff --git a/Runtime/World/CDamageVulnerability.hpp b/Runtime/World/CDamageVulnerability.hpp index 8c92526ed..fd89b6bd4 100644 --- a/Runtime/World/CDamageVulnerability.hpp +++ b/Runtime/World/CDamageVulnerability.hpp @@ -9,32 +9,9 @@ enum class EVulnerability { Weak, Normal, Deflect, Immune, PassThrough, DirectWe enum class EDeflectType { None, One, Two, Three, Four }; class CDamageVulnerability { - EVulnerability x0_power; - EVulnerability x4_ice; - EVulnerability x8_wave; - EVulnerability xc_plasma; - EVulnerability x10_bomb; - EVulnerability x14_powerbomb; - EVulnerability x18_missile; - EVulnerability x1c_boostBall; - EVulnerability x20_phazon; - EVulnerability x24_enemyWp1; - EVulnerability x28_enemyWp2Poison; - EVulnerability x2c_enemyWp3Lava; - EVulnerability x30_enemyWp4; - EVulnerability x34_unk1; - EVulnerability x38_unk2; - - EVulnerability x3c_chargedPower; - EVulnerability x40_chargedIce; - EVulnerability x44_chargedWave; - EVulnerability x48_chargedPlasma; - - EVulnerability x4c_superMissile; - EVulnerability x50_iceSpreader; - EVulnerability x54_wavebuster; - EVulnerability x58_flamethrower; - + std::array x0_normal; + std::array x3c_charged; + std::array x4c_combo; EDeflectType x5c_deflected; EDeflectType x60_chargedDeflected{}; EDeflectType x64_comboDeflected{}; @@ -54,29 +31,10 @@ public: EVulnerability boostBall, EVulnerability phazon, EVulnerability enemyWp1, EVulnerability enemyWp2, EVulnerability enemyWp3, EVulnerability enemyWp4, EVulnerability v1, EVulnerability v2, EDeflectType deflectType) - : x0_power(power) - , x4_ice(ice) - , x8_wave(wave) - , xc_plasma(plasma) - , x10_bomb(bomb) - , x14_powerbomb(powerBomb) - , x18_missile(missile) - , x1c_boostBall(boostBall) - , x20_phazon(phazon) - , x24_enemyWp1(enemyWp1) - , x28_enemyWp2Poison(enemyWp2) - , x2c_enemyWp3Lava(enemyWp3) - , x30_enemyWp4(enemyWp4) - , x34_unk1(v1) - , x38_unk2(v2) - , x3c_chargedPower(x0_power) - , x40_chargedIce(x4_ice) - , x44_chargedWave(x8_wave) - , x48_chargedPlasma(xc_plasma) - , x4c_superMissile(x0_power) - , x50_iceSpreader(x4_ice) - , x54_wavebuster(x8_wave) - , x58_flamethrower(xc_plasma) + : x0_normal({power, ice, wave, plasma, powerBomb, missile, boostBall, phazon, enemyWp1, enemyWp2, enemyWp3, enemyWp4, + v1, v2}) + , x3c_charged({x0_normal[0], x0_normal[1], x0_normal[2], x0_normal[3]}) + , x4c_combo({x0_normal[0], x0_normal[1], x0_normal[2], x0_normal[3]}) , x5c_deflected(deflectType) {} constexpr CDamageVulnerability(EVulnerability power, EVulnerability ice, EVulnerability wave, EVulnerability plasma, @@ -87,29 +45,10 @@ public: EVulnerability chargedIce, EVulnerability chargedWave, EVulnerability chargedPlasma, EVulnerability superMissile, EVulnerability iceSpreader, EVulnerability waveBuster, EVulnerability flameThrower, EDeflectType deflected) - : x0_power(power) - , x4_ice(ice) - , x8_wave(wave) - , xc_plasma(plasma) - , x10_bomb(bomb) - , x14_powerbomb(powerBomb) - , x18_missile(missile) - , x1c_boostBall(boostBall) - , x20_phazon(phazon) - , x24_enemyWp1(enemyWp1) - , x28_enemyWp2Poison(enemyWp2) - , x2c_enemyWp3Lava(enemyWp3) - , x30_enemyWp4(enemyWp4) - , x34_unk1(v1) - , x38_unk2(v2) - , x3c_chargedPower(chargedPower) - , x40_chargedIce(chargedIce) - , x44_chargedWave(chargedWave) - , x48_chargedPlasma(chargedPlasma) - , x4c_superMissile(superMissile) - , x50_iceSpreader(iceSpreader) - , x54_wavebuster(waveBuster) - , x58_flamethrower(flameThrower) + : x0_normal({power, ice, wave, plasma, powerBomb, missile, boostBall, phazon, enemyWp1, enemyWp2, enemyWp3, enemyWp4, + v1, v2}) + , x3c_charged({chargedPower, chargedIce, chargedWave, chargedPlasma}) + , x4c_combo({superMissile, iceSpreader, waveBuster, flameThrower}) , x5c_deflected(deflected) {} EDeflectType GetDeflectionType(const CWeaponMode& mode) const;