caliverse_server/GameServer/Contents/SeasonPass/Action/SeasonPassAction.cs

using GameServer.PacketHandler;
using MetaAssets;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCommon.BusinessLogDomain;

using META_ID = System.UInt32;

namespace GameServer
{
    public class SeasonPassAction : EntityActionBase
    {
        public SeasonPassAction(EntityBase owner) : base(owner)
        {
        }

        public override Task<Result> onInit()
        {
            var result = new Result();

            return Task.FromResult(result);
        }

        public async Task<Result> tryUpdateSeasonPass(string transId = "")
        {
            var result = new Result();

            var player = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

            var server_logic = GameServerApp.getServerLogic();
            var seasonPassManager = server_logic.getSeasonPassManager();

            var season_pass_attribute = player.getOriginEntityAttribute<SeasonPassAttribute>();
            NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");

            if (seasonPassManager.currentSeasonPass != 0 &&
                season_pass_attribute.SeasonPassMetaId != seasonPassManager.currentSeasonPass)
            {
                await StartNewSeasonPass(seasonPassManager.currentSeasonPass, transId);
            }

            return result;
        }

        public override void onClear()
        {
            return;
        }

        public bool isChargedSeasonPass()
        {
            var player = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

            var season_pass_attribute = player.getOriginEntityAttribute<SeasonPassAttribute>();
            NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");

            return season_pass_attribute.IsChargedPass;
        }

        public async Task<Result> tryBuyChargedPass()
        {
            var result = new Result();
            var err_msg = string.Empty;

            var player = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

            var server_logic = GameServerApp.getServerLogic();

            if (isActivatedSeasonPass() == false)
            {
                result.setFail(ServerErrorCode.SeasonPassNotAblePeriod, err_msg);
                BuyChargedSeasonPassPacketHandler.send_S2C_ACK_BUY_CHARGED_SEASON_PASS(player, result);
                return result;
            }

            var fn_buy_charged_season_pass = async delegate ()
            {
                var result = new Result();
                var invokers = new List<ILogInvoker>();

                var season_pass_attribute = player.getEntityAttribute<SeasonPassAttribute>();
                NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");

                if (season_pass_attribute.IsChargedPass == true)
                {
                    result.setFail(ServerErrorCode.SeasonPassAlreadyBuyCharged, err_msg);
                    BuyChargedSeasonPassPacketHandler.send_S2C_ACK_BUY_CHARGED_SEASON_PASS(player, result);
                    return result;
                }

                if(MetaData.Instance.SeasonPassMetaData.TryGetValue((int)season_pass_attribute.SeasonPassMetaId, out var season_pass_meta_data) == false)
                {
                    err_msg = $"Failed to get SeasonPassMetaData. meta_id : {season_pass_attribute.SeasonPassMetaId}";
                    result.setFail(ServerErrorCode.SeasonPassMetaDataNotFound, err_msg);
                    Log.getLogger().error(err_msg);
                    BuyChargedSeasonPassPacketHandler.send_S2C_ACK_BUY_CHARGED_SEASON_PASS(player, result);
                    return result;
                }

                var money_action = player.getEntityAction<MoneyAction>();

                if (EnumHelper.isDefined<CurrencyType>(season_pass_meta_data.SeasonPass_Currency) == false)
                {
                    err_msg = $"is Not Defined CurrencyType !!! CurrencyType : {season_pass_meta_data.SeasonPass_Currency} - {player.toBasicString()}";
                    result.setFail(ServerErrorCode.ServerTypeInvalid, err_msg);
                    Log.getLogger().error(err_msg);
                    BuyChargedSeasonPassPacketHandler.send_S2C_ACK_BUY_CHARGED_SEASON_PASS(player, result);
                    return result;
                }
                result = await money_action.changeMoney((CurrencyType)season_pass_meta_data.SeasonPass_Currency, -1 * season_pass_meta_data.SeasonPass_Cost);

                season_pass_attribute.IsChargedPass = true;
                season_pass_attribute.modifiedEntityAttribute();

                var task_log_data = SeasonPassBusinessLogHelper.toLogInfo(season_pass_attribute, 0, 0, 0);
                invokers.Add(new SeasonPassBusinessLog(task_log_data));

                var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.SeasonPassBuyCharged
                                                               , server_logic.getDynamoDbClient());
                {
                    batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
                }

                batch.appendBusinessLogs(invokers);

                result = await QueryHelper.sendQueryAndBusinessLog(batch);
                if (result.isFail())
                {
                    BuyChargedSeasonPassPacketHandler.send_S2C_ACK_BUY_CHARGED_SEASON_PASS(player, result);
                    return result;
                }

                var found_transaction_runner = player.findTransactionRunner(TransactionIdType.PrivateContents);
                if (null == found_transaction_runner)
                {
                    var err_msg = $"Not found TransactionRunner !!! : {toBasicString()} - {player.toBasicString()}";
                    Log.getLogger().warn(err_msg);
                    BuyChargedSeasonPassPacketHandler.send_S2C_ACK_BUY_CHARGED_SEASON_PASS(player, result);
                    return result;
                }

                BuyChargedSeasonPassPacketHandler.send_S2C_ACK_BUY_CHARGED_SEASON_PASS(player, result, found_transaction_runner.getCommonResult());

                return result;
            };

            result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "BuyChargedPass", fn_buy_charged_season_pass);
            if (result.isFail())
            {
                err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {player.toBasicString()}";
                Log.getLogger().error(err_msg);
            }
            return result;
        }

        public async Task<Result> tryTakeSeasonPassReward(int grade_reward)
        {
            var result = new Result();
            var err_msg = string.Empty;

            var player = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

            var season_pass_attribute = player.getEntityAttribute<SeasonPassAttribute>();
            NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");

            var server_logic = GameServerApp.getServerLogic();

            if (isActivatedSeasonPass() == false)
            {
                result.setFail(ServerErrorCode.SeasonPassNotAblePeriod, err_msg);
                TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                return result;
            }

            foreach (var taken_grade_reward in season_pass_attribute.takenRewards)
            {
                if(taken_grade_reward == grade_reward)
                {
                    result.setFail(ServerErrorCode.SeasonPassAlreadyTakenReward, err_msg);
                    TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                    return result;
                }
            }

            if(season_pass_attribute.Grade < grade_reward)
            {
                result.setFail(ServerErrorCode.SeasonPassNotEnoughGrade, err_msg);
                TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                return result;
            }

            if(MetaData.Instance.SeasonPassRewardTablebySeasonPassId.TryGetValue((int)season_pass_attribute.SeasonPassMetaId, out var season_pass_meat_data) == false)
            {
                result.setFail(ServerErrorCode.SeasonPassRewardMetaDataNotFound, err_msg);
                TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                return result;
            }

            if(season_pass_meat_data.TryGetValue(grade_reward, out var meta_data) == false)
            {
                result.setFail(ServerErrorCode.SeasonPassRewardMetaDataNotFound, err_msg);
                TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                return result;
            }

            if(meta_data.SeasonPassType == ESeasonPassType.Charged &&
                season_pass_attribute.IsChargedPass == false)
            {
                result.setFail(ServerErrorCode.SeasonPassNeedChargedPass, err_msg);
                TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                return result;
            }

            if(MetaData.Instance._RewardMetaTable.TryGetValue(meta_data.RewardGroupID, out var reward_meta_data_list) == false)
            {
                result.setFail(ServerErrorCode.RewardInfoNotExist, err_msg);
                TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                return result;
            }

            var fn_take_season_pass_reward = async delegate ()
            {
                var result = new Result();
                var invokers = new List<ILogInvoker>();

                var season_pass_attribute = player.getEntityAttribute<SeasonPassAttribute>();
                NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");

                season_pass_attribute.takenRewards.Add(grade_reward);
                season_pass_attribute.modifiedEntityAttribute();

                var task_log_data = SeasonPassBusinessLogHelper.toLogInfo(season_pass_attribute, 0, 0, grade_reward);
                invokers.Add(new SeasonPassBusinessLog(task_log_data));

                var rewards = new List<MetaAssets.Reward>();
                foreach (var reward in reward_meta_data_list)
                {
                    rewards.Add(reward.Reward);
                }
                IReward season_pass_reward = new RewardSeasonPass(player, player.getUserGuid(), rewards);
                result = await RewardManager.It.proceedRewardProcess(season_pass_reward);
                if (result.isFail())
                {
                    TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                    return result;
                }

                RewardManager.It.postRewardProcess(season_pass_reward);

                var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.SeasonPassTakeReward
                                                               , server_logic.getDynamoDbClient());
                {
                    batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
                }

                batch.appendBusinessLogs(invokers);

                result = await QueryHelper.sendQueryAndBusinessLog(batch);
                if (result.isFail())
                {
                    TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                    return result;
                }

                var found_transaction_runner = player.findTransactionRunner(TransactionIdType.PrivateContents);
                if (null == found_transaction_runner)
                {
                    var err_msg = $"Not found TransactionRunner !!! : {toBasicString()} - {player.toBasicString()}";
                    Log.getLogger().warn(err_msg);
                    TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result);
                    return result;
                }

                TakeSeasonPassRewardPacketHandler.send_S2C_ACK_TAKE_SEASON_PASS_REWARD(player, result, grade_reward, found_transaction_runner.getCommonResult());
                return result;
            };

            result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "TakeSeasonPassReward", fn_take_season_pass_reward);
            if (result.isFail())
            {
                err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {player.toBasicString()}";
                Log.getLogger().error(err_msg);
            }
            return result;
        }

        private Result AbleToGetExp(UInt32 increase_exp, out Dictionary<int,SeasonPassRewardMetaData>? season_pass_reward_meta_data)
        {
            var result = new Result();
            var err_msg = string.Empty;
            season_pass_reward_meta_data = null;

            var player = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

            var season_pass_attribute = player.getOriginEntityAttribute<SeasonPassAttribute>();
            NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");

            if (isActivatedSeasonPass() == false)
            {
                return result;
            }

            if (increase_exp < 0)
            {
                result.setFail(ServerErrorCode.SeasonPassInvalidExp, err_msg);
                return result;
            }

            if (MetaData.Instance.SeasonPassRewardTablebySeasonPassId.TryGetValue((int)season_pass_attribute.SeasonPassMetaId, out season_pass_reward_meta_data) == false)
            {
                err_msg = $"Failed to get SeasonPassMetaData. meta_id : {season_pass_attribute.SeasonPassMetaId}";
                result.setFail(ServerErrorCode.SeasonPassMetaDataNotFound, err_msg);
                Log.getLogger().error(err_msg);
                return result;
            }

            if (season_pass_reward_meta_data.TryGetValue((int)season_pass_attribute.Grade + 1, out var next_grade_meta_data) == false)
            {
                season_pass_reward_meta_data = null;
                return result;
            }

            return result;
        }

        public Result IncreaseExp(UInt32 increase_exp)
        {
            var result = new Result();
            var err_msg = string.Empty;

            var player = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

            result = AbleToGetExp(increase_exp, out var season_pass_reward_meta_data);
            if (result.isFail() || season_pass_reward_meta_data == null)
            {
                return result;
            }

            var season_pass_attribute = player.getEntityAttribute<SeasonPassAttribute>();
            NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");

            UInt32 calculated_exp = season_pass_attribute.Exp + increase_exp;
            int calculated_grade = 1;
            UInt32 max_exp = 0;

            foreach (var season_pass_meta_data in season_pass_reward_meta_data)
            {
                if(calculated_grade < season_pass_meta_data.Value.Grade && season_pass_meta_data.Value.MaxSeasonPassExp <= calculated_exp)
                {
                    max_exp = (UInt32)season_pass_meta_data.Value.MaxSeasonPassExp;
                    calculated_grade = season_pass_meta_data.Value.Grade;
                }
            }

            if (season_pass_reward_meta_data.TryGetValue((int)calculated_grade + 1, out var next_grade_meta_data) == false)
            {
                calculated_exp = max_exp;
            }

            season_pass_attribute.Exp = calculated_exp;
            season_pass_attribute.Grade = calculated_grade;
            season_pass_attribute.modifiedEntityAttribute();

            return result;
        }

        public async Task<Result> StartNewSeasonPass(META_ID new_season_pass_metaid, string transId = "")
        {
            var result = new Result();
            var err_msg = string.Empty;

            var player = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

            var server_logic = GameServerApp.getServerLogic();
            var season_pass_attribute = player.getOriginEntityAttribute<SeasonPassAttribute>();
            NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");

            if (season_pass_attribute.SeasonPassMetaId == new_season_pass_metaid)
            {
                return result;
            }

            var fn_start_new_season_pass = async delegate ()
            {
                var result = new Result();
                var err_msg = string.Empty;

                var invokers = new List<ILogInvoker>();

                var season_pass_attribute = player.getEntityAttribute<SeasonPassAttribute>();
                NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");

                season_pass_attribute.SeasonPassMetaId = new_season_pass_metaid;
                season_pass_attribute.IsChargedPass = false;
                season_pass_attribute.Exp = 0;
                season_pass_attribute.Grade = 1;
                season_pass_attribute.takenRewards.Clear();

                season_pass_attribute.modifiedEntityAttribute();

                var task_log_data = SeasonPassBusinessLogHelper.toLogInfo(season_pass_attribute, 0, 0, 0);
                invokers.Add(new SeasonPassBusinessLog(task_log_data));

                var batch = new QueryBatchEx<QueryRunnerWithDocument>( player, LogActionType.SeasonPassStartNew
                                                                   , server_logic.getDynamoDbClient() , true, transId);
                {
                    batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
                }

                batch.appendBusinessLogs(invokers);

                result = await QueryHelper.sendQueryAndBusinessLog(batch);
                if (result.isFail())
                {
                    return result;
                }

                SeasonPassNotifyHelper.send_S2C_NTF_SEASON_PASS_INFOS(player);
                return result;
            };

            var transaction_name = "StartNewSeasonPass";
            result = await player.runTransactionRunnerSafelyWithTransGuid( player.getUserGuid()
                                                                         , TransactionIdType.PrivateContents, transaction_name
                                                                         , fn_start_new_season_pass );
            if (result.isFail())
            {
                err_msg = $"Failed to runTransactionRunnerSafelyWithTransGuid() !!! : {result.toBasicString()} - transactionName:{transaction_name}, {player.toBasicString()}";
                Log.getLogger().error(err_msg);
            }

            return result;
        }

        public bool isActivatedSeasonPass()
        {
            var player = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

            var season_pass_attribute = player.getEntityAttribute<SeasonPassAttribute>();
            NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");
            if (MetaData.Instance.SeasonPassMetaData.TryGetValue((int)season_pass_attribute.SeasonPassMetaId, out var season_pass_meta_data) == false)
            {
                return false;
            }

            var current_time = DateTimeHelper.Current;

            if(season_pass_meta_data.StartTime > current_time ||
                season_pass_meta_data.EndTime < current_time)
            {
                return false;
            }

            return true;
        }

        public async Task CheatSeasonDataInit()
        {
            var result = new Result();
            var err_msg = string.Empty;

            var player = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

            var server_logic = GameServerApp.getServerLogic();

            var fn_cheat_season_pass_init = async delegate ()
            {
                var result = new Result();
                var invokers = new List<ILogInvoker>();

                var season_pass_attribute = player.getEntityAttribute<SeasonPassAttribute>();
                NullReferenceCheckHelper.throwIfNull(season_pass_attribute, () => $"season_pass_attribute is null !!!");
                season_pass_attribute.Exp = 0;
                season_pass_attribute.Grade = 1;
                season_pass_attribute.takenRewards.Clear();
                season_pass_attribute.IsChargedPass = false;
                season_pass_attribute.modifiedEntityAttribute();

                var task_log_data = SeasonPassBusinessLogHelper.toLogInfo(season_pass_attribute, 0, 0, 0);
                invokers.Add(new SeasonPassBusinessLog(task_log_data));

                var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandSeasonPassInit
                                                           , server_logic.getDynamoDbClient());
                {
                    batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
                }

                batch.appendBusinessLogs(invokers);

                result = await QueryHelper.sendQueryAndBusinessLog(batch);
                if (result.isFail())
                {
                    return result;
                }

                SeasonPassNotifyHelper.send_S2C_NTF_SEASON_PASS_INFOS(player);
                return result;
            };

            var transaction_name = "Cheat.SeasonPassInit";
            result = await player.runTransactionRunnerSafelyWithTransGuid(player.getUserGuid()
                                                                         , TransactionIdType.PrivateContents, transaction_name
                                                                         , fn_cheat_season_pass_init);
            if (result.isFail())
            {
                err_msg = $"Failed to runTransactionRunnerSafelyWithTransGuid() !!! : {result.toBasicString()} - transactionName:{transaction_name}, {player.toBasicString()}";
                Log.getLogger().error(err_msg);
            }
        }
    }
}