bcjang/caliverse_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

초기커밋

Browse Source
This commit is contained in:
bcjang
2025-05-01 07:20:41 +09:00
commit 98bb2e3c5c
2747 changed files with 646947 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

592
GameServer/Contents/Claim/Action/ClaimAction.cs Normal file
View File

@@ -0,0 +1,592 @@
using Amazon.S3.Model;
using Google.Protobuf.WellKnownTypes;
using RabbitMQ.Client;
using ServerCommon;
using ServerCore; using ServerBase;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;
namespace GameServer
{
public class ClaimAction : EntityActionBase
{
private ConcurrentDictionary<Int32, ServerCommon.Claim> m_normal_claim { get; set; } = new();
private ConcurrentDictionary<Int32, ServerCommon.Claim> m_membership_claim { get; set; } = new();
private bool m_data_load = false;
public ClaimAction(EntityBase owner) : base(owner)
{
}
public override Task<Result> onInit()
{
var result = new Result();
return Task.FromResult(result);
}
public void setDataLoad(bool isLoad)
{
m_data_load = isLoad;
}
public bool getDataLoad()
{
return m_data_load;
}
public Result setClaimFromDoc(ClaimDoc doc)
{
var result = new Result();
var owner = getOwner();
NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
EntityBase claim;
var claim_attrib = doc.getAttrib<ClaimAttrib>();
NullReferenceCheckHelper.throwIfNull(claim_attrib, () => $"claim_attrib is null !!!");
claim = new ServerCommon.Claim(owner, claim_attrib.ClaimType);
var claim_attribute = claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
if (false == doc.getAttribWrappers().TryGetValue(typeof(ClaimAttrib), out var to_copy_doc_attrib))
{
var err_msg = $"Fail to get ClaimAttrib";
result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
return result;
}
var attrib_base = to_copy_doc_attrib.getAttribBase();
var doc_attrib = attrib_base as ClaimAttrib;
if (doc_attrib is null)
{
var err_msg = $"Fail to get ClaimAttrib";
result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
return result;
}
claim_attribute.ClaimType = doc_attrib.ClaimType;
claim_attribute.ActiveRewardIdx = doc_attrib.ActiveRewardIdx;
claim_attribute.ActiveTime = doc_attrib.ActiveTime;
claim_attribute.CreateTime = doc_attrib.CreateTime;
claim_attribute.CompleteTime = doc_attrib.CompleteTime;
claim_attribute.IsComplete = doc_attrib.IsComplete;
claim_attribute.syncOriginDocBaseWithNewDoc<ClaimAttribute>(doc);
Int32 claim_id = claim_attribute.ClaimId = doc_attrib.ClaimId;
var casted_claim = claim as ServerCommon.Claim;
NullReferenceCheckHelper.throwIfNull(casted_claim, () => $"casted_claim is null !!!");
if (claim_attrib.ClaimType == MetaAssets.ClaimType.Normal)
{
m_normal_claim.TryAdd(claim_id, casted_claim);
}
else
{
m_membership_claim.TryAdd(claim_id, casted_claim);
}
return result;
}
public async Task<(Result, List<ClaimMetaData>, List<Int32>)> update()
{
var result = new Result();
var owner = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
(var acceptable_claims, var old_claims) = getUpdatableClaims();
if (acceptable_claims.Count == 0 && old_claims.Count == 0) return (result, new(), new());
result = await owner.runTransactionRunnerSafelyWithTransGuid( owner.getUserGuid()
, TransactionIdType.PrivateContents, "ClaimUpdate", delegateUpdateClaim);
if (result.isFail())
{
string err_msg = $"Failed to runTransactionRunnerSafelyWithTransGuid() !!! : {result.toBasicString()} - {owner.toBasicString()}";
Log.getLogger().error(err_msg);
return (result, new(), new());
}
return (result, acceptable_claims, old_claims);
async Task<Result> delegateUpdateClaim() => await updateClaim(owner, acceptable_claims, old_claims);
}
public (List<ClaimMetaData>, List<Int32>) getUpdatableClaims()
{
var acceptable_claims = getAcceptableClaims();
var old_claims = getOldClaim();
return (acceptable_claims, old_claims);
}
public static List<ClaimMetaData> getOldClaims()
{
List<ClaimMetaData> rets = new();
DateTime nowDt = DateTimeHelper.Current;
foreach (ClaimMetaData metaData in MetaData.Instance._ClaimMetaTable.Values)
{
if (metaData.EndTime < nowDt)
{
rets.Add(metaData);
}
}
return rets;
}
private async Task<Result> updateClaim(Player owner, List<ClaimMetaData> acceptableClaim, List<Int32> oldClaim)
{
(var result, var new_claims) = updateClaims(acceptableClaim, oldClaim);
if (result.isFail()) return result;
var server_logic = GameServerApp.getServerLogic();
var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None, server_logic.getDynamoDbClient());
{
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
}
result = await QueryHelper.sendQueryAndBusinessLog(batch);
if (result.isFail())
{
return result;
}
foreach (var new_claim in new_claims)
{
var claim_attribute = new_claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
if (claim_attribute.ClaimType == MetaAssets.ClaimType.Normal)
{
m_normal_claim.TryAdd(claim_attribute.ClaimId, new_claim as ServerCommon.Claim);
}
else
{
m_membership_claim.TryAdd(claim_attribute.ClaimId, new_claim as ServerCommon.Claim);
}
}
foreach (var old_claim in oldClaim)
{
m_normal_claim.TryRemove(old_claim, out _);
m_membership_claim.TryRemove(old_claim, out _);
}
return result;
}
private (Result, List<ServerCommon.Claim>) updateClaims(List<ClaimMetaData> acceptable_claims, List<Int32> oldClaims)
{
var result = new Result();
DateTime now = DateTimeHelper.Current;
List<ServerCommon.Claim> claims = new();
foreach (var meta in acceptable_claims)
{
var claim_id = meta.ClaimId;
var claim_type = meta.ClaimType;
if (claim_type == MetaAssets.ClaimType.Normal)
{
if (m_normal_claim.ContainsKey(claim_id)) continue;
}
else
{
if (m_membership_claim.ContainsKey(claim_id)) continue;
}
var new_claim = makeNewClaim(now, meta);
claims.Add(new_claim);
//m_normal_claim.TryAdd(claim_id, normal_claim);
}
foreach (var old_claim in oldClaims)
{
if (false == m_normal_claim.TryGetValue(old_claim, out var normal_claim)) continue;
NullReferenceCheckHelper.throwIfNull(normal_claim, () => $"normal_claim is null !!!");
var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(normal_claim_attribute, () => $"normal_claim_attribute is null !!!");
normal_claim_attribute.deleteEntityAttribute();
}
foreach (var old_claim in oldClaims)
{
if (false == m_membership_claim.TryGetValue(old_claim, out var membership_claim)) continue;
NullReferenceCheckHelper.throwIfNull(membership_claim, () => $"membership_claim is null !!!");
var membership_claim_attribute = membership_claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(membership_claim_attribute, () => $"membership_claim_attribute is null !!!");
membership_claim_attribute.deleteEntityAttribute();
}
return (result, claims);
}
private ServerCommon.Claim resetClaim(ServerCommon.Claim claim, ClaimMetaData metaData)
{
var owner = getOwner() as Player;
DateTime now = DateTimeHelper.Current;
var claim_attribute = claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
claim_attribute.ActiveRewardIdx = metaData.DetailInfo.First().Value.Idx;
claim_attribute.ActiveTime = now;
claim_attribute.CreateTime = now;
claim_attribute.CompleteTime = now;
claim_attribute.IsComplete = 0;
claim_attribute.modifiedEntityAttribute();
return claim;
}
private ServerCommon.Claim updateClaimRewardable(ServerCommon.Claim claim, ClaimMetaData metaData)
{
var owner = getOwner() as Player;
DateTime now = DateTimeHelper.Current;
var claim_attribute = claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
claim_attribute.ActiveTime = now.AddSeconds(-86400);
claim_attribute.modifiedEntityAttribute();
return claim;
}
private ServerCommon.Claim makeNewClaim(DateTime now, ClaimMetaData metaData)
{
var owner = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
var claim = new ServerCommon.Claim(getOwner(), metaData.ClaimType);
var claim_attribute = claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
claim_attribute.ClaimId = metaData.ClaimId;
claim_attribute.ClaimType = metaData.ClaimType;
claim_attribute.ActiveRewardIdx = metaData.DetailInfo.First().Value.Idx;
claim_attribute.ActiveTime = now;
claim_attribute.CreateTime = now;
claim_attribute.CompleteTime = now;
claim_attribute.IsComplete = 0;
var new_claim_doc = new ClaimDoc(owner.getUserGuid(), metaData.ClaimType, metaData.ClaimId);
claim_attribute.syncOriginDocBaseWithNewDoc<ClaimAttribute>(new_claim_doc);
var claim_attrib = new_claim_doc.getAttrib<ClaimAttrib>();
NullReferenceCheckHelper.throwIfNull(claim_attrib, () => $"claim_attrib is null !!!");
claim_attrib.ClaimId = metaData.ClaimId;
claim_attrib.ClaimType = metaData.ClaimType;
claim_attrib.ActiveRewardIdx = metaData.DetailInfo.First().Value.Idx;
claim_attrib.ActiveTime = now;
claim_attrib.CreateTime = now;
claim_attrib.CompleteTime = now;
claim_attrib.IsComplete = 0;
claim_attribute.newEntityAttribute();
return claim;
}
private List<ClaimMetaData> getAcceptableClaims()
{
var owner = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
List<ClaimMetaData> rets = new();
var current_metas = ClaimRewardHelper.getCurrentClaims();
foreach (var metaData in current_metas)
{
var claim_id = metaData.GetMetaId();
if (m_normal_claim.ContainsKey(claim_id)) continue;
rets.Add(metaData);
}
return rets;
}
public List<Int32> getOldClaim()
{
List<ClaimMetaData> old_metas = getOldClaims();
List<Int32> old_claims = new();
foreach (var meta in old_metas)
{
var claim_id = meta.ClaimId;
if (m_normal_claim.ContainsKey(claim_id))
{
old_claims.Add(claim_id);
}
}
return old_claims;
}
public async Task cheatClaimReset()
{
var player = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
var server_logic = GameServerApp.getServerLogic();
var result = new Result();
var fn_reset_claim = async delegate ()
{
var result = new Result();
var err_msg = string.Empty;
List<ILogInvoker> log_invokers = new();
foreach (var normal_claim in m_normal_claim.Values)
{
var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(normal_claim_attribute, () => $"normal_claim_attribute is null !!!");
var claim_id = normal_claim_attribute.ClaimId;
(result, var claim_meta) = ClaimRewardHelper.getClaimMeta(claim_id, MetaAssets.ClaimType.Normal);
if (result.isFail())continue;
NullReferenceCheckHelper.throwIfNull(claim_meta, () => $"claim_meta is null !!!");
resetClaim(normal_claim, claim_meta);
var log_invoker = new CheatClaimResetBusinessLog(MetaAssets.ClaimType.Normal, claim_id, normal_claim_attribute.ActiveRewardIdx);
log_invokers.Add(log_invoker);
}
foreach (var membership_claim in m_membership_claim.Values)
{
var membership_claim_attribute = membership_claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(membership_claim_attribute, () => $"normal_claim_attribute is null !!!");
var claim_id = membership_claim_attribute.ClaimId;
(result, var claim_meta) = ClaimRewardHelper.getClaimMeta(claim_id, MetaAssets.ClaimType.Membership);
if (result.isFail()) continue;
NullReferenceCheckHelper.throwIfNull(claim_meta, () => $"claim_meta is null !!!");
resetClaim(membership_claim, claim_meta);
var log_invoker = new CheatClaimResetBusinessLog(MetaAssets.ClaimType.Membership, claim_id, membership_claim_attribute.ActiveRewardIdx);
log_invokers.Add(log_invoker);
}
var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandClaimReset, server_logic.getDynamoDbClient());
{
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
}
result = await QueryHelper.sendQueryAndBusinessLog(batch);
if (result.isFail())
{
return result;
}
foreach (var normal_claim in m_normal_claim.Values)
{
var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
if (normal_claim_attribute is null) continue;
var claim_id = normal_claim_attribute.ClaimId;
}
send_GS2C_NTF_CLAIM_UPDATE();
return result;
};
result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "CheatResetClaim", fn_reset_claim);
if (result.isFail())
{
var err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {player.toBasicString()}";
Log.getLogger().error(err_msg);
return;
}
}
public async Task cheatClaimUpdateRewardable()
{
var player = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(player, () => $"server_logic is null !!!");
var server_logic = GameServerApp.getServerLogic();
var result = new Result();
var fn_claim_update_rewardable = async delegate ()
{
var result = new Result();
var err_msg = string.Empty;
List<ILogInvoker> log_invokers = new();
foreach (var normal_claim in m_normal_claim.Values)
{
var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
if (normal_claim_attribute is null) continue;
var claim_id = normal_claim_attribute.ClaimId;
(result, var claim_meta) = ClaimRewardHelper.getClaimMeta(claim_id, MetaAssets.ClaimType.Normal);
if (result.isFail()) continue;
NullReferenceCheckHelper.throwIfNull(claim_meta, () => $"claim_meta is null !!!");
updateClaimRewardable(normal_claim, claim_meta);
var log_invoker = new CheatClaimRewardableBusinessLog(MetaAssets.ClaimType.Normal, claim_id, normal_claim_attribute.ActiveRewardIdx);
log_invokers.Add(log_invoker);
}
foreach (var membership_claim in m_membership_claim.Values)
{
var membership_claim_attribute = membership_claim.getEntityAttribute<ClaimAttribute>();
if (membership_claim_attribute is null) continue;
var claim_id = membership_claim_attribute.ClaimId;
(result, var claim_meta) = ClaimRewardHelper.getClaimMeta(claim_id, MetaAssets.ClaimType.Membership);
if (result.isFail()) continue;
NullReferenceCheckHelper.throwIfNull(claim_meta, () => $"claim_meta is null !!!");
updateClaimRewardable(membership_claim, claim_meta);
var log_invoker = new CheatClaimRewardableBusinessLog(MetaAssets.ClaimType.Membership, claim_id, membership_claim_attribute.ActiveRewardIdx);
log_invokers.Add(log_invoker);
}
var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandClaimUpdate, server_logic.getDynamoDbClient());
{
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
}
batch.appendBusinessLogs(log_invokers);
result = await QueryHelper.sendQueryAndBusinessLog(batch);
if (result.isFail())
{
return result;
}
foreach (var normal_claim in m_normal_claim.Values)
{
var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
if(normal_claim_attribute is null) continue;
var claim_id = normal_claim_attribute.ClaimId;
}
send_GS2C_NTF_CLAIM_UPDATE();
return result;
};
result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "CheatClaimUpdateRewardable", fn_claim_update_rewardable);
if (result.isFail())
{
var err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {player.toBasicString()}";
Log.getLogger().error(err_msg);
return;
}
}
public ConcurrentDictionary<Int32, ServerCommon.Claim> getClaims(MetaAssets.ClaimType type)
{
if (type == MetaAssets.ClaimType.Normal)
{
return m_normal_claim;
}
else
{
return m_membership_claim;
}
}
public Result getClaim(Int32 claimId, MetaAssets.ClaimType type, [MaybeNullWhen(false)] out ServerCommon.Claim? claim)
{
var result = new Result();
if (type == MetaAssets.ClaimType.Normal)
{
result = getNormalClaim(claimId, out claim);
}
else
{
result = getMembershipClaim(claimId, out claim);
}
return result;
}
public ConcurrentDictionary<Int32, ServerCommon.Claim> getNormalClaims()
{
return m_normal_claim;
}
public Result getNormalClaim(Int32 claimId, [MaybeNullWhen(false)] out ServerCommon.Claim? claim)
{
var result = new Result();
if (false == m_normal_claim.TryGetValue(claimId, out claim))
{
var err_msg = $"m_normal_claim claimId : {claimId} not exist, {getOwner().toBasicString()}";
result.setFail(ServerErrorCode.ClaimInfoNotExist, err_msg);
Log.getLogger().error(result.toBasicString());
return result;
}
NullReferenceCheckHelper.throwIfNull(claim, () => $"claim is null !!!");
return result;
}
public ConcurrentDictionary<Int32, ServerCommon.Claim> getMembershipClaims()
{
return m_membership_claim;
}
public Result getMembershipClaim(Int32 claimId, [MaybeNullWhen(false)] out ServerCommon.Claim? claim)
{
var result = new Result();
if (false == m_membership_claim.TryGetValue(claimId, out claim))
{
var err_msg = $"m_membership_claim claimId : {claimId} not exist, {getOwner().toBasicString()}";
result.setFail(ServerErrorCode.ClaimInfoNotExist, err_msg);
Log.getLogger().error(result.toBasicString());
return result;
}
NullReferenceCheckHelper.throwIfNull(claim, () => $"claim is null !!!");
return result;
}
public override void onClear()
{
return;
}
public void send_GS2C_NTF_CLAIM_UPDATE()
{
var player = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
var server_logic = GameServerApp.getServerLogic();
NullReferenceCheckHelper.throwIfNull(server_logic, () => $"server_logic is null !!!");
var normal_claim_infos = ClaimRewardHelper.MakeClaimSendInfo(player, MetaAssets.ClaimType.Normal);
var membership_claim_infos = ClaimRewardHelper.MakeClaimSendInfo(player, MetaAssets.ClaimType.Membership);
foreach (var info in normal_claim_infos)
{
ClientToGame ntf_packet = new();
ntf_packet.Message = new();
ntf_packet.Message.ClaimUpdateNoti = new();
ntf_packet.Message.ClaimUpdateNoti.ClaimId = info.Key;
ntf_packet.Message.ClaimUpdateNoti.NormalInfo = info.Value;
ntf_packet.Message.ClaimUpdateNoti.MembershipInfo = membership_claim_infos.TryGetValue(info.Key, out var membership_info) ? membership_info : new();
if (false == server_logic.onSendPacket(player, ntf_packet))
{
Log.getLogger().error($"SendPacket Fail");
continue;
}
}
}
}
}

193
GameServer/Contents/Claim/Action/ClaimRewardAction.cs Normal file
View File

@@ -0,0 +1,193 @@
using GameServer.Reward;
using ServerCommon;
using ServerControlCenter;
using ServerCore; using ServerBase;
namespace GameServer
{
public class ClaimRewardReference
{
public string m_user_guid { get; set; } = string.Empty;
public Int32 m_claim_id { get; set; } = 0;
public MetaAssets.ClaimType m_claim_type { get; set; } = MetaAssets.ClaimType.Normal;
public Int32 m_reward_group_id { get; set; } = 0;
public List<MetaAssets.Reward> m_reward_data { get; set; } = new();
public ClaimMetaData? m_meta_data { get; set; } = null;
public ServerCommon.Claim? m_claim { get; set; } = null;
public List<MetaAssets.Reward> m_rewared_money { get; set; } = new();
public List<Item> m_rewarded_items { get; set; } = new();
public CommonResult m_common_result { get; set; } = new();
}
public class ClaimRewardAction : EntityActionBase
{
public ClaimRewardAction(EntityBase owner)
: base(owner)
{
}
public override void onClear()
{
return;
}
public override async Task<Result> onInit()
{
await Task.CompletedTask;
var result = new Result();
return result;
}
public async Task<Result> rewardClaim(ClaimRewardReference claimRewardRef)
{
var owner = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
setActiveIdx(claimRewardRef);
IReward reward_proc = new RewardClaim(owner, claimRewardRef.m_user_guid, claimRewardRef);
var result = await RewardManager.It.proceedRewardProcess(reward_proc);
if (result.isFail())
{
return result;
}
RewardManager.It.postRewardProcess(reward_proc);
return new();
}
private void setActiveIdx(ClaimRewardReference claimRewardRef)
{
DateTime now = DateTimeHelper.Current;
NullReferenceCheckHelper.throwIfNull(claimRewardRef.m_meta_data, () => $"claimRewardRef.m_meta_data is null !!!");
NullReferenceCheckHelper.throwIfNull(claimRewardRef.m_claim, () => $"claimRewardRef.m_claim is null !!!");
int lastRewarIdx = claimRewardRef.m_meta_data.DetailInfo.Last().Value.Idx;
var claimAttribute = claimRewardRef.m_claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(claimAttribute, () => $"claimAttribute is null !!!");
claimAttribute.ActiveTime = now;
int nextActiveIdx = claimAttribute.ActiveRewardIdx + 1;
if (nextActiveIdx > lastRewarIdx)
{
claimAttribute.IsComplete = 1;
nextActiveIdx = 0;
}
claimAttribute.ActiveRewardIdx = nextActiveIdx;
claimAttribute.modifiedEntityAttribute();
}
public Result claimRewardConditionCheck(ref ClaimRewardReference claimRewardRef)
{
var owner = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
MetaAssets.ClaimType type = claimRewardRef.m_claim_type;
(var result, var claim_meta) = ClaimRewardHelper.getClaimMeta(claimRewardRef.m_claim_id, type);
if (result.isFail()) return result;
claimRewardRef.m_meta_data = claim_meta;
var claim_action = owner.getEntityAction<ClaimAction>();
result = claim_action.getClaim(claimRewardRef.m_claim_id, type, out var claim);
if (result.isFail()) return result;
claimRewardRef.m_claim = claim;
result = timeConditionCheck(ref claimRewardRef);
if (result.isFail()) return result;
result = rewardConditionCheck(ref claimRewardRef);
if (result.isFail()) return result;
return result;
}
private Result timeConditionCheck(ref ClaimRewardReference claimRewardRef)
{
var result = new Result();
NullReferenceCheckHelper.throwIfNull(claimRewardRef.m_claim, () => $"claimRewardRef.m_claim is null !!!");
NullReferenceCheckHelper.throwIfNull(claimRewardRef.m_meta_data, () => $"claimRewardRef.m_meta_data is null !!!");
var attribute = claimRewardRef.m_claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
var active_idx = attribute.ActiveRewardIdx;
if (false == claimRewardRef.m_meta_data.DetailInfo.TryGetValue(active_idx, out var detailInfo))
{
var err_msg = $"detailInfo activeIdx = {active_idx} Data not exist";
result.setFail(ServerErrorCode.ClaimInfoNotExist, err_msg);
return result;
}
var cool_time = detailInfo.CoolTime;
var now_dt = DateTimeHelper.Current;
var active_time = attribute.ActiveTime;
if (now_dt < claimRewardRef.m_meta_data.StartTime || claimRewardRef.m_meta_data.EndTime < now_dt)
{
var err_msg = $"Claim Not Correct Time activeIdx = {active_idx} metaData.StartTime : {claimRewardRef.m_meta_data.StartTime}, metaData.EndTime : {claimRewardRef.m_meta_data.EndTime} ";
result.setFail(ServerErrorCode.ClaimRewardEventEnd, err_msg);
Log.getLogger().error(result.toBasicString());
return result;
}
var apply_cool_second = active_time.AddSeconds(cool_time);
if (apply_cool_second > now_dt)
{
var err_msg = $"HandleClaimRewardReq not enough Time to activeIdx = {active_idx} Data not exist";
result.setFail(ServerErrorCode.ClaimRewardNotEnoughTime, err_msg);
return result;
}
return result;
}
private Result rewardConditionCheck(ref ClaimRewardReference claimRewardRef)
{
var result = new Result();
NullReferenceCheckHelper.throwIfNull(claimRewardRef.m_claim, () => $"claimRewardRef.m_claim is null !!!");
NullReferenceCheckHelper.throwIfNull(claimRewardRef.m_meta_data, () => $"claimRewardRef.m_meta_data is null !!!");
var attribute = claimRewardRef.m_claim.getEntityAttribute<ClaimAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
var active_idx = attribute.ActiveRewardIdx;
if (false == claimRewardRef.m_meta_data.DetailInfo.TryGetValue(active_idx, out var detailInfo))
{
var err_msg = $"detailInfo activeIdx = {active_idx} Data not exist";
result.setFail(ServerErrorCode.ClaimInfoNotExist, err_msg);
return result;
}
int rewardGroupId = detailInfo.RewardGroupId;
if (!MetaData.Instance._RewardMetaTable.TryGetValue(rewardGroupId, out var rewardList))
{
var err_msg = $"_RewardDataTable not exist info rewardGroupId = {rewardGroupId}";
result.setFail(ServerErrorCode.RewardInfoNotExist, err_msg);
return result;
}
claimRewardRef.m_reward_group_id = rewardGroupId;
claimRewardRef.m_reward_data.Clear();
foreach (var reward in rewardList)
{
claimRewardRef.m_reward_data.Add(reward.Reward);
}
return result;
}
}
}

24
GameServer/Contents/Claim/ClaimCheat.cs Normal file
View File

@@ -0,0 +1,24 @@

namespace GameServer;
[ChatCommandAttribute("resetclaim", typeof(ChatCommandResetClaim), AuthAdminLevelType.Developer, AuthAdminLevelType.GmNormal, AuthAdminLevelType.GmSuper)]
internal class ChatCommandResetClaim : ChatCommandBase
{
public override async Task invoke(Player player, string token, string[] args)
{
var claim_action = player.getEntityAction<ClaimAction>();
await claim_action.cheatClaimReset();
}
}
[ChatCommandAttribute("claimupdaterewardable", typeof(ChatCommandRewardClaim), AuthAdminLevelType.Developer, AuthAdminLevelType.GmNormal, AuthAdminLevelType.GmSuper)]
internal class ChatCommandRewardClaim : ChatCommandBase
{
public override async Task invoke(Player player, string token, string[] args)
{
var claim_action = player.getEntityAction<ClaimAction>();
await claim_action.cheatClaimUpdateRewardable();
}
}

107
GameServer/Contents/Claim/DBQuery/DBQClaimReadAll.cs Normal file
View File

@@ -0,0 +1,107 @@
using ServerCommon;
using ServerCore; using ServerBase;
namespace GameServer
{
public class DBQClaimReadAll : QueryExecutorBase
{
private MetaAssets.ClaimType m_claim_type { get; set; } = MetaAssets.ClaimType.None;
private string m_pk { get; set; } = string.Empty;
private string m_sk { get; set; } = string.Empty;
private readonly string m_combination_key_for_pk;
public DBQClaimReadAll(string combinationKeyForPk)
: base(typeof(DBQClaimReadAll).Name)
{
m_combination_key_for_pk = combinationKeyForPk;
}
//===================================================================================================
// DB 쿼리 직전에 준비해야 할 로직들을 작성한다.
//===================================================================================================
public override Task<Result> onPrepareQuery()
{
var result = new Result();
var owner = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(owner, () => "owner is null !!!");
var doc = new ClaimDoc(owner.getUserGuid());
doc.setCombinationKeyForPK(m_combination_key_for_pk);
var error_code = doc.onApplyPKSK();
if (error_code.isFail())
{
var err_msg = $"Failed to onApplyPKSK() !!! : {error_code.toBasicString()} - {toBasicString()}, {owner.toBasicString()}";
result.setFail(error_code, err_msg);
Log.getLogger().error(result.toBasicString());
return Task.FromResult(result);
}
m_pk = doc.getPK();
return Task.FromResult(result);
}
//===================================================================================================
// onPrepareQuery()를 성공할 경우 호출된다.
//===================================================================================================
public override async Task<Result> onQuery()
{
var result = new Result();
var err_msg = string.Empty;
var owner = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(owner, () => "owner is null !!!");
var query_batch = getQueryBatch();
NullReferenceCheckHelper.throwIfNull(query_batch, () => "query_batch is null !!!");
var db_connector = query_batch.getDynamoDbConnector();
var query_config = db_connector.makeQueryConfigForReadByPKOnly(m_pk);
(result, var read_docs) = await db_connector.simpleQueryDocTypesWithQueryOperationConfig<ClaimDoc>(query_config, eventTid: query_batch.getTransId());
if (result.isFail()) return result;
var claim_action = owner.getEntityAction<ClaimAction>();
NullReferenceCheckHelper.throwIfNull(claim_action, () => "claim_action is null !!!");
foreach (var read_doc in read_docs)
{
var set_result = claim_action.setClaimFromDoc(read_doc);
if (set_result.isFail())
{
Log.getLogger().error(result.toBasicString());
continue;
}
}
claim_action.setDataLoad(true);
return result;
}
//===================================================================================================
// DB 쿼리를 성공하고, doFnCommit()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
//===================================================================================================
public override Task onQueryResponseCommit()
{
return Task.CompletedTask;
}
//===================================================================================================
// DB 쿼리를 실패하고, doFnRollback()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
//===================================================================================================
public override Task onQueryResponseRollback(Result errorResult)
{
return Task.CompletedTask;
}
private new Player? getOwner() => getQueryBatch()?.getLogActor() as Player;
}
}

36
GameServer/Contents/Claim/Log/CheatClaimResetBusinessLog.cs Normal file
View File

@@ -0,0 +1,36 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class CheatClaimResetBusinessLog : ILogInvokerEx
{
CheatClaimResetLogInfo m_info;
public CheatClaimResetBusinessLog(MetaAssets.ClaimType claimType, Int32 claimId, Int32 ActiveRewardIdx)
: base(LogDomainType.ClaimReward)
{
m_info = CheatClaimResetLogInfo.creatCheatClaimResetLogInfo(this, claimType, claimId, ActiveRewardIdx);
}
public override bool hasLog()
{
return true;
}
protected override void fillup(ref BusinessLog.LogBody body)
{
body.append(m_info);
}
}

33
GameServer/Contents/Claim/Log/CheatClaimRewardableBusinessLog.cs Normal file
View File

@@ -0,0 +1,33 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class CheatClaimRewardableBusinessLog : ILogInvokerEx
{
CheatClaimRewardableLogInfo m_info;
public CheatClaimRewardableBusinessLog(MetaAssets.ClaimType claimType, Int32 claimId, Int32 ActiveRewardIdx)
: base(LogDomainType.ClaimReward)
{
m_info = CheatClaimRewardableLogInfo.creatCheatClaimRewardableLogInfo(this, claimType, claimId, ActiveRewardIdx);
}
public override bool hasLog()
{
return true;
}
protected override void fillup(ref BusinessLog.LogBody body)
{
body.append(m_info);
}
}

35
GameServer/Contents/Claim/Log/ClaimRewardBusinessLog.cs Normal file
View File

@@ -0,0 +1,35 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class ClaimRewardBusinessLog : ILogInvokerEx
{
ClaimRewardLogInfo m_info;
public ClaimRewardBusinessLog(int claimId, int claimType, int rewardDataId)
: base(LogDomainType.ClaimReward)
{
m_info = new ClaimRewardLogInfo(this, claimId, claimType, rewardDataId);
}
public override bool hasLog()
{
return true;
}
protected override void fillup(ref BusinessLog.LogBody body)
{
body.append(m_info);
}
}

131
GameServer/Contents/Claim/PacketHandler/ClaimRewardPacketHandler.cs Normal file
View File

@@ -0,0 +1,131 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
namespace GameServer.PacketHandler;
[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.ClaimRewardReq), typeof(ClaimRewardPacketHandler), typeof(GameLoginListener))]
public class ClaimRewardPacketHandler : PacketRecvHandler
{
public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
{
var owner = session as Player;
NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
var recv_msg = recvMessage as ClientToGame;
NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
var request = recv_msg.Request.ClaimRewardReq;
var claim_type = request.ClaimType;
var claim_id = request.ClaimId;
ClaimRewardReference claim_reward_ref = new();
claim_reward_ref.m_claim_id = claim_id;
System.Enum.TryParse(claim_type.ToString(), out MetaAssets.ClaimType parsedType);
claim_reward_ref.m_claim_type = parsedType;
claim_reward_ref.m_user_guid = owner.getUserGuid();
var result = await claimReward(owner, claim_reward_ref);
if (result.isFail())
{
send_GS2C_ACK_CLAIM_REWARD_FAIL(owner, result);
return result;
}
send_GS2C_ACK_CLAIM_REWARD(owner, result, claim_reward_ref);
NullReferenceCheckHelper.throwIfNull(claim_reward_ref.m_meta_data, () => $"claim_reward_ref.m_meta_data is null !!!");
var rewards = claim_reward_ref.m_meta_data.DetailInfo.Values.ToList();
foreach (var reward in rewards)
{
await QuestManager.It.QuestCheck(owner, new QuestReward(EQuestEventTargetType.REWARD, EQuestEventNameType.RECEIVED, reward.RewardGroupId));
}
return result;
}
private async Task<Result> claimReward(Player owner, ClaimRewardReference claimRewardRef)
{
var claim_reward_action = owner.getEntityAction<ClaimRewardAction>();
var result = claim_reward_action.claimRewardConditionCheck(ref claimRewardRef);
if (result.isFail()) return result;
result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "RewardClaim", delegateRewardClaim);
if (result.isFail())
{
string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {owner.toBasicString()}";
Log.getLogger().error(err_msg);
return result;
}
return result;
async Task<Result> delegateRewardClaim() => await rewardClaim(owner, claimRewardRef);
}
private async Task<Result> rewardClaim(Player owner, ClaimRewardReference claimRewardRef)
{
var claim_reward_action = owner.getEntityAction<ClaimRewardAction>();
var result = await claim_reward_action.rewardClaim(claimRewardRef);
var server_logic = GameServerApp.getServerLogic();
var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.ClaimReward, server_logic.getDynamoDbClient());
{
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
}
var log_invoker = new ClaimRewardBusinessLog(claimRewardRef.m_claim_id, (int)claimRewardRef.m_claim_type, claimRewardRef.m_reward_group_id);
batch.appendBusinessLog(log_invoker);
result = await QueryHelper.sendQueryAndBusinessLog(batch);
if (result.isFail()) return result;
var found_transaction_runner = owner.findTransactionRunner(TransactionIdType.PrivateContents);
NullReferenceCheckHelper.throwIfNull(found_transaction_runner, () => $"found_transaction_runner is null !!! - {owner.toBasicString()}");
var common_result = found_transaction_runner.getCommonResult();
claimRewardRef.m_common_result = common_result;
return result;
}
private static bool send_GS2C_ACK_CLAIM_REWARD_FAIL(Player owner, Result result)
{
var ack_packet = new ClientToGame();
ack_packet.Response = new ClientToGameRes();
ack_packet.Response.ErrorCode = result.ErrorCode;
ack_packet.Response.ClaimRewardRes = new();
if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
return true;
}
private static bool send_GS2C_ACK_CLAIM_REWARD(Player owner, Result result, ClaimRewardReference claimRewardRef)
{
var ack_packet = new ClientToGame();
ack_packet.Response = new ClientToGameRes();
ack_packet.Response.ErrorCode = result.ErrorCode;
ack_packet.Response.ClaimRewardRes = new();
ack_packet.Response.ClaimRewardRes.ClaimId = claimRewardRef.m_claim_id;
ack_packet.Response.ClaimRewardRes.CommonResult = claimRewardRef.m_common_result;
//var rewarded_items = claimRewardRef.m_rewarded_items;
//var rewarded_money = claimRewardRef.m_rewared_money;
//var items = RewardManager.Instance.convertItemAndMoneyToItem(rewarded_items, rewarded_money);
//ack_packet.Response.ClaimRewardRes.RewardItems.AddRange(items);
if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
return true;
}
}

80
GameServer/Contents/Claim/PacketHandler/GetClaimInfoPacketHandler.cs Normal file
View File

@@ -0,0 +1,80 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
namespace GameServer.PacketHandler;
[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.GetClaimInfoReq), typeof(GetClaimInfoPacketHandler), typeof(GameLoginListener))]
public class GetClaimInfoPacketHandler : PacketRecvHandler
{
public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
{
var owner = session as Player;
NullReferenceCheckHelper.throwIfNull(owner, () => "player is null !!!");
var claim_action = owner.getEntityAction<ClaimAction>();
NullReferenceCheckHelper.throwIfNull(claim_action, () => $"claim action is null !!! - {owner.toBasicString()}");
//var result = await claim_action.loadClaim();
// if (result.isFail())
// {
// send_GS2C_ACK_GET_CLAIM_ERROR(owner, result);
// }
send_GS2C_ACK_GET_CLAIM_SUCCESS(owner);
return await Task.FromResult(new Result());
}
private static bool send_GS2C_ACK_GET_CLAIM_SUCCESS(Player owner)
{
var normal_claim_infos = ClaimRewardHelper.MakeClaimSendInfo(owner, MetaAssets.ClaimType.Normal);
var membership_claim_infos = ClaimRewardHelper.MakeClaimSendInfo(owner, MetaAssets.ClaimType.Membership);
foreach (var normal_info in normal_claim_infos)
{
var claim_id = normal_info.Key;
var ack_packet = new ClientToGame();
ack_packet.Response = new ClientToGameRes();
ack_packet.Response.GetClaimInfoRes = new();
ack_packet.Response.GetClaimInfoRes.ClaimId = claim_id;
ack_packet.Response.GetClaimInfoRes.NormalInfo = normal_info.Value;
ack_packet.Response.GetClaimInfoRes.MembershipInfo = new();
if (true == membership_claim_infos.TryGetValue(claim_id, out var membership_info))
{
ack_packet.Response.GetClaimInfoRes.MembershipInfo = membership_info;
}
GameServerApp.getServerLogic().onSendPacket(owner, ack_packet);
}
if (normal_claim_infos.Count == 0)
{
var ack_packet = new ClientToGame();
ack_packet.Response = new ClientToGameRes();
ack_packet.Response.GetClaimInfoRes = new();
ack_packet.Response.GetClaimInfoRes.ClaimId = 0;
ack_packet.Response.GetClaimInfoRes.NormalInfo = new();
ack_packet.Response.GetClaimInfoRes.MembershipInfo = new();
GameServerApp.getServerLogic().onSendPacket(owner, ack_packet);
}
return true;
}
private static bool send_GS2C_ACK_GET_CLAIM_ERROR(Player owner, Result result)
{
var ack_packet = new ClientToGame();
ack_packet.Response = new ClientToGameRes();
ack_packet.Response.ErrorCode = result.ErrorCode;
ack_packet.Response.GetClaimInfoRes = new();
if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
return true;
}
}