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

250501 커밋

Browse Source
This commit is contained in:
bcjang
2025-05-01 07:23:28 +09:00
parent 98bb2e3c5c
commit 23176551b7
353 changed files with 9972 additions and 6652 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
GameServer/Contents/BeaconShop/Action/BeaconShopAction.cs
View File

@@ -14,6 +14,7 @@ using META_ID = System.UInt32;
using BEACON_GUID = System.String;
using ITEM_GUID = System.String;
using USER_GUID = System.String;
using Amazon.S3.Model;
namespace GameServer;
@@ -74,11 +75,6 @@ public class BeaconShopAction : EntityActionBase
}
}
public bool hasBeaconShopSoldRecord(BEACON_GUID beaconGuid)
{
return m_beacon_shop_sold_records.TryGetValue(beaconGuid, out var record);
}
public async Task<Result> AddBeaconShopSoldRecordsFromDocs(List<BeaconShopSoldRecordDoc> beaconShopSoldRecordDocs)
{
var result = new Result();
@@ -174,6 +170,13 @@ public class BeaconShopAction : EntityActionBase
return result;
}
if (isRentalSafeTime(ugc_npc) == false)
{
err_msg = $"Rental Safe Time is over - {player.toBasicString()}";
result.setFail(ServerErrorCode.BeaconShopOverRentalSafeTime, err_msg);
return result;
}
var fn_start_register_beacon_shop_item = async delegate ()
{
var result = new Result();
@@ -280,7 +283,7 @@ public class BeaconShopAction : EntityActionBase
);
if (result.isFail()) { return result; }
var task_log_data = BeaconShopBusinessLogHelper.toLogInfo(beaconShopMongoDoc);
var task_log_data = BeaconShopBusinessLogHelper.toLogInfo(beaconShopMongoDoc, beacon_shop_attribute.IsActiveSelling);
invokers.Add(new BeaconShopBusinessLog(task_log_data));
result = await m_beacon_shop_repository.insert(beaconShopMongoDoc);
@@ -317,7 +320,9 @@ public class BeaconShopAction : EntityActionBase
return result;
}
BeaconShopHelper.send_GS2GS_NTF_UPDATE_BEACON_SHOP_ITEM(player.getUserGuid(), BeaconGuid);
var hasBeaconShopItem = ugc_npc_beacon_shop_action.hasBeaconShopItem();
BeaconShopHelper.send_GS2GS_NTF_UPDATE_BEACON_SHOP_ITEM(player.getUserGuid(), BeaconGuid, hasBeaconShopItem);
PacketHandler.BeaconShopRegisterItemPacketHandler.send_S2C_ACK_BEACON_SHOP_REGISTER_ITEM(player, result, beacon_shop_item, found_transaction_runner.getCommonResult());
return result;
@@ -352,6 +357,31 @@ public class BeaconShopAction : EntityActionBase
return result;
}
var ugc_npc_beacon_shop_action = found_ugc_npc.getEntityAction<UgcNpcBeaconShopAction>();
//1. 아이템 찾기
var found_item = ugc_npc_beacon_shop_action.getBeaconShopItem(itemGuid);
if (found_item == null)
{
err_msg = $"Failed to tryGetItemByItemGuid BeaconShopItem !!! : itemGuid : {itemGuid}, {player.toBasicString()}";
result.setFail(ServerErrorCode.ItemNotFound, err_msg);
PacketHandler.BeaconShopReturnItemPacketHandler.send_S2C_ACK_BEACON_SHOP_RETURN_ITEM(player, result);
return result;
}
//2. 판매 아이템 활성화 확인
var beacon_shop_item_attribute = found_item.getEntityAttribute<BeaconShopItemAttribute>();
NullReferenceCheckHelper.throwIfNull(beacon_shop_item_attribute, () => $"beacon_shop_item_attribute is null !!! - {player.toBasicString()}");
if (beacon_shop_item_attribute.IsActiveSelling == true)
{
if (isRentalSafeTime(found_ugc_npc) == false)
{
err_msg = $"Rental Safe Time is over - {player.toBasicString()}";
result.setFail(ServerErrorCode.BeaconShopOverRentalSafeTime, err_msg);
return result;
}
}
var fn_start_return_item = async delegate ()
{
using (var runner_with_scope = new EntityTransactionRunnerWithScopLock(found_ugc_npc))
@@ -455,7 +485,7 @@ public class BeaconShopAction : EntityActionBase
{
PacketHandler.BeaconShopReturnItemPacketHandler.send_S2C_ACK_BEACON_SHOP_RETURN_ITEM(player, result);
ugc_npc_beacon_shop_action.setUpdateBeaconShopItem();
player.send_S2C_NTF_BEACON_SHOP_REFRESH(beaconGuid);
player.send_S2C_NTF_BEACON_SHOP_REFRESH(beaconGuid, BoolType.True);
return result;
}
@@ -493,6 +523,39 @@ public class BeaconShopAction : EntityActionBase
return result;
}
var ugc_npc_beacon_shop_action = found_ugc_npc.getEntityAction<UgcNpcBeaconShopAction>();
var beacon_shop_item = ugc_npc_beacon_shop_action.getBeaconShopItem(itemGuid);
if (beacon_shop_item == null)
{
err_msg = $"Not found Beacon Shop Item !!! : itemGuid:{itemGuid} beaconOwner:{beaconOwnerGuid} - {player.toBasicString()}";
result.setFail(ServerErrorCode.BeaconShopNotFoundItem, err_msg);
return result;
}
// 판매 아이템 활성화 확인
var beacon_shop_item_attribute = beacon_shop_item.getEntityAttribute<BeaconShopItemAttribute>();
NullReferenceCheckHelper.throwIfNull(beacon_shop_item_attribute, () => $"beacon_shop_item_attribute is null !!! - {player.toBasicString()}");
if (beacon_shop_item_attribute.IsActiveSelling == false)
{
err_msg = $"Is Deactive Selling Item !! - {player.toBasicString()}";
result.setFail(ServerErrorCode.BeaconShopDeactiveItemForSell, err_msg);
return result;
}
if (isRentalMyhome(found_ugc_npc) == false)
{
err_msg = $"Beacon is not in myHome !!! - {player.toBasicString()}";
result.setFail(ServerErrorCode.BeaconShopBeaconIsNotInRentalHome, err_msg);
return result;
}
if (isRentalSafeTime(found_ugc_npc) == false)
{
err_msg = $"Rental Safe Time is over - {player.toBasicString()}";
result.setFail(ServerErrorCode.BeaconShopOverRentalSafeTime, err_msg);
return result;
}
var fn_start_purchase_item = async delegate ()
{
var result = new Result();
@@ -677,7 +740,7 @@ public class BeaconShopAction : EntityActionBase
{
PacketHandler.BeaconShopReturnItemPacketHandler.send_S2C_ACK_BEACON_SHOP_RETURN_ITEM(player, result);
ugc_npc_beacon_shop_action.setUpdateBeaconShopItem();
player.send_S2C_NTF_BEACON_SHOP_REFRESH(beaconGuid);
player.send_S2C_NTF_BEACON_SHOP_REFRESH(beaconGuid, BoolType.True);
return result;
}
@@ -702,7 +765,9 @@ public class BeaconShopAction : EntityActionBase
PacketHandler.BeaconShopPurchaseItemPacketHandler.send_S2C_ACK_BEACON_SHOP_PURCHASE_ITEM(player, result, itemGuid, beaconGuid, left_item_stack_count, found_transaction_runner.getCommonResult());
BeaconShopHelper.send_GS2GS_NTF_UPDATE_BEACON_SHOP_ITEM(beacon_owner_guid, beaconGuid);
var hasBeaconShopItem = ugc_npc_beacon_shop_action.hasBeaconShopItem();
BeaconShopHelper.send_GS2GS_NTF_UPDATE_BEACON_SHOP_ITEM(beacon_owner_guid, beaconGuid, hasBeaconShopItem);
var player_manager = server_logic.getPlayerManager();
if (player_manager.tryGetUserByPrimaryKey(beacon_owner_guid, out var found_user) == true)
@@ -724,6 +789,91 @@ public class BeaconShopAction : EntityActionBase
return result;
}
private bool isRentalMyhome(UgcNpc ugcNpc)
{
var player = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
var beacon_attribute = ugcNpc.getEntityAttribute<UgcNpcAttribute>();
NullReferenceCheckHelper.throwIfNull(beacon_attribute, () => $"beacon_attribute is null !!!");
var rental_agent_action = player.getEntityAction<RentalAgentAction>();
if (beacon_attribute.State != EntityStateType.UsingByMyHome ||
rental_agent_action.isRentalMyhome(beacon_attribute.LocatedInstanceGuid) == false)
{
return false;
}
return true;
}
// 랜탈 기간이 안전한 시간 내 인지 확인
private bool isRentalSafeTime(UgcNpc ugcNpc)
{
var player = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
var beacon_attribute = ugcNpc.getEntityAttribute<UgcNpcAttribute>();
NullReferenceCheckHelper.throwIfNull(beacon_attribute, () => $"beacon_attribute is null !!!");
var rental_agent_action = player.getEntityAction<RentalAgentAction>();
var rental_finish_time = rental_agent_action.getRentalMyhomeFinishTime(beacon_attribute.LocatedInstanceGuid);
if (rental_finish_time.HasValue == false)
{
return false;
}
var now = DateTime.UtcNow;
if (rental_finish_time.Value.AddSeconds(-5) < now)
{
return false;
}
return true;
}
public async Task<Result> BeaconShopDeactiveItems(BEACON_GUID beaconGuid, USER_GUID beaconOwnerGuid, List<ILogInvoker> invokers)
{
var result = new Result();
var err_msg = string.Empty;
var player = getOwner() as Player;
NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
// 1. 아이템 비활성화
(result, var found_ugc_npc, var ugc_npc_owner) = await NpcHelper.findUgcNpc(beaconGuid, beaconOwnerGuid);
if (found_ugc_npc == null)
{
if (result.isSuccess())
result.setFail(ServerErrorCode.UgcNpcNotFound, err_msg);
err_msg = $"Not found Beacon !!! : beaconOwner:{beaconOwnerGuid} - {player.toBasicString()}";
return result;
}
var ugc_npc_attribute = found_ugc_npc.getEntityAttribute<UgcNpcAttribute>();
NullReferenceCheckHelper.throwIfNull(ugc_npc_attribute, () => $"ugc_npc_attribute is null !!! - {player.toBasicString()}");
var ugc_npc_beacon_shop_action = found_ugc_npc.getEntityAction<UgcNpcBeaconShopAction>();
ugc_npc_beacon_shop_action.setDeactiveAllItems();
//2. mongo에서 제거 & 비지니스 로그 작성
var beacon_shop_item_list = ugc_npc_beacon_shop_action.getHasBeaconShopItem();
foreach (var beacon_shop_item in beacon_shop_item_list)
{
var beacon_shop_item_attribute = beacon_shop_item.getEntityAttribute<BeaconShopItemAttribute>();
NullReferenceCheckHelper.throwIfNull(beacon_shop_item_attribute, () => $"beacon_shop_item_attribute is null !!! - {toBasicString()}");
await m_beacon_shop_repository.delete(beacon_shop_item_attribute.ItemGuid);
var task_log_data = BeaconShopBusinessLogHelper.toLogInfo(beacon_shop_item_attribute, ugc_npc_attribute, player.getUserGuid());
invokers.Add(new BeaconShopBusinessLog(task_log_data));
}
return result;
}
private (Result, DynamoDbItemRequestQueryContext?) BeaconShopSoldPriceUpdate(string combinationKeyForPK, string combinationKeyForSK, double givenPrice, double taxPrice, int numOfReceiptNotReceived)
{
var result = new Result();
@@ -1062,19 +1212,24 @@ public class BeaconShopAction : EntityActionBase
return result;
}
int numOfReceiptNotReceived = 0;
if (m_beacon_shop_sold_price.TryGetValue(beaconGuid, out var beaconShopSoldPrice) == true)
{
var beacon_shop_sold_price_attribute = beaconShopSoldPrice.getEntityAttribute<BeaconShopSoldPriceAttribute>();
NullReferenceCheckHelper.throwIfNull(beacon_shop_sold_price_attribute, () => $"beacon_shop_sold_price_attribute is null !!! - {player.toBasicString()}");
numOfReceiptNotReceived = beacon_shop_sold_price_attribute.NumOfReceiptNotReceived;
}
int numOfReceiptNotReceived = getBeaconShopNumOfReceiptNotReceived(beaconGuid);
PacketHandler.BeaconShopGetItemInfosPacketHandler.send_S2C_ACK_BEACON_SHOP_GET_ITEM_INFOS(player, result, beacon_shop_item_reload_data, beacon_shop_profile_attribute.DailyRegisterCount, numOfReceiptNotReceived);
return result;
}
public int getBeaconShopNumOfReceiptNotReceived(BEACON_GUID beaconGuid)
{
if (m_beacon_shop_sold_price.TryGetValue(beaconGuid, out var beaconShopSoldPrice) == true)
{
var beacon_shop_sold_price_attribute = beaconShopSoldPrice.getEntityAttribute<BeaconShopSoldPriceAttribute>();
NullReferenceCheckHelper.throwIfNull(beacon_shop_sold_price_attribute, () => $"beacon_shop_sold_price_attribute is null !!! - {getOwner().toBasicString()}");
return beacon_shop_sold_price_attribute.NumOfReceiptNotReceived;
}
return 0;
}
private async Task<Result> ProcessUpdateDailyRegisterCount(UgcNpc found_ugc_npc)
{
var result = new Result();
@@ -1134,10 +1289,7 @@ public class BeaconShopAction : EntityActionBase
NullReferenceCheckHelper.throwIfNull(beacon_attribute, () => $"beacon_attribute is null !!!");
// 1. 비컨 체크
var rental_agent_action = player.getEntityAction<RentalAgentAction>();
if (beacon_attribute.State != EntityStateType.UsingByMyHome ||
rental_agent_action.isRentalMyhome(beacon_attribute.LocatedInstanceGuid) == false)
if (isRentalMyhome(ugcNpc) == false)
{
err_msg = $"Beacon is not in myHome !!! : beacon State:{beacon_attribute.State} - {player.toBasicString()}";
result.setFail(ServerErrorCode.BeaconShopBeaconIsNotInRentalHome, err_msg);

4
GameServer/Contents/BeaconShop/BeaconShopItem.cs
View File

@@ -89,12 +89,13 @@ namespace GameServer
beacon_shop_attribute.BeaconGuid = beacon_guid;
beacon_shop_attribute.SellingFinishTime = selling_finish_time;
beacon_shop_attribute.PriceForUnit = price_for_unit;
beacon_shop_attribute.IsActiveSelling = true;
beacon_shop_attribute.ItemMetaId = deleted_item_attribute.ItemMetaId;
beacon_shop_attribute.ItemStackCount = amount;
beacon_shop_attribute.Level = deleted_item_attribute.Level;
beacon_shop_attribute.Attributes = deleted_item_attribute.Attributes.Select(x => x).ToList();
beacon_shop_attribute.EquipedIvenType = deleted_item_attribute.EquipedIvenType;
beacon_shop_attribute.EquipedInvenType = deleted_item_attribute.EquipedInvenType;
beacon_shop_attribute.EquipedPos = deleted_item_attribute.EquipedPos;
beacon_shop_attribute.newEntityAttribute();
@@ -132,6 +133,7 @@ namespace GameServer
beacon_shop_4_client.ItemMetaid = (int)beacon_shop_attribute.ItemMetaId;
beacon_shop_4_client.SellingFinishTime = Timestamp.FromDateTime(beacon_shop_attribute.SellingFinishTime);
beacon_shop_4_client.PriceForUnit = beacon_shop_attribute.PriceForUnit;
beacon_shop_4_client.IsActiveSelling = beacon_shop_attribute.IsActiveSelling == true ? BoolType.True : BoolType.False;
beacon_shop_4_client.Amount = beacon_shop_attribute.ItemStackCount;
return beacon_shop_4_client;

40
GameServer/Contents/BeaconShop/Helper/BeaconShopHelper.cs
View File

@@ -10,6 +10,41 @@ namespace GameServer
{
internal static class BeaconShopHelper
{
public static async Task<Result> DeactiveBeaconShopItems(string beaconGuid)
{
var server_logic = GameServerApp.getServerLogic();
var dynamo_db_client = server_logic.getDynamoDbClient();
var (result, primary_key_object) = await DynamoDBDocBaseHelper.makePrimaryKey<BeaconShopItemDoc>(beaconGuid);
if (result.isFail() || primary_key_object == null)
{
return result;
}
var query_config = dynamo_db_client.makeQueryConfigForReadByPKOnly(primary_key_object.PK);
(result, var read_docs) = await dynamo_db_client.simpleQueryDocTypesWithQueryOperationConfig<BeaconShopItemDoc>(query_config);
if (result.isFail())
{
return result;
}
foreach (var beacon_shop_item_doc in read_docs)
{
var beaconShopItemAttrib = beacon_shop_item_doc.getAttrib<BeaconShopItemAttrib>();
NullReferenceCheckHelper.throwIfNull(beaconShopItemAttrib, () => $"beaconShopItemAttrib is null !!");
beaconShopItemAttrib.IsActiveSelling = false;
beacon_shop_item_doc.setQueryType(QueryType.Update);
result = await dynamo_db_client.simpleUpdateDocumentWithDocType(beacon_shop_item_doc);
if (result.isFail())
{
return result;
}
}
return result;
}
public static BeaconShopItemBoardInfo toBeaconShopItemMongoDataClient(this BeaconShopMongoDoc beaconShopMongoDoc)
{
var beacon_shop_4_client = new BeaconShopItemBoardInfo();
@@ -81,7 +116,7 @@ namespace GameServer
rabbit_mq_4_game.SendMessage(targetServer, ntf_packet);
}
public static void send_GS2GS_NTF_UPDATE_BEACON_SHOP_ITEM(USER_GUID targetUserGuid, BEACON_GUID targetBeaconGuid)
public static void send_GS2GS_NTF_UPDATE_BEACON_SHOP_ITEM(USER_GUID targetUserGuid, BEACON_GUID targetBeaconGuid, bool hasBeaconShopItem)
{
var server_logic = GameServerApp.getServerLogic();
@@ -94,6 +129,7 @@ namespace GameServer
ntf_update_beacon_shop_item.TargetUserGuid = targetUserGuid;
ntf_update_beacon_shop_item.TargetBeaconGuid = targetBeaconGuid;
ntf_update_beacon_shop_item.HasBeaconShopItem = hasBeaconShopItem == true ? BoolType.True : BoolType.False;
rabbit_mq_4_game.sendMessageToExchangeAllGame(ntf_packet);
}
@@ -112,7 +148,7 @@ namespace GameServer
item_attrib.ItemStackCount = itemStackCount;
item_attrib.Level = beacon_shop_item_attrib.Level;
item_attrib.Attributes = beacon_shop_item_attrib.Attributes.Select(x => x).ToList();
item_attrib.EquipedIvenType = beacon_shop_item_attrib.EquipedIvenType;
item_attrib.EquipedInvenType = beacon_shop_item_attrib.EquipedInvenType;
item_attrib.EquipedPos = beacon_shop_item_attrib.EquipedPos;
return itemDoc;

8
GameServer/Contents/BeaconShop/Log/BeaconShopBusinessLogHelper.cs
View File

@@ -6,14 +6,14 @@ namespace GameServer
{
static public class BeaconShopBusinessLogHelper
{
static public BeaconShopLogData toLogInfo(BeaconShopMongoDoc beaconShopMongoDoc)
static public BeaconShopLogData toLogInfo(BeaconShopMongoDoc beaconShopMongoDoc, bool isActiveSelling)
{
var logData = new BeaconShopLogData();
logData.setInfo(beaconShopMongoDoc);
logData.setInfo(beaconShopMongoDoc, isActiveSelling);
return logData;
}
static public void setInfo(this BeaconShopLogData logData, BeaconShopMongoDoc beaconShopMongoDoc)
static public void setInfo(this BeaconShopLogData logData, BeaconShopMongoDoc beaconShopMongoDoc, bool isActiveSelling)
{
logData.ItemGuid = beaconShopMongoDoc.ItemGuid;
logData.TagId = beaconShopMongoDoc.TagId;
@@ -28,6 +28,7 @@ namespace GameServer
logData.BeaconMyHomeGuid = beaconShopMongoDoc.BeaconMyHomeGuid;
logData.SellingFinishTime = beaconShopMongoDoc.SellingFinishTime;
logData.BuyerGuid = string.Empty;
logData.IsActiveSelling = isActiveSelling;
}
static public BeaconShopLogData toLogInfo(BeaconShopItemAttribute beaconShopItemAttribute, UgcNpcAttribute ugcNpcAttribute, string buyerGuid)
@@ -51,6 +52,7 @@ namespace GameServer
logData.BeaconMyHomeGuid = ugcNpcAttribute.LocatedInstanceGuid;
logData.SellingFinishTime = beaconShopItemAttribute.SellingFinishTime;
logData.BuyerGuid = buyerGuid;
logData.IsActiveSelling = beaconShopItemAttribute.IsActiveSelling;
}
static public BeaconShopSoldRecordLogData toLogInfo(BeaconShopSoldRecordAttribute beaconShopSoldRecordAttribute)

7
GameServer/Contents/BeaconShop/PacketHandler/BeaconShopNotifyHelper.cs
View File

@@ -5,9 +5,9 @@ namespace GameServer
{
public static class BeaconShopNotifyHelper
{
public static bool send_S2C_NTF_BEACON_SHOP_REFRESH(this Player player, BEACON_GUID beaconGuid)
public static bool send_S2C_NTF_BEACON_SHOP_REFRESH(this Player player, BEACON_GUID beaconGuid, BoolType hasBeaconShopItem)
{
var noti_packet = makeAckBeaconShopRefreshPacket(beaconGuid);
var noti_packet = makeAckBeaconShopRefreshPacket(beaconGuid, hasBeaconShopItem);
if (false == GameServerApp.getServerLogic().onSendPacket(player, noti_packet))
{
@@ -17,13 +17,14 @@ namespace GameServer
return true;
}
public static ClientToGame makeAckBeaconShopRefreshPacket(BEACON_GUID beaconGuid)
public static ClientToGame makeAckBeaconShopRefreshPacket(BEACON_GUID beaconGuid, BoolType hasBeaconShopItem)
{
var noti_packet = new ClientToGame();
noti_packet.Message = new();
noti_packet.Message.NtfBeaconShopRefresh = new();
noti_packet.Message.NtfBeaconShopRefresh.BeaconGuid = beaconGuid;
noti_packet.Message.NtfBeaconShopRefresh.HasBeaconShopItem = hasBeaconShopItem;
return noti_packet;
}

2
GameServer/Contents/Craft/Action/CraftAction.cs
View File

@@ -908,7 +908,7 @@ namespace GameServer
foreach (var craft in craftList)
{
var craft_attribute = craft.getOriginEntityAttribute<CraftAttribute>();
var craft_attribute = craft.getEntityAttribute<CraftAttribute>();
NullReferenceCheckHelper.throwIfNull(craft_attribute, () => $"craft_attribute is null !!!");
craft_attribute.CraftFinishTime = DateTimeHelper.Current;

44
GameServer/Contents/GameMode/Action/GameGameObjectAction.cs Normal file
View File

@@ -0,0 +1,44 @@
using System.Collections.Concurrent;
using GameServer.Contents.GameMode.InteractionObject;
using GameServer.Contents.GameMode.Manage.PlayManage;
using MetaAssets;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Action;
public class GameGameObjectAction : EntityActionBase, IGameObject
{
//todo : 장르별로 구분할 필요 있으면 depth 하나 더 둔다.
protected EGameObjectType m_object_type = EGameObjectType.None;
public GameGameObjectAction (EntityBase owner, EGameObjectType objectType)
: base(owner)
{
m_object_type = objectType;
}
public virtual Task<Result> interact(string anchorGuid, DateTime interactionTime)
{
Log.getLogger().error($"interact Not implemant, {toBasicString()}");
throw new NotImplementedException();
}
public override Task<Result> onInit()
{
Log.getLogger().error($"onInit Not implemant, {toBasicString()}");
throw new NotImplementedException();
}
public override void onClear()
{
Log.getLogger().error($"onClear Not implemant, {toBasicString()}");
throw new NotImplementedException();
}
public override string toBasicString()
{
return $"GameObjectType : {m_object_type}, " + base.toBasicString();
}
}

8
GameServer/Contents/GameMode/Helper/GameModeConstants.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace GameServer.Contents.GameMode.Helper;
public class GameModeConstants
{
public static readonly int GAME_MODE_DEFAULT_INTERVAL_MSECS = 200;
public static readonly int GAME_MODE_RUN_RACE_CHECK_INTERVAL_MSECS = 200;
public static readonly int GAME_MODE_TPS_FFA_CHECK_INTERVAL_MSECS = 200;
}

253
GameServer/Contents/GameMode/Helper/GameModeHelper.cs
View File

@@ -1,4 +1,11 @@
using Google.Protobuf;
using GameServer.Contents.GameMode.Manage;
using GameServer.Contents.GameMode.Manage.LeaveManage;
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using GameServer.Contents.GameMode.Mode_Battle.ModeFreeForAll.Manage;
using GameServer.Contents.GameMode.Mode_Running.Manage;
using GameServer.Contents.GameMode.Mode_Running.ModeRace.Manage;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
@@ -15,57 +22,243 @@ namespace GameServer;
public class GameModeHelper
{
public static (Result, IGameModeJoinHandler) getGameModeJoinHandler(InstanceRoom instanceRoom, EPlaceType placeType)
public static (Result, IGameModeJoinHandler) getGameModeJoinHandler(InstanceRoom instanceRoom, int gameModeId, string roomId)
{
(var genre_type, var mode_type) = getGameModeMeta(gameModeId, roomId);
var result = new Result();
switch (placeType)
switch (mode_type)
{
case EPlaceType.BattleRoom:
return (result, new BattleInstanceJoinHandler(instanceRoom));
case EPlaceType.ArcadeRunning:
return (result, new ArcadeRunningInstanceJoinHandler(instanceRoom));
case EPlaceType.GameRoom:
return (result, new GameRoomJoinHandler(instanceRoom));
case GameModeType.TPS_FFA:
return (result, new TPSFreeForAllJoinHandler(instanceRoom));
case GameModeType.TPS_TDM:
return (result, new TPSTeamDeathMatchJoinHandler(instanceRoom));
case GameModeType.RUN_ADV:
return (result, new RunAdventureJoinHandler(instanceRoom));
case GameModeType.RUN_RACE:
return (result, new RunRaceJoinHandler(instanceRoom));
//case GameModeType.DANCE_:
// return (result, new (instanceRoom));
default:
var err_msg = $"invalid placeType in this mode!!!! placeType : {placeType}";
var err_msg = $"invalid gameMode !!! gameModeId : {gameModeId}";
result.setFail(ServerErrorCode.GameModeJoinHandlerNotExist, err_msg);
return (result, new BattleInstanceJoinHandler(instanceRoom));
return (result, new TPSFreeForAllJoinHandler(instanceRoom));
}
}
public static (Result, IGameModeInitHandler) getGameModeInitHandler(InstanceRoom instanceRoom, EPlaceType placeType)
public static (Result, IGameModeInitHandler) getGameModeInitHandler(InstanceRoom instanceRoom, int gameModeId, string roomId)
{
(var genre_type, var mode_type) = getGameModeMeta(gameModeId, roomId);
var result = new Result();
switch (placeType)
switch (mode_type)
{
case EPlaceType.BattleRoom:
return (result, new BattleInstanceInitHandler(instanceRoom));
case EPlaceType.ArcadeRunning:
return (result, new ArcadeRunningInstanceInitHandler(instanceRoom));
case EPlaceType.GameRoom:
return (result, new GameRoomInitHandler(instanceRoom));
case GameModeType.TPS_FFA:
return (result, new TPSFreeForAllInitHandler(instanceRoom));
case GameModeType.TPS_TDM:
return (result, new TPSTeamDeathMatchInitHandler(instanceRoom));
case GameModeType.RUN_ADV:
return (result, new RunAdventureInitHandler(instanceRoom));
case GameModeType.RUN_RACE:
return (result, new RunRaceInitHandler(instanceRoom));
default:
var err_msg = $"getGameModeInitHandler not!!!! placeType : {placeType}";
var err_msg = $"getGameModeInitHandler not exist!!!! mode_type : {mode_type}";
result.setFail(ServerErrorCode.GameModeInitHandlerNotExist, err_msg);
return (result, new BattleInstanceInitHandler(instanceRoom));
return (result, new TPSFreeForAllInitHandler(instanceRoom));
}
}
public static (Result, IGameModeJoinSuccessHandler?) getGameModeJoinSuccessHandler(Player player, InstanceRoom instanceRoom, EPlaceType placeType)
public static (Result, IGameModeJoinSuccessHandler?) getGameModeJoinSuccessHandler(Player player, InstanceRoom instanceRoom, int gameModeId, string roomId)
{
var result = new Result();
switch (placeType)
(var genre_type, var mode_type) = getGameModeMeta(gameModeId, roomId);
switch (mode_type)
{
case EPlaceType.BattleRoom:
return (result, new BattleInstanceJoinSuccessHandler(player, instanceRoom));
case EPlaceType.ArcadeRunning:
return (result, new ArcadeRunningInstanceJoinSuccessHandler(player, instanceRoom));
case EPlaceType.GameRoom:
return (result, new GameRoomJoinSuccessHandler(player, instanceRoom));
case GameModeType.TPS_FFA:
return (result, new TPSFreeForAllJoinSuccessHandler(player, instanceRoom));
case GameModeType.TPS_TDM:
return (result, new TPSTeamDeathMatchJoinSuccessHandler(player, instanceRoom));
case GameModeType.RUN_ADV:
return (result, new RunAdventureJoinSuccessHandler(player, instanceRoom));
case GameModeType.RUN_RACE:
return (result, new RunRaceJoinSuccessHandler(player, instanceRoom));
default:
var err_msg = $"getGameModeInitHandler not!!!! placeType : {placeType}";
var err_msg = $"getGameModeInitHandler not exist !!!! mode_type : {mode_type}";
result.setFail(ServerErrorCode.GameModeJoinSuccessHandlerNotExist, err_msg);
return (result, null);
}
}
public static (Result, IGameMode?) createGameMode(InstanceRoom instanceRoom, GameModeType modeType)
{
var result = new Result();
switch (modeType)
{
case GameModeType.TPS_FFA:
return (result, new GameModeTPSFreeForAll<GameModeTPSFreeForAllData>(new GameModeTPSFreeForAllData(), instanceRoom));
case GameModeType.TPS_TDM:
return (result, new GameModeTPSTeamDeathMatch<GameModeTPSTeamDeathMatchData>(new GameModeTPSTeamDeathMatchData(), instanceRoom));
case GameModeType.RUN_ADV:
return (result, new GameModeRunAdventure<GameModeRunAdventureData>(new GameModeRunAdventureData(), instanceRoom));
case GameModeType.RUN_RACE:
return (result, new GameModeRunRace<GameModeRunRaceData>(new GameModeRunRaceData(), instanceRoom));
default:
var err_msg = $"createGameMode not exist !!!! mode_type : {modeType}";
result.setFail(ServerErrorCode.GameModeCreateFail, err_msg);
return (result, null);
}
}
public static (Result, IGameModeLeaveHandler?) getGameModeLeaveHandler(Player player, string roomId)
{
var result = new Result();
(var genre_type, var mode_type) = getGameModeMeta(1, roomId);
switch (mode_type)
{
case GameModeType.TPS_FFA:
return (result, new TPSFreeForAllLeaveHandler(player, roomId));
case GameModeType.TPS_TDM:
return (result, new TPSTeamDeathMatchLeaveHandler(player, roomId));
case GameModeType.RUN_ADV:
return (result, new RunAdventureLeaveHandler(player, roomId));
case GameModeType.RUN_RACE:
return (result, new RunRaceLeaveHandler(player, roomId));
default:
var err_msg = $"getGameModeInitHandler not exist !!!! mode_type : {mode_type}";
result.setFail(ServerErrorCode.GameModeJoinSuccessHandlerNotExist, err_msg);
return (result, null);
}
}
public static (Result, IGameModeDestroyHandler?) getGameModeDestroyHandler(string roomId)
{
var result = new Result();
(var genre_type, var mode_type) = getGameModeMeta(1, roomId);
switch (mode_type)
{
case GameModeType.TPS_FFA:
return (result, new TPSFreeForAllDestroyHandler(roomId));
case GameModeType.TPS_TDM:
return (result, new TPSTeamDeathMatchDestroyHandler(roomId));
case GameModeType.RUN_ADV:
return (result, new RunAdventureDestroyHandler(roomId));
case GameModeType.RUN_RACE:
return (result, new RunRaceDestroyHandler(roomId));
default:
var err_msg = $"getGameModeInitHandler not exist !!!! mode_type : {mode_type}";
result.setFail(ServerErrorCode.GameModeJoinSuccessHandlerNotExist, err_msg);
return (result, null);
}
}
public static IHostMigrator createHostMigrator(int gameModeId)
{
var result = new Result();
(var genre_type, var mode_type) = getGameModeMeta(gameModeId, "battle"); //kihoon 임시 마이그레이터 나중에 수정 필요
switch (mode_type)
{
case GameModeType.TPS_FFA:
//return HostMigrationFactory.createCommonHostMigrator((int) BattlePlayMode.PodCombat, GameServerApp.getServerLogic());
return new BattleFFAModeHostMigrator();
default:
Log.getLogger().error($"createHostMigrator Not implements mode : {mode_type}");
return new BattleFFAModeHostMigrator();
}
}
public static (GameGenreType genreType, GameModeType modeType) getGameModeMeta(int gameModeId, string roomid)
{
// kihoon todo : Meta에서 데이터 가져와야 한다.
// kihoon todo : Meta가 없을경우의 result 처리 필요
//kihoon todo : roomid 는 임시 나중에 mode id로 넣어서 처리 해줘야 된다.
if (roomid.Contains("battle"))
{
return (GameGenreType.TPS, GameModeType.TPS_FFA);
}
else if (roomid.Contains("1017101"))
{
return (GameGenreType.Running, GameModeType.RUN_RACE);
}
return (GameGenreType.TPS, GameModeType.TPS_FFA);
}
public static GameModeBase toGameModeBase(IGameMode gameMode)
{
var game_mode_base = gameMode as GameModeBase;
NullReferenceCheckHelper.throwIfNull(game_mode_base, () => $"game_mode_base is null !!!");
return game_mode_base;
}
public static async Task<Result> leaveGameInstanceRoom(string userGuid, string roomId)
{
var result = new Result();
var err_msg = string.Empty;
var server_logic = GameServerApp.getServerLogic();
var instance_room_storage = new InstanceRoomStorage();
instance_room_storage.Init(server_logic.getRedisDb(), "");
await instance_room_storage.leaveInstanceRoom(userGuid, roomId);
var instance_room_id_base = getInstanceRoomIdBaseFromInstanceRoomId(roomId);
await instance_room_storage.decreaseInstanceRoomScore(instance_room_id_base, roomId);
return result;
}
public static string getInstanceRoomIdBaseFromInstanceRoomId(string instanceRoomId)
{
var instance_room_Id_element = instanceRoomId.Split(":");
if (instance_room_Id_element.Length >= 2)
{
return $"{instance_room_Id_element[0]}:{instance_room_Id_element[1]}";
}
Log.getLogger().error($"Instance room id weired : {instanceRoomId}");
return string.Empty;
}
public static IGameObject? getObjectInteractAction(GameModeBase gameModeBase, Anchor anchor)
{
var entity_type = gameModeBase.getEntityType();
switch (entity_type)
{
case EntityType.GameModeTpsfreeForAll:
//kihoon todo : table id 넘겨서 pickup, combat, weapon, buff, 인지 전달 받아야 된다.
return getTpsFreeForAllInteractAction(gameModeBase, anchor);
case EntityType.GameModeTpsteamDeathMatch:
return getTpsTeamDeathMatchInteractAction(gameModeBase, anchor);
case EntityType.GameModeRunAdventure:
return getRunAcventureInteractAction(gameModeBase, anchor);
case EntityType.GameModeRunRace:
return getRunRaceInteractAction(gameModeBase, anchor);
default:
return null;
}
}
public static IGameObject? getRunRaceInteractAction(GameModeBase gameModeBase, Anchor anchor)
{
//kihoon todo :현재 savePoint 밖에 없어서 그거 넘긴다.
return gameModeBase.getEntityAction<RaceGameObjectSavePointInteractAction>();
}
public static IGameObject? getTpsFreeForAllInteractAction(GameModeBase gameModeBase, Anchor anchor)
{
return null;
}
public static IGameObject? getTpsTeamDeathMatchInteractAction(GameModeBase gameModeBase, Anchor anchor)
{
return null;
}
public static IGameObject? getRunAcventureInteractAction(GameModeBase gameModeBase, Anchor anchor)
{
return null;
}
}

35
GameServer/Contents/GameMode/Helper/GameNotifyHelper.cs Normal file
View File

@@ -0,0 +1,35 @@
using Google.Protobuf.WellKnownTypes;
using Newtonsoft.Json;
using ServerCore;
namespace GameServer.Contents.GameMode.Helper;
public class GameNotifyHelper
{
public static void broadcast_GS2C_NTF_GAME_STATE_UPDATE(InstanceRoom instanceRoom, GameModeState state, DateTime nextUpdatableTime)
{
var ntf = makeNtfGameStateUpdate(instanceRoom, state, nextUpdatableTime);
Log.getLogger().debug($"broadcast_GS2C_NTF_BATTLE_INSTANCE_STATE ntf instanceRoom Id : {instanceRoom.getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfGameStateUpdate)}");
instanceRoom.Broadcast(ntf);
}
public static void send_GS2C_NTF_GAME_STATE_UPDATE(Player player, InstanceRoom instanceRoom, GameModeState state, DateTime nextUpdatableTime)
{
var ntf = makeNtfGameStateUpdate(instanceRoom, state, nextUpdatableTime);
Log.getLogger().debug($"send_GS2C_NTF_GAME_STATE_UPDATE ntf instanceRoom Id : {instanceRoom.getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfGameStateUpdate)}");
GameServerApp.getServerLogic().onSendPacket(player, ntf);
}
public static ClientToGame makeNtfGameStateUpdate(InstanceRoom instanceRoom, GameModeState state, DateTime nextUpdatableTime)
{
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
ntf.Message.NtfGameStateUpdate = new ClientToGameMessage.Types.GS2C_NTF_GAME_STATE_UPDATE_NOTI();
ntf.Message.NtfGameStateUpdate.CurrentState = state;
ntf.Message.NtfGameStateUpdate.NextUpdatableTime = Timestamp.FromDateTime(nextUpdatableTime);
return ntf;
}
}

76
GameServer/Contents/GameMode/InteractionObject/GameObject.cs Normal file
View File

@@ -0,0 +1,76 @@
using GameServer.Contents.GameMode.Manage.PlayManage;
using MetaAssets;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.InteractionObject;
public class GameObject : EntityBase
{
public EntityType m_type = EntityType.None;
public string m_anchor_guid { get; set; } = string.Empty;
public DateTime m_active_time { get; set; } = DateTimeHelper.Current;
public bool m_is_active { get; set; } = true;
public GameObject(EntityType type, string guid) : base(type)
{
m_type = type;
m_anchor_guid = guid;
}
public GameObject(EntityType type, string guid, bool isActive) : base(type)
{
m_type = type;
m_anchor_guid = guid;
m_is_active = isActive;
}
}
public class GameObjectSavePoint : GameObject
{
public GameObjectSavePoint(string anchorGuid) : base(EntityType.GameObjectSavePoint, anchorGuid)
{
}
}
public class GameObjectWeapon : GameObject
{
public GameObjectWeapon(string anchorGuid) : base(EntityType.GameObjectWeapon, anchorGuid)
{
}
}
public class GameObjectBuff : GameObject
{
public GameObjectBuff(string anchorGuid) : base(EntityType.GameObjectBuff, anchorGuid)
{
}
}
public class GameObjectPodStorage : GameObject
{
public GameObjectPodStorage(string anchorGuid) : base(EntityType.GameObjectPodStorage, anchorGuid)
{
}
}
public class GameObjectCombatPod : GameObject
{
public GameObjectCombatPod(string anchorGuid) : base(EntityType.GameObjectCombatPod, anchorGuid)
{
}
}
public class GameObjectPickupPod : GameObject
{
public GameObjectPickupPod(string anchorGuid) : base(EntityType.GameObjectPickupPod, anchorGuid)
{
}
}

30
GameServer/Contents/GameMode/Manage/GameModeInitHandlerBase.cs
View File

@@ -1,30 +0,0 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public abstract class GameModeInitHandlerBase : IGameModeInitHandler
{
protected readonly EPlaceType m_place_type;
protected readonly InstanceRoom m_instance_room;
public GameModeInitHandlerBase(InstanceRoom instanceRoom, EPlaceType placeType)
{
m_instance_room = instanceRoom;
m_place_type = placeType;
}
public abstract Result gamedModeInstanceInitValidate();
public abstract Result gamedModeInstanceInit();
}

30
GameServer/Contents/GameMode/Manage/GameModeJoinHandlerBase.cs
View File

@@ -1,30 +0,0 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public abstract class GameModeJoinHandlerBase : IGameModeJoinHandler
{
protected readonly InstanceRoom m_instance_room;
protected readonly EPlaceType m_place_type = EPlaceType.NONE;
public GameModeJoinHandlerBase(InstanceRoom instanceRoom, EPlaceType placeType)
{
m_instance_room = instanceRoom;
m_place_type = placeType;
}
public abstract Result gamedModeInstanceJoinValidate(EPlaceType placeType); //kihoon todo : 여기에 나중에 EPlaceType 대신 GameModeType이란걸 넣어야 한다.
public abstract Result gamedModeInstanceJoin(Player player);
}

24
GameServer/Contents/GameMode/Manage/GameRoomInitHandler.cs
View File

@@ -1,24 +0,0 @@
using ServerCommon;
namespace GameServer;
public class GameRoomInitHandler : GameModeInitHandlerBase
{
public GameRoomInitHandler(InstanceRoom instanceRoom) : base(instanceRoom, EPlaceType.GameRoom)
{
}
public override Result gamedModeInstanceInitValidate()
{
var result = new Result();
return result;
}
public override Result gamedModeInstanceInit()
{
var result = new Result();
return result;
}
}

27
GameServer/Contents/GameMode/Manage/GameRoomJoinHandler.cs
View File

@@ -1,27 +0,0 @@
using ServerCommon;
namespace GameServer;
public class GameRoomJoinHandler : GameModeJoinHandlerBase
{
public GameRoomJoinHandler(InstanceRoom instanceRoom) : base(instanceRoom, EPlaceType.GameRoom)
{
}
public override Result gamedModeInstanceJoinValidate(EPlaceType placeType)
{
var result = new Result();
return result;
}
public override Result gamedModeInstanceJoin(Player player)
{
var result = new Result();
string err_msg = string.Empty;
return result;
}
}

13
GameServer/Contents/GameMode/Manage/IGameModeJoinHandler.cs
View File

@@ -1,13 +0,0 @@

using ServerCore;
using ServerBase;
using ServerCommon;
namespace GameServer;
public interface IGameModeJoinHandler
{
public Result gamedModeInstanceJoinValidate(EPlaceType placeType); //kihoon todo : 여기에 나중에 EPlaceType 대신 GameModeType이란걸 넣어야 한다.
public Result gamedModeInstanceJoin(Player player);
}

55
GameServer/Contents/GameMode/Manage/JoinManage/GameModeInitHandlerBase.cs Normal file
View File

@@ -0,0 +1,55 @@
using GameServer.Contents.GameMode.Helper;
using GameServer.Contents.GameMode.Manage;
using GameServer.Contents.GameMode.Manage.PlayManage;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer;
public abstract class GameModeInitHandlerBase : IGameModeInitHandler
{
protected readonly GameModeType m_game_mode_type;
protected readonly InstanceRoom m_instance_room;
public GameModeInitHandlerBase(InstanceRoom instanceRoom, GameModeType gameModeType)
{
m_instance_room = instanceRoom;
m_game_mode_type = gameModeType;
}
public abstract Result gamedModeInstanceInitValidate();
public virtual async Task<Result> gamedModeInstanceInit()
{
var result = await GameModeManager.It.createGameMode(m_instance_room, m_game_mode_type); //kihoon todo : 이렇게 짜는게 맞는지...고민좀 해보자
if (result.isFail()) return result;
var room_id = m_instance_room.getMap().m_room_id;
if(false == GameModeManager.It.tryGetGameMode(room_id, out var gameMode))
{
var err_msg = $"game_mode is null !!!! gameModeType : {m_game_mode_type}, instanceRoomId : {room_id}";
Log.getLogger().error(err_msg);
result.setFail(ServerErrorCode.GameModeClassIsNull, err_msg);
return result;
}
var initializer = gameMode as IInitializer;
NullReferenceCheckHelper.throwIfNull(initializer, () => $"initializer is null !!! casting error");
var gamd_mod_base = gameMode as GameModeBase;
NullReferenceCheckHelper.throwIfNull(gamd_mod_base, () => $"gamd_mod_base is null !!! casting error");
//모드별로 필요한 내용 초기화
using (var releaser = await gamd_mod_base.getAsyncLock())
{
if (gamd_mod_base.isLoadCompleted()) return result;
result = await initializer.onInit();
if (result.isFail()) return result;
}
return result;
}
}

20
GameServer/Contents/GameMode/Manage/JoinManage/GameModeJoinHandlerBase.cs Normal file
View File

@@ -0,0 +1,20 @@
using ServerCommon;
namespace GameServer.Contents.GameMode.Manage;
public abstract class GameModeJoinHandlerBase : IGameModeJoinHandler
{
protected readonly InstanceRoom m_instance_room;
protected readonly GameModeType m_game_mode_type;
public GameModeJoinHandlerBase(InstanceRoom instanceRoom, GameModeType gameModeType)
{
m_instance_room = instanceRoom;
m_game_mode_type = gameModeType;
}
public abstract Result gamedModeInstanceJoinValidate();
public abstract Result gamedModeInstanceJoin(Player player);
}

22
GameServer/Contents/GameMode/Manage/GameModeJoinSuccessHandlerBase.cs → GameServer/Contents/GameMode/Manage/JoinManage/GameModeJoinSuccessHandlerBase.cs
View File

@@ -1,29 +1,21 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
namespace GameServer.Contents.GameMode.Manage;
public abstract class GameModeJoinSuccessHandlerBase : IGameModeJoinSuccessHandler
{
protected Player m_player;
//protected InstanceRoom m_instance_room;
protected EPlaceType m_place_type;
protected GameModeType m_game_mode_type;
protected List<ILogInvoker> m_log_invorkers;
protected InstanceRoom m_instance_room;
public GameModeJoinSuccessHandlerBase(Player player, EPlaceType placeType)
public GameModeJoinSuccessHandlerBase(Player player, GameModeType gameModeType, InstanceRoom instanceRoom)
{
m_player = player;
//m_instance_room = instanceRoom;
m_place_type = placeType;
m_game_mode_type = gameModeType;
m_log_invorkers = new();
m_instance_room = instanceRoom;
}
public async Task<Result> joinSuccess()

2
GameServer/Contents/GameMode/Manage/IGameModeInitHandler.cs → GameServer/Contents/GameMode/Manage/JoinManage/IGameModeInitHandler.cs
View File

@@ -3,5 +3,5 @@
public interface IGameModeInitHandler
{
public Result gamedModeInstanceInitValidate();
public Result gamedModeInstanceInit();
public Task<Result> gamedModeInstanceInit();
}

9
GameServer/Contents/GameMode/Manage/JoinManage/IGameModeJoinHandler.cs Normal file
View File

@@ -0,0 +1,9 @@
using ServerCommon;
namespace GameServer.Contents.GameMode.Manage;
public interface IGameModeJoinHandler
{
public Result gamedModeInstanceJoinValidate();
public Result gamedModeInstanceJoin(Player player);
}

3
GameServer/Contents/GameMode/Manage/IGameModeJoinSuccessHandler.cs → GameServer/Contents/GameMode/Manage/JoinManage/IGameModeJoinSuccessHandler.cs
View File

@@ -1,5 +1,4 @@

namespace GameServer;
namespace GameServer.Contents.GameMode.Manage;
public interface IGameModeJoinSuccessHandler
{

76
GameServer/Contents/GameMode/Manage/LeaveManage/GameModeDestroyHandlerBase.cs Normal file
View File

@@ -0,0 +1,76 @@
using GameServer.Contents.GameMode.Manage.PlayManage;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Manage.LeaveManage;
public abstract class GameModeDestroyHandlerBase : IGameModeDestroyHandler
{
protected readonly GameModeType m_game_mode_type;
protected string m_room_id;
protected IGameMode? m_game_mode;
public GameModeDestroyHandlerBase(string roomId, GameModeType gameModeType)
{
m_game_mode_type = gameModeType;
m_room_id = roomId;
}
public abstract Task<Result> postDestroy(IGameMode gameMode);
public async Task<Result> gameModeDestroy()
{
var result = new Result();
if (false == GameModeManager.It.tryGetGameMode(m_room_id, out var gameMode))
{
var err_msg = $"game_mode is null !!!! gameModeType : {m_game_mode_type}, instanceRoomId : {m_room_id}";
Log.getLogger().error(err_msg);
result.setFail(ServerErrorCode.GameModeClassIsNull, err_msg);
return result;
}
var game_mode_base = gameMode as GameModeBase;
NullReferenceCheckHelper.throwIfNull(game_mode_base, () => $"game_mode_base is null !!! casting error");
using (var releaser = await game_mode_base.getAsyncLock())
{
var ticker = game_mode_base.getEntityTicker();
if (ticker is not null)
{
try
{
ticker.cancel();
ticker = null;
}
catch(Exception e)
{
var err_msg = $"Exception !!!, Failed to cancel ||| : Exception:{e}";
Log.getLogger().debug(err_msg);
}
}
//모드별 destroy 처리
await postDestroy(gameMode);
if (false == GameModeManager.It.tryRemoveGameMode(m_room_id, out var _))
{
var err_msg = $"game_mode is null !!!! gameModeType : {m_game_mode_type}, instanceRoomId : {m_room_id}";
Log.getLogger().warn(err_msg);
}
}
return result;
}
}

125
GameServer/Contents/GameMode/Manage/LeaveManage/GameModeLeaveHandlerBase.cs Normal file
View File

@@ -0,0 +1,125 @@
using GameServer.Contents.GameMode.Helper;
using GameServer.Contents.GameMode.Manage.PlayManage;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Manage.LeaveManage;
public abstract class GameModeLeaveHandlerBase : IGameModeLeaveHandler
{
protected readonly GameModeType m_game_mode_type;
protected Player m_player;
protected string m_room_id;
public GameModeLeaveHandlerBase(Player player, string roomId, GameModeType gameModeType)
{
m_game_mode_type = gameModeType;
m_player = player;
m_room_id = roomId;
}
public virtual async Task<Result> gameModeLeave()
{
var result = new Result();
if (false == GameModeManager.It.tryGetGameMode(m_room_id, out var gameMode))
{
var err_msg = $"battle_instance_room is null : room_id - {m_room_id}";
Log.getLogger().error(err_msg);
result.setFail(ServerErrorCode.BattleInstanceInfoNotExist, err_msg);
return result;
}
await removeUserFromInstanceRoom(m_player, gameMode);
await leaveGameZone(gameMode);
await removeHost(gameMode);
result = await postLeave(gameMode);
if(result.isFail()) return result;
result = await notifyAfterLeave(gameMode);
if(result.isFail()) return result;
result = await logAfterLeave(gameMode);
if(result.isFail()) return result;
await destroyCheck(gameMode);
return result;
}
public async Task removeUserFromInstanceRoom(Player player, IGameMode gameMode)
{
var game_mode_base = GameModeHelper.toGameModeBase(gameMode);
await Task.CompletedTask;
var instance_room = game_mode_base.getInstanceRoom();
var user_guid = player.getUserGuid();
var result = instance_room.getMap().tryRemovePlayer(player);
if (result.isFail()) return;
await GameModeHelper.leaveGameInstanceRoom(user_guid, m_room_id);
}
public async Task removeHost(IGameMode gameMode)
{
var game_mode_base = GameModeHelper.toGameModeBase(gameMode);
var host_user_guid = game_mode_base.m_host_migrator.getHostUserGuid();
if (m_player.getUserGuid().Equals(host_user_guid))
{
using (var releaser = await game_mode_base.getAsyncLock())
{
game_mode_base.m_host_migrator.removeHost();
}
}
}
public async Task leaveGameZone(IGameMode gameMode)
{
var game_mode_base = GameModeHelper.toGameModeBase(gameMode);
await Task.CompletedTask;
var location_attribute = m_player.getEntityAttribute<LocationAttribute>();
NullReferenceCheckHelper.throwIfNull(location_attribute, () => $"LocationAttribute is null !!! - player:{m_player.toBasicString()}");
location_attribute.CurrentIndunLocation.clear();
var game_zone_action = m_player.getEntityAction<GameZoneAction>();
await game_zone_action.tryLeaveGameZone();
var instance_room = game_mode_base.getInstanceRoom();
if (instance_room.SessionCount + instance_room.getMap().getCurrCountAsAddConnectedUser() > 0)
{
ClientToGame clientToGame = new ClientToGame();
clientToGame.Message = new ClientToGameMessage();
clientToGame.Message.LeaveInstanceRoomMember = new ClientToGameMessage.Types.LeaveInstanceRoomMember();
clientToGame.Message.LeaveInstanceRoomMember.MemberGuid = m_player.getUserGuid();
instance_room.Broadcast(clientToGame);
}
}
public async Task destroyCheck(IGameMode gameMode)
{
var game_mode_base = GameModeHelper.toGameModeBase(gameMode);
if (game_mode_base.getInstanceRoom().isDestroy)
{
(var result, var destroy_handler) = GameModeHelper.getGameModeDestroyHandler(game_mode_base.getRoomId());
if (result.isSuccess() && destroy_handler is not null)
{
await destroy_handler.gameModeDestroy();
}
}
await Task.CompletedTask;
}
public abstract Task<Result> postLeave(IGameMode gameMode);
public abstract Task<Result> notifyAfterLeave(IGameMode gameMode);
public abstract Task<Result> logAfterLeave(IGameMode gameMode);
}

7
GameServer/Contents/GameMode/Manage/LeaveManage/IGameModeDestroyHandler.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace GameServer.Contents.GameMode.Manage.LeaveManage;
public interface IGameModeDestroyHandler
{
Task<Result> gameModeDestroy();
}

6
GameServer/Contents/GameMode/Manage/LeaveManage/IGameModeLeaveHandler.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace GameServer.Contents.GameMode.Manage.LeaveManage;
public interface IGameModeLeaveHandler
{
Task<Result> gameModeLeave();
}

135
GameServer/Contents/GameMode/Manage/PlayManage/GameModeBase.cs Normal file
View File

@@ -0,0 +1,135 @@
using Amazon.DynamoDBv2.Model;
using GameServer.Contents.GameMode.Helper;
using GameServer.Contents.GameMode.Manage.StateManage;
using NeoSmart.AsyncLock;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Manage.PlayManage;
public abstract class GameModeBase : EntityBase, IGameMode, IWithLogActor
{
protected bool m_is_init_completed = false;
protected InstanceRoom m_instance_room;
public readonly IHostMigrator m_host_migrator;
protected EntityTicker? m_ticker;
protected Int32 m_ticker_interval_msecs = GameModeConstants.GAME_MODE_DEFAULT_INTERVAL_MSECS;
protected IGameModeState? m_current_game_mode_state; //kihoon todo: 이거 수정해야된다. IGameMode를 받으면 안될듯...아니면 받더래도
public GameModeBase(EntityType type, InstanceRoom instanceRoom) : base(type)
{
m_is_init_completed = false;
m_instance_room = instanceRoom;
ArgumentNullReferenceCheckHelper.throwIfNull(instanceRoom, () => $"GameModeBase constructor instanceRoom is null !!!");
m_host_migrator = HostMigrationFactory.createCommonHostMigrator(1, GameServerApp.getServerLogic()); //kihoon todo : gamemodeID를 넘겨야 한다;
}
public override async Task<Result> onInit()
{
var result = new Result();
//action 추가
addEntityActions();
//GameModeBase 쪽 로직 더 넣을것 있으면 여기에
result = await base.onInit();
if (result.isFail()) return result;
//init이 다 되면 ticker 만든다.
result = await createTask();
if (result.isFail()) return result;
//타이머 생성후 초기해야될 것이 있으면 한다.
await initAfterTimerCreate();
m_is_init_completed = true;
return result;
}
public void addEntityActions()
{
}
public string getRoomId()
{
return m_instance_room.getMap().m_room_id;
}
private async Task<Result> createTask()
{
var result = new Result();
m_ticker = createTaskTicker();
NullReferenceCheckHelper.throwIfNull(m_ticker, () => $"m_ticker is null !!! - id");
await m_ticker.onInit();
await Task.CompletedTask;
return result;
}
public EntityTicker createTaskTicker() //나중에 모드별로 별도 정의 필요하면 그때 virtual로
{
var ticker = new GameModeLifeCycleTicker(this, m_ticker_interval_msecs, gameModeTaskTick);
return ticker;
}
private async Task gameModeTaskTick()
{
if (!m_is_init_completed) return;
try
{
await taskUpdate();
}
catch(Exception e)
{
Log.getLogger().error($"Exception !!!, new gameModeTaskTick() : exception:{e}, basicString : {toBasicString()}");
}
}
public abstract Task taskUpdate();
public abstract Task initAfterTimerCreate();
public override string toBasicString()
{
var basic_string = base.toBasicString() + $"GameModeBase.... room_id : {getRoomId()}";
return basic_string;
}
public bool isLoadCompleted()
{
return m_is_init_completed;
}
public IGameModeState getGameModeState()
{
NullReferenceCheckHelper.throwIfNull(m_current_game_mode_state, () => $"m_current_game_mode_state is null !!");
return m_current_game_mode_state;
}
public void setGameModeState(IGameModeState state)
{
m_current_game_mode_state = state;
}
public InstanceRoom getInstanceRoom() => m_instance_room;
public EntityTicker? getEntityTicker() => m_ticker;
public ILogActor toLogActor()
{
var server_logic = GameServerApp.getServerLogic();
var region_id = server_logic.getServerConfig().getRegionId();
var server_name = server_logic.getServerName();
var log_info = new BattleInstanceActorLog(region_id, server_name, getRoomId(), m_instance_room.getInstanceId());
return log_info;
}
}

54
GameServer/Contents/GameMode/Manage/PlayManage/GameModeLifeCycleTicker.cs Normal file
View File

@@ -0,0 +1,54 @@
using System.Diagnostics;
using Amazon.Runtime;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer;
public class GameModeLifeCycleTicker : EntityTicker
{
private Func<Task> m_task_tick;
public GameModeLifeCycleTicker(EntityBase parent, Int32 onTickIntervalMilliseconds, Func<Task> taskTick)
: base(EntityType.GameModeLifeCycleTicker, parent, onTickIntervalMilliseconds, null)
{
m_task_tick = taskTick;
}
public override async Task onTaskTick()
{
var result = new Result();
var err_msg = string.Empty;
Stopwatch? stopwatch = null;
var event_tid = string.Empty;
var server_logic = GameServerApp.getServerLogic();
var server_config = server_logic.getServerConfig();
var seasonPassManager = server_logic.getSeasonPassManager();
if (true == server_config.PerformanceCheckEnable)
{
event_tid = System.Guid.NewGuid().ToString("N");
stopwatch = Stopwatch.StartNew();
}
//logic 처리
await m_task_tick();
if (null != stopwatch)
{
var elapsed_msec = stopwatch.ElapsedMilliseconds;
stopwatch.Stop();
Log.getLogger().debug($"{GetType()} Ticker Stopwatch Stop : ETID:{event_tid}, ElapsedMSec:{elapsed_msec}, TickIntervalMSec:{getOnTickIntervalMilliseconds()}");
}
}
public override string toBasicString()
{
return $"{this.getTypeName()}";
}
public override string toSummaryString()
{
return $"{this.getTypeName()}";
}
}

71
GameServer/Contents/GameMode/Manage/PlayManage/GameModeManager.cs Normal file
View File

@@ -0,0 +1,71 @@
using System.Collections.Concurrent;
using System.Diagnostics.CodeAnalysis;
using GameServer.Contents.GameMode.Helper;
using GameServer.Contents.GameMode.Manage.PlayManage;
using ServerCore;
using NeoSmart.AsyncLock;
using ServerBase;
using ServerCommon;
namespace GameServer;
public class GameModeManager : Singleton<GameModeManager>
{
private AsyncLock m_lock = new();
private ConcurrentDictionary<string, IGameMode> m_game_modes = new(); /**/
public async Task onInit()
{
//1. 이벤트 관리하는 Task 추가
//var result = await createBattleEventCheckerTask(); //kihoon todo : 이부분은 GameModeEventCheckerTask라는 걸로 변경 처리 해준다. 여기서 처리 안해줄수 도 있다.
await Task.CompletedTask;
}
public async Task<Result> createGameMode(InstanceRoom instanceRoom, GameModeType gameModeType)
{
(var result, var game_mode) = GameModeHelper.createGameMode(instanceRoom, gameModeType);
if (result.isFail()) return result;
if (game_mode is null)
{
var err_msg = $"game_mode is null !!!! gameModeType : {gameModeType}, instanceRoomId : {instanceRoom.getMap().m_room_id}";
Log.getLogger().error(err_msg);
result.setFail(ServerErrorCode.GameModeClassIsNull, err_msg);
return result;
}
var room_id = instanceRoom.getMap().m_room_id;
if (false == tryAdd(room_id, game_mode))
{
//이미 들어가져 있으므로 로그만 남겨놓고 리턴
Log.getLogger().warn($"game_mode already exist...... gameModeType : {gameModeType}, instanceRoomId : {instanceRoom.getMap().m_room_id}");
}
await Task.CompletedTask;
return result;
}
public bool tryGetGameMode(string roomId, [MaybeNullWhen(false)] out IGameMode gameMode)
{
var ret = m_game_modes.TryGetValue(roomId, out gameMode);
if (ret == false)
{
var err_msg = $"gameMode is null : room_id - {roomId}";
Log.getLogger().error(err_msg);
}
return ret;
}
public bool tryRemoveGameMode(string roomId, [MaybeNullWhen(false)] out IGameMode gameMode)
{
return m_game_modes.TryRemove(roomId, out gameMode);
}
public bool tryAdd(string roomId, IGameMode gameMode)
{
return m_game_modes.TryAdd(roomId, gameMode);
}
}

6
GameServer/Contents/GameMode/Manage/PlayManage/IDeadHandler.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace GameServer.Contents.GameMode.Manage.PlayManage;
public interface IDeadHandler
{
}

6
GameServer/Contents/GameMode/Manage/PlayManage/IGameMode.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace GameServer.Contents.GameMode.Manage.PlayManage;
public interface IGameMode
{
}

6
GameServer/Contents/GameMode/Manage/PlayManage/IGameModeGenre.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace GameServer.Contents.GameMode.Manage.PlayManage;
public interface IGameModeGenre
{
}

6
GameServer/Contents/GameMode/Manage/PlayManage/IGameObject.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace GameServer.Contents.GameMode.Manage.PlayManage;
public interface IGameObject
{
Task<Result> interact(string anchorGuid, DateTime interactionTime);
}

42
GameServer/Contents/GameMode/Manage/StateManage/GameModeStateBase.cs Normal file
View File

@@ -0,0 +1,42 @@
using GameServer.Contents.GameMode.Manage.PlayManage;
using ServerCore;
namespace GameServer.Contents.GameMode.Manage.StateManage;
public abstract class GameModeStateBase : IGameModeState
{
protected IGameMode m_game_mode;
protected GameModeBase m_game_mode_base;
private GameModeState m_state = GameModeState.None;
protected DateTime m_next_state_change_time;
public GameModeStateBase(IGameMode gameMode, GameModeState state)
{
m_game_mode = gameMode;
var game_mode_base = m_game_mode as GameModeBase;
NullReferenceCheckHelper.throwIfNull(game_mode_base, () => $"game_mode_base is null !!");
m_game_mode_base = game_mode_base;
m_next_state_change_time = DateTimeHelper.Current.AddSeconds(10); //kihoon todo: 대기시간은 나중에 meta로 반영해야 된다.
m_state = state;
}
public abstract void enter();
public abstract void update();
public abstract void exit();
public abstract GameModeState checkState();
public GameModeState getStateType()
{
return m_state;
}
public DateTime getNextStateChangeTime()
{
return m_next_state_change_time;
}
}

14
GameServer/Contents/GameMode/Manage/StateManage/IGameModeState.cs Normal file
View File

@@ -0,0 +1,14 @@
using GameServer.Contents.GameMode.Manage.PlayManage;
namespace GameServer;
public interface IGameModeState
{
public void enter();
public void exit();
public void update();
public GameModeState checkState();
public GameModeState getStateType();
}

179
GameServer/Contents/GameMode/Mode-Battle/Cheat/BattleCheat.cs
View File

@@ -1,179 +0,0 @@
using Nettention.Proud;
using ServerCore;
using ServerBase;
using ServerCommon;
namespace GameServer;
[ChatCommandAttribute("battleinstanceinit", typeof(CheatBattleInstanceInit), AuthAdminLevelType.Developer,
AuthAdminLevelType.GmNormal, AuthAdminLevelType.GmSuper)]
public class CheatBattleInstanceInit : ChatCommandBase
{
public override async Task invoke(Player player, string token, string[] args)
{
Log.getLogger().info($"battleinstanceinit");
var server_logic = GameServerApp.getServerLogic();
var room_id = player.getCurrentInstanceRoomId();
if (room_id.Equals(string.Empty))
{
Log.getLogger().error($"cheat:battleinstanceinit.... this cheat only use in instance");
return;
}
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (battle_instance_room is null)
{
Log.getLogger().error($"cheat:battleinstanceinit.... battle_instance_room is null room_id : {room_id}");
return;
}
using (var releaser = await battle_instance_room.getAsyncLock())
{
var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
if (false == attribute.m_combat_pod_mode.m_round_state_type.Equals(BattleRoundStateType.RoundEndAll) &&
false == attribute.m_combat_pod_mode.m_round_state_type.Equals(BattleRoundStateType.Destroyed))
{
Log.getLogger().error($"cheat:battleinstanceinit.... this cheat only RoundEndAll room_id : {room_id}");
return;
}
var now = DateTimeHelper.Current;
battle_instance_room.setEventStartTime(now);
attribute.m_combat_pod_mode.m_round_state_type = BattleRoundStateType.Rounding;
attribute.m_combat_pod_mode.m_current_state_start_time = now;
attribute.m_combat_pod_mode.m_current_round = 1;
attribute.m_combat_pod_mode.m_charged_step = 0;
attribute.m_combat_pod_mode.m_rewarded_step = 0;
attribute.m_combat_pod_mode.m_pod_combat.setActive(now);
(Result result, var anchor_guid) =
BattleRoomHelper.getRandomCombatPodAnchorGuid(attribute, battle_instance_room);
if (result.isFail())
{
Log.getLogger().error("get Random pod combat anchor guid faile !!! ");
return;
}
attribute.m_combat_pod_mode.m_pod_combat.m_source_storage_anchor_guid = anchor_guid;
BattleRoomNotifyHelper.broadcast_GS2C_NTF_BATTLE_INSTANCE_STATE(battle_instance_room);
var update_action = battle_instance_room.getEntityAction<BattleInstanceUpdateAction>();
NullReferenceCheckHelper.throwIfNull(update_action, () => $"attribute is null !!!");
update_action.battleObjectStateInitAndNotify(battle_instance_room, attribute);
BattleRoomNotifyHelper.broadcast_GS2C_NTF_POD_COMBAT_STATE(battle_instance_room);
}
}
}
[ChatCommandAttribute("gamemodeoccupyhost", typeof(BattleHostOccupy), AuthAdminLevelType.Developer,
AuthAdminLevelType.GmNormal, AuthAdminLevelType.GmSuper)]
public class BattleHostOccupy : ChatCommandBase
{
public override async Task invoke(Player player, string token, string[] args)
{
//Log.getLogger().info($"battleinstanceinit");
var server_logic = GameServerApp.getServerLogic();
var room_id = player.getCurrentInstanceRoomId();
if (room_id.Equals(string.Empty))
{
Log.getLogger().error($"cheat:gamemodeoccupyhost.... this cheat only use in instance");
return;
}
//kihoon todo : 임시 분기 처리
//나중에 게임모드로 분리되면 그때 재작업
if (room_id.Contains("battle"))
{
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (battle_instance_room is null)
{
Log.getLogger().error($"cheat:gamemodeoccupyhost.... battle_instance_room is null room_id : {room_id}");
return;
}
using (var releaser = await battle_instance_room.getAsyncLock())
{
battle_instance_room.m_host_migrator.modifyHost(player.getUserGuid());
}
BattleRoomNotifyHelper.broadcast_GS2C_NTF_P2P_HOST_UPDATE(battle_instance_room.m_instance_room,
player.getUserGuid());
}
else if (room_id.Contains("1017101"))
{
var instance_room = InstanceRoomManager.Instance.getInstanceRoomByRoomId(room_id);
if (instance_room is null)
{
Log.getLogger().error($"cheat:gamemodeoccupyhost.... instance_room is null room_id : {room_id}");
return;
}
BattleRoomNotifyHelper.broadcast_GS2C_NTF_P2P_HOST_UPDATE(instance_room, player.getUserGuid());
}
}
}
//======================================================================================================================
//
//======================================================================================================================
[ChatCommandAttribute("gamehostmigration", typeof(BattleHostMigration), AuthAdminLevelType.Developer,
AuthAdminLevelType.GmNormal, AuthAdminLevelType.GmSuper)]
public class BattleHostMigration : ChatCommandBase
{
public override async Task invoke(Player player, string token, string[] args)
{
Log.getLogger().info($"gamehostmigration");
var server_logic = GameServerApp.getServerLogic();
var room_id = player.getCurrentInstanceRoomId();
if (room_id.Equals(string.Empty))
{
Log.getLogger().error($"cheat:gamehostmigration.... this cheat only use in instance");
return;
}
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (battle_instance_room is null)
{
Log.getLogger().error($"cheat:gamehostmigration.... battle_instance_room is null room_id : {room_id}");
return;
}
using var releaser = await battle_instance_room.getAsyncLock();
if (battle_instance_room.m_host_migrator is CommonHostMigrator common_hot_migrator)
{
common_hot_migrator.HostMigrationSystem.setIgnoreMigrationCondition(true);
common_hot_migrator.migrateCheck(true);
var super_peer_guid_id = common_hot_migrator.getHostUserGuid();
BattleRoomNotifyHelper.broadcast_GS2C_NTF_P2P_HOST_UPDATE(
battle_instance_room.m_instance_room, super_peer_guid_id);
common_hot_migrator.HostMigrationSystem.setIgnoreMigrationCondition(false);
}
else
{
Log.getLogger()
.error(
$"cheat:gamehostmigration.... battle_instance_room is not CommonHostMigrator room_id : {room_id}");
}
}
}

37
GameServer/Contents/GameMode/Mode-Battle/Manage/BattleInstanceInitHandler.cs
View File

@@ -1,37 +0,0 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class BattleInstanceInitHandler : GameModeInitHandlerBase
{
public BattleInstanceInitHandler(InstanceRoom instanceRoom) : base(instanceRoom, EPlaceType.BattleRoom)
{
}
public override Result gamedModeInstanceInitValidate()
{
var result = BattleRoomHelper.checkBattleActive(m_place_type);
return result;
}
public override Result gamedModeInstanceInit()
{
var result = BattleInstanceManager.It.battleInstanceInit(m_instance_room, m_instance_room.getMap().m_room_id).Result; //kihoon todo :이거 리팩토링 대상
if (result.isFail())
{
Log.getLogger().error(result.toBasicString());
}
return result;
}
}

47
GameServer/Contents/GameMode/Mode-Battle/Manage/BattleInstanceJoinHandler.cs
View File

@@ -1,47 +0,0 @@

using ServerCore;
using ServerBase;
using ServerCommon;
namespace GameServer;
public class BattleInstanceJoinHandler : GameModeJoinHandlerBase
{
public BattleInstanceJoinHandler(InstanceRoom instanceRoom) : base(instanceRoom, EPlaceType.BattleRoom)
{
}
public override Result gamedModeInstanceJoinValidate(EPlaceType placeType)
{
var result = BattleRoomHelper.checkBattleActive(m_place_type);
return result;
}
public override Result gamedModeInstanceJoin(Player player)
{
var result = new Result();
string err_msg = string.Empty;
//instanceroom 정보는 남아있는데 battleinstance만 없어지는 케이스가 있어서 예외 처리를 위해 넣어놓음
var room_id = m_instance_room.getMap().m_room_id;
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id); //리팩토링 대상
if (battle_instance_room is null)
{
Log.getLogger().error($"Battle Room Instance is null.. so init start roomId : {room_id}");
result = Task.Run(() => BattleInstanceManager.It.battleInstanceInit(m_instance_room, room_id)).GetAwaiter().GetResult();
if (result.isFail())
{
err_msg = $"BattleIntanceJoin init error, _roomId : {room_id}";
Log.getLogger().error(err_msg);
return result;
}
}
return result;
}
}

326
GameServer/Contents/GameMode/Mode-Battle/Manage/BattleInstanceManager.cs
View File

@@ -1,18 +1,18 @@
using System.Collections.Concurrent;
using System.Diagnostics.CodeAnalysis;
using GameServer.Contents.Battle.Tickers;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using Google.Protobuf.WellKnownTypes;
using NeoSmart.AsyncLock;
using Newtonsoft.Json;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using Constant = System.Reflection.Metadata.Constant;
namespace GameServer;
@@ -20,191 +20,19 @@ namespace GameServer;
public class BattleInstanceManager : Singleton<BattleInstanceManager>
{
private AsyncLock m_lock_init = new();
public AsyncLock m_lock_data_load = new();
private ConcurrentDictionary<string, BattleInstanceRoom> m_battle_instances = new(); //인스턴스 생성 삭제를 주로 관리 하기 위한 Dictionary ... 아...이거 구조 별론데,....
//private ConcurrentDictionary<string, BattleInstanceRoom> m_battle_instances = new(); //인스턴스 생성 삭제를 주로 관리 하기 위한 Dictionary ... 아...이거 구조 별론데,....
private ConcurrentDictionary<Int32 /*event_id*/, SystemBattleEvent> m_battle_events = new();
public async Task onInit()
{
//1. 이벤트 관리하는 Task 추가
var result = await createBattleEventCheckerTask();
}
public bool hasBattleInstance(string roomId)
{
return m_battle_instances.ContainsKey(roomId);
}
public BattleInstanceRoom? getBattleInstanceRoom(string roomId)
{
if (false == m_battle_instances.TryGetValue(roomId, out var room))
{
return null;
}
return room;
}
public ConcurrentDictionary<string, BattleInstanceRoom> getBattleInstanceRooms()
{
return m_battle_instances;
}
//
// public bool isLoadComplete(string roomId)
// {
// if (false == m_battle_instances.TryGetValue(roomId, out var battleInstanceRoom))
// {
// return false;
// }
// return battleInstanceRoom.m_is_load_complete;
// }
public async Task<Result> battleInstanceInit(InstanceRoom instanceRoom, string roomId)
{
var result = new Result();
var err_msg = string.Empty;
using (await m_lock_init.LockAsync())
{
//1. 배틀 인스턴스에 대한 정보 생성
Log.getLogger().info($"Battle Instance Create And Init : {roomId}");
if (hasBattleInstance(roomId)) return result;
// instance 정보 추가 등록
var server_logic = GameServerApp.getServerLogic();
var instance_room_storage = new InstanceRoomStorage();
instance_room_storage.Init(server_logic.getRedisDb(), "");
DateTime start_time = DateTimeHelper.Current;
Int32 config_id = 1;
Int32 reward_id = 1;
Int32 hot_time = 1;
Int32 round_count = 8;
var system_battle_event = BattleRoomHelper.getBattleRoomStartTimeByEventId(roomId);
if (system_battle_event is null)
{
Log.getLogger().error($"system_battle_event is null!!! : {result.toBasicString()} - instanceRoomId:{roomId}");
}
else
{
start_time = system_battle_event.m_start_time;
config_id = system_battle_event.m_ffa_config_data_id;
reward_id = system_battle_event.m_ffa_reward_group_id;
hot_time = system_battle_event.m_ffa_hot_time;
round_count = system_battle_event.m_round_count;
}
result = await instance_room_storage.setInstanceRoomExtraInfo(roomId, EPlaceType.BattleRoom, start_time);
if (result.isFail())
{
Log.getLogger().error($"Failed to BattleRoom setInstanceRoomExtraInfo() !!! : {result.toBasicString()} - instanceRoomId:{roomId}");
return result;
}
BattleInstanceRoom battle_instance_room = new BattleInstanceRoom(instanceRoom, start_time, config_id, reward_id, hot_time, round_count);
if (false == m_battle_instances.TryAdd(roomId, battle_instance_room))
{
//이미 존재하는 경우는 onInit 절차를 거쳤다고 생각하고, init 처리 안해주고 리턴
err_msg = $"Battle Instance Room Already exist room_id : {roomId}";
result.setFail(ServerErrorCode.BattleInstanceInfoAlreadyExist, err_msg);
Log.getLogger().warn(result.toBasicString());
return result;
}
//2. 초기화
result = await battle_instance_room.init();
if (result.isFail())
{
Log.getLogger().warn(result.toBasicString());
return result;
}
}
Log.getLogger().info($"battleInstanceInit done roomId : {roomId}");
return result;
}
public Result addOrUpatePlayer(string roomId, Player player)
{
var result = new Result();
string err_msg = string.Empty;
if (false == m_battle_instances.TryGetValue(roomId, out var battle_instance_room))
{
err_msg = $"m_battle_instances not exist battleRoomInstance, roomId : {roomId}";
result.setFail(ServerErrorCode.BattleInstanceInfoNotExist, err_msg);
Log.getLogger().error(result.toBasicString());
return result;
}
//유저 정보 추가 해줘야 한다.
result = battle_instance_room.AddOrUpdatePlayer(player);
return result;
}
private async Task<Result> createBattleEventCheckerTask()
{
var result = new Result();
var battle_entity_ticker_initializers = new Initializers();
//채널 인던 다 필요한가?
//이벤트 인스턴스 관련 생성 삭제에 대한 관리 Ticker
//battle_entity_ticker_initializers.appendInitializer(new BattleEventCheckTicker(1000, null));
//battle_entity_ticker_initializers.appendInitializer(new BattleEventNotifyTicker(ServerCommon.Constant.EVENT_UPDATE_INTERVAL_MMIN, null));
result = await battle_entity_ticker_initializers.init("BattleEntityTickers");
if (result.isFail())
{
Log.getLogger().error($"Failed to init() !!! : {result.toBasicString()}");
return result;
}
var battle_event_check_ticker = new BattleEventCheckTicker(BattleConstant.BATTLE_EVENT_CHECK_INTERVAL, null);
await battle_event_check_ticker.onInit();
await createTask(battle_event_check_ticker);
var battle_event_notify_ticker = new BattleEventNotifyTicker(ServerCommon.Constant.EVENT_UPDATE_INTERVAL_MMIN, null);
await battle_event_check_ticker.onInit();
await createTask(battle_event_notify_ticker);
return result;
}
private async Task<Result> createTask(EntityTicker ticker)
{
var result = new Result();
await Task.CompletedTask;
try
{
new PeriodicTaskTimer( ticker.getTypeName() , ticker.getOnTickIntervalMilliseconds(), ticker.getCancelToken(), ticker.onTaskTick);
Log.getLogger().debug("createTask done");
}
catch(Exception e)
{
var err_msg = $"Exception !!!, new PeriodicTaskTimer() : exception:{e}";
result.setFail(ServerErrorCode.TryCatchException, err_msg);
return result;
}
return result;
}
public async Task tryLeaveBattelInstance(Player player, string instanceRoomId)
{
if (false == BattleRoomHelper.checkBattleActive()) return;
Log.getLogger().debug($"tryLeaveBattelInstance start instanceRoomId : {instanceRoomId}");
var location_attribute = player.getEntityAttribute<LocationAttribute>();
@@ -214,87 +42,74 @@ public class BattleInstanceManager : Singleton<BattleInstanceManager>
if (instanceRoomId == string.Empty)
{
Log.getLogger().warn($"tryLeaveBattelInstance IntanceRoomId is Empty");
removeBattlePlayer(player.getUserGuid());
return;
}
if (false == m_battle_instances.TryGetValue(instanceRoomId, out var battleInstanceRoom))
if (false == GameModeManager.It.tryGetGameMode(instanceRoomId, out var gameMode))
{
removeBattlePlayer(player.getUserGuid());
return;
}
var ffa = gameMode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!! - {player.toBasicString()}");
await ffa.removePodCombat(player);
await battleInstanceRoom.removePodCombat(player);
var host_user_guid = battleInstanceRoom.m_host_migrator.getHostUserGuid();
var host_user_guid = ffa.m_host_migrator.getHostUserGuid();
if (player.getUserGuid().Equals(host_user_guid))
{
using (var releaser = await battleInstanceRoom.getAsyncLock())
using (var releaser = await ffa.getAsyncLock())
{
battleInstanceRoom.m_host_migrator.removeHost();
ffa.m_host_migrator.removeHost();
}
}
//여기서 instanceroom 이 is Destroy 면 DestroyBattleRoom 호출 해줄것
if (battleInstanceRoom.m_instance_room.isDestroy)
if (ffa.getInstanceRoom().isDestroy)
{
m_battle_instances.TryRemove(instanceRoomId, out var _);
await battleInstanceRoom.destroyBattleRoom();
//kihoon todo : 이부분 수정 필요
//m_battle_instances.TryRemove(instanceRoomId, out var _);
//await battleInstanceRoom.destroyBattleRoom();
Log.getLogger().debug($"tryLeaveBattelInstance destroy battle room instanceRoomId : {instanceRoomId}");
}
}
public async Task tryDestroyBattleRoom(string instanceRoomId)
{
if (false == BattleRoomHelper.checkBattleActive()) return;
if (false == instanceRoomId.Contains(BattleConstant.PREFIX_BATTLE_INSTANCE_ROOM_ID)) return;
if (false == m_battle_instances.TryGetValue(instanceRoomId, out var battleInstanceRoom))
{
Log.getLogger().error($"instanceRoomId : {instanceRoomId} is not exist instnaces");
return;
}
var is_destroy = battleInstanceRoom.m_instance_room.isDestroy;
if (is_destroy)
{
await battleInstanceRoom.destroyBattleRoom();
m_battle_instances.TryRemove(instanceRoomId, out _);
}
}
// public async Task tryDestroyBattleRoom(string instanceRoomId)
// {
// await Task.CompletedTask;
// if (false == instanceRoomId.Contains(BattleConstant.PREFIX_BATTLE_INSTANCE_ROOM_ID)) return;
//
// // if (false == m_battle_instances.TryGetValue(instanceRoomId, out var battleInstanceRoom))
// // {
// // Log.getLogger().error($"instanceRoomId : {instanceRoomId} is not exist instnaces");
// // return;
// // }
//
// // var is_destroy = battleInstanceRoom.m_instance_room.isDestroy;
// // if (is_destroy)
// // {
// // await battleInstanceRoom.destroyBattleRoom();
// // //m_battle_instances.TryRemove(instanceRoomId, out _);
// // }
// }
private void removeBattlePlayer(string userGuid)
{
foreach (var battle_instance_room in m_battle_instances.Values)
{
battle_instance_room.removeBattlePlayerIfExist(userGuid);
}
}
public async Task<bool> LeaveBattleRoom(Player player, string instanceRoomId, bool disconnected = false)
{
if (false == m_battle_instances.TryGetValue(instanceRoomId, out var battleRoom))
{
Log.getLogger().info($"LeaveBattleRoom m_battle_instances.TryGetValue false instanceRoomId : {instanceRoomId}");
return false;
}
await battleRoom.LeaveBattleRoom(player, instanceRoomId, disconnected);
(var result, var leeave_handler) = GameModeHelper.getGameModeLeaveHandler(player, instanceRoomId);
if (result.isFail() || leeave_handler is null) return false;
// if (battleRoom.m_instance_room.isDestroy)
// {
// InstanceRoomManager.Instance.DestroyRoom(instanceRoomId);
// }
await leeave_handler.gameModeLeave();
Log.getLogger().debug($"leave battle room player : {player.toBasicString()}, instanceRoomId : {instanceRoomId}");
return true;
}
public async Task<Result> sendNtfAboutBattleInstance(BattleInstanceRoom battieInstanceRoom, Player player)
public async Task<Result> sendNtfAboutBattleInstance(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battieInstanceRoom, Player player)
{
var result = new Result();
@@ -313,7 +128,7 @@ public class BattleInstanceManager : Singleton<BattleInstanceManager>
}
private void sendNtfBattleObjectsState(BattleInstanceRoom battleInstanceRoom, Player player)
private void sendNtfBattleObjectsState(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, Player player)
{
List<BattleObjectInfo> infos = new();
var attribute = battleInstanceRoom.getEntityAttribute<BattleInstanceSnapshotAttribute>();
@@ -496,6 +311,55 @@ public class BattleInstanceManager : Singleton<BattleInstanceManager>
return true;
}
private async Task<Result> createBattleEventCheckerTask()
{
var result = new Result();
public BattleInstanceManager Self => this;
var battle_entity_ticker_initializers = new Initializers();
//채널 인던 다 필요한가?
//이벤트 인스턴스 관련 생성 삭제에 대한 관리 Ticker
//battle_entity_ticker_initializers.appendInitializer(new BattleEventCheckTicker(1000, null));
//battle_entity_ticker_initializers.appendInitializer(new BattleEventNotifyTicker(Constant.EVENT_UPDATE_INTERVAL_MMIN, null));
result = await battle_entity_ticker_initializers.init("BattleEntityTickers");
if (result.isFail())
{
Log.getLogger().error($"Failed to init() !!! : {result.toBasicString()}");
return result;
}
var battle_event_check_ticker = new BattleEventCheckTicker(BattleConstant.BATTLE_EVENT_CHECK_INTERVAL, null);
await battle_event_check_ticker.onInit();
await createTask(battle_event_check_ticker);
var battle_event_notify_ticker = new BattleEventNotifyTicker(ServerCommon.Constant.EVENT_UPDATE_INTERVAL_MMIN, null);
await battle_event_check_ticker.onInit();
await createTask(battle_event_notify_ticker);
return result;
}
private async Task<Result> createTask(EntityTicker ticker)
{
var result = new Result();
await Task.CompletedTask;
try
{
new PeriodicTaskTimer( ticker.getTypeName() , ticker.getOnTickIntervalMilliseconds(), ticker.getCancelToken(), ticker.onTaskTick);
Log.getLogger().debug("createTask done");
}
catch(Exception e)
{
var err_msg = $"Exception !!!, new PeriodicTaskTimer() : exception:{e}";
result.setFail(ServerErrorCode.TryCatchException, err_msg);
return result;
}
return result;
}
}

56
GameServer/Contents/GameMode/Mode-Battle/Manage/BattleInstanceRoom.cs
View File

@@ -17,13 +17,13 @@ public partial class InstanceRoom
{
public async Task<bool> battleInstanceInit()
{
var result = await BattleInstanceManager.It.battleInstanceInit(this, _roomId);
if (result.isFail())
{
Log.getLogger().error(result.toBasicString());
return false;
}
// var result = await BattleInstanceManager.It.battleInstanceInit(this, _roomId);
// if (result.isFail())
// {
// Log.getLogger().error(result.toBasicString());
// return false;
// }
await Task.CompletedTask;
return true;
}
@@ -60,47 +60,5 @@ public partial class InstanceRoom
return users;
}
public async Task LeaveBattleInstanceRoom(Player player, bool disconnected)
{
var user_guid = player.getUserGuid();
Log.getLogger().info($"BattleInstanceRoom.Leave() Start !!! - userGuid:{user_guid}, instanceRoomId:{_roomId}, sessionCount:{SessionCount}, addConnectedUser:{getMap().getCurrCountAsAddConnectedUser()}");
if (m_players.TryRemove(player.getUserGuid(), out _))
{
await BattleInstanceRoomHandler.leaveBattleInstanceRoom(user_guid, _roomId);
}
var location_attribute = player.getEntityAttribute<LocationAttribute>();
NullReferenceCheckHelper.throwIfNull(location_attribute, () => $"LocationAttribute is null !!! - player:{player.toBasicString()}");
location_attribute.CurrentIndunLocation.clear();
var game_zone_action = player.getEntityAction<GameZoneAction>();
await game_zone_action.tryLeaveGameZone();
if (SessionCount + getMap().getCurrCountAsAddConnectedUser() == 0)
{
if (!_isPartyInstance || _concertEnd)
{
await destroyRoom();
}
}
else
{
{
ClientToGame clientToGame = new ClientToGame();
clientToGame.Message = new ClientToGameMessage();
clientToGame.Message.LeaveInstanceRoomMember = new ClientToGameMessage.Types.LeaveInstanceRoomMember();
clientToGame.Message.LeaveInstanceRoomMember.MemberGuid = player.getUserGuid();
Broadcast(clientToGame);
}
}
Log.getLogger().info($"InstanceRoom.Leave() Finish !!! - userGuid:{user_guid}, instanceRoomId:{_roomId}, sessionCount:{SessionCount}, addConnectedUser:{getMap().getCurrCountAsAddConnectedUser()}");
}
}

30
GameServer/Contents/GameMode/Mode-Battle/Manage/BattleInstanceRoomHandler.cs
View File

@@ -373,33 +373,7 @@ public class BattleInstanceRoomHandler
}
public static async Task<Result> leaveBattleInstanceRoom(string userGuid, string instanceRoomId)
{
var result = new Result();
var err_msg = string.Empty;
var server_logic = GameServerApp.getServerLogic();
var instance_room_storage = new InstanceRoomStorage();
instance_room_storage.Init(server_logic.getRedisDb(), "");
await instance_room_storage.leaveInstanceRoom(userGuid, instanceRoomId);
var instance_room_id_base = getInstanceRoomIdBaseFromInstanceRoomId(instanceRoomId);
await instance_room_storage.decreaseInstanceRoomScore(instance_room_id_base, instanceRoomId);
return result;
}
public static string getInstanceRoomIdBaseFromInstanceRoomId(string instanceRoomId)
{
var instance_room_Id_element = instanceRoomId.Split(":");
if (instance_room_Id_element.Length >= 2)
{
return $"{instance_room_Id_element[0]}:{instance_room_Id_element[1]}";
}
Log.getLogger().error($"Instance room id weired : {instanceRoomId}");
return string.Empty;
}
}

27
GameServer/Contents/GameMode/Mode-Battle/Manage/GameModeTPS.cs Normal file
View File

@@ -0,0 +1,27 @@
using GameServer.Contents.GameMode.Manage.PlayManage;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class GameModeTPS: GameModeBase, IGameModeGenre
{
public GameModeTPS(EntityType type, InstanceRoom instanceRoom) : base(type, instanceRoom)
{
}
public override Task taskUpdate()
{
return Task.CompletedTask;
}
public override string toBasicString()
{
var basic_string = base.toBasicString() + $"GameModeTPS....";
return basic_string;
}
public override Task initAfterTimerCreate()
{
return Task.CompletedTask;
}
}

6
GameServer/Contents/GameMode/Mode-Battle/Manage/IBattleMode.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public interface IBattleMode
{
public Task<Result> init();
}

6
GameServer/Contents/GameMode/Mode-Battle/Manage/ITPSMode.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public interface ITPSMode
{
Task<Result> initTPSMode();
}

144
GameServer/Contents/GameMode/Mode-Battle/Action/BattleInstanceAction.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Action/BattleInstanceAction.cs
View File

@@ -1,14 +1,11 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using System.Net;
using GameServer.Contents.Battle.Log;
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using MetaAssets;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using ServerCore;
namespace GameServer;
@@ -30,13 +27,13 @@ public class BattleInstanceAction : EntityActionBase
{
var result = new Result();
var battle_instance_room = getOwner() as BattleInstanceRoom;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room_owner is null !!!");
var game_mode_base = getOwner() as GameModeBase;
NullReferenceCheckHelper.throwIfNull(game_mode_base, () => $"game_mode_base is null !!!");
var server_logic = GameServerApp.getServerLogic();
var dynamodb_client = server_logic.getDynamoDbClient();
string room_id = battle_instance_room.m_instance_room.getMap().m_room_id;
string room_id = game_mode_base.getRoomId();
var config = dynamodb_client.makeQueryConfigForReadByPKSK(BattleInstanceSnapshotDoc.pk, room_id);
(result, var read_docs) = await dynamodb_client.simpleQueryDocTypesWithQueryOperationConfig<BattleInstanceSnapshotDoc>(config);
@@ -47,18 +44,18 @@ public class BattleInstanceAction : EntityActionBase
var event_id = BattleRoomHelper.getBattleEventIdFromRoomId(room_id);
BattleInstanceSnapshotDoc doc = new(room_id);
string snapshot_load_type = "LOAD";
//string snapshot_load_type = "LOAD";
if (read_docs.Count == 0 || event_id == 0)
{
//데이터가 없으므로 생성 처리
result = await createBattleInstanceSnapshot(room_id);
if (result.isFail()) return result;
snapshot_load_type = "CREATE";
// snapshot_load_type = "CREATE";
}
else if (read_docs.Count > 0)
{
doc = read_docs[0];
var battle_instance_action = battle_instance_room.getEntityAction<BattleInstanceAction>();
var battle_instance_action = game_mode_base.getEntityAction<BattleInstanceAction>();
NullReferenceCheckHelper.throwIfNull(battle_instance_action, () => $"battle_instance_action is null !!!");
result = battle_instance_action.setSnapshotFromDoc(doc);
}
@@ -66,18 +63,19 @@ public class BattleInstanceAction : EntityActionBase
if (result.isFail()) return result;
Log.getLogger().debug($"loadOrCreateSnapshot room_id : {battle_instance_room.toBasicString()}");
Log.getLogger().debug($"loadOrCreateSnapshot room_id : {game_mode_base.toBasicString()}");
var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
var attribute = game_mode_base.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
var invokers = new List<ILogInvoker>();
var log_action = new LogActionEx(LogActionType.BattleInstanceSnapshotCreate);
BattleSnapShotBusinessLog business_log = new(battle_instance_room, snapshot_load_type);
invokers.Add(business_log);
BusinessLogger.collectLogs(log_action, battle_instance_room, invokers);
//kihoon todo : 이거 Base쪽으로 올려야 된다.
//var invokers = new List<ILogInvoker>();
//var log_action = new LogAction(LogActionType.BattleInstanceSnapshotCreate);
//BattleSnapShotBusinessLog business_log = new(battle_instance_room, snapshot_load_type);
//invokers.Add(business_log);
//BusinessLogger.collectLogs(log_action, battle_instance_room, invokers);
return result;
}
@@ -90,53 +88,57 @@ public class BattleInstanceAction : EntityActionBase
BattleInstanceSnapshotDoc doc = new(roomId);
var battle_instance_room = getOwner() as BattleInstanceRoom;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room is null !!!");
var game_mode_base = getOwner() as GameModeBase;
NullReferenceCheckHelper.throwIfNull(game_mode_base, () => $"battle_instance_room is null !!!");
var game_mode_ffa = getOwner() as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(game_mode_ffa, () => $"battle_instance_room is null !!!");
var server_logic = GameServerApp.getServerLogic();
var fn_create_battle_instance_snapshot = async delegate()
{
var battle_instance_snaptshot_attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
var battle_instance_snaptshot_attribute = game_mode_base.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(battle_instance_snaptshot_attribute, () => $"battle_instance_snaptshot_attribute is null !!!");
battle_instance_snaptshot_attribute.m_room_id = roomId;
battle_instance_snaptshot_attribute.m_combat_pod_mode.m_current_state_start_time = battle_instance_room.m_battle_instance_event_start_time;
battle_instance_snaptshot_attribute.m_combat_pod_mode.m_current_state_start_time = game_mode_ffa.m_battle_instance_event_start_time;
addRespawnPosInfoFromMeta(battle_instance_room, battle_instance_snaptshot_attribute);
addStorageInfoFromMeta(battle_instance_room, battle_instance_snaptshot_attribute);
addPickupPodInfoFromMeta(battle_instance_room, battle_instance_snaptshot_attribute);
//kihoon 이거다 수정해야된다.
addRespawnPosInfoFromMeta(game_mode_ffa, battle_instance_snaptshot_attribute);
addStorageInfoFromMeta(game_mode_ffa, battle_instance_snaptshot_attribute);
addPickupPodInfoFromMeta(game_mode_ffa, battle_instance_snaptshot_attribute);
var anchors = battle_instance_room.m_instance_room.getMap().getAnchors();
var anchors = game_mode_base.getInstanceRoom().getMap().getAnchors();
foreach (var anchor in anchors)
{
addBattleObjectWeapon(battle_instance_snaptshot_attribute, anchor.Value);
addBattleObjectBuff(battle_instance_snaptshot_attribute, anchor.Value);
}
var result = await createBattleObjectCombatPod(battle_instance_room, battle_instance_snaptshot_attribute);
var result = await createBattleObjectCombatPod(game_mode_ffa, battle_instance_snaptshot_attribute);
if (result.isFail()) return result;
result = await createBattleObjectPickupPodReward(battle_instance_room, battle_instance_snaptshot_attribute);
result = await createBattleObjectPickupPodReward(game_mode_ffa, battle_instance_snaptshot_attribute);
if (result.isFail()) return result;
battle_instance_snaptshot_attribute.modifiedEntityAttribute(true);
var batch = new QueryBatchEx<QueryRunnerWithDocument>(battle_instance_room, LogActionType.BattleInstanceSnapshotCreate, server_logic.getDynamoDbClient());
//kihoon todo : 이거 수정해야된다.
var batch = new QueryBatchEx<QueryRunnerWithDocument>(game_mode_base, LogActionType.BattleInstanceSnapshotCreate, server_logic.getDynamoDbClient());
{
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
}
result = await QueryHelper.sendQueryAndBusinessLog(batch);
return result;
};
result = await battle_instance_room.runTransactionRunnerSafelyWithTransGuid(battle_instance_room.m_instance_room.getMap().m_room_id,
result = await game_mode_base.runTransactionRunnerSafelyWithTransGuid(game_mode_base.getRoomId(),
TransactionIdType.PrivateContents, BattleConstant.BATTLE_INSTANCE_TRANSACTION_NAME, fn_create_battle_instance_snapshot);
if (result.isFail())
{
var err_msg = $"Failed to runTransactionRunnerSafelyWithTransGuid() !!! : {result.toBasicString()} - CreateBattleInstanceSnapshot, {battle_instance_room.toBasicString()}";
var err_msg = $"Failed to runTransactionRunnerSafelyWithTransGuid() !!! : {result.toBasicString()} - CreateBattleInstanceSnapshot, {game_mode_base.toBasicString()}";
Log.getLogger().error(err_msg);
return result;
}
@@ -152,7 +154,7 @@ public class BattleInstanceAction : EntityActionBase
var battle_instance_snapshot_attrib = doc.getAttrib<BattleInstanceSnapshotAttrib>();
NullReferenceCheckHelper.throwIfNull(battle_instance_snapshot_attrib, () => $"battle_instance_snapshot_attrib is null !!!");
var battle_instance_room = getOwner() as BattleInstanceRoom;
var battle_instance_room = getOwner() as GameModeBase;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room is null !!!");
var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
@@ -164,25 +166,25 @@ public class BattleInstanceAction : EntityActionBase
return result;
}
private void deleteChangedGuidAnchor(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
{
deleteChangedBattleObjectPodStorageAnchor(battleInstanceRoom, attribute, attrib);
deleteChangedBattleObjectPickupPodAnchor(battleInstanceRoom, attribute, attrib);
deleteChangedRespawnAnchor(battleInstanceRoom, attribute, attrib);
deleteChangedBattleObjectWeaponAnchor(battleInstanceRoom, attribute, attrib);
deleteChangedBattleObjectBuffAnchor(battleInstanceRoom, attribute, attrib);
//pod combat은 timer에서 처리해준다.
}
// private void deleteChangedGuidAnchor(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
// {
// deleteChangedBattleObjectPodStorageAnchor(battleInstanceRoom, attribute, attrib);
// deleteChangedBattleObjectPickupPodAnchor(battleInstanceRoom, attribute, attrib);
// deleteChangedRespawnAnchor(battleInstanceRoom, attribute, attrib);
// deleteChangedBattleObjectWeaponAnchor(battleInstanceRoom, attribute, attrib);
// deleteChangedBattleObjectBuffAnchor(battleInstanceRoom, attribute, attrib);
//
// //pod combat은 timer에서 처리해준다.
// }
private void setNewGuidAnchor(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private void setNewGuidAnchor(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
addRespawnPosInfoFromMeta(battleInstanceRoom, attribute);
addStorageInfoFromMeta(battleInstanceRoom, attribute);
addPickupPodInfoFromMeta(battleInstanceRoom, attribute);
var anchors = battleInstanceRoom.m_instance_room.getMap().getAnchors();
var anchors = battleInstanceRoom.getInstanceRoom().getMap().getAnchors();
foreach (var anchor in anchors)
{
addBattleObjectWeapon(attribute, anchor.Value);
@@ -193,15 +195,15 @@ public class BattleInstanceAction : EntityActionBase
}
private void deleteChangedBattleObjectPodStorageAnchor(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
private void deleteChangedBattleObjectPodStorageAnchor(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
{
List<string> delete_keys = new();
foreach (var stand in attrib.m_combat_pod_attrib.m_pod_storages)
{
//기존에 들고 있던 guid 가 map에서 없어지거나 바뀌었을 경우가 있을수 있으므로 예외 처리
if (false == battleInstanceRoom.m_instance_room.getMap().getAnchors().ContainsKey(stand.Key))
if (false == battleInstanceRoom.getInstanceRoom().getMap().getAnchors().ContainsKey(stand.Key))
{
Log.getLogger().warn($"stand : {stand.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.m_instance_room.getMap().m_room_id}");
Log.getLogger().warn($"stand : {stand.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.getRoomId()}");
delete_keys.Add(stand.Key);
continue;
}
@@ -214,15 +216,15 @@ public class BattleInstanceAction : EntityActionBase
}
}
private void deleteChangedBattleObjectPickupPodAnchor(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
private void deleteChangedBattleObjectPickupPodAnchor(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
{
List<string> delete_keys = new();
foreach (var box in attrib.m_combat_pod_attrib.m_pickup_pods)
{
//기존에 들고 있던 guid 가 map에서 없어지거나 바뀌었을 경우가 있을수 있으므로 예외 처리
if (false == battleInstanceRoom.m_instance_room.getMap().getAnchors().ContainsKey(box.Key))
if (false == battleInstanceRoom.getInstanceRoom().getMap().getAnchors().ContainsKey(box.Key))
{
Log.getLogger().info($"box : {box.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.m_instance_room.getMap().m_room_id}");
Log.getLogger().info($"box : {box.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.getRoomId()}");
delete_keys.Add(box.Key);
continue;
}
@@ -235,7 +237,7 @@ public class BattleInstanceAction : EntityActionBase
}
}
private void deleteChangedRespawnAnchor(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
private void deleteChangedRespawnAnchor(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
{
List<string> delete_keys = new();
foreach (var each in attrib.m_combat_pod_attrib.m_respawns)
@@ -243,7 +245,7 @@ public class BattleInstanceAction : EntityActionBase
//map에 respawn pos가 없어지거나 바뀌었을 경우가 있을수 있으므로 예외 처리
if (false == battleInstanceRoom.m_respawn_pos_anchors_meta.Contains(each.Key))
{
Log.getLogger().warn($"spawn idx : {each.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.m_instance_room.getMap().m_room_id}");
Log.getLogger().warn($"spawn idx : {each.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.getRoomId()}");
delete_keys.Add(each.Key);
continue;
}
@@ -255,15 +257,15 @@ public class BattleInstanceAction : EntityActionBase
}
}
private void deleteChangedBattleObjectWeaponAnchor(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
private void deleteChangedBattleObjectWeaponAnchor(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
{
List<string> delete_keys = new();
foreach (var weapon in attrib.m_combat_pod_attrib.m_weapons)
{
//기존에 들고 있던 guid 가 map에서 없어지거나 바뀌었을 경우가 있을수 있으므로 예외 처리
if (false == battleInstanceRoom.m_instance_room.getMap().getAnchors().ContainsKey(weapon.Key))
if (false == battleInstanceRoom.getInstanceRoom().getMap().getAnchors().ContainsKey(weapon.Key))
{
Log.getLogger().warn($"weapon : {weapon.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.m_instance_room.getMap().m_room_id}");
Log.getLogger().warn($"weapon : {weapon.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.getRoomId()}");
delete_keys.Add(weapon.Key);
continue;
}
@@ -276,15 +278,15 @@ public class BattleInstanceAction : EntityActionBase
}
}
private void deleteChangedBattleObjectBuffAnchor(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
private void deleteChangedBattleObjectBuffAnchor(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, BattleInstanceSnapshotAttrib attrib)
{
List<string> delete_keys = new();
foreach (var buff in attrib.m_combat_pod_attrib.m_buffs)
{
//map에 respawn pos가 없어지거나 바뀌었을 경우가 있을수 있으므로 예외 처리
if (false == battleInstanceRoom.m_instance_room.getMap().getAnchors().ContainsKey(buff.Key))
if (false == battleInstanceRoom.getInstanceRoom().getMap().getAnchors().ContainsKey(buff.Key))
{
Log.getLogger().warn($"buff : {buff.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.m_instance_room.getMap().m_room_id}");
Log.getLogger().warn($"buff : {buff.Key} is not exist.. so don't add attribute.... roomId : {battleInstanceRoom.getInstanceRoom().getMap().m_room_id}");
delete_keys.Add(buff.Key);
continue;
}
@@ -297,7 +299,7 @@ public class BattleInstanceAction : EntityActionBase
}
}
private void addRespawnPosInfoFromMeta(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private void addRespawnPosInfoFromMeta(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var now = DateTimeHelper.Current;
@@ -308,9 +310,9 @@ public class BattleInstanceAction : EntityActionBase
}
}
private void addStorageInfoFromMeta(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private void addStorageInfoFromMeta(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> ffa, BattleInstanceSnapshotAttribute attribute)
{
foreach (var storage_group in battleInstanceRoom.m_battle_pod_storage_guid_group.Values)
foreach (var storage_group in ffa.m_battle_pod_storage_guid_group.Values)
{
foreach (var anchor_guid in storage_group)
{
@@ -319,9 +321,9 @@ public class BattleInstanceAction : EntityActionBase
}
}
private void addPickupPodInfoFromMeta(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private void addPickupPodInfoFromMeta(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> ffa, BattleInstanceSnapshotAttribute attribute)
{
foreach (var pickup_pod_group in battleInstanceRoom.m_battle_pickup_pod_guid_group.Values)
foreach (var pickup_pod_group in ffa.m_battle_pickup_pod_guid_group.Values)
{
foreach (var anchor_guid in pickup_pod_group)
{
@@ -377,7 +379,7 @@ public class BattleInstanceAction : EntityActionBase
}
private async Task<Result> createBattleObjectPickupPodReward(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private async Task<Result> createBattleObjectPickupPodReward(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var result = new Result();
@@ -389,7 +391,7 @@ public class BattleInstanceAction : EntityActionBase
return result;
}
private async Task<Result> createBattleObjectCombatPod(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private async Task<Result> createBattleObjectCombatPod(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var battle_update_action = battleInstanceRoom.getEntityAction<BattleInstanceUpdateAction>();
NullReferenceCheckHelper.throwIfNull(battle_update_action, () => $"battle_update_action is null !!!");

78
GameServer/Contents/GameMode/Mode-Battle/Action/BattleInstanceStateUpdateAction.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Action/BattleInstanceStateUpdateAction.cs
View File

@@ -1,21 +1,17 @@
using Newtonsoft.Json;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using MetaAssets;
using Newtonsoft.Json;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using ServerCore;
namespace GameServer;
public partial class BattleInstanceUpdateAction
{
private async Task<Result> battleInstanceStateUpdate(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private async Task<Result> battleInstanceStateUpdate(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var result = new Result();
var round_state = attribute.m_combat_pod_mode.m_round_state_type;
@@ -36,13 +32,13 @@ public partial class BattleInstanceUpdateAction
case BattleRoundStateType.Destroyed:
break;
default:
Log.getLogger().error($"BattleRoundStateType None error room_id : {battleInstanceRoom.m_instance_room.getMap().m_room_id}");
Log.getLogger().error($"BattleRoundStateType None error room_id : {battleInstanceRoom.getRoomId()}");
return result;
}
return result;
}
private async Task<Result> battleInstanceWaitStateUpdate(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private async Task<Result> battleInstanceWaitStateUpdate(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var result = new Result();
await Task.CompletedTask;
@@ -86,21 +82,21 @@ public partial class BattleInstanceUpdateAction
//로그 추가
var invokers = new List<ILogInvoker>();
var log_action = new LogActionEx(LogActionType.BattleRoundStateUpdate);
var log_action = new LogAction(LogActionType.BattleRoundStateUpdate.ToString());
var room_id = battleInstanceRoom.m_instance_room.getMap().m_room_id;
var room_id = battleInstanceRoom.getRoomId();
var ended_round = attribute.m_combat_pod_mode.m_current_round;
var round_state = attribute.m_combat_pod_mode.m_round_state_type;
var users = battleInstanceRoom.m_instance_room.tryGetInstanceExistUserForLog();
var users = battleInstanceRoom.getInstanceRoom().tryGetInstanceExistUserForLog();
BattleRoundUpdateBusinessLog business_log = new(room_id, ended_round, round_state, users);
invokers.Add(business_log);
BusinessLogger.collectLogs(log_action, battleInstanceRoom, invokers);
//BusinessLogger.collectLogs(log_action, battleInstanceRoom, invokers); //kihoon todo : 이거 수정해야된다.
return result;
}
private async Task<Result> battleInstanceRoundingStateUpdate(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private async Task<Result> battleInstanceRoundingStateUpdate(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var result = new Result();
@@ -122,7 +118,7 @@ public partial class BattleInstanceUpdateAction
return result;
}
private async Task roundingUpdate(BattleInstanceRoom battleInstanceRoom, DateTime roundEndTime)
private async Task roundingUpdate(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, DateTime roundEndTime)
{
var result = new Result();
string occupier_guid = string.Empty;
@@ -137,7 +133,7 @@ public partial class BattleInstanceUpdateAction
Player? rewarded_player = null;
if (!occupier_guid.Equals(string.Empty))
{
if (false == battleInstanceRoom.m_instance_room.tryGetInstanceMember(occupier_guid, out rewarded_player))
if (false == battleInstanceRoom.getInstanceRoom().tryGetInstanceMember(occupier_guid, out rewarded_player))
{
//보상은 안되더라도 라운드는 진행 가능하게 처리해야할듯...
var err_msg = $"not exist user in instance_room !!! user_guid : {occupier_guid}";
@@ -160,7 +156,7 @@ public partial class BattleInstanceUpdateAction
}
}
private async Task<Result> roundingUpdateWithReward(BattleInstanceRoom battleInstanceRoom, DateTime roundEndTime, Player player)
private async Task<Result> roundingUpdateWithReward(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, DateTime roundEndTime, Player player)
{
var result = new Result();
@@ -214,10 +210,10 @@ public partial class BattleInstanceUpdateAction
}
//로그 추가
var room_id = battleInstanceRoom.m_instance_room.getMap().m_room_id;
var room_id = battleInstanceRoom.getRoomId();
var ended_round = attribute.m_combat_pod_mode.m_current_round;
var round_state = attribute.m_combat_pod_mode.m_round_state_type;
var users = battleInstanceRoom.m_instance_room.tryGetInstanceExistUserForLog();
var users = battleInstanceRoom.getInstanceRoom().tryGetInstanceExistUserForLog();
BattleRoundUpdateBusinessLog business_log = new(room_id, ended_round, round_state, users);
batch.appendBusinessLog(business_log);
@@ -254,7 +250,7 @@ public partial class BattleInstanceUpdateAction
}
private async Task<Result> roundingUpdateWithoutReward(BattleInstanceRoom battleInstanceRoom, DateTime roundEndTime)
private async Task<Result> roundingUpdateWithoutReward(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, DateTime roundEndTime)
{
var result = new Result();
@@ -289,21 +285,21 @@ public partial class BattleInstanceUpdateAction
attribute.modifiedEntityAttribute(true);
//batch 처리
var batch = new QueryBatchEx<QueryRunnerWithDocument>(battleInstanceRoom, LogActionType.BattleRoundStateUpdate, server_logic.getDynamoDbClient());
{
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
}
// var batch = new QueryBatch<QueryRunnerWithDocument>(battleInstanceRoom, LogActionType.BattleRoundStateUpdate, server_logic.getDynamoDbClient());
// {
// batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
// }
//로그 추가
var room_id = battleInstanceRoom.m_instance_room.getMap().m_room_id;
var room_id = battleInstanceRoom.getRoomId();
var ended_round = attribute.m_combat_pod_mode.m_current_round;
var round_state = attribute.m_combat_pod_mode.m_round_state_type;
var users = battleInstanceRoom.m_instance_room.tryGetInstanceExistUserForLog();
var users = battleInstanceRoom.getInstanceRoom().tryGetInstanceExistUserForLog();
BattleRoundUpdateBusinessLog business_log = new(room_id, ended_round, round_state, users);
batch.appendBusinessLog(business_log);
//batch.appendBusinessLog(business_log); //kihoon todo : 로그랑 배치 수정해서 올려야 된다.
result = await QueryHelper.sendQueryAndBusinessLog(batch);
//result = await QueryHelper.sendQueryAndBusinessLog(batch);
await Task.CompletedTask;
if (result.isFail()) return result;
@@ -311,7 +307,7 @@ public partial class BattleInstanceUpdateAction
return result;
};
result = await battleInstanceRoom.runTransactionRunnerSafelyWithTransGuid(battleInstanceRoom.m_instance_room.getMap().m_room_id,
result = await battleInstanceRoom.runTransactionRunnerSafelyWithTransGuid(battleInstanceRoom.getRoomId(),
TransactionIdType.PrivateContents, BattleConstant.BATTLE_INSTANCE_TRANSACTION_NAME, fn_battle_round_update);
if (result.isFail())
{
@@ -332,7 +328,7 @@ public partial class BattleInstanceUpdateAction
return result;
}
private async Task stepUpdate(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, DateTime now)
private async Task stepUpdate(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, DateTime now)
{
var max_charge_level = battleInstanceRoom.m_ffa_reward_meta
.Where(kvp => kvp.Key == battleInstanceRoom.m_ffa_reward_meta.Keys.Max())
@@ -365,7 +361,7 @@ public partial class BattleInstanceUpdateAction
}
}
private async Task podCombatRewardUpdate(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, DateTime now)
private async Task podCombatRewardUpdate(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, DateTime now)
{
var occupier_guid = string.Empty;
CommonResult common_result = new();
@@ -375,7 +371,7 @@ public partial class BattleInstanceUpdateAction
occupier_guid = attribute.m_combat_pod_mode.m_pod_combat.m_current_occupier_guid;
if (occupier_guid.Equals(string.Empty)) return;
if (false == battleInstanceRoom.m_instance_room.tryGetInstanceMember(occupier_guid, out var player))
if (false == battleInstanceRoom.getInstanceRoom().tryGetInstanceMember(occupier_guid, out var player))
{
Log.getLogger().error($"Not Exist Player in battle instance room occupier_guid : {occupier_guid}");
return;
@@ -440,7 +436,7 @@ public partial class BattleInstanceUpdateAction
info.m_battle_object_type = EBattleObjectType.Pod_Combat;
List<BattleObjectLogInfo> log_infos = new();
var room_id = battleInstanceRoom.m_instance_room.getMap().m_room_id;
var room_id = battleInstanceRoom.getRoomId();
var current_round = attribute.m_combat_pod_mode.m_current_round;
var round_state_type = attribute.m_combat_pod_mode.m_round_state_type;
var business_log = new BattlePodCombatRewardBusinessLog(room_id, current_round, round_state_type
@@ -478,7 +474,7 @@ public partial class BattleInstanceUpdateAction
}
}
private async Task<Result> battleInstanceEndStateUpdate(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private async Task<Result> battleInstanceEndStateUpdate(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var result = new Result();
await Task.CompletedTask;
@@ -495,21 +491,21 @@ public partial class BattleInstanceUpdateAction
attribute.m_combat_pod_mode.m_current_state_start_time = end_time;
}
var users = battleInstanceRoom.m_instance_room.tryGetInstanceExistUserForLog();
var users = battleInstanceRoom.getInstanceRoom().tryGetInstanceExistUserForLog();
//여기서 배틀 인스턴스가 완전히 shutdown 됐다는 Noti 전달
BattleRoomNotifyHelper.broadcast_GS2C_NTF_BATTLE_INSTANCE_STATE(battleInstanceRoom);
//log 추가
var invokers = new List<ILogInvoker>();
var log_action = new LogActionEx(LogActionType.BattleRoundStateUpdate);
var log_action = new LogAction(LogActionType.BattleRoundStateUpdate.ToString());
var room_id = battleInstanceRoom.m_instance_room.getMap().m_room_id;
var room_id = battleInstanceRoom.getRoomId();
var ended_round = attribute.m_combat_pod_mode.m_current_round;
var round_state = attribute.m_combat_pod_mode.m_round_state_type;
BattleRoundUpdateBusinessLog business_log = new(room_id, ended_round, round_state, users);
invokers.Add(business_log);
BusinessLogger.collectLogs(log_action, battleInstanceRoom, invokers);
//BusinessLogger.collectLogs(log_action, battleInstanceRoom, invokers);// kihoon todo : 이거 수정해야된다.
return result;
}

178
GameServer/Contents/GameMode/Mode-Battle/Action/BattleInstanceUpdateAction.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Action/BattleInstanceUpdateAction.cs
View File

@@ -1,15 +1,12 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using GameServer.Contents.Battle.Reward;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using MetaAssets;
using Nettention.Proud;
using Newtonsoft.Json;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using ServerCore;
namespace GameServer;
@@ -21,20 +18,20 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
public override async Task<Result> onInit()
{
await Task.CompletedTask;
var result = new Result();
return result;
}
public override void onClear()
{
}
public async Task<Result> update()
{
var battle_instance_room = getOwner() as BattleInstanceRoom;
var battle_instance_room = getOwner() as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room is null !!!");
var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
@@ -45,7 +42,7 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
Log.getLogger().error($"battleObjectStateUpdate result error !!! result : {result.toBasicString()}");
return result;
}
result = await battleInstanceStateUpdate(battle_instance_room, attribute);
if (result.isFail())
{
@@ -59,41 +56,37 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
Log.getLogger().error($"battleInstancHostUpdate result error !!! result : {result.toBasicString()}");
return result;
}
return result;
}
private async Task<Result> battleInstancHostUpdate(BattleInstanceRoom battleInstanceRoom)
private async Task<Result> battleInstancHostUpdate(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
var result = new Result();
string host_user_guid = string.Empty;
var is_migrated = false;
using (var releaser = await battleInstanceRoom.getAsyncLock())
{
//이미 host 지정이 끝났으면 리턴
//kihoon todo : 일단 계속 체크해서 호스트가 얼마나 바뀌는지 확인 해보고 적절한 주기 찾아볼것
//if (!battleInstanceRoom.m_host_migrator.getHostUserGuid().Equals(string.Empty)) return result;
var host_migrator = battleInstanceRoom.m_host_migrator;
// TODO : 인터페이스 변경 예정
(result, is_migrated) = host_migrator.migrateCheck();
//kihoon todo : 일단 계속 체크해서 호스트가 얼마나 바뀌는지 확인 해보고 적절한 주기 찾아볼것
if (!battleInstanceRoom.m_host_migrator.getHostUserGuid().Equals(string.Empty)) return result;
var p2p_group_id = battleInstanceRoom.getInstanceRoom().getMap().getP2PGroupId();
result = battleInstanceRoom.m_host_migrator.defineHost(p2p_group_id, new SuperPeerSelectionPolicy(), new HostID[1]);
if (result.isFail()) return result;
if (is_migrated)
{
host_user_guid = host_migrator.getHostUserGuid();
}
host_user_guid = battleInstanceRoom.m_host_migrator.getHostUserGuid();
Log.getLogger().info($"battleInstancHost set complete host_user_guid : {host_user_guid}");
}
if (is_migrated)
{
Log.getLogger().info($"battleInstancHost set complete host_user_guid : {host_user_guid}");
BattleRoomNotifyHelper.broadcast_GS2C_NTF_P2P_HOST_UPDATE(battleInstanceRoom.m_instance_room, host_user_guid);
}
BattleRoomNotifyHelper.broadcast_GS2C_NTF_P2P_HOST_UPDATE(battleInstanceRoom.getInstanceRoom(), host_user_guid);
return result;
}
private async Task<Result> battleObjectStateUpdate(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
private async Task<Result> battleObjectStateUpdate(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var result = new Result();
await Task.CompletedTask;
@@ -104,42 +97,42 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
using (var releaser = await battleInstanceRoom.getAsyncLock())
{
(var weapon_info, var weapon_log_info) = battleObjectWeaponStateUpdate(attribute, now);
infos.AddRange(weapon_info);
infos.AddRange(weapon_info);
log_infos.AddRange(weapon_log_info);
(var buff_info, var buff_log_info) = battleObjectBuffStateUpdate(attribute, now);
infos.AddRange(buff_info);
infos.AddRange(buff_info);
log_infos.AddRange(buff_log_info);
(var pickup_pod_info, var pickup_pod_log_info) = battleObjectPickupPodUpdate(attribute, now);
infos.AddRange(pickup_pod_info);
log_infos.AddRange(pickup_pod_log_info);
infos.AddRange(pickup_pod_info);
log_infos.AddRange(pickup_pod_log_info);
}
if (infos.Count > 0)
{
BattleRoomNotifyHelper.broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO(battleInstanceRoom, infos);
var invokers = new List<ILogInvoker>();
var log_action = new LogActionEx(LogActionType.BattleObjectStateUpdate);
var business_log = new BattleObjectStateUpdateBusinessLog(battleInstanceRoom.m_instance_room.getMap().m_room_id, log_infos);
var log_action = new LogAction(LogActionType.BattleObjectStateUpdate.ToString());
var business_log = new BattleObjectStateUpdateBusinessLog(battleInstanceRoom.getInstanceRoom().getMap().m_room_id, log_infos);
invokers.Add(business_log);
BusinessLogger.collectLogs(log_action, battleInstanceRoom, invokers);
BusinessLogger.collectLogs(log_action, battleInstanceRoom, invokers); //kihoon todo : 이거 수정해야된다.
}
return result;
}
private (List<BattleObjectInfo>, List<BattleObjectLogInfo>) battleObjectPickupPodUpdate(BattleInstanceSnapshotAttribute attribute, DateTime now)
{
// if (attribute.m_combat_pod_mode.m_round_state_type.Equals(BattleRoundStateType.RoundEndAll) ||
// if (attribute.m_combat_pod_mode.m_round_state_type.Equals(BattleRoundStateType.RoundEndAll) ||
// attribute.m_combat_pod_mode.m_round_state_type.Equals(BattleRoundStateType.Destroyed)) return new();
List<BattleObjectInfo> infos = new();
List<BattleObjectLogInfo> log_infos = new();
var battle_instance_room = getOwner() as BattleInstanceRoom;
var battle_instance_room = getOwner() as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room is null !!!");
foreach (var generated_info in attribute.m_combat_pod_mode.m_pickup_pod_generated_info)
{
var group_id = generated_info.Key.Item1;
@@ -153,24 +146,24 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
var anchor_guid = generatedInfo.m_anchor_guid;
var next_generated_time = generatedInfo.m_next_generate_time;
//아직 시간이 안됐거나, 할당된게 있으면 continue;
if (now < next_generated_time || anchor_guid.Equals(string.Empty) == false) continue;
//비어 있으면 할당 해준다. 시간체크는 보상 받았을때 해준다.
//비어 있으면 할당 해준다. 시간체크는 보상 받았을때 해준다.
(var result, var allocated_anchor_guid) = BattleRoomHelper.getRandomPickupPod(group_id, idx, battle_instance_room, attribute);
if (result.isFail())
{
Log.getLogger(result.toBasicString());
continue;
}
if(false == battle_instance_room.m_instance_room.getMap().getAnchors().TryGetValue(allocated_anchor_guid, out var anchorInfo))
if(false == battle_instance_room.getInstanceRoom().getMap().getAnchors().TryGetValue(allocated_anchor_guid, out var anchorInfo))
{
Log.getLogger().error($"not exist anchor anchor_guid : {allocated_anchor_guid}");
continue;
}
var table_id = anchorInfo.AnchorProp.TableId;
if (false == MetaData.Instance._BattleObjectSpawnGroupMetaTable.TryGetValue(table_id, out var battle_object_spawn_group))
{
@@ -179,11 +172,11 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
}
PickupPodGeneratedInfo new_generated_info = new(generated_info.Key.Item1, generated_info.Key.Item2, allocated_anchor_guid, generatedInfo.m_anchor_guid, generatedInfo.m_next_generate_time);
attribute.m_combat_pod_mode.m_pickup_pod_generated_info.AddOrUpdate(generated_info.Key, new_generated_info, (i, tuple) => new_generated_info);
attribute.m_combat_pod_mode.m_pickup_pod_generated_info.AddOrUpdate(generated_info.Key, new_generated_info, (i, tuple) => new_generated_info);
if (false == attribute.m_combat_pod_mode.m_pickup_pods.TryGetValue(allocated_anchor_guid, out var pickupPod))
{
var err_msg = $"pickup pod date not exist !! allocated_anchor_guid : {allocated_anchor_guid}, roomId : {battle_instance_room.m_instance_room.getMap().m_room_id}";
var err_msg = $"pickup pod date not exist !! allocated_anchor_guid : {allocated_anchor_guid}, roomId : {battle_instance_room.getRoomId()}";
Log.getLogger().error(err_msg);
continue;
}
@@ -194,14 +187,14 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
info.AnchorGuid = allocated_anchor_guid;
info.IsActive = pickupPod.m_is_active ? BoolType.True : BoolType.False;
infos.Add(info);
BattleObjectLogInfo log_info = new();
log_info.m_anchor_guid = pickupPod.m_anchor_guid;
log_info.m_battle_object_type = pickupPod.m_type;
log_info.m_active_time = pickupPod.m_active_time;
log_infos.Add(log_info);
}
return (infos, log_infos);
}
@@ -215,12 +208,12 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
if (buff.m_active_time <= now && buff.m_is_active == false)
{
buff.m_is_active = true;
BattleObjectInfo info = new();
info.AnchorGuid = buff.m_anchor_guid;
info.IsActive = BoolType.True;
infos.Add(info);
BattleObjectLogInfo log_info = new();
log_info.m_anchor_guid = buff.m_anchor_guid;
log_info.m_battle_object_type = buff.m_type;
@@ -241,7 +234,7 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
if (weapon.m_active_time <= now && weapon.m_is_active == false)
{
weapon.m_is_active = true;
BattleObjectInfo info = new();
info.AnchorGuid = weapon.m_anchor_guid;
info.IsActive = BoolType.True;
@@ -257,16 +250,16 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
return (infos, log_infos);
}
public Result battleObjectStateInitAndNotify(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
public Result battleObjectStateInitAndNotify(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var infos = new List<BattleObjectInfo>();
var result = new Result();
foreach (BattleObjectPodStorage storage in attribute.m_combat_pod_mode.m_pod_storages.Values)
{
storage.m_reward_cnt = 0;
storage.m_is_active = true;
BattleObjectInfo info = new();
info.AnchorGuid = storage.m_anchor_guid;
@@ -277,25 +270,25 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
return result;
}
public async Task<Result> createCombatPod(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
public async Task<Result> createCombatPod(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
await Task.CompletedTask;
var result = new Result();
var combat_pod_guid = System.Guid.NewGuid().ToString("N");
(result, var anchor_guid) = BattleRoomHelper.getRandomCombatPodAnchorGuid(attribute, battleInstanceRoom);
if (result.isFail()) return result;
attribute.m_combat_pod_mode.m_pod_combat = new BattleObjectPodCombat(combat_pod_guid, anchor_guid, DateTimeHelper.Current);
return result;
}
public async Task<Result> createPickupPodReward(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
public async Task<Result> createPickupPodReward(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
await Task.CompletedTask;
var result = new Result();
@@ -309,7 +302,7 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
foreach (var guid in pickup_pod_guids)
{
if (false == battleInstanceRoom.m_instance_room.getMap().getAnchors().TryGetValue(guid, out var anchorInfo))
if (false == battleInstanceRoom.getInstanceRoom().getMap().getAnchors().TryGetValue(guid, out var anchorInfo))
{
var err_msg = $"Not exitst anchorInfo guid : {guid}";
result.setFail(ServerErrorCode.BattleInstanceNotExistAnchors, err_msg);
@@ -325,7 +318,7 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
Log.getLogger(result.toBasicString());
continue;
}
max_reward_count = objectSpawnGroupMetaData.MaxSpawnQuantity;
break;
}
@@ -340,10 +333,10 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
}
public async Task<Result> createPickupPodRewardByGroup(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, Int32 groupId, Int32 maxRewardCount)
public async Task<Result> createPickupPodRewardByGroup(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, Int32 groupId, Int32 maxRewardCount)
{
await Task.CompletedTask;
var result = new Result();
for (int i = 0; i < maxRewardCount; i++)
{
@@ -354,7 +347,7 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
}
PickupPodGeneratedInfo new_generated_info = new(groupId, i, anchor_guid, string.Empty, DateTimeHelper.Current);
if(false == attribute.m_combat_pod_mode.m_pickup_pod_generated_info.TryGetValue((groupId, i), out var generatedInfo))
{
attribute.m_combat_pod_mode.m_pickup_pod_generated_info.TryAdd((groupId, i), new_generated_info);
@@ -363,9 +356,9 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
{
new_generated_info.m_before_anchor_guid = generatedInfo.m_anchor_guid;
}
Log.getLogger().info($"create pickup pod generation info new_generated_info : {JsonConvert.SerializeObject(new_generated_info)}");
attribute.m_combat_pod_mode.m_pickup_pod_generated_info.AddOrUpdate((groupId, i), new_generated_info, (key, tuple) => new_generated_info);
if (false == attribute.m_combat_pod_mode.m_pickup_pods.TryGetValue(anchor_guid, out var pickupPod))
{
@@ -375,9 +368,10 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
pickupPod.m_is_active = true;
}
return result;
}
public async Task<(Result, List<MetaAssets.Reward>, int, int)> podCombatUpdateIfHasOccupier(BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, Player player)
public async Task<(Result, List<MetaAssets.Reward>, int, int)> podCombatUpdateIfHasOccupier(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute, Player player)
{
var result = new Result();
var occupier_guid = attribute.m_combat_pod_mode.m_pod_combat.m_current_occupier_guid;
@@ -397,12 +391,12 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
attribute.m_combat_pod_mode.m_rewarded_step = max_charge_level;
attribute.m_combat_pod_mode.m_charged_step = max_charge_level;
return (result, rewards, rewardable_step_start, rewardable_step_end);
}
private async Task<Result> addPodCommbatOccupyReward(Player player, BattleInstanceRoom battleInstanceRoom, List<MetaAssets.Reward> rewards)
private async Task<Result> addPodCommbatOccupyReward(Player player, GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, List<MetaAssets.Reward> rewards)
{
IReward reward_proc = new RewardPodCombat(player, player.getUserGuid(), rewards);
var result = await RewardManager.It.proceedRewardProcess(reward_proc);
@@ -414,7 +408,7 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
return result;
}
private List<MetaAssets.Reward> makePodCombatOccupyReward(int start, int end, BattleInstanceRoom battleInstanceRoom)
private List<MetaAssets.Reward> makePodCombatOccupyReward(int start, int end, GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
List<MetaAssets.Reward> rewards = new();
@@ -429,27 +423,27 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
var item_id = ffaRewardData.RewardItemID;
var item_count = ffaRewardData.RewardCount * battleInstanceRoom.m_hot_time_reward;
RewardMutable reward_metable = new();
reward_metable.Item = new();
reward_metable.Item.Id = item_id;
reward_metable.Item.Count = item_count;
MetaAssets.Reward reward = new MetaAssets.Reward(reward_metable);
rewards.Add(reward);
Log.getLogger().Debug($"pod Combat reward Added step : {i}, ItemId : {item_id}, itemCount : {item_count}");
}
return rewards;
}
private List<BattleObjectInfo> battleObjectPickupPodsDeactive(BattleInstanceSnapshotAttribute attribute)
{
List<BattleObjectInfo> infos = new();
foreach (var pickup in attribute.m_combat_pod_mode.m_pickup_pods.Values)
{
pickup.m_is_active = false;
@@ -467,8 +461,8 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
var next_generated_time = generated_info.Value.m_next_generate_time;
PickupPodGeneratedInfo new_info = new(idx.Item1, idx.Item2, string.Empty, string.Empty, now);
attribute.m_combat_pod_mode.m_pickup_pod_generated_info.AddOrUpdate(idx, new_info, (i, tuple) => new_info);
attribute.m_combat_pod_mode.m_pickup_pod_generated_info.AddOrUpdate(idx, new_info, (i, tuple) => new_info);
}
return infos;
@@ -489,4 +483,4 @@ public partial class BattleInstanceUpdateAction : EntityActionBase
return infos;
}
}
}

3
GameServer/Contents/GameMode/Mode-Battle/Action/BattleLocationAction.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Action/BattleLocationAction.cs
View File

@@ -1,6 +1,7 @@
using Newtonsoft.Json;
using ServerBase;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
namespace GameServer;

12
GameServer/Contents/GameMode/Mode-Battle/Action/BattleObjectInteractAction.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Action/BattleObjectInteractAction.cs
View File

@@ -1,6 +1,8 @@
using MetaAssets;
using GameServer.Contents.GameMode.Manage.PlayManage;
using MetaAssets;
using ServerBase;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
namespace GameServer;
@@ -42,7 +44,7 @@ public class BattleObjectInteractAction : EntityActionBase
Log.getLogger().info($"interaction pickup pod player : {player.toBasicString()}, guid : {handler.m_interaction_anchor_guid}, next active time : {handler.m_battle_object.m_active_time}");
var battle_instance_room = getOwner() as BattleInstanceRoom;
var battle_instance_room = getOwner() as GameModeBase;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room is null !!!");
var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
@@ -60,7 +62,7 @@ public class BattleObjectInteractAction : EntityActionBase
await Task.CompletedTask;
var result = new Result();
var battle_instance_room = getOwner() as BattleInstanceRoom;
var battle_instance_room = getOwner() as GameModeBase;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room is null !!!");
var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
@@ -121,7 +123,7 @@ public class BattleObjectInteractAction : EntityActionBase
var result = new Result();
var battle_instance_room = getOwner() as BattleInstanceRoom;
var battle_instance_room = getOwner() as GameModeBase;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room is null !!!");
string err_msg = string.Empty;

11
GameServer/Contents/GameMode/Mode-Battle/Action/BattleObjectRewardAction.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Action/BattleObjectRewardAction.cs
View File

@@ -1,8 +1,11 @@
using GameServer.Contents.Battle.Reward;
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using MetaAssets;
using Newtonsoft.Json;
using ServerBase;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
namespace GameServer;
@@ -41,7 +44,7 @@ public class BattleObjectRewardAction : EntityActionBase
var reward_id = pod_storage_meta.TypeID;
var reward_count = pod_storage_meta.ObjectValue;
var battle_instance_room = getOwner() as BattleInstanceRoom;
var battle_instance_room = getOwner() as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room is null !!!");
RewardMutable reward_metable = new();
@@ -76,7 +79,7 @@ public class BattleObjectRewardAction : EntityActionBase
return result;
}
var battle_instance_room = getOwner() as BattleInstanceRoom;
var battle_instance_room = getOwner() as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"battle_instance_room is null !!!");
Int32 idx = Int32.MinValue;
@@ -100,7 +103,7 @@ public class BattleObjectRewardAction : EntityActionBase
}
if (idx == Int32.MinValue) return result; //보상줄게 없다는 얘기이므로 그량 리턴
if(false == battle_instance_room.m_instance_room.getMap().getAnchors().TryGetValue(handler.m_interaction_anchor_guid, out var anchorInfo))
if(false == battle_instance_room.getInstanceRoom().getMap().getAnchors().TryGetValue(handler.m_interaction_anchor_guid, out var anchorInfo))
{
err_msg = $"not exist anchor anchor_guid : {handler.m_interaction_anchor_guid}";
Log.getLogger().error(err_msg);

12
GameServer/Contents/GameMode/Mode-Battle/Action/BattleZoneMoveAction.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Action/BattleZoneMoveAction.cs
View File

@@ -1,18 +1,12 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using Google.Protobuf.WellKnownTypes;
using MetaAssets;
using Newtonsoft.Json;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using ServerCore;
using USER_GUID = System.String;
namespace GameServer;
public partial class GameZoneMoveAction

57
GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Action/FfaGameObjectPodStorageInteractAction.cs Normal file
View File

@@ -0,0 +1,57 @@
using GameServer.Contents.GameMode.Action;
using GameServer.Contents.GameMode.Manage.PlayManage;
using MetaAssets;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer;
public class FfaGameObjectPodStorageInteractAction : GameGameObjectAction
{
public FfaGameObjectPodStorageInteractAction(EntityBase owner)
: base(owner, EGameObjectType.Pod_Combat)
{
}
public override async Task<Result> onInit()
{
await Task.CompletedTask;
var result = new Result();
return result;
}
public override void onClear()
{
return;
}
public override async Task<Result> interact(string anchorGuid, DateTime interactionTime)
{
await Task.CompletedTask;
var result = new Result();
var game_mode_base = getOwner() as GameModeBase;
NullReferenceCheckHelper.throwIfNull(game_mode_base, () => $"game_mode_base is null !!!");
var attribute = game_mode_base.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
bool has_pod_combat = hasPodCombat(anchorGuid, attribute);
return result;
}
public override string toBasicString()
{
return $"class name : {nameof(FfaGameObjectPodStorageInteractAction)}...." + base.toBasicString();
}
private bool hasPodCombat(string anchorGuid, BattleInstanceSnapshotAttribute attribute)
{
var pod_combat = attribute.m_combat_pod_mode.m_pod_combat;
if (pod_combat.m_source_storage_anchor_guid.Equals(anchorGuid) && pod_combat.m_state.Equals(PodCombatStateType.Active)) return true;
return false;
}
}

145
GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Cheat/BattleCheat.cs Normal file
View File

@@ -0,0 +1,145 @@
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer;
[ChatCommandAttribute("battleinstanceinit", typeof(CheatBattleInstanceInit), AuthAdminLevelType.Developer, AuthAdminLevelType.GmNormal, AuthAdminLevelType.GmSuper)]
public class CheatBattleInstanceInit : ChatCommandBase
{
public override async Task invoke(Player player, string token, string[] args)
{
Log.getLogger().info($"battleinstanceinit");
var server_logic = GameServerApp.getServerLogic();
var room_id = player.getCurrentInstanceRoomId();
if (room_id.Equals(string.Empty))
{
Log.getLogger().error($"cheat:battleinstanceinit.... this cheat only use in instance");
return;
}
if (false == GameModeManager.It.tryGetGameMode(room_id, out var gameMode))
{
Log.getLogger().error($"cheat:battleinstanceinit.... battle_instance_room is null room_id : {room_id}");
return;
}
var game_mode_base = gameMode as GameModeBase;
// var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (game_mode_base is null)
{
Log.getLogger().error($"cheat:battleinstanceinit.... game_mode_base is null room_id : {room_id}");
return;
}
using (var releaser = await game_mode_base.getAsyncLock())
{
var attribute = game_mode_base.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
if (false == attribute.m_combat_pod_mode.m_round_state_type.Equals(BattleRoundStateType.RoundEndAll) && false == attribute.m_combat_pod_mode.m_round_state_type.Equals(BattleRoundStateType.Destroyed))
{
Log.getLogger().error($"cheat:battleinstanceinit.... this cheat only RoundEndAll room_id : {room_id}");
return;
}
var now = DateTimeHelper.Current;
var ffa = gameMode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
if (ffa is null)
{
Log.getLogger().error($"cheat:battleinstanceinit.... ffa is null room_id : {room_id}");
return;
}
ffa.setEventStartTime(now);
attribute.m_combat_pod_mode.m_round_state_type = BattleRoundStateType.Rounding;
attribute.m_combat_pod_mode.m_current_state_start_time = now;
attribute.m_combat_pod_mode.m_current_round = 1;
attribute.m_combat_pod_mode.m_charged_step = 0;
attribute.m_combat_pod_mode.m_rewarded_step = 0;
attribute.m_combat_pod_mode.m_pod_combat.setActive(now);
(Result result, var anchor_guid) = BattleRoomHelper.getRandomCombatPodAnchorGuid(attribute, ffa);
if (result.isFail())
{
Log.getLogger().error("get Random pod combat anchor guid faile !!! ");
return;
}
attribute.m_combat_pod_mode.m_pod_combat.m_source_storage_anchor_guid = anchor_guid;
BattleRoomNotifyHelper.broadcast_GS2C_NTF_BATTLE_INSTANCE_STATE(ffa);
var update_action = game_mode_base.getEntityAction<BattleInstanceUpdateAction>();
NullReferenceCheckHelper.throwIfNull(update_action, () => $"attribute is null !!!");
update_action.battleObjectStateInitAndNotify(ffa, attribute);
BattleRoomNotifyHelper.broadcast_GS2C_NTF_POD_COMBAT_STATE(ffa);
}
}
}
[ChatCommandAttribute("gamemodeoccupyhost", typeof(BattleHostOccupy), AuthAdminLevelType.Developer, AuthAdminLevelType.GmNormal, AuthAdminLevelType.GmSuper)]
public class BattleHostOccupy : ChatCommandBase
{
public override async Task invoke(Player player, string token, string[] args)
{
//Log.getLogger().info($"battleinstanceinit");
var server_logic = GameServerApp.getServerLogic();
var room_id = player.getCurrentInstanceRoomId();
if (room_id.Equals(string.Empty))
{
Log.getLogger().error($"cheat:gamemodeoccupyhost.... this cheat only use in instance");
return;
}
//kihoon todo : 임시 분기 처리
//나중에 게임모드로 분리되면 그때 재작업
if (room_id.Contains("battle"))
{
//var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (false == GameModeManager.It.tryGetGameMode(room_id, out var gameMode))
{
Log.getLogger().error($"cheat:gamemodeoccupyhost.... battle_instance_room is null room_id : {room_id}");
return;
}
var game_mode_base = gameMode as GameModeBase;
NullReferenceCheckHelper.throwIfNull(game_mode_base, () => $"game_mode_base is null !!!");
using (var releaser = await game_mode_base.getAsyncLock())
{
game_mode_base.m_host_migrator.modifyHost(player.getUserGuid());
}
BattleRoomNotifyHelper.broadcast_GS2C_NTF_P2P_HOST_UPDATE(game_mode_base.getInstanceRoom(), player.getUserGuid());
}
else if (room_id.Contains("1017101"))
{
var instance_room = InstanceRoomManager.Instance.getInstanceRoomByRoomId(room_id);
if (instance_room is null)
{
Log.getLogger().error($"cheat:gamemodeoccupyhost.... instance_room is null room_id : {room_id}");
return;
}
BattleRoomNotifyHelper.broadcast_GS2C_NTF_P2P_HOST_UPDATE(instance_room, player.getUserGuid());
}
}
}

3
GameServer/Contents/GameMode/Mode-Battle/Doc/BattleEventDoc.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Doc/BattleEventDoc.cs
View File

@@ -1,7 +1,8 @@
using MetaAssets;
using Newtonsoft.Json;
using ServerBase;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
namespace GameServer.Contents.Battle.Doc;

78
GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Entity/BattleInstanceRoom.cs Normal file
View File

@@ -0,0 +1,78 @@
using System.Collections.Concurrent;
using Axion.Collections.Concurrent;
using GameServer.Contents.Battle.Log;
using GameServer.Contents.GameMode.Helper;
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using MetaAssets;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using Org.BouncyCastle.Tls.Crypto.Impl;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer;
public class BattleInstanceRoom : EntityBase, IWithLogActor, IBattleMode
{
public BattleInstanceRoom()
: base(EntityType.BattleInstance)
{
}
public override async Task<Result> onInit()
{
await Task.CompletedTask;
var result = new Result();
return result;
}
public ILogActor toLogActor()
{
var server_logic = GameServerApp.getServerLogic();
var region_id = server_logic.getServerConfig().getRegionId();
var server_name = server_logic.getServerName();
var log_info = new BattleInstanceActorLog(region_id, server_name, "", 0);
return log_info;
}
public async Task<bool> LeaveBattleRoom(Player player, string roomId, bool disconnected = false)
{
if (false == GameModeManager.It.tryGetGameMode(roomId, out var gameMode)) return false;
var game_mode_base = GameModeHelper.toGameModeBase(gameMode);
Log.getLogger().info($"LeaveBattleRoom, player : {player.toBasicString()}, roomId : {roomId}, disconnected : {disconnected}");
//await game_mode_base.getInstanceRoom().LeaveGameInstanceRoom(player, disconnected);
await Task.CompletedTask;
if (game_mode_base.getInstanceRoom().isDestroy)
{
Log.getLogger().info($"m_instance_room.isDestroy, so destroyBattleRoom : {player.toBasicString()}, roomId : {roomId}, disconnected : {disconnected}");
InstanceRoomManager.Instance.DestroyRoom(roomId);
Log.getLogger().info($"destroy InstanceRoomManager room Player : {player.toBasicString()}, roomId : {roomId}, disconnected : {disconnected}");
}
return true;
}
public override string toBasicString()
{
return $"BattleInstanceRoom room_id";
}
public Task<Result> init()
{
throw new NotImplementedException();
}
}

3
GameServer/Contents/GameMode/Mode-Battle/Entity/BattleInstanceSnapshotAttribute.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Entity/BattleInstanceSnapshotAttribute.cs
View File

@@ -4,7 +4,8 @@ using System.Collections.Generic;
using Amazon.DynamoDBv2.Model;
using Newtonsoft.Json;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
using ServerBase;
namespace GameServer;

3
GameServer/Contents/GameMode/Mode-Battle/Entity/BattleInstanceSnapshotDoc.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Entity/BattleInstanceSnapshotDoc.cs
View File

@@ -1,7 +1,8 @@
using System.Collections.Concurrent;
using Newtonsoft.Json;
using ServerBase;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
namespace GameServer;

9
GameServer/Contents/GameMode/Mode-Battle/Entity/BattlePlayer.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Entity/BattlePlayer.cs
View File

@@ -1,9 +1,6 @@

using ServerCore;
using ServerBase;
using ServerBase;
using ServerCommon;
namespace GameServer;
public class BattlePlayer : EntityBase
@@ -12,5 +9,7 @@ public class BattlePlayer : EntityBase
public BattlePlayer(Player player) : base(EntityType.BattlePlayer)
{
m_player = player;
}
}
}

2
GameServer/Contents/GameMode/Mode-Battle/Entity/SystemBattleEvent.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Entity/SystemBattleEvent.cs
View File

@@ -1,5 +1,5 @@
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
namespace GameServer;

0
GameServer/Contents/GameMode/Mode-Battle/Helper/BattleConstant.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Helper/BattleConstant.cs
View File

10
GameServer/Contents/GameMode/Mode-Battle/Helper/BattleInstancePlayModeHelper.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Helper/BattleInstancePlayModeHelper.cs
View File

@@ -1,6 +1,8 @@
using MetaAssets;
using GameServer.Contents.GameMode.Manage.PlayManage;
using MetaAssets;
using ServerBase;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
namespace GameServer;
@@ -80,9 +82,9 @@ public static class BattleInstancePlayModeHelper
}
public static (Result, BattleObjectMetaData) getBattleObjectMeta(string anchorGuid, BattleInstanceRoom battleInstanceRoom)
public static (Result, BattleObjectMetaData) getBattleObjectMeta(string anchorGuid, GameModeBase battleInstanceRoom)
{
var map = battleInstanceRoom.m_instance_room.getMap();
var map = battleInstanceRoom.getInstanceRoom().getMap();
string err_msg = string.Empty;
var result = new Result();
if(false == map.m_anchors.TryGetValue(anchorGuid, out var anchorInfo))

10
GameServer/Contents/GameMode/Mode-Battle/Helper/BattleObjectInteractionLogicHandler.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Helper/BattleObjectInteractionLogicHandler.cs
View File

@@ -1,13 +1,7 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using MetaAssets;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using ServerCore;
namespace GameServer;

27
GameServer/Contents/GameMode/Mode-Battle/Helper/BattleRoomHelper.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Helper/BattleRoomHelper.cs
View File

@@ -1,6 +1,8 @@
using Newtonsoft.Json;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using Newtonsoft.Json;
using ServerBase;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
namespace GameServer;
@@ -36,7 +38,7 @@ public class BattleRoomHelper
}
public static (Result, string) getRandomCombatPodAnchorGuid(BattleInstanceSnapshotAttribute attribute, BattleInstanceRoom battleInstanceRoom)
public static (Result, string) getRandomCombatPodAnchorGuid(BattleInstanceSnapshotAttribute attribute, GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
var result = new Result();
@@ -44,7 +46,7 @@ public class BattleRoomHelper
var keys = new List<int>(battleInstanceRoom.m_battle_pod_storage_guid_group.Keys);
if (keys.Count == 0)
{
err_msg = $"battle_instance_room.m_battle_pod_stand_group_pos_meta Keys Count is zero battle_instance_room : {battleInstanceRoom.m_instance_room.getMap().m_room_id}";
err_msg = $"battle_instance_room.m_battle_pod_stand_group_pos_meta Keys Count is zero battle_instance_room : {battleInstanceRoom.getRoomId()}";
result.setFail(ServerErrorCode.BattleInstanceNotExistAnchors, err_msg);
Log.getLogger().error(result.toBasicString());
return (result, string.Empty);
@@ -61,7 +63,7 @@ public class BattleRoomHelper
// 선택된 battle_group_id의 List<BattlePosMeta> 가져오기
if (false == battleInstanceRoom.m_battle_pod_storage_guid_group.TryGetValue(selected_battle_group_id, out var battle_pos_metas))
{
err_msg = $"battle_instance_room.m_battle_pod_stand_group_pos_meta value not exist battle_instance_room : {battleInstanceRoom.m_instance_room.getMap().m_room_id}";
err_msg = $"battle_instance_room.m_battle_pod_stand_group_pos_meta value not exist battle_instance_room : {battleInstanceRoom.getRoomId()}";
result.setFail(ServerErrorCode.BattleInstanceNotExistAnchors, err_msg);
return (result, string.Empty);
}
@@ -75,12 +77,12 @@ public class BattleRoomHelper
return (result, anchor_guid);
}
err_msg = $"not exist anchorGuid {battleInstanceRoom.m_instance_room.getMap().m_room_id}";
err_msg = $"not exist anchorGuid {battleInstanceRoom.getRoomId()}";
result.setFail(ServerErrorCode.BattleInstanceNotExistAnchors, err_msg);
return (result, string.Empty);
}
public static (Result, string) getRandomRespawnPos(BattleInstanceSnapshotAttribute attribute, BattleInstanceRoom battleInstanceRoom)
public static (Result, string) getRandomRespawnPos(BattleInstanceSnapshotAttribute attribute, GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
List<string> active_respawns = new();
var now = DateTimeHelper.Current;
@@ -110,7 +112,7 @@ public class BattleRoomHelper
}
public static (Result, string) getRandomPickupPod(int groupId, int idx, BattleInstanceRoom battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
public static (Result, string) getRandomPickupPod(int groupId, int idx, GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleInstanceSnapshotAttribute attribute)
{
var result = new Result();
@@ -120,7 +122,7 @@ public class BattleRoomHelper
//선택된 battle_group_id의 List<BattlePosMeta> 가져오기
if (false == battleInstanceRoom.m_battle_pickup_pod_guid_group.TryGetValue(groupId, out var pickup_pod_guid_group))
{
err_msg = $"battle_instance_room.m_battle_pickup_pod_group_pos_meta value not exist battle_instance_room : {battleInstanceRoom.m_instance_room.getMap().m_room_id}";
err_msg = $"battle_instance_room.m_battle_pickup_pod_group_pos_meta value not exist battle_instance_room : {battleInstanceRoom.getInstanceRoom().getMap().m_room_id}";
result.setFail(ServerErrorCode.BattleInstanceNotExistAnchors, err_msg);
return (result, string.Empty);
}
@@ -252,12 +254,15 @@ public class BattleRoomHelper
switch (mode)
{
case BattlePlayMode.PodCombat:
return HostMigrationFactory.createCommonHostMigrator((int) BattlePlayMode.PodCombat, GameServerApp.getServerLogic());
//return new BattleFFAModeHostMigrator();
//return HostMigrationFactory.createCommonHostMigrator((int) BattlePlayMode.PodCombat, GameServerApp.getServerLogic());
return new BattleFFAModeHostMigrator();
default:
Log.getLogger($"createHostMigrator Not implements mode : {mode}");
throw new NotImplementedException();
}
}
}

78
GameServer/Contents/GameMode/Mode-Battle/Helper/BattleRoomNotifyHelper.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Helper/BattleRoomNotifyHelper.cs
View File

@@ -1,28 +1,30 @@
using Google.Protobuf.WellKnownTypes;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using Google.Protobuf.WellKnownTypes;
using Newtonsoft.Json;
using ServerCore; using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer;
public static class BattleRoomNotifyHelper
{
public static void send_GS2C_NTF_POD_COMBAT_STATE(BattleInstanceRoom battleInstanceRoom, Player player)
public static void send_GS2C_NTF_POD_COMBAT_STATE(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, Player player)
{
var ntf = makePodCombatStateNotify(battleInstanceRoom);
GameServerApp.getServerLogic().onSendPacket(player, ntf);
}
public static void broadcast_GS2C_NTF_POD_COMBAT_STATE(BattleInstanceRoom battleInstanceRoom)
public static void broadcast_GS2C_NTF_POD_COMBAT_STATE(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
var ntf = makePodCombatStateNotify(battleInstanceRoom);
Log.getLogger().debug($"broadcast_GS2C_NTF_POD_COMBAT_STATE ntf battleInstanceRoom Id : {battleInstanceRoom.m_instance_room.getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfPodCombatState)}");
Log.getLogger().debug($"broadcast_GS2C_NTF_POD_COMBAT_STATE ntf battleInstanceRoom Id : {battleInstanceRoom.getRoomId()} data : {JsonConvert.SerializeObject(ntf.Message.NtfPodCombatState)}");
battleInstanceRoom.m_instance_room.Broadcast(ntf);
battleInstanceRoom.getInstanceRoom().Broadcast(ntf);
}
private static ClientToGame makePodCombatStateNotify(BattleInstanceRoom battleInstanceRoom)
private static ClientToGame makePodCombatStateNotify(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
@@ -49,22 +51,22 @@ public static class BattleRoomNotifyHelper
}
public static void send_GS2C_NTF_BATTLE_INSTANCE_STATE(BattleInstanceRoom battleInstanceRoom, Player player)
public static void send_GS2C_NTF_BATTLE_INSTANCE_STATE(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, Player player)
{
var ntf = makeBattleInstanceStateNotify(battleInstanceRoom);
Log.getLogger().debug($"send_GS2C_NTF_BATTLE_INSTANCE_STATE ntf battleInstanceRoom Id : {battleInstanceRoom.m_instance_room.getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattleInstanceState)}");
Log.getLogger().debug($"send_GS2C_NTF_BATTLE_INSTANCE_STATE ntf battleInstanceRoom Id : {battleInstanceRoom.getRoomId()} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattleInstanceState)}");
GameServerApp.getServerLogic().onSendPacket(player, ntf);
}
public static void broadcast_GS2C_NTF_BATTLE_INSTANCE_STATE(BattleInstanceRoom battleInstanceRoom)
public static void broadcast_GS2C_NTF_BATTLE_INSTANCE_STATE(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
var ntf = makeBattleInstanceStateNotify(battleInstanceRoom);
Log.getLogger().debug($"broadcast_GS2C_NTF_BATTLE_INSTANCE_STATE ntf battleInstanceRoom Id : {battleInstanceRoom.m_instance_room.getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattleInstanceState)}");
battleInstanceRoom.m_instance_room.Broadcast(ntf);
Log.getLogger().debug($"broadcast_GS2C_NTF_BATTLE_INSTANCE_STATE ntf battleInstanceRoom Id : {battleInstanceRoom.getRoomId()} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattleInstanceState)}");
battleInstanceRoom.getInstanceRoom().Broadcast(ntf);
}
private static ClientToGame makeBattleInstanceStateNotify(BattleInstanceRoom battleInstanceRoom)
private static ClientToGame makeBattleInstanceStateNotify(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
@@ -83,7 +85,7 @@ public static class BattleRoomNotifyHelper
return ntf;
}
public static void send_GS2C_NTF_PLAYER_DEATH(BattleInstanceRoom battleInstanceRoom, string killerGuid, string deadUserGuid, Player player)
public static void send_GS2C_NTF_PLAYER_DEATH(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, string killerGuid, string deadUserGuid, Player player)
{
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
@@ -91,13 +93,13 @@ public static class BattleRoomNotifyHelper
ntf.Message.NtfBattlePlayerDeath.DeadUserGuid = deadUserGuid;
ntf.Message.NtfBattlePlayerDeath.KillerUserGuid = killerGuid;
Log.getLogger().debug($"send_GS2C_NTF_PLAYER_DEATH ntf battleInstanceRoom Id : {battleInstanceRoom.m_instance_room.getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattlePlayerDeath)}");
Log.getLogger().debug($"send_GS2C_NTF_PLAYER_DEATH ntf battleInstanceRoom Id : {battleInstanceRoom.getRoomId()} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattlePlayerDeath)}");
battleInstanceRoom.m_instance_room.Broadcast(ntf);
battleInstanceRoom.getInstanceRoom().Broadcast(ntf);
}
public static void send_GS2C_NTF_PLAYER_RESPAWN(BattleInstanceRoom battleInstanceRoom, Pos pos, Player player)
public static void send_GS2C_NTF_PLAYER_RESPAWN(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, Pos pos, Player player)
{
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
@@ -105,12 +107,12 @@ public static class BattleRoomNotifyHelper
ntf.Message.NtfBattlePlayerRespawn.RespawnUserGuid = player.getUserGuid();
ntf.Message.NtfBattlePlayerRespawn.Pos = pos;
Log.getLogger().debug($"send_GS2C_NTF_PLAYER_RESPAWN ntf battleInstanceRoom Id : {battleInstanceRoom.m_instance_room.getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattlePlayerRespawn)}");
Log.getLogger().debug($"send_GS2C_NTF_PLAYER_RESPAWN ntf battleInstanceRoom Id : {battleInstanceRoom.getInstanceRoom().getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattlePlayerRespawn)}");
battleInstanceRoom.m_instance_room.Broadcast(ntf);
battleInstanceRoom.getInstanceRoom().Broadcast(ntf);
}
public static void broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO(BattleInstanceRoom battleInstanceRoom, BattleObjectInteractionLogicHandler handler)
public static void broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, BattleObjectInteractionLogicHandler handler)
{
BattleObjectInfo info = new();
info.AnchorGuid = handler.m_battle_object.m_anchor_guid;
@@ -124,16 +126,16 @@ public static class BattleRoomNotifyHelper
broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO(battleInstanceRoom, infos);
}
public static void broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO(BattleInstanceRoom battleInstanceRoom, List<BattleObjectInfo> infos)
public static void broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, List<BattleObjectInfo> infos)
{
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
ntf.Message.NtfBattleObjectStateInfo = new ClientToGameMessage.Types.GS2C_NTF_BATTLE_OBJECT_STATE_INFO();
ntf.Message.NtfBattleObjectStateInfo.BattleObjectInfos.AddRange(infos);
Log.getLogger().debug($"broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO ntf battleInstanceRoom Id : {battleInstanceRoom.m_instance_room.getMap().m_room_id} data :{JsonConvert.SerializeObject(infos)}");
Log.getLogger().debug($"broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO ntf battleInstanceRoom Id : {battleInstanceRoom.getRoomId()} data :{JsonConvert.SerializeObject(infos)}");
battleInstanceRoom.m_instance_room.Broadcast(ntf);
battleInstanceRoom.getInstanceRoom().Broadcast(ntf);
}
public static void send_GS2C_NTF_BATTLE_OBJECT_STATE_INFO(List<BattleObjectInfo> infos, Player player)
@@ -150,7 +152,7 @@ public static class BattleRoomNotifyHelper
}
public static void broadcast_GS2C_NTF_BATTLE_OBJECT_INTERACTION(BattleInstanceRoom battleInstanceRoom, string userGuid, string anchorGuid)
public static void broadcast_GS2C_NTF_BATTLE_OBJECT_INTERACTION(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, string userGuid, string anchorGuid)
{
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
@@ -158,12 +160,12 @@ public static class BattleRoomNotifyHelper
ntf.Message.NtfBattleObjectInteraction.AnchorGuid = anchorGuid;
ntf.Message.NtfBattleObjectInteraction.UserGuid = userGuid;
Log.getLogger().debug($"broadcast_GS2C_NTF_BATTLE_OBJECT_INTERACTION ntf battleInstanceRoom Id : {battleInstanceRoom.m_instance_room.getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattleObjectInteraction)}");
Log.getLogger().debug($"broadcast_GS2C_NTF_BATTLE_OBJECT_INTERACTION ntf battleInstanceRoom Id : {battleInstanceRoom.getRoomId()} data : {JsonConvert.SerializeObject(ntf.Message.NtfBattleObjectInteraction)}");
battleInstanceRoom.m_instance_room.Broadcast(ntf);
battleInstanceRoom.getInstanceRoom().Broadcast(ntf);
}
public static void broadcast_GS2C_NTF_BATTLE_REWARD(BattleInstanceRoom battleInstanceRoom, string acquireUserGuid, CommonResult commonResult)
public static void broadcast_GS2C_NTF_BATTLE_REWARD(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, string acquireUserGuid, CommonResult commonResult)
{
if (commonResult.EntityCommonResults.Count == 0) return;
if (acquireUserGuid.Equals(string.Empty)) return;
@@ -175,23 +177,11 @@ public static class BattleRoomNotifyHelper
ntf.Message.NtfBattleInstanceReward.AcquireUserGuid = acquireUserGuid;
Log.getLogger().debug($"send battle reward ntf acquireUserGuid : {acquireUserGuid}, commonResult : {JsonConvert.SerializeObject(commonResult)}");
battleInstanceRoom.m_instance_room.Broadcast(ntf);
battleInstanceRoom.getInstanceRoom().Broadcast(ntf);
}
public static void broadcast_GS2C_NTF_BATTLE_INSTANCE_DESTROYED(BattleInstanceRoom battleInstanceRoom)
{
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
ntf.Message.NtfBattleInstanceDestroyed = new ClientToGameMessage.Types.GS2C_NTF_BATTLE_INSTANCE_DESTROYED();
battleInstanceRoom.m_instance_room.Broadcast(ntf);
}
public static void send_GS2C_NTF_BATTLE_EVENT(Player player)
{
if (false == BattleRoomHelper.checkBattleActive()) return;
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
ntf.Message.NtfBattleEvent = new ClientToGameMessage.Types.GS2C_NTF_BATTLE_EVENT();
@@ -202,8 +192,6 @@ public static class BattleRoomNotifyHelper
public static void broadcast_GS2C_NTF_BATTLE_EVENT(List<BattleEventInfo> infos)
{
if (false == BattleRoomHelper.checkBattleActive()) return;
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
ntf.Message.NtfBattleEvent = new ClientToGameMessage.Types.GS2C_NTF_BATTLE_EVENT();
@@ -216,16 +204,16 @@ public static class BattleRoomNotifyHelper
}
}
public static void broadcast_GS2C_NTF_PREPARATION_FOR_LEAVING_BATTLE_INSTANCE(BattleInstanceRoom battleInstanceRoom, string leavingUserGuid)
public static void broadcast_GS2C_NTF_PREPARATION_FOR_LEAVING_BATTLE_INSTANCE(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, string leavingUserGuid)
{
ClientToGame ntf = new ClientToGame();
ntf.Message = new ClientToGameMessage();
ntf.Message.NtfPreparationForLeavingBattleInstance = new ClientToGameMessage.Types.GS2C_NTF_PREPARATION_FOR_LEAVING_BATTLE_INSTANCE();
ntf.Message.NtfPreparationForLeavingBattleInstance.LeavingUserGuid = leavingUserGuid;
Log.getLogger().debug($"broadcast_GS2C_NTF_PREPARATION_FOR_LEAVING_BATTLE_INSTANCE ntf battleInstanceRoom Id : {battleInstanceRoom.m_instance_room.getMap().m_room_id} data : {JsonConvert.SerializeObject(ntf.Message.NtfPreparationForLeavingBattleInstance)}");
Log.getLogger().debug($"broadcast_GS2C_NTF_PREPARATION_FOR_LEAVING_BATTLE_INSTANCE ntf battleInstanceRoom Id : {battleInstanceRoom.getRoomId()} data : {JsonConvert.SerializeObject(ntf.Message.NtfPreparationForLeavingBattleInstance)}");
battleInstanceRoom.m_instance_room.Broadcast(ntf);
battleInstanceRoom.getInstanceRoom().Broadcast(ntf);
}
public static void broadcast_GS2C_NTF_P2P_HOST_UPDATE(InstanceRoom instanceRoom, string hostUserGuid)

9
GameServer/Contents/GameMode/Mode-Battle/Log/BattleEventLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattleEventLog.cs
View File

@@ -1,18 +1,9 @@
using Newtonsoft.Json;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class BattleEventLog : ILogActor
{
[JsonProperty]

8
GameServer/Contents/GameMode/Mode-Battle/Log/BattleInstanceActorLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattleInstanceActorLog.cs
View File

@@ -1,14 +1,6 @@
using Newtonsoft.Json;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;

11
GameServer/Contents/GameMode/Mode-Battle/Log/BattleObjectInteractionBusinessLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattleObjectInteractionBusinessLog.cs
View File

@@ -1,17 +1,10 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class BattleObjectInteractionBusinessLog : ILogInvokerEx
public class BattleObjectInteractionBusinessLog : ILogInvokerEx
{
private BattleObjectInteractionLogInfo m_info;

12
GameServer/Contents/GameMode/Mode-Battle/Log/BattleObjectStateUpdateBusinessLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattleObjectStateUpdateBusinessLog.cs
View File

@@ -1,18 +1,10 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class BattleObjectStateUpdateBusinessLog : ILogInvokerEx
public class BattleObjectStateUpdateBusinessLog : ILogInvokerEx
{
private BattleObjectStateUpdateLogInfo m_info;
public BattleObjectStateUpdateBusinessLog(string roomId, List<BattleObjectLogInfo> infos) : base(LogDomainType.BattleObjectStateUpdate)

11
GameServer/Contents/GameMode/Mode-Battle/Log/BattlePodCombatRewardBusinessLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattlePodCombatRewardBusinessLog.cs
View File

@@ -1,17 +1,10 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class BattlePodCombatRewardBusinessLog : ILogInvokerEx
public class BattlePodCombatRewardBusinessLog : ILogInvokerEx
{
private BattlePodCombatRewardLogInfo m_info;

14
GameServer/Contents/GameMode/Mode-Battle/Log/BattleRespawnBusinessLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattleRespawnBusinessLog.cs
View File

@@ -1,17 +1,9 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer.Contents.Battle.Log;
namespace GameServer;
public class BattleRespawnBusinessLog : ILogInvokerEx
public class BattleRespawnBusinessLog : ILogInvokerEx
{
private BattleRespawnLogInfo m_info;

11
GameServer/Contents/GameMode/Mode-Battle/Log/BattleRoomJoinBusinessLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattleRoomJoinBusinessLog.cs
View File

@@ -1,17 +1,10 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class BattleRoomJoinBusinessLog : ILogInvokerEx
public class BattleRoomJoinBusinessLog : ILogInvokerEx
{
private BattleRoomJoinSuccessLogInfo m_info;
public BattleRoomJoinBusinessLog(string joinUserGuid, string joinUserNickname, string roomId, int joinRound) : base(LogDomainType.BattleRoomJoin)

11
GameServer/Contents/GameMode/Mode-Battle/Log/BattleRoomPlayerDeadBusinessLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattleRoomPlayerDeadBusinessLog.cs
View File

@@ -1,17 +1,10 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
public class BattleRoomPlayerDeadBusinessLog : ILogInvokerEx
public class BattleRoomPlayerDeadBusinessLog : ILogInvokerEx
{
private BattleRoomPlayerDeadLogInfo m_info;

14
GameServer/Contents/GameMode/Mode-Battle/Log/BattleRoundUpdateBusinessLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattleRoundUpdateBusinessLog.cs
View File

@@ -1,17 +1,9 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerBase;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace ServerCommon;
namespace GameServer;
public class BattleRoundUpdateBusinessLog : ILogInvokerEx
public class BattleRoundUpdateBusinessLog : ILogInvokerEx
{
private BattleRoundingUpdateLogInfo m_info;

24
GameServer/Contents/GameMode/Mode-Battle/Log/BattleSnapShotBusinessLog.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Log/BattleSnapShotBusinessLog.cs
View File

@@ -1,23 +1,19 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using ServerCore;
namespace GameServer.Contents.Battle.Log;
namespace GameServer;
public class BattleSnapShotBusinessLog : ILogInvokerEx
public class BattleSnapShotBusinessLog : ILogInvokerEx
{
private BattleSnapshotLogInfo m_info;
public BattleSnapShotBusinessLog(BattleInstanceRoom battleInstanceRoom, string loadType): base(LogDomainType.BattleSnapshot)
public BattleSnapShotBusinessLog(GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, string loadType): base(LogDomainType.BattleSnapshot)
{
m_info = createBattleSnapshotLogInfo(this, battleInstanceRoom, loadType);
//kihoon todo : GameModeTPSFreeForAll<GameModeTPSFreeForAllData> 이걸로 받을지 아니면 고칠지 고민 필요
m_info = createBattleSnapshotLogInfo(this, battleInstanceRoom, loadType);
}
public override bool hasLog()
@@ -31,9 +27,9 @@ public class BattleSnapShotBusinessLog : ILogInvokerEx
public BattleSnapshotLogInfo createBattleSnapshotLogInfo(ILogInvokerEx parent, BattleInstanceRoom battleInstanceRoom, string loadType)
public BattleSnapshotLogInfo createBattleSnapshotLogInfo(ILogInvoker parent, GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, string loadType)
{
var room_id = battleInstanceRoom.m_instance_room.getMap().m_room_id;
var room_id = battleInstanceRoom.getRoomId();
BattleSnapshotLogInfo info = new(parent, room_id, loadType);
var attribute = battleInstanceRoom.getEntityAttribute<BattleInstanceSnapshotAttribute>();
@@ -43,7 +39,7 @@ public class BattleSnapShotBusinessLog : ILogInvokerEx
return info;
}
info.m_play_mode = battleInstanceRoom.m_play_mode;
//info.m_play_mode = battleInstanceRoom.m_play_mode;
info.m_battle_instance_event_start_time = battleInstanceRoom.m_battle_instance_event_start_time;
info.m_pod_combat_reward_group_id = battleInstanceRoom.m_pod_combat_reward_group_id;
info.m_pod_combat_ffa_id = battleInstanceRoom.m_pod_combat_ffa_id;

386
GameServer/Contents/GameMode/Mode-Battle/Entity/BattleInstanceRoom.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Manage/GameModeTPSFreeForAll.cs
View File

@@ -1,79 +1,50 @@
using System.Collections.Concurrent;
using Axion.Collections.Concurrent;
using GameServer.Contents.Battle.Log;
using GameServer.Contents.GameMode.Helper;
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using MetaAssets;
using Newtonsoft.Json;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using ServerCore;
namespace GameServer;
public class BattleInstanceRoom : EntityBase, IWithLogActor
public class GameModeTPSFreeForAll<T> : GameModeTPS where T : ITPSMode
{
//public string m_instance_room_guid { get; } = string.Empty;
public bool m_is_load_complete { get; private set; } = false;
public InstanceRoom m_instance_room { get; }
private readonly CancellationTokenSource m_cancel_token = new();
public readonly IHostMigrator m_host_migrator; //생성자에서 모드에 맞춰서 할당한다.
public BattlePlayMode m_play_mode { get; set; } = BattlePlayMode.PodCombat;
T m_tps_mode_data;
public DateTime m_battle_instance_event_start_time { get; private set; } = DateTimeHelper.Current; //실제 이벤트 시작시간
//public DateTime m_battle_instance_load_time { get; } = DateTimeHelper.Current; //이벤트 시작시간과 관계 없이 메모리에 로드 될때의 시간 이 변수가 필요할지 모르겠다.
//todo : 모드별 관리 메타를 따로 구성해야할듯...
//todo : 제네릭으로 받아도 되려나?.. 고민 필요 우선 임시데이터
//kihoon todo : 이거 위치 수정해야됨
//todo : 제네릭으로 받아도 되려나?.. 고민 필요 우선 임시데이터
public Int32 m_pod_combat_reward_group_id = 1;
public Int32 m_pod_combat_ffa_id = 1;
public BattleFFAConfigData m_ffa_config_meta;
public BattleFFAConfigData m_ffa_config_meta;
public Dictionary<int, BattleFFARewardData> m_ffa_reward_meta = new();
public Int32 m_hot_time_reward = 1;
public Int32 m_round_count = 8;
//public Int32 m_pickup_pod_reward_max_count { get; } = 2;
//public int m_max_step_per_round { get; set; } = 10;
public ConcurrentHashSet<string /*anchor_guid*/> m_respawn_pos_anchors_meta { get; private set; } = new(); //이건 랜덤 돌릴 일이 잦아서 그냥 들고 있는다...
public ConcurrentDictionary<int /*battle_group_id*/ , HashSet<string>> m_battle_pod_storage_guid_group { get; private set; } = new(); //pod combat을 생성해줄때 필요
public ConcurrentDictionary<int /*battle_group_id*/ , HashSet<string>> m_battle_pickup_pod_guid_group { get; private set; } = new();
public BattleInstanceRoom(InstanceRoom room, DateTime eventStartTime, Int32 configId, Int32 rewardId, Int32 hotTime, Int32 roundCount)
: base(EntityType.BattleInstance)
public GameModeTPSFreeForAll(T tpsModeData, InstanceRoom instanceRoom) : base(EntityType.GameModeRunRace, instanceRoom)
{
m_instance_room = room;
NullReferenceCheckHelper.throwIfNull(m_instance_room, () => $"m_instance_room is null !!!");
m_battle_instance_event_start_time = eventStartTime;
m_play_mode = BattlePlayMode.PodCombat;
m_host_migrator = BattleRoomHelper.createHostMigrator(m_play_mode);
m_pod_combat_ffa_id = configId;
m_pod_combat_reward_group_id = rewardId;
m_hot_time_reward = hotTime;
m_round_count = roundCount;
//m_instance_room_guid = BattleConstant.PREFIX_BATTLE_TRANSACTION_GUID + System.Guid.NewGuid();
// BattleFFAConfigData
m_tps_mode_data = tpsModeData;
// kihoon todo : 이것도 위치 이동이 필요하다.
if (false == MetaData.Instance._BattleFFAConfigMetaTable.TryGetValue(m_pod_combat_ffa_id, out var configData))
{
var err_msg = $"Not exist Battle Conig Data id : {m_pod_combat_ffa_id}";
Log.getLogger().error(err_msg);
NullReferenceCheckHelper.throwIfNull(configData, () => $"configData is null !!!");
}
m_ffa_config_meta = new BattleFFAConfigData(new BattleFFAConfigDataMutable()
{
Id = configData.Id,
@@ -89,58 +60,107 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
CurrencyCount = configData.CurrencyCount,
TPSGuideURL = configData.TPSGuideURL
});
if (false == MetaData.Instance._BattleFFARewardMetaTable.TryGetValue(m_pod_combat_reward_group_id, out var rewardMeta))
{
var err_msg = $"Not exist reward Meta Data id : {m_pod_combat_ffa_id}";
Log.getLogger().error(err_msg);
NullReferenceCheckHelper.throwIfNull(rewardMeta, () => $"rewardMeta is null !!!");
}
foreach (var meta_set in rewardMeta)
{
var val = meta_set.Value;
var key = meta_set.Key;
BattleFFARewardData data = new BattleFFARewardData(new BattleFFARewardDataMutable()
{
Id = val.Id,
GroupID = val.GroupID,
ChargeLevel = val.ChargeLevel,
ChargeTime = val.ChargeTime,
RewardItemID = val.RewardItemID,
RewardCount = val.RewardCount
});
m_ffa_reward_meta.TryAdd(key, data);
}
Log.getLogger().info($"BattleInstanceRoom construct done roomId : " +
$"{room.getMap().m_room_id}, eventStartTime : {eventStartTime}, configId : {configId}, rewardId : {rewardId}, hotTime : {hotTime}, roundCount : {roundCount}");
}
public async Task<Result> init()
public override async Task<Result> onInit()
{
string err_msg = string.Empty;
Log.getLogger().debug("run race onInit called");
//제너릭 init
await m_tps_mode_data.initTPSMode();
//레이스 모드에 필요한 액션 추가
addFFAEntityAction();
//게임 모드에 필요한 상수값 입력
setDefaultMetaConstants();
await initBattleRoom();
//다 마무리 되면 부모 init 호출
var result = await base.onInit();
Log.getLogger().debug("run race onInit done");
return result;
}
private void addFFAEntityAction()
{
Log.getLogger().debug("FFA addEntityAction called");
//Action 추가
//kihoon todo : 이거 아래 걸로 일부 수정 필요
addEntityAction(new BattleInstanceAction(this));
addEntityAction(new BattleInstanceUpdateAction(this));
addEntityAction(new BattleObjectInteractAction(this));
addEntityAction(new BattleObjectRewardAction(this));
addEntityAction(new FfaGameObjectPodStorageInteractAction(this));
//Attribute 추가
addEntityAttribute(new BattleInstanceSnapshotAttribute(this));
addEntityAttribute(new BattleInstanceSnapshotAttribute(this)); //ㅏkihoon todo : 이거 여기에 넣는게 맞나?
Log.getLogger().debug("FFA addEntityAction done");
}
public async Task<Result> initBattleRoom()
{
var result = new Result();
// instance 정보 추가 등록
var server_logic = GameServerApp.getServerLogic();
var instance_room_storage = new InstanceRoomStorage();
instance_room_storage.Init(server_logic.getRedisDb(), "");
DateTime start_time = DateTimeHelper.Current;
Int32 config_id = 1;
Int32 reward_id = 1;
Int32 hot_time = 1;
Int32 round_count = 8;
var system_battle_event = BattleRoomHelper.getBattleRoomStartTimeByEventId(getRoomId());
if (system_battle_event is null)
{
Log.getLogger().error($"system_battle_event is null!!! : {result.toBasicString()} - instanceRoomId:{getRoomId()}");
}
else
{
start_time = system_battle_event.m_start_time;
config_id = system_battle_event.m_ffa_config_data_id;
reward_id = system_battle_event.m_ffa_reward_group_id;
hot_time = system_battle_event.m_ffa_hot_time;
round_count = system_battle_event.m_round_count;
}
result = await instance_room_storage.setInstanceRoomExtraInfo(getRoomId(), EPlaceType.BattleRoom, start_time); //kihoon todo : 이거 나중에 GameRoom으로 바뀔때 문제 되니까 코드 바꿔야 된다.
if (result.isFail())
{
Log.getLogger().error($"Failed to BattleRoom setInstanceRoomExtraInfo() !!! : {result.toBasicString()} - instanceRoomId:{getRoomId()}");
return result;
}
//Anchor 정보 로드
loadAnchorPos();
//스냅샷 데이터 로드, 없으면 신규 생성
var battle_instance_action = getEntityAction<BattleInstanceAction>();
NullReferenceCheckHelper.throwIfNull(battle_instance_action, () => $"battle_instance_action is null !!!");
var result = await battle_instance_action.loadOrCreateSnapshot();
var err_msg = string.Empty;
result = await battle_instance_action.loadOrCreateSnapshot();
if (result.isFail())
{
err_msg = $"loadSnapshot error instanceId : {m_instance_room.getInstanceId()}, roomId : {m_instance_room.getMap().m_room_id}";
@@ -149,58 +169,11 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
}
Log.getLogger().info($"load Snapshot done instanceId : {m_instance_room.getInstanceId()}, roomId : {m_instance_room.getMap().m_room_id}");
//태스크 생성
result = await createTask();
if (result.isFail())
{
err_msg = $"battle instance room onCreateTask error instanceId : {m_instance_room.getInstanceId()}, roomId : {m_instance_room.getMap().m_room_id}";
Log.getLogger().error(err_msg);
return result;
}
Log.getLogger().info($"createTask done instanceId : {m_instance_room.getInstanceId()}, roomId : {m_instance_room.getMap().m_room_id}");
m_is_load_complete = true;
// P2P Host Migrator p2p 그룹 id 설정
m_host_migrator.setGroupHostId(m_instance_room.getMap().getP2PGroupId());
return result;
}
public override async Task<Result> onInit()
{
await Task.CompletedTask;
var result = new Result();
return result;
}
private async Task<Result> createTask()
{
var result = new Result();
//Timer에서 사용할 Action 초기화
var battle_update_action = getEntityAction<BattleInstanceUpdateAction>();
NullReferenceCheckHelper.throwIfNull(battle_update_action, () => $"battle_update_action is null !!!");
try
{
//임시로 0.8초로 처리 나중에 이거 Meta로 빼야 된다.
new PeriodicTaskTimer( GetType().Name, BattleConstant.BATTLE_ROOM_CHECK_INTERVAL, m_cancel_token, onTaskTick);
await battle_update_action.onInit();
Log.getLogger().debug("battle_update_action.onInit() dome");
}
catch(Exception e)
{
var err_msg = $"Exception !!!, new PeriodicTaskTimer() : exception:{e} - {toBasicString()}";
result.setFail(ServerErrorCode.TryCatchException, err_msg);
return result;
}
return result;
}
private void loadAnchorPos()
{
foreach (var anchor_info_dict in m_instance_room.getMap().getAnchors())
@@ -218,15 +191,14 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
var table_id = anchor_info.AnchorProp.TableId;
loadRespawnPos(type, anchor_guid);
loadBattleObjectGroups(type, anchor_guid, table_id);
}
}
private void loadRespawnPos(string type, string anchorGuid)
{
if (!type.Equals(BattleConstant.RESPAWN_POS_ANCHOR_NAME)) return;
if (false == m_respawn_pos_anchors_meta.Add(anchorGuid))
{
Log.getLogger().warn($"respawnPos add fail type : {type}, anchorGuid : {anchorGuid}");
@@ -234,28 +206,10 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
Log.getLogger().info($"respawnPos add success type : {type}, anchorGuid : {anchorGuid}");
}
// private void loadBattleObject(string type, string anchorGuid)
// {
// if (!type.Equals(BattleConstant.BATTLE_OBJECT_ANCHOR_NAME)) return;
//
// if (false == m_battle_object_anchors_meta.Add(anchorGuid))
// {
// Log.getLogger().warn($"m_battle_object_anchors add fail type : {type}, anchorGuid : {anchorGuid}");
// }
// Log.getLogger().info($"m_battle_object_anchors add success type : {type}, anchorGuid : {anchorGuid}");
// }
private bool loadBattleObjectGroups(string type, string anchorGuid, Int32 tableID)
{
if (!type.Equals(BattleConstant.BATTLE_OBJECT_GROUP_ANCHOR_NAME)) return true;
// if (false == m_battle_object_group_anchors_meta.Add(anchorGuid))
// {
// Log.getLogger().warn($"m_battle_object_group_anchors add fail type : {type}, anchorGuid : {anchorGuid}");
// }
// Log.getLogger().info($"m_battle_object_group_anchors add success type : {type}, anchorGuid : {anchorGuid}");
if (false == MetaData.Instance._BattleObjectSpawnGroupMetaTable.TryGetValue(tableID, out var battle_object_spawn_meta))
{
Log.getLogger().warn($"battle_object_group add fail type : {type}, anchorGuid : {anchorGuid}, table_id : {tableID}");
@@ -283,7 +237,6 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
return true;
}
private void loadBattleObjectPodStorageGroup(string anchorGuid, int groupId)
{
if (false == m_battle_pod_storage_guid_group.ContainsKey(groupId))
@@ -297,7 +250,7 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
return;
}
poses.Add(anchorGuid);
Log.getLogger().info($"m_battle_pod_stand_group_pos_meta Add anchorGuid : {anchorGuid}, group_id : {groupId}");
}
@@ -313,52 +266,41 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
return;
}
poses.Add(anchorGuid);
Log.getLogger().info($"m_battle_pod_box_group_pos_meta Add anchorGuid : {anchorGuid}, group_id : {groupId}");
}
public Result AddOrUpdatePlayer(Player player)
public void setEventStartTime(DateTime t)
{
var result = new Result();
// if (false == m_battle_players.TryAdd(player.getUserGuid(), new BattlePlayer(player)))
// {
// string err_msg = $"Player tryAdd fail guid : {player.getUserGuid()}";
// result.setFail(ServerErrorCode.BattleInstanceJoinPlayerError, err_msg);
// Log.getLogger().error(result.toBasicString());
// return result;
// }
return result;
m_battle_instance_event_start_time = t;
}
private async Task onTaskTick()
private void setDefaultMetaConstants()
{
if (!m_is_load_complete) return;
m_ticker_interval_msecs = GameModeConstants.GAME_MODE_TPS_FFA_CHECK_INTERVAL_MSECS; //이것도 위로 올릴수 있을것 같은데??
}
public override async Task taskUpdate()
{
//여기에 타이머 처리 해야된다.
var battle_update_action = getEntityAction<BattleInstanceUpdateAction>();
NullReferenceCheckHelper.throwIfNull(battle_update_action, () => $"battle_update_action is null !!!");
var result = await battle_update_action.update();
if (result.isFail())
{
var err_msg = $"playr mode hander update error : {result.toBasicString()}";
Log.getLogger().error(err_msg);
}
await Task.CompletedTask;
}
public ILogActor toLogActor()
public override string toBasicString()
{
var server_logic = GameServerApp.getServerLogic();
var region_id = server_logic.getServerConfig().getRegionId();
var server_name = server_logic.getServerName();
var log_info = new BattleInstanceActorLog(region_id, server_name, m_instance_room.getMap().m_room_id, m_instance_room.getInstanceId());
return log_info;
}
var basic_string = base.toBasicString() + $"GameModeTPSFreeForAll....";
return basic_string;
}
public async Task removePodCombat(Player player)
{
var attribute = getEntityAttribute<BattleInstanceSnapshotAttribute>();
@@ -370,47 +312,23 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
{
attribute.m_combat_pod_mode.m_pod_combat.changeDropState(player.getCurrentPositionInfo().Pos);
}
BattleRoomNotifyHelper.broadcast_GS2C_NTF_POD_COMBAT_STATE(this);
var ffa = this as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!!");
BattleRoomNotifyHelper.broadcast_GS2C_NTF_POD_COMBAT_STATE(ffa); //kihoon todo : 이거 코드 이상하다... 수정해야된다.
}
}
public void removeBattlePlayerIfExist(string userGuid)
{
// if (true == m_battle_players.ContainsKey(userGuid))
// {
// if (false == m_battle_players.TryRemove(userGuid, out var player))
// {
// Log.getLogger().warn($"m_battle_players try remove faial userGuid : {userGuid}");
// }
// }
}
public async Task<bool> LeaveBattleRoom(Player player, string roomId, bool disconnected = false)
{
//BattleRoom에서 먼저 빼준다.
//m_battle_players.TryRemove(player.getUserGuid(), out _);
Log.getLogger().info($"LeaveBattleRoom, player : {player.toBasicString()}, roomId : {roomId}, disconnected : {disconnected}");
await m_instance_room.LeaveBattleInstanceRoom(player, disconnected);
if (m_instance_room.isDestroy)
{
Log.getLogger().info($"m_instance_room.isDestroy, so destroyBattleRoom : {player.toBasicString()}, roomId : {roomId}, disconnected : {disconnected}");
await destroyBattleRoom();
InstanceRoomManager.Instance.DestroyRoom(roomId);
Log.getLogger().info($"destroy InstanceRoomManager room Player : {player.toBasicString()}, roomId : {roomId}, disconnected : {disconnected}");
}
return true;
}
public async Task destroyBattleRoom()
{
await Task.CompletedTask;
//여기서 timer 종료 처리
m_cancel_token.Cancel();
var entity_ticker = getEntityTicker();
if(entity_ticker is not null) entity_ticker.getCancelToken().Cancel();
Log.getLogger().debug($"battle instance room token canceled m_room_id :{m_instance_room.getMap().m_room_id}");
var fn_save_battle_instance = async delegate()
@@ -419,7 +337,7 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
var fn_result = new Result();
using (var releaser = await getAsyncLock())
{
//여기서 battleRoomSnapshot 저장
//여기서 battleRoomSnapshot 저장
var battle_instance_snapshot_attribute = getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(battle_instance_snapshot_attribute, () => $"battle_instance_snapshot_attribute is null !!!");
if (!battle_instance_snapshot_attribute.m_combat_pod_mode.m_pod_combat.m_current_occupier_guid.Equals(string.Empty))
@@ -428,15 +346,18 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
}
battle_instance_snapshot_attribute.modifiedEntityAttribute(true);
var batch = new QueryBatchEx<QueryRunnerWithDocument>(this, LogActionType.BattleInstanceSnapshotSave, server_logic.getDynamoDbClient(), true);
{
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
}
BattleSnapShotBusinessLog business_log = new(this, "");
var ffa = this as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!!");
BattleSnapShotBusinessLog business_log = new(ffa, "");
batch.appendBusinessLog(business_log);
fn_result = await QueryHelper.sendQueryAndBusinessLog(batch);
if (fn_result.isSuccess())
@@ -456,19 +377,8 @@ public class BattleInstanceRoom : EntityBase, IWithLogActor
var err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {toBasicString()}";
Log.getLogger().error(err_msg);
}
}
public override string toBasicString()
{
return $"BattleInstanceRoom room_id : {m_instance_room.getMap().m_room_id}";
}
public void setEventStartTime(DateTime t)
{
m_battle_instance_event_start_time = t;
}
}
}

12
GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Manage/GameModeTPSFreeForAllData.cs Normal file
View File

@@ -0,0 +1,12 @@
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class GameModeTPSFreeForAllData : ITPSMode
{
public async Task<Result> initTPSMode()
{
var result = new Result();
await Task.CompletedTask;
return result;
}
}

76
GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Manage/TPSFreeForAllDestroyHandler.cs Normal file
View File

@@ -0,0 +1,76 @@
using GameServer.Contents.Battle.Log;
using GameServer.Contents.GameMode.Helper;
using GameServer.Contents.GameMode.Manage.LeaveManage;
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using Newtonsoft.Json;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Mode_Battle.ModeFreeForAll.Manage;
public class TPSFreeForAllDestroyHandler : GameModeDestroyHandlerBase
{
public TPSFreeForAllDestroyHandler(string roomId) : base(roomId, GameModeType.TPS_FFA)
{
}
public override async Task<Result> postDestroy(IGameMode gameMode)
{
await Task.CompletedTask;
Log.getLogger().debug($"tps ffa post destroy start roomId :{m_room_id}");
var game_mode_base = GameModeHelper.toGameModeBase(gameMode);
var fn_save_battle_instance = async delegate()
{
var server_logic = GameServerApp.getServerLogic();
var fn_result = new Result();
//여기서 battleRoomSnapshot 저장
var battle_instance_snapshot_attribute = game_mode_base.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(battle_instance_snapshot_attribute, () => $"battle_instance_snapshot_attribute is null !!!");
if (!battle_instance_snapshot_attribute.m_combat_pod_mode.m_pod_combat.m_current_occupier_guid.Equals(string.Empty))
{
battle_instance_snapshot_attribute.m_combat_pod_mode.m_pod_combat.m_current_occupier_guid = string.Empty;
}
battle_instance_snapshot_attribute.modifiedEntityAttribute(true);
var batch = new QueryBatchEx<QueryRunnerWithDocument>(game_mode_base, LogActionType.BattleInstanceSnapshotSave, server_logic.getDynamoDbClient(), true);
{
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
}
var ffa = game_mode_base as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!! - {game_mode_base.toBasicString()}");
BattleSnapShotBusinessLog business_log = new(ffa, "");
batch.appendBusinessLog(business_log);
fn_result = await QueryHelper.sendQueryAndBusinessLog(batch);
if (fn_result.isSuccess())
{
Log.getLogger().info($"save battle instance snapshot done attribute : {JsonConvert.SerializeObject(battle_instance_snapshot_attribute)}");
}
return fn_result;
};
var result = await game_mode_base.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "SaveBattleInstanceByDestroy", fn_save_battle_instance);
if (result.isFail())
{
var err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {game_mode_base.toBasicString()}";
Log.getLogger().error(err_msg);
}
return result;
}
}

46
GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Manage/TPSFreeForAllInitHandler.cs Normal file
View File

@@ -0,0 +1,46 @@
using GameServer.Contents.GameMode.Manage;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class TPSFreeForAllInitHandler : GameModeInitHandlerBase
{
public TPSFreeForAllInitHandler(InstanceRoom instanceRoom) : base(instanceRoom, GameModeType.TPS_FFA)
{
}
public override Result gamedModeInstanceInitValidate()
{
var result = new Result();
return result;
}
// public override async Task<Result> gamedModeInstanceInit()
// {
// Log.getLogger().debug("tps ffa gamedModeInstanceInit called");
//
// //await base.gamedModeInstanceInit(); //kihoon todo 이거 바꿔줘야 한다. ..
//
//
//
// var room_id = m_instance_room.getMap().m_room_id;
// var result = BattleInstanceManager.It.battleInstanceInit(m_instance_room, room_id).Result; //kihoon todo :이거 리팩토링 대상
// if (result.isFail())
// {
// Log.getLogger().error(result.toBasicString());
// }
//
// //kihoon todo : 임시 코드 나중에 gameMode로 이동해야됨
// //var battle_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
// //NullReferenceCheckHelper.throwIfNull(battle_room, () => $"battle_room is null !!");
//
// //GameModeManager.It.tryAdd(room_id, battle_room);
//
// Log.getLogger().debug("tps ffa gamedModeInstanceInit done");
//
// return result;
// }
}

48
GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Manage/TPSFreeForAllJoinHandler.cs Normal file
View File

@@ -0,0 +1,48 @@
using GameServer.Contents.GameMode.Manage;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class TPSFreeForAllJoinHandler : GameModeJoinHandlerBase
{
public TPSFreeForAllJoinHandler(InstanceRoom instanceRoom) : base(instanceRoom, GameModeType.TPS_FFA)
{
}
public override Result gamedModeInstanceJoinValidate()
{
var result = new Result();
return result;
}
public override Result gamedModeInstanceJoin(Player player)
{
Log.getLogger().debug("tps ffa gamedModeInstanceJoin called");
var result = new Result();
string err_msg = string.Empty;
//instanceroom 정보는 남아있는데 battleinstance만 없어지는 케이스가 있어서 예외 처리를 위해 넣어놓음
var room_id = m_instance_room.getMap().m_room_id;
//var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id); //kihoon todo : 이거 리팩토링 대상.... IGameMode에서 가져오는게 맞나?? 다른 모드 넣으면서 고민좀 해보자...
if (false == GameModeManager.It.tryGetGameMode(room_id, out var gameMode))
{
Log.getLogger().error($"Battle Room Instance is null.. so init start roomId : {room_id}");
//kihoon todo : 이거 코드 바꿔야 된다.
// result = Task.Run(() => BattleInstanceManager.It.battleInstanceInit(m_instance_room, room_id)).GetAwaiter().GetResult();
// if (result.isFail())
// {
// err_msg = $"BattleIntanceJoin init error, _roomId : {room_id}";
// Log.getLogger().error(err_msg);
// return result;
// }
}
Log.getLogger().debug("tps ffa gamedModeInstanceJoin done");
return result;
}
}

69
GameServer/Contents/GameMode/Mode-Battle/Manage/BattleInstanceJoinSuccessHandler.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Manage/TPSFreeForAllJoinSuccessHandler.cs
View File

@@ -1,58 +1,68 @@

using ServerCore;
using GameServer.Contents.GameMode.Manage;
using GameServer.Contents.GameMode.Manage.PlayManage;
using ServerBase;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
namespace GameServer;
public class BattleInstanceJoinSuccessHandler : GameModeJoinSuccessHandlerBase
public class TPSFreeForAllJoinSuccessHandler : GameModeJoinSuccessHandlerBase
{
private readonly BattleInstanceRoom m_battle_instance_room;
public BattleInstanceJoinSuccessHandler(Player player, InstanceRoom instanceRoom)
: base(player, EPlaceType.BattleRoom)
//private readonly BattleInstanceRoom m_battle_instance_room;//kihoon todo : 이거 GameMode 로 변경해야 한다... ..
private IGameMode m_game_mode;
public TPSFreeForAllJoinSuccessHandler(Player player, InstanceRoom instanceRoom) : base(player, GameModeType.TPS_FFA, instanceRoom)
{
var room_id = instanceRoom.getMap().m_room_id;
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"m_battle_instance_room is null !!!");
//m_battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id)!;
//NullReferenceCheckHelper.throwIfNull(m_battle_instance_room, () => $"m_battle_instance_room is null !!!");
m_battle_instance_room = battle_instance_room;
GameModeManager.It.tryGetGameMode(room_id, out var gameMode);
NullReferenceCheckHelper.throwIfNull(gameMode, () => $"gameMode is null !!!");
m_game_mode = gameMode;
//m_battle_instance_room = battle_instance_room;
}
public override Result joinSuccessValidate()
{
var result = BattleRoomHelper.checkBattleActive(m_place_type);
if (result.isFail()) return result;
var result = new Result();
return result;
}
public override async Task<Result> joinSuccessConfirmation()
{
var result = new Result();
string err_msg = string.Empty;
var room_id = m_battle_instance_room.m_instance_room.getMap().m_room_id;
var battle_instance_attribute = m_battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
var ffa = m_game_mode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!!");
var room_id = ffa.getRoomId();
var battle_instance_attribute = ffa.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(battle_instance_attribute, () => $"battle_instance_attribute is null !!!");
(result, var pos_meta_guid) = BattleRoomHelper.getRandomRespawnPos(battle_instance_attribute, m_battle_instance_room);
(result, var pos_meta_guid) = BattleRoomHelper.getRandomRespawnPos(battle_instance_attribute, ffa);
if (result.isFail())
{
return result;
}
if (false == m_battle_instance_room.m_respawn_pos_anchors_meta.Contains(pos_meta_guid))
if (false == ffa.m_respawn_pos_anchors_meta.Contains(pos_meta_guid))
{
err_msg = $"respawn pos meta not exist idx : {pos_meta_guid}";
result.setFail(ServerErrorCode.BattleInstanceUsableSpawnPointNotExist, err_msg);
return result;
}
using (var releaser = await m_battle_instance_room.getAsyncLock())
using (var releaser = await ffa.getAsyncLock())
{
var now = DateTimeHelper.Current;
var next_respawn_time = now.AddSeconds(m_battle_instance_room.m_ffa_config_meta.PlayerRespawnTime);
var next_respawn_time = now.AddSeconds(ffa.m_ffa_config_meta.PlayerRespawnTime);
battle_instance_attribute.m_combat_pod_mode.m_respawns.AddOrUpdate(pos_meta_guid, next_respawn_time, (key, old) => next_respawn_time);
@@ -61,7 +71,7 @@ public class BattleInstanceJoinSuccessHandler : GameModeJoinSuccessHandlerBase
var currenct_pos = location_action.getCurrentPos();
if (false == m_battle_instance_room.m_instance_room.getMap().getAnchors().TryGetValue(pos_meta_guid, out var anchorInfo))
if (false == ffa.getInstanceRoom().getMap().getAnchors().TryGetValue(pos_meta_guid, out var anchorInfo))
{
err_msg = $"anchorInfo not exist idx : {pos_meta_guid}";
result.setFail(ServerErrorCode.BattleInstanceNotExistAnchors, err_msg);
@@ -80,7 +90,9 @@ public class BattleInstanceJoinSuccessHandler : GameModeJoinSuccessHandlerBase
{
var result = new Result();
m_player.send_S2C_NTF_SET_LOCATION();
result = await BattleInstanceManager.It.sendNtfAboutBattleInstance(m_battle_instance_room, m_player);
var ffa = m_game_mode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!!");
result = await BattleInstanceManager.It.sendNtfAboutBattleInstance(ffa, m_player);
if (result.isFail()) return result;
return result;
}
@@ -88,16 +100,21 @@ public class BattleInstanceJoinSuccessHandler : GameModeJoinSuccessHandlerBase
public override void joinSuccessWriteLog()
{
var room_id = m_battle_instance_room.m_instance_room.getMap().m_room_id;
var ffa = m_game_mode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!!");
var room_id = ffa.getRoomId();
var user_guid = m_player.getUserGuid();
var user_nickname = m_player.getUserNickname();
var battle_instance_attribute = m_battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
var battle_instance_attribute = ffa.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(battle_instance_attribute, () => $"battle_instance_attribute is null !!!");
var currenct_round = battle_instance_attribute.m_combat_pod_mode.m_current_round;
var log_action = new LogActionEx(LogActionType.BattleInstanceJoin);
var log_action = new LogAction(LogActionType.BattleInstanceJoin.ToString());
var invoker = new BattleRoomJoinBusinessLog(user_guid, user_nickname, room_id, currenct_round);
BusinessLogger.collectLogs(log_action, m_player, new List<ILogInvoker>(){invoker});
}

47
GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Manage/TPSFreeForAllLeaveHandler.cs Normal file
View File

@@ -0,0 +1,47 @@
using GameServer.Contents.GameMode.Helper;
using GameServer.Contents.GameMode.Manage.LeaveManage;
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Mode_Battle.ModeFreeForAll.Manage;
public class TPSFreeForAllLeaveHandler : GameModeLeaveHandlerBase
{
public TPSFreeForAllLeaveHandler(Player player, string roomId) : base(player, roomId, GameModeType.TPS_FFA)
{
}
public override async Task<Result> postLeave(IGameMode gameMode)
{
Log.getLogger().debug($"ffa postLeave start instanceRoomId : {m_room_id}");
var ffa = gameMode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"location ffa is null !!! - {m_player.toBasicString()}");
await ffa.removePodCombat(m_player);
return new Result();
}
public override async Task<Result> notifyAfterLeave(IGameMode gameMode)
{
var result = new Result();
await Task.CompletedTask;
return result;
}
public override async Task<Result> logAfterLeave(IGameMode gameMode)
{
var result = new Result();
await Task.CompletedTask;
return result;
}
}

75
GameServer/Contents/GameMode/Mode-Battle/PacketHandler/BattleObjectInteractionPacketHandler.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/PacketHandler/BattleObjectInteractionPacketHandler.cs
View File

@@ -1,11 +1,10 @@
using Google.Protobuf;
using ServerCore;
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using Google.Protobuf;
using MetaAssets;
using ServerBase;
using ServerCommon;
using MetaAssets;
using ServerCore;
namespace GameServer.PacketHandler;
@@ -25,17 +24,17 @@ public class BattleObjectInteractionPacketHandler : PacketRecvHandler
var player = session as Player;
NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
var server_config = server_logic.getServerConfig();
bool is_battle_system_active = server_config.BattleSystemEnable;
if (false == is_battle_system_active)
{
err_msg = $"is_battle_system_active is false!!!";
result.setFail(ServerErrorCode.BattleInstanceInActive, err_msg);
Log.getLogger().error(err_msg);
send_S2C_ACK_BATTLE_OBJECT_INTERACTION(player, result, "");
return result;
}
//var server_config = server_logic.getServerConfig();
// bool is_battle_system_active = server_config.BattleSystemEnable;
//
// if (false == is_battle_system_active)
// {
// err_msg = $"is_battle_system_active is false!!!";
// result.setFail(ServerErrorCode.BattleInstanceInActive, err_msg);
// Log.getLogger().error(err_msg);
// send_S2C_ACK_BATTLE_OBJECT_INTERACTION(player, result, "");
// return result;
// }
var req_msg = recvMessage as ClientToGame;
ArgumentNullReferenceCheckHelper.throwIfNull(req_msg, () => $"req_msg is null !!! - {player.toBasicString()}");
@@ -55,8 +54,7 @@ public class BattleObjectInteractionPacketHandler : PacketRecvHandler
var packet_create_time = request.PacketCreateTime;
var room_id = player.getCurrentInstanceRoomId();
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (battle_instance_room == null)
if(false == GameModeManager.It.tryGetGameMode(room_id, out var gameMode))
{
err_msg = $"battle_instance_room is null : room_id - {room_id}";
Log.getLogger().error(err_msg);
@@ -64,8 +62,21 @@ public class BattleObjectInteractionPacketHandler : PacketRecvHandler
send_S2C_ACK_BATTLE_OBJECT_INTERACTION(player, result, anchor_guid);
return result;
}
var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
// var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
// if (battle_instance_room == null)
// {
// err_msg = $"battle_instance_room is null : room_id - {room_id}";
// Log.getLogger().error(err_msg);
// result.setFail(ServerErrorCode.BattleInstanceInfoNotExist, err_msg);
// send_S2C_ACK_BATTLE_OBJECT_INTERACTION(player, result, anchor_guid);
// return result;
// }
var game_mode_base = gameMode as GameModeBase;
NullReferenceCheckHelper.throwIfNull(game_mode_base, () => $"game_mode_base is null !!!");
var attribute = game_mode_base.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
if (packet_create_time is not null)
@@ -78,9 +89,9 @@ public class BattleObjectInteractionPacketHandler : PacketRecvHandler
CommonResult common_result = new();
var fn_interact_battle_object = async delegate()
{
using (var releaser = await battle_instance_room.getAsyncLock())
using (var releaser = await game_mode_base.getAsyncLock())
{
result = await interactObject(handler, battle_instance_room, anchor_guid, player);
result = await interactObject(handler, game_mode_base, anchor_guid, player);
if (result.isFail()) return result;
//batch 처리
@@ -114,20 +125,22 @@ public class BattleObjectInteractionPacketHandler : PacketRecvHandler
return result;
}
//순서 바꾸지 말것(클라 요청사항)
send_S2C_ACK_BATTLE_OBJECT_INTERACTION(player, result, anchor_guid);
BattleRoomNotifyHelper.broadcast_GS2C_NTF_BATTLE_OBJECT_INTERACTION(battle_instance_room, player.getUserGuid(), anchor_guid);
BattleRoomNotifyHelper.broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO(battle_instance_room, handler);
sendOtherNotifies(handler, battle_instance_room, common_result);
var ffa = game_mode_base as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!! - {player.toBasicString()}");
BattleRoomNotifyHelper.broadcast_GS2C_NTF_BATTLE_OBJECT_INTERACTION(ffa, player.getUserGuid(), anchor_guid);
BattleRoomNotifyHelper.broadcast_GS2C_NTF_BATTLE_OBJECT_STATE_INFO(ffa, handler);
sendOtherNotifies(handler, ffa, common_result);
return result;
}
private void sendOtherNotifies(BattleObjectInteractionLogicHandler handler, BattleInstanceRoom battleInstanceRoom, CommonResult commonResult)
private void sendOtherNotifies(BattleObjectInteractionLogicHandler handler, GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom, CommonResult commonResult)
{
//pod combat이 활성화 되서 stand는 전부 비활성화
if (handler.m_need_noti_objects.Count > 0)
@@ -156,7 +169,7 @@ public class BattleObjectInteractionPacketHandler : PacketRecvHandler
BattleRoomNotifyHelper.broadcast_GS2C_NTF_BATTLE_REWARD(battleInstanceRoom, handler.m_user_guid, commonResult);
}
public async Task<Result> interactObject(BattleObjectInteractionLogicHandler handler, BattleInstanceRoom battleInstanceRoom, string anchorGuid, Player player)
public async Task<Result> interactObject(BattleObjectInteractionLogicHandler handler, GameModeBase battleInstanceRoom, string anchorGuid, Player player)
{
var attribute = battleInstanceRoom.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
@@ -181,7 +194,7 @@ public class BattleObjectInteractionPacketHandler : PacketRecvHandler
return result;
}
public async Task<Result> interactBattleObject(BattleObjectInteractionLogicHandler handler, BattleInstanceRoom battleInstanceRoom, string anchorGuid, Player player)
public async Task<Result> interactBattleObject(BattleObjectInteractionLogicHandler handler, GameModeBase battleInstanceRoom, string anchorGuid, Player player)
{
var result = new Result();
string err_msg = string.Empty;
@@ -238,7 +251,7 @@ public class BattleObjectInteractionPacketHandler : PacketRecvHandler
}
public async Task<Result> interactPodCombat(BattleObjectInteractionLogicHandler handler, BattleInstanceRoom battleInstanceRoom, string anchorGuid, Player player)
public async Task<Result> interactPodCombat(BattleObjectInteractionLogicHandler handler, GameModeBase battleInstanceRoom, string anchorGuid, Player player)
{
await Task.CompletedTask;

43
GameServer/Contents/GameMode/Mode-Battle/PacketHandler/BattlePlayerDeadPacketHandler.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/PacketHandler/BattlePlayerDeadPacketHandler.cs
View File

@@ -1,17 +1,7 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using static ClientToGameReq.Types;
using static ClientToGameRes.Types;
using ServerCore;
namespace GameServer.PacketHandler;
@@ -42,8 +32,9 @@ public class BattlePlayerDeadPacketHandler : PacketRecvHandler
return result;
}
var room_id = player.getCurrentInstanceRoomId();
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (battle_instance_room == null)
//var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (false == GameModeManager.It.tryGetGameMode(room_id, out var gameMode))
{
err_msg = $"battle_instance_room is null : room_id - {room_id}";
Log.getLogger().error(err_msg);
@@ -72,22 +63,24 @@ public class BattlePlayerDeadPacketHandler : PacketRecvHandler
{
Log.getLogger().info($"Player Deat packet received room_id : {room_id}, anchor_guid : {killer_guid}, packetCreateTime : {packet_create_time}, player : {player.toBasicString()}");
}
result = await playerDeadProcess(player, killer_guid, battle_instance_room);
var ffa = gameMode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!!");
result = await playerDeadProcess(player, killer_guid, ffa);
if (result.isFail()) return result;
await killUserQuestCheck(killer_guid, battle_instance_room);
await killUserQuestCheck(killer_guid, ffa);
return result;
}
public async Task killUserQuestCheck(string killerGuid, BattleInstanceRoom battleInstanceRoom)
public async Task killUserQuestCheck(string killerGuid, GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
battleInstanceRoom.m_instance_room.tryGetInstanceMember(killerGuid, out var killer);
battleInstanceRoom.getInstanceRoom().tryGetInstanceMember(killerGuid, out var killer);
if (killer is null)
{
Log.getLogger().warn($"killer User not exist instance killerGuid : {killerGuid}, roomId :{battleInstanceRoom.m_instance_room.getMap().m_room_id} ");
Log.getLogger().warn($"killer User not exist instance killerGuid : {killerGuid}, roomId :{battleInstanceRoom.getRoomId()} ");
return;
}
@@ -95,7 +88,7 @@ public class BattlePlayerDeadPacketHandler : PacketRecvHandler
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
if (false == attribute.m_combat_pod_mode.m_tactical_board.TryGetValue(killerGuid, out var boradInfo))
{
Log.getLogger().warn($"killer User not exist m_tactical_board killerGuid : {killerGuid}, roomId :{battleInstanceRoom.m_instance_room.getMap().m_room_id} ");
Log.getLogger().warn($"killer User not exist m_tactical_board killerGuid : {killerGuid}, roomId :{battleInstanceRoom.getRoomId()} ");
return;
}
@@ -103,7 +96,7 @@ public class BattlePlayerDeadPacketHandler : PacketRecvHandler
await QuestManager.It.QuestCheck(killer, new QuestTpsPlayerKill(EQuestEventTargetType.TPS, EQuestEventNameType.PLAYERKILL, kill_count));
}
public async Task<Result> playerDeadProcess(Player player, string kilerUserGuid, BattleInstanceRoom battleInstanceRoom)
public async Task<Result> playerDeadProcess(Player player, string kilerUserGuid, GameModeTPSFreeForAll<GameModeTPSFreeForAllData> battleInstanceRoom)
{
var dead_user_guid = player.getUserGuid();
var dead_user_nickname = player.getUserNickname();
@@ -137,16 +130,16 @@ public class BattlePlayerDeadPacketHandler : PacketRecvHandler
BattleRoomNotifyHelper.broadcast_GS2C_NTF_POD_COMBAT_STATE(battleInstanceRoom);
}
battleInstanceRoom.m_instance_room.tryGetInstanceMember(kilerUserGuid, out var killer_player);
battleInstanceRoom.getInstanceRoom().tryGetInstanceMember(kilerUserGuid, out var killer_player);
string killer_nickname = string.Empty;
if (killer_player is not null)
{
killer_nickname = killer_player.getUserNickname();
}
var log_action = new LogActionEx(LogActionType.BattleUserDead);
var log_action = new LogAction(LogActionType.BattleUserDead.ToString());
var invoker = new BattleRoomPlayerDeadBusinessLog(dead_user_guid, dead_user_nickname, kilerUserGuid, killer_nickname
, battleInstanceRoom.m_instance_room.getMap().m_room_id, attribute.m_combat_pod_mode.m_current_round, need_pod_combat_drop_noti);
, battleInstanceRoom.getRoomId(), attribute.m_combat_pod_mode.m_current_round, need_pod_combat_drop_noti);
BusinessLogger.collectLogs(log_action, player, new List<ILogInvoker>(){invoker});
return fn_result;

49
GameServer/Contents/GameMode/Mode-Battle/PacketHandler/BattlePlayerRespawnPacketHandler.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/PacketHandler/BattlePlayerRespawnPacketHandler.cs
View File

@@ -1,17 +1,9 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using GameServer.Contents.Battle.Log;
using GameServer.Contents.GameMode.Manage.PlayManage;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using static ClientToGameReq.Types;
using static ClientToGameRes.Types;
using ServerCore;
namespace GameServer.PacketHandler;
@@ -43,10 +35,11 @@ public class BattlePlayerRespawnPacketHandler : PacketRecvHandler
}
var room_id = player.getCurrentInstanceRoomId();
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (battle_instance_room == null)
//var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (false == GameModeManager.It.tryGetGameMode(room_id, out var gameMode))
{
err_msg = $"battle_instance_room is null : room_id - {room_id}";
err_msg = $"gameMode is null : room_id - {room_id}";
Log.getLogger().error(err_msg);
result.setFail(ServerErrorCode.BattleInstanceInfoNotExist, err_msg);
send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, null, result);
@@ -71,24 +64,28 @@ public class BattlePlayerRespawnPacketHandler : PacketRecvHandler
{
Log.getLogger().info($"Battle Player respawn packet received packetCreateTime : {packet_create_time}, player : {player.toBasicString()}");
}
var game_mode_base = gameMode as GameModeBase;
NullReferenceCheckHelper.throwIfNull(game_mode_base, () => $"game_mode_base is null !!!");
AnchorInfo? anchor_info = null;
var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
var attribute = game_mode_base.getEntityAttribute<BattleInstanceSnapshotAttribute>();
var next_respawn_time = DateTimeHelper.Current;
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
using (var releaser = await battle_instance_room.getAsyncLock())
var ffa = gameMode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!!");
using (var releaser = await game_mode_base.getAsyncLock())
{
(result, var pos_meta_guid) = BattleRoomHelper.getRandomRespawnPos(attribute, battle_instance_room);
(result, var pos_meta_guid) = BattleRoomHelper.getRandomRespawnPos(attribute, ffa);
if (result.isFail())
{
send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, null, result);
return result;
}
if (false == battle_instance_room.m_respawn_pos_anchors_meta.Contains(pos_meta_guid))
if (false == ffa.m_respawn_pos_anchors_meta.Contains(pos_meta_guid))
{
err_msg = $"respawn pos meta not exist pos_meta_guid : {pos_meta_guid}";
result.setFail(ServerErrorCode.BattleInstanceUsableSpawnPointNotExist, err_msg);
@@ -97,12 +94,12 @@ public class BattlePlayerRespawnPacketHandler : PacketRecvHandler
}
var now = DateTimeHelper.Current;
next_respawn_time = now.AddSeconds(battle_instance_room.m_ffa_config_meta.PlayerRespawnTime);
next_respawn_time = now.AddSeconds(ffa.m_ffa_config_meta.PlayerRespawnTime);
attribute.m_combat_pod_mode.m_respawns.AddOrUpdate(pos_meta_guid, next_respawn_time, (key, old) => next_respawn_time);
attribute.modifiedEntityAttribute(true);
if (false == battle_instance_room.m_instance_room.getMap().m_anchors.TryGetValue(pos_meta_guid, out var anchorInfo))
if (false == game_mode_base.getInstanceRoom().getMap().m_anchors.TryGetValue(pos_meta_guid, out var anchorInfo))
{
err_msg = $"anchorInfo not exist pos_meta_guid : {pos_meta_guid}";
result.setFail(ServerErrorCode.BattleInstanceNotExistAnchors, err_msg);
@@ -117,15 +114,15 @@ public class BattlePlayerRespawnPacketHandler : PacketRecvHandler
cloned_anchor_pos.Z += 100;
send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, cloned_anchor_pos, result);
BattleRoomNotifyHelper.send_GS2C_NTF_PLAYER_RESPAWN(battle_instance_room, cloned_anchor_pos, player);
BattleRoomNotifyHelper.send_GS2C_NTF_PLAYER_RESPAWN(ffa, cloned_anchor_pos, player);
//로그 남긴다.
var invokers = new List<ILogInvoker>();
var log_action = new LogActionEx(LogActionType.BattleUserRespawn);
var log_action = new LogAction(LogActionType.BattleUserRespawn.ToString());
var round = attribute.m_combat_pod_mode.m_current_round;
var round_state = attribute.m_combat_pod_mode.m_round_state_type;
var users = battle_instance_room.m_instance_room.tryGetInstanceExistUserForLog();
var users = ffa.getInstanceRoom().tryGetInstanceExistUserForLog();
BattleRespawnBusinessLog business_log = new(room_id, round, round_state, player.getUserGuid(), player.getUserNickname(), anchor_info.AnchorGuid, next_respawn_time);
invokers.Add(business_log);
BusinessLogger.collectLogs(log_action, player, invokers);

15
GameServer/Contents/GameMode/Mode-Battle/PacketHandler/JoinBattleInstancePacketHandler.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/PacketHandler/JoinBattleInstancePacketHandler.cs
View File

@@ -1,17 +1,8 @@
using Google.Protobuf;

using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using static ClientToGameReq.Types;
using static ClientToGameRes.Types;
using ServerCore;
namespace GameServer.PacketHandler;
@@ -120,7 +111,7 @@ public class JoinBattleInstancePacketHandler : PacketRecvHandler
return result;
}
var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.JoinInstance, server_logic.getDynamoDbClient(), true);
var batch = new QueryBatch<QueryRunnerWithDocument>(player, LogActionType.JoinInstance.ToString(), server_logic.getDynamoDbClient(), true);
{
batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
batch.addQuery(new QueryFinal());

24
GameServer/Contents/GameMode/Mode-Battle/PacketHandler/LeaveBattleInstancePacketHandler.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/PacketHandler/LeaveBattleInstancePacketHandler.cs
View File

@@ -1,18 +1,10 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using MetaAssets;
using Newtonsoft.Json;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using static ClientToGameReq.Types;
using static ClientToGameRes.Types;
using ServerCore;
namespace GameServer.PacketHandler;
@@ -167,8 +159,9 @@ public class LeaveBattleInstancePacketHandler : PacketRecvHandler
return result;
}
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(instance_room_Id);
if (battle_instance_room is null)
//var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(instance_room_Id);
if (false == GameModeManager.It.tryGetGameMode(instance_room_Id, out var gameMode))
{
err_msg = $"battle_instance_room not esist instance_room_Id : {instance_room_Id}, player : {player.toBasicString()}";
result.setFail(ServerErrorCode.BattleInstanceInfoNotExist, err_msg);
@@ -176,7 +169,10 @@ public class LeaveBattleInstancePacketHandler : PacketRecvHandler
return result;
}
var battle_instance_room_attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
var ffa = gameMode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!! - {player.toBasicString()}");
var battle_instance_room_attribute = ffa.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(battle_instance_room_attribute, () => $"battle_instance_room_attribute is null !!! - {player.toBasicString()}");
// 2. move to channel

39
GameServer/Contents/GameMode/Mode-Battle/PacketHandler/PreparationForLeavingBattleInstancePacketHandler.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/PacketHandler/PreparationForLeavingBattleInstancePacketHandler.cs
View File

@@ -1,15 +1,7 @@
using Nettention.Proud;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using GameServer.Contents.GameMode.Mode_Battle.Manage;
using Nettention.Proud;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using ServerCore;
namespace GameServer.PacketHandler;
@@ -61,8 +53,8 @@ public class PreparationForLeavingBattleInstancePacketHandler : PacketRecvHandle
var room_id = player.getCurrentInstanceRoomId();
var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (battle_instance_room == null)
//var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
if (false == GameModeManager.It.tryGetGameMode(room_id, out var gameMode))
{
err_msg = $"battle_instance_room is null : room_id - {room_id}";
Log.getLogger().error(err_msg);
@@ -72,14 +64,15 @@ public class PreparationForLeavingBattleInstancePacketHandler : PacketRecvHandle
}
var user_guid = player.getUserGuid();
var ffa = gameMode as GameModeTPSFreeForAll<GameModeTPSFreeForAllData>;
NullReferenceCheckHelper.throwIfNull(ffa, () => $"ffa is null !!!");
var fn_preparation_for_leaving = async delegate()
{
bool need_pod_combat_drop_noti = false;
using (var releaser = await battle_instance_room.getAsyncLock())
using (var releaser = await ffa.getAsyncLock())
{
var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
var attribute = ffa.getEntityAttribute<BattleInstanceSnapshotAttribute>();
NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
var current_owner_guid = attribute.m_combat_pod_mode.m_pod_combat.m_current_occupier_guid;
need_pod_combat_drop_noti = user_guid.Equals(current_owner_guid);
@@ -92,20 +85,20 @@ public class PreparationForLeavingBattleInstancePacketHandler : PacketRecvHandle
}
send_S2C_ACK_PREPARE_FOR_LEAVING_BATTLE_INSTANCE(player, result);
BattleRoomNotifyHelper.broadcast_GS2C_NTF_PREPARATION_FOR_LEAVING_BATTLE_INSTANCE(battle_instance_room, user_guid);
BattleRoomNotifyHelper.broadcast_GS2C_NTF_PREPARATION_FOR_LEAVING_BATTLE_INSTANCE(ffa, user_guid);
if (need_pod_combat_drop_noti)
{
BattleRoomNotifyHelper.broadcast_GS2C_NTF_POD_COMBAT_STATE(battle_instance_room);
BattleRoomNotifyHelper.broadcast_GS2C_NTF_POD_COMBAT_STATE(ffa);
}
var host_guid = battle_instance_room.m_host_migrator.getHostUserGuid();
var host_guid = ffa.m_host_migrator.getHostUserGuid();
if (user_guid.Equals(host_guid))
{
var hosts = new List<HostID>();
hosts.Add(player.getHostId());
var p2p_group_id = battle_instance_room.m_instance_room.getMap().getP2PGroupId();
var define_result = battle_instance_room.m_host_migrator.defineHost(p2p_group_id, new SuperPeerSelectionPolicy(), hosts.ToArray());
var p2p_group_id = ffa.getInstanceRoom().getMap().getP2PGroupId();
var define_result = ffa.m_host_migrator.defineHost(p2p_group_id, new SuperPeerSelectionPolicy(), hosts.ToArray());
if (define_result.isFail())
{
Log.getLogger().warn(define_result.toBasicString());
@@ -113,8 +106,8 @@ public class PreparationForLeavingBattleInstancePacketHandler : PacketRecvHandle
return result;
}
var new_host_user_guid = battle_instance_room.m_host_migrator.getHostUserGuid();
BattleRoomNotifyHelper.broadcast_GS2C_NTF_P2P_HOST_UPDATE(battle_instance_room.m_instance_room, new_host_user_guid);
var new_host_user_guid = ffa.m_host_migrator.getHostUserGuid();
BattleRoomNotifyHelper.broadcast_GS2C_NTF_P2P_HOST_UPDATE(ffa.getInstanceRoom(), new_host_user_guid);
}
return result;
};

17
GameServer/Contents/GameMode/Mode-Battle/Redis/BattleInstanceRoomStorage.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Redis/BattleInstanceRoomStorage.cs
View File

@@ -2,25 +2,13 @@
using MetaAssets;
using Newtonsoft.Json;
using ServerControlCenter;
using ServerCore; using ServerBase;
using ServerCore;
using StackExchange.Redis;
using System.Numerics;
using ServerBase;
namespace ServerCommon;
// public class InstanceRoomInfo
// {
// public string roomId { get; set; } = string.Empty;
// public string InstanceAddress { get; set; } = string.Empty;
// public int InstancePort { get; set; } = 0;
// public int InstanceId { get; set; } = 0;
// public int UgcNpcCount { get; set; } = 0;
// public string MyhomeGuid { get; set; } = string.Empty;
// public EPlaceType InstancePlaceType { get; set; } = EPlaceType.NONE;
// public Timestamp InstanceStartTime { get; set; } = DateTimeHelper.MinTime.ToTimestamp();
// }
public class BattleInstanceRoomStorage
{
@@ -35,6 +23,7 @@ public class BattleInstanceRoomStorage
public void Init(IDatabase redisDB, string keyPrefix)
{
_database = redisDB;
_roomKeyPrefix = keyPrefix;
if (_roomKeyPrefix != string.Empty && !_roomKeyPrefix.EndsWith(":"))
{

0
GameServer/Contents/GameMode/Mode-Battle/Reward/RewardPickupPod.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Reward/RewardPickupPod.cs
View File

13
GameServer/Contents/GameMode/Mode-Battle/Reward/RewardPodCombat.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Reward/RewardPodCombat.cs
View File

@@ -1,15 +1,4 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
namespace GameServer;
namespace GameServer.Contents.Battle.Reward;
public class RewardPodCombat : RewardBase
{

0
GameServer/Contents/GameMode/Mode-Battle/Reward/RewardPodStorage.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Reward/RewardPodStorage.cs
View File

5
GameServer/Contents/GameMode/Mode-Battle/Tickers/BattleEventCheckTicker.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Tickers/BattleEventCheckTicker.cs
View File

@@ -3,8 +3,9 @@ using System.Net;
using GameServer.Contents.Battle.Doc;
using MetaAssets;
using Newtonsoft.Json;
using ServerBase;
using ServerCommon;
using ServerCore; using ServerBase;
using ServerCore;
namespace GameServer;
@@ -20,8 +21,6 @@ public class BattleEventCheckTicker : EntityTicker
public override async Task onTaskTick()
{
if (false == BattleRoomHelper.checkBattleActive()) return;
var result = await refreshEvent();
if (result.isFail())
{

17
GameServer/Contents/GameMode/Mode-Battle/Tickers/BattleEventNotifyTicker.cs → GameServer/Contents/GameMode/Mode-Battle/ModeFreeForAll/Tickers/BattleEventNotifyTicker.cs
View File

@@ -1,15 +1,8 @@
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using ServerCore;
using ServerBase;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;
using ServerCore;
namespace GameServer;
namespace GameServer.Contents.Battle.Tickers;
public class BattleEventNotifyTicker : EntityTicker
{
@@ -21,11 +14,7 @@ public class BattleEventNotifyTicker : EntityTicker
public override async Task onTaskTick()
{
if (false == BattleRoomHelper.checkBattleActive()) return;
//필요한 Noti가 있다면 broadCast
await notifyBattleEvent();
}
private async Task notifyBattleEvent()

19
GameServer/Contents/GameMode/Mode-Battle/ModeTeamDeathMatch/Manage/GameModeTPSTeamDeathMatch.cs Normal file
View File

@@ -0,0 +1,19 @@
using GameServer.Contents.GameMode.Manage.PlayManage;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class GameModeTPSTeamDeathMatch<T> : GameModeTPS where T : ITPSMode
{
T m_tps_mode_data;
public GameModeTPSTeamDeathMatch(T tpsModeData, InstanceRoom instanceRoom) : base(EntityType.GameModeTpsteamDeathMatch, instanceRoom)
{
m_tps_mode_data = tpsModeData;
}
public override string toBasicString()
{
var basic_string = base.toBasicString() + $"GameModeTPSTeamDeathMatch....";
return basic_string;
}
}

13
GameServer/Contents/GameMode/Mode-Battle/ModeTeamDeathMatch/Manage/GameModeTPSTeamDeathMatchData.cs Normal file
View File

@@ -0,0 +1,13 @@
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class GameModeTPSTeamDeathMatchData : ITPSMode
{
public async Task<Result> initTPSMode()
{
var result = new Result();
await Task.CompletedTask;
return result;
}
}

21
GameServer/Contents/GameMode/Mode-Battle/ModeTeamDeathMatch/Manage/TPSTeamDeathMatchDestroyHandler.cs Normal file
View File

@@ -0,0 +1,21 @@
using GameServer.Contents.GameMode.Manage.LeaveManage;
using GameServer.Contents.GameMode.Manage.PlayManage;
using ServerCommon;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class TPSTeamDeathMatchDestroyHandler : GameModeDestroyHandlerBase
{
public TPSTeamDeathMatchDestroyHandler(string roomId) : base(roomId, GameModeType.TPS_TDM)
{
}
public override async Task<Result> postDestroy(IGameMode gameMode)
{
var result = new Result();
await Task.CompletedTask;
return result;
}
}

17
GameServer/Contents/GameMode/Mode-Battle/ModeTeamDeathMatch/Manage/TPSTeamDeathMatchInitHandler.cs Normal file
View File

@@ -0,0 +1,17 @@
using GameServer.Contents.GameMode.Manage;
using ServerCommon;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class TPSTeamDeathMatchInitHandler : GameModeInitHandlerBase
{
public TPSTeamDeathMatchInitHandler(InstanceRoom instanceRoom) : base(instanceRoom, GameModeType.TPS_TDM)
{
}
public override Result gamedModeInstanceInitValidate()
{
var result = new Result();
return result;
}
}

30
GameServer/Contents/GameMode/Mode-Battle/ModeTeamDeathMatch/Manage/TPSTeamDeathMatchJoinHandler.cs Normal file
View File

@@ -0,0 +1,30 @@
using GameServer.Contents.GameMode.Manage;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class TPSTeamDeathMatchJoinHandler : GameModeJoinHandlerBase
{
public TPSTeamDeathMatchJoinHandler(InstanceRoom instanceRoom) : base(instanceRoom, GameModeType.TPS_TDM)
{
}
public override Result gamedModeInstanceJoinValidate()
{
var result = new Result();
return result;
}
public override Result gamedModeInstanceJoin(Player player)
{
Log.getLogger().debug("tps tdm gamedModeInstanceJoin called");
var result = new Result();
string err_msg = string.Empty;
Log.getLogger().debug("tps tdm gamedModeInstanceJoin done");
return result;
}
}

48
GameServer/Contents/GameMode/Mode-Battle/ModeTeamDeathMatch/Manage/TPSTeamDeathMatchJoinSuccessHandler.cs Normal file
View File

@@ -0,0 +1,48 @@
using GameServer.Contents.GameMode.Manage;
using ServerCommon;
using ServerCore;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class TPSTeamDeathMatchJoinSuccessHandler : GameModeJoinSuccessHandlerBase
{
//private readonly BattleInstanceRoom m_battle_instance_room;
public TPSTeamDeathMatchJoinSuccessHandler(Player player, InstanceRoom instanceRoom) : base(player, GameModeType.TPS_TDM, instanceRoom)
{
var room_id = instanceRoom.getMap().m_room_id;
//var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
//NullReferenceCheckHelper.throwIfNull(battle_instance_room, () => $"m_battle_instance_room is null !!!");
//m_battle_instance_room = battle_instance_room;
}
public override Result joinSuccessValidate()
{
var result = new Result();
return result;
}
public override async Task<Result> joinSuccessConfirmation()
{
var result = new Result();
string err_msg = string.Empty;
await Task.CompletedTask;
return result;
}
public override async Task<Result> joinSuccessNotify()
{
var result = new Result();
await Task.CompletedTask;
return result;
}
public override void joinSuccessWriteLog()
{
}
}

39
GameServer/Contents/GameMode/Mode-Battle/ModeTeamDeathMatch/Manage/TPSTeamDeathMatchLeaveHandler.cs Normal file
View File

@@ -0,0 +1,39 @@
using GameServer.Contents.GameMode.Manage.LeaveManage;
using GameServer.Contents.GameMode.Manage.PlayManage;
using ServerCommon;
namespace GameServer.Contents.GameMode.Mode_Battle.Manage;
public class TPSTeamDeathMatchLeaveHandler : GameModeLeaveHandlerBase
{
public TPSTeamDeathMatchLeaveHandler(Player player, string roomId) : base(player, roomId, GameModeType.TPS_TDM)
{
}
public override async Task<Result> postLeave(IGameMode gameMode)
{
var result = new Result();
await Task.CompletedTask;
return new Result();
}
public override async Task<Result> notifyAfterLeave(IGameMode gameMode)
{
var result = new Result();
await Task.CompletedTask;
return result;
}
public override async Task<Result> logAfterLeave(IGameMode gameMode)
{
var result = new Result();
await Task.CompletedTask;
return result;
}
}

Some files were not shown because too many files have changed in this diff Show More