Nanocom Boosters and Authentic FM-Taro Scale Logic (#315)

* Groundwork for nanocom boosters

* The item use handler now has a switch for multiple item types (currently gumballs, and a stub for boosters)
* All item types are now checked for expiration, not just vehicles

* implement nanocom booster helpers, save and expiry

* implement authentic taro and fm modfication

* magic number and code refactor

* make sure only close by group members are counted

* add safe taro fm handling, rate command, race and mission booster logic

* add config option to disable authentic group scaling

* rename for consistency

* make rates percentages, fix chat message, add config options

* add config option to the ini file

* add index guard for hasBoost functions

* reorder config ini options

* add bank item expiry option

* fix trade oversight

---------

Co-authored-by: CakeLancelot <CakeLancelot@users.noreply.github.com>

Author: FinnHornhoover

config.ini

@@ -43,17 +43,37 @@ simulatemobs=true
 # little message players see when they enter the game
 motd=Welcome to OpenFusion!
 
-# The following are the default locations of the JSON files the server
-# requires to run. You can override them by changing their values and
-# uncommenting them (removing the leading # character from that line).
-
 # Should drop fixes be enabled?
 # This will add drops to (mostly Academy-specific) mobs that don't have drops
 # and rearrange drop tables that are either unassigned or stranded in difficult to reach mobs
 # e.g. Hyper Fusionfly and Fusion Numbuh Four drops will become more accessible.
 # This is a polish option that is slightly inauthentic to the original game.
 #dropfixesenabled=true
 
+# Should groups have to divide up gained Taros / FM among themselves?
+# Taros is divided up, FM gets diminished per group member, roughly -12.5% per group member
+# Original game worked like this. Uncomment below to disable this behavior.
+#lesstarofmingroupdisabled=true
+
+# General reward percentages
+# You can change the rate of taro and fusion matter gains for all players.
+# The numbers are in percentages, i.e. 1000 is 1000%. You should only use whole numbers, no decimals.
+# Uncomment and change below to your desired rate. Defaults are 100%, regular gain rates.
+#tarorate=100
+#fusionmatterrate=100
+
+# Should expired items in the bank disappear automatically?
+# Original game let you kep expired items in the bank until you take them out.
+# Uncomment below to enable this behavior.
+#removeexpireditemsfrombank=true
+
+# Should there be a score cap for infected zone races?
+#izracescorecapped=true
+
+# The following are the default locations of the JSON files the server
+# requires to run. You can override them by changing their values and
+# uncommenting them (removing the leading # character from that line).
+
 # location of the tabledata folder
 #tdatadir=tdata/
 # location of the patch folder
@@ -79,9 +99,6 @@ motd=Welcome to OpenFusion!
 # location of the database
 #dbpath=database.db
 
-# should there be a score cap for infected zone races?
-#izracescorecapped=true
-
 # should tutorial flags be disabled off the bat?
 disablefirstuseflag=true
 

src/Abilities.cpp

@@ -170,11 +170,11 @@ static SkillResult handleSkillBatteryDrain(SkillData* skill, int power, ICombata
     if(!blocked) {
         boostDrain = (int)(skill->values[0][power] * scalingFactor);
         if(boostDrain > plr->batteryW) boostDrain = plr->batteryW;
-        plr->batteryW -= boostDrain;
+        plr->subtractCapped(CappedValueType::BATTERY_W, boostDrain);
 
         potionDrain = (int)(skill->values[1][power] * scalingFactor);
         if(potionDrain > plr->batteryN) potionDrain = plr->batteryN;
-        plr->batteryN -= potionDrain;
+        plr->subtractCapped(CappedValueType::BATTERY_N, potionDrain);
     }
 
     sSkillResult_BatteryDrain result{};
@@ -364,7 +364,7 @@ void Abilities::useNPCSkill(EntityRef npc, int skillID, std::vector<ICombatant*>
     ICombatant* src = nullptr;
     if(npc.kind == EntityKind::COMBAT_NPC || npc.kind == EntityKind::MOB)
         src = dynamic_cast<ICombatant*>(entity);
-    
+
     SkillData* skill = &SkillTable[skillID];
 
     std::vector<SkillResult> results = handleSkill(skill, 0, src, affected);
@@ -443,7 +443,7 @@ std::vector<ICombatant*> Abilities::matchTargets(ICombatant* src, SkillData* ski
         }
     }
 
-    return targets; 
+    return targets;
 }
 
 /* ripped from client (enums emplaced) */

src/BuiltinCommands.cpp

@@ -75,30 +75,22 @@ static void setValuePlayer(CNSocket* sock, CNPacketData* data) {
     case CN_GM_SET_VALUE_TYPE__HP:
         response.iSetValue = plr->HP = setData->iSetValue;
         break;
-    case CN_GM_SET_VALUE_TYPE__WEAPON_BATTERY :
-        plr->batteryW = setData->iSetValue;
-
-        // caps
-        if (plr->batteryW > 9999)
-            plr->batteryW = 9999;
-
+    case CN_GM_SET_VALUE_TYPE__WEAPON_BATTERY:
+        plr->setCapped(CappedValueType::BATTERY_W, setData->iSetValue);
         response.iSetValue = plr->batteryW;
         break;
     case CN_GM_SET_VALUE_TYPE__NANO_BATTERY:
-        plr->batteryN = setData->iSetValue;
-
-        // caps
-        if (plr->batteryN > 9999)
-            plr->batteryN = 9999;
-
+        plr->setCapped(CappedValueType::BATTERY_N, setData->iSetValue);
         response.iSetValue = plr->batteryN;
         break;
     case CN_GM_SET_VALUE_TYPE__FUSION_MATTER:
-        Missions::updateFusionMatter(sock, setData->iSetValue - plr->fusionmatter);
+        plr->setCapped(CappedValueType::FUSIONMATTER, setData->iSetValue);
+        Missions::updateFusionMatter(sock);
         response.iSetValue = plr->fusionmatter;
         break;
     case CN_GM_SET_VALUE_TYPE__CANDY:
-        response.iSetValue = plr->money = setData->iSetValue;
+        plr->setCapped(CappedValueType::TAROS, setData->iSetValue);
+        response.iSetValue = plr->money;
         break;
     case CN_GM_SET_VALUE_TYPE__SPEED:
     case CN_GM_SET_VALUE_TYPE__JUMP:
@@ -148,6 +140,60 @@ static void setGMSpecialOnOff(CNSocket *sock, CNPacketData *data) {
     // this is only used for muting players, so no need to update the client since that logic is server-side
 }
 
+static void setGMRewardRate(CNSocket *sock, CNPacketData *data) {
+    Player *plr = PlayerManager::getPlayer(sock);
+
+    // access check
+    if (plr->accountLevel > 30)
+        return;
+
+    auto req = (sP_CL2FE_GM_REQ_REWARD_RATE*)data->buf;
+
+    if (req->iGetSet != 0) {
+        double *rate = nullptr;
+
+        switch (req->iRewardType) {
+        case REWARD_TYPE_TAROS:
+            rate = plr->rateT;
+            break;
+        case REWARD_TYPE_FUSIONMATTER:
+            rate = plr->rateF;
+            break;
+        }
+
+        if (rate == nullptr) {
+            std::cout << "[WARN] Invalid reward type for setGMRewardRate(): " << req->iRewardType << std::endl;
+            return;
+        }
+
+        if (req->iSetRateValue < 0 || req->iSetRateValue > 1000) {
+            std::cout << "[WARN] Invalid rate value for setGMRewardRate(): " << req->iSetRateValue << " (must be between 0 and 1000)" << std::endl;
+            return;
+        }
+
+        switch (req->iRewardRateIndex) {
+        case RATE_SLOT_ALL:
+            for (int i = 0; i < 5; i++)
+                rate[i] = req->iSetRateValue / 100.0;
+            break;
+        case RATE_SLOT_COMBAT:
+        case RATE_SLOT_MISSION:
+        case RATE_SLOT_EGG:
+        case RATE_SLOT_RACING:
+            rate[req->iRewardRateIndex] = req->iSetRateValue / 100.0;
+            break;
+        }
+    }
+
+    INITSTRUCT(sP_FE2CL_GM_REP_REWARD_RATE_SUCC, resp);
+    for (int i = 0; i < 5; i++) {
+        // double to float
+        resp.afRewardRate_Taros[i] = plr->rateT[i];
+        resp.afRewardRate_FusionMatter[i] = plr->rateF[i];
+    }
+    sock->sendPacket(resp, P_FE2CL_GM_REP_REWARD_RATE_SUCC);
+}
+
 static void locatePlayer(CNSocket *sock, CNPacketData *data) {
     Player *plr = PlayerManager::getPlayer(sock);
 
@@ -371,6 +417,7 @@ void BuiltinCommands::init() {
 
     REGISTER_SHARD_PACKET(P_CL2FE_GM_REQ_PC_SPECIAL_STATE_SWITCH, setGMSpecialSwitchPlayer);
     REGISTER_SHARD_PACKET(P_CL2FE_GM_REQ_TARGET_PC_SPECIAL_STATE_ONOFF, setGMSpecialOnOff);
+    REGISTER_SHARD_PACKET(P_CL2FE_GM_REQ_REWARD_RATE, setGMRewardRate);
 
     REGISTER_SHARD_PACKET(P_CL2FE_GM_REQ_PC_LOCATION, locatePlayer);
     REGISTER_SHARD_PACKET(P_CL2FE_GM_REQ_KICK_PLAYER, kickPlayer);

src/Combat.cpp

@@ -300,7 +300,7 @@ EntityRef CombatNPC::getRef() {
 }
 
 void CombatNPC::step(time_t currTime) {
-    
+
     if(stateHandlers.find(state) != stateHandlers.end())
         stateHandlers[state](this, currTime);
     else {
@@ -441,11 +441,7 @@ static void pcAttackNpcs(CNSocket *sock, CNPacketData *data) {
         damage = getDamage(damage.first, (int)mob->data["m_iProtection"], true, (plr->batteryW > 6 + difficulty),
             Nanos::nanoStyle(plr->activeNano), (int)mob->data["m_iNpcStyle"], difficulty);
 
-        if (plr->batteryW >= 6 + difficulty)
-            plr->batteryW -= 6 + difficulty;
-        else
-            plr->batteryW = 0;
-
+        plr->subtractCapped(CappedValueType::BATTERY_W, 6 + difficulty);
         damage.first = mob->takeDamage(sock, damage.first);
 
         respdata[i].iID = mob->id;
@@ -690,10 +686,7 @@ static void pcAttackChars(CNSocket *sock, CNPacketData *data) {
                 Nanos::nanoStyle(plr->activeNano), (int)mob->data["m_iNpcStyle"], difficulty);
         }
 
-        if (plr->batteryW >= 6 + plr->level)
-            plr->batteryW -= 6 + plr->level;
-        else
-            plr->batteryW = 0;
+        plr->subtractCapped(CappedValueType::BATTERY_W, 6 + plr->level);
 
         damage.first = target->takeDamage(sock, damage.first);
 
@@ -742,7 +735,7 @@ static int8_t addBullet(Player* plr, bool isGrenade) {
     toAdd.weaponBoost = plr->batteryW > 0;
     if (toAdd.weaponBoost) {
         int boostCost = Rand::rand(11) + 20;
-        plr->batteryW = boostCost > plr->batteryW ? 0 : plr->batteryW - boostCost;
+        plr->subtractCapped(CappedValueType::BATTERY_W, boostCost);
     }
 
     Bullets[plr->iID][findId] = toAdd;

src/Email.cpp

@@ -75,7 +75,7 @@ static void emailReceiveTaros(CNSocket* sock, CNPacketData* data) {
 
     Database::EmailData email = Database::getEmail(plr->iID, pkt->iEmailIndex);
     // money transfer
-    plr->money += email.Taros;
+    plr->addCapped(CappedValueType::TAROS, email.Taros);
     email.Taros = 0;
     // update Taros in email
     Database::updateEmailContent(&email);
@@ -274,7 +274,7 @@ static void emailSend(CNSocket* sock, CNPacketData* data) {
     }
 
     int cost = pkt->iCash + 50 + 20 * attachments.size(); // attached taros + postage
-    plr->money -= cost;
+    plr->subtractCapped(CappedValueType::TAROS, cost);
     Database::EmailData email = {
         (int)pkt->iTo_PCUID, // PlayerId
         Database::getNextEmailIndex(pkt->iTo_PCUID), // MsgIndex
@@ -291,7 +291,7 @@ static void emailSend(CNSocket* sock, CNPacketData* data) {
     };
 
     if (!Database::sendEmail(&email, attachments, plr)) {
-        plr->money += cost; // give money back
+        plr->addCapped(CappedValueType::TAROS, cost); // give money back
         // give items back
         while (!attachments.empty()) {
             sItemBase attachment = attachments.back();

src/Entities.cpp

@@ -117,6 +117,121 @@ sPCAppearanceData Player::getAppearanceData() {
     return data;
 }
 
+bool Player::hasQuestBoost() const {
+    if (AEQUIP_COUNT < AEQUIP_COUNT_WITH_BOOSTERS)
+        return false;
+
+    const sItemBase& booster = Equip[10];
+    return booster.iID == 153 && booster.iOpt > 0;
+}
+
+bool Player::hasHunterBoost() const {
+    if (AEQUIP_COUNT < AEQUIP_COUNT_WITH_BOOSTERS)
+        return false;
+
+    const sItemBase& booster = Equip[11];
+    return booster.iID == 154 && booster.iOpt > 0;
+}
+
+bool Player::hasRacerBoost() const {
+    if (AEQUIP_COUNT < AEQUIP_COUNT_WITH_BOOSTERS)
+        return false;
+
+    const sItemBase& booster = Equip[9];
+    return booster.iID == 155 && booster.iOpt > 0;
+}
+
+bool Player::hasSuperBoost() const {
+    return Player::hasQuestBoost() && Player::hasHunterBoost() && Player::hasRacerBoost();
+}
+
+static int32_t getCap(CappedValueType type) {
+    switch (type) {
+    case CappedValueType::TAROS:
+        return PC_CANDY_MAX;
+    case CappedValueType::FUSIONMATTER:
+        return PC_FUSIONMATTER_MAX;
+    case CappedValueType::BATTERY_W:
+        return PC_BATTERY_MAX;
+    case CappedValueType::BATTERY_N:
+        return PC_BATTERY_MAX;
+    case CappedValueType::TAROS_IN_TRADE:
+        return PC_CANDY_MAX;
+    default:
+        return INT32_MAX;
+    }
+}
+
+static int32_t *getCappedValue(Player *player, CappedValueType type) {
+    switch (type) {
+    case CappedValueType::TAROS:
+        return &player->money;
+    case CappedValueType::FUSIONMATTER:
+        return &player->fusionmatter;
+    case CappedValueType::BATTERY_W:
+        return &player->batteryW;
+    case CappedValueType::BATTERY_N:
+        return &player->batteryN;
+    case CappedValueType::TAROS_IN_TRADE:
+        return &player->moneyInTrade;
+    default:
+        return nullptr;
+    }
+}
+
+void Player::addCapped(CappedValueType type, int32_t diff) {
+    if (diff <= 0)
+        return;
+
+    int32_t max = getCap(type);
+    int32_t *value = getCappedValue(this, type);
+
+    if (value == nullptr)
+        return;
+
+    if (diff > max)
+        diff = max;
+
+    if (*value + diff > max)
+        *value = max;
+    else
+        *value += diff;
+}
+
+void Player::subtractCapped(CappedValueType type, int32_t diff) {
+    if (diff <= 0)
+        return;
+
+    int32_t max = getCap(type);
+    int32_t *value = getCappedValue(this, type);
+
+    if (value == nullptr)
+        return;
+
+    if (diff > max)
+        diff = max;
+
+    if (*value - diff < 0)
+        *value = 0;
+    else
+        *value -= diff;
+}
+
+void Player::setCapped(CappedValueType type, int32_t value) {
+    int32_t max = getCap(type);
+    int32_t *valToSet = getCappedValue(this, type);
+
+    if (valToSet == nullptr)
+        return;
+
+    if (value < 0)
+        value = 0;
+    else if (value > max)
+        value = max;
+
+    *valToSet = value;
+}
+
 // TODO: this is less effiecient than it was, because of memset()
 void Player::enterIntoViewOf(CNSocket *sock) {
     INITSTRUCT(sP_FE2CL_PC_NEW, pkt);