pirate-corsaire-server/Callbacks/reward.js

const RewardPacket                  = require("../Packets/Reward");
const DesignChangedPacket           = require("../Packets/DesignChanged");
const LevelUpPacket                 = require("../Packets/LevelUp");
const GuildDataEconomyDonatedPacket = require("../Packets/GuildDataEconomyDonated");

const StatisticsWorker              = global.StatisticsWorker;

const Game                          = require("../Game/Game");
const { players }                   = Game;

const constants                     = require("../Data/constants");
const leaderboards 		            = require("../Data/leaderboard");    
const eliteRewards 		            = require("../Data/eliteRewards");

const [playerEconomy, guildEconomy] = require("../Data/batchSave");

const { CATEGORIES } = constants;
const { CATEGORY_ECONOMY, CATEGORY_DESIGN, CATEGORY_STATUS, CATEGORY_RANKING_POINTS } = CATEGORIES;

const statusMappedToLeaderboard = {
	1: 1,
	2: 2,
	3: 3
};

const EXP_GUILD_ALLOWED_SOURCES = {
    2: true,
    3: true
};

async function rewardCallback(reward) {
    if (!reward) return;

    const player = players[reward.authorID];
    if (!player) return;
        
    const initializedPacket = RewardPacket.init(reward.isRegular, reward.rewards.length);
    const initializedGuildPacket = RewardPacket.init(true, 1);
    let designRewardID = 0;
    
    reward.rewards.forEach(r => {
        if (r.categoryID === CATEGORY_STATUS) {
            if (player.guild.id && r.id === 1 && EXP_GUILD_ALLOWED_SOURCES[reward.source.typeID]) {
                const newLevel = player.guild.levelUpdate(r.amount);
                
                guildEconomy.accumulateItem(`${player.guild.id}-${r.categoryID}-${r.id}`, r.amount);

                const guildExperienceReward = {
                    categoryID: 9,
                    id: r.id,
                    amount: r.amount
                };

                initializedGuildPacket.update(guildExperienceReward);
                const guildRewardPacket = initializedGuildPacket.get();

                const topic = Game.getTopic(player.guild.topic);
                topic.push(guildRewardPacket);

                if (newLevel !== -1) {
                    const levelUp = {
                        level: newLevel,
                        statusLevelID: 4,
                        id: player.id
                    };

                    const levelUpPacket = LevelUpPacket(levelUp);
                    topic.push(levelUpPacket);

                    /*player.emit("levelUp", {
                        level: newLevel, 
                        statusLevelID: 4, 
                        id: player.id
                    });*/
                };
            };

            const leaderboardID = statusMappedToLeaderboard[r.id];
            const leaderboard = leaderboards[leaderboardID];
            if (leaderboard) leaderboard.updatePosition(player.id, r.amount);

            player.updateLevels(r.id, r.amount);
        }// else if (r.categoryID === CATEGORY_RANKING_POINTS) player.updateRankingPoints(r.id, r.amount);
        else player.inventory.refreshSingle(r);
         
        if (r.categoryID === CATEGORY_ECONOMY) {
            if (player.guild.id) {
                let guildTax = 0;
              
                switch (r.id) {
                    case 1:
                        guildTax = player.guild.taxRates[0];
                    break;

                    case 2:
                        guildTax = player.guild.taxRates[1];
                    break;
                };

                const guildTaxAmount = Math.floor(r.amount * guildTax);
                const playerRewardAmount = r.amount - guildTaxAmount;
                console.info("guild tax reward", guildTaxAmount, r.categoryID, r.id);
                player.guild.bank.depositTax({
                    categoryID: r.categoryID,
                    id: r.id,
                    amount: guildTaxAmount
                });

                const guildEconomyDonated = {
                    id: r.id,
                    amount: guildTaxAmount
                };

                const guildEconomyDonatedPacket = GuildDataEconomyDonatedPacket(guildEconomyDonated);

                const topic = Game.getTopic(player.guild.topic);
                topic.push(guildEconomyDonatedPacket);
                
                if (guildTax) guildEconomy.accumulateItem(`${player.guild.id}-${r.categoryID}-${r.id}`, guildTaxAmount);
            
                r.amount -= guildTaxAmount;
            };
        };

        if (r.categoryID === CATEGORY_DESIGN && !designRewardID) designRewardID = r.id;
        console.info("reward amount", r.amount)
        playerEconomy.accumulateItem(`${player.id}-${r.categoryID}-${r.id}`, r.amount);
        initializedPacket.update(r);
        
        const now = new Date();

        StatisticsWorker.postMessage({
            id: 1,
            data: {
                timestamp: now,
                playerID: player.id,
                categoryID: r.categoryID,
                id: r.id,
                amount: r.amount,
                source: {
                    typeID: reward.source.typeID,
                    entityTypeID: reward.source.entityTypeID,
                }
            }
        });
    });

    const packet = initializedPacket.get();
    player.map.registerIndividualNetworkPacket(player.id, packet);
    
    if (designRewardID) {
        player.textureID = designRewardID;

        const designReward = { 
            typeID: player.typeID,
            id: player.id, 
            designID: designRewardID
        };
        
        const packet = DesignChangedPacket(designReward);
        player.map.registerNetworkPacket(player.id, packet);

        if (designRewardID === 5) {
            for (let i = 1, length = player.eliteLevel; i < length; i++) {
                const currentEliteLevelRewards = eliteRewards[i];
                if (currentEliteLevelRewards) {
                    currentEliteLevelRewards.single(0, player.inventory.getPosessions(), rewards => player.rewardCallback({ isRegular: true, authorID: player.id, source: {}, rewards }));					
                    
                    player.inventory.resourceSharedLimiter.cannon.quantity.maximum += 2;
                };
            };

            const ePropertyChanged = {
                typeID: 5, 
                value: player.inventory.resourceSharedLimiter.cannon.quantity.maximum
            };
    
            player.emit("propertyChanged", ePropertyChanged, player.id);
        };
    };
};

module.exports = rewardCallback;