ascnet/AscNet.GameServer/Handlers/FightModule.cs

451 lines
20 KiB
C#
Raw Normal View History

2023-11-25 11:56:53 +00:00
using AscNet.Common.Database;
using AscNet.Common.MsgPack;
using static AscNet.Common.MsgPack.NotifyCharacterDataList;
2023-11-11 07:28:21 +00:00
using AscNet.Common.Util;
using AscNet.Common;
2023-12-10 02:01:51 +00:00
using AscNet.Table.V2.share.fuben;
using AscNet.Table.V2.share.item;
2023-11-24 13:01:26 +00:00
using AscNet.Table.V2.share.reward;
2023-10-14 17:16:45 +00:00
using MessagePack;
using AscNet.GameServer.Handlers.Drops;
2023-12-10 02:01:51 +00:00
using AscNet.Table.V2.share.robot;
using AscNet.Table.V2.share.character.skill;
2023-10-14 17:16:45 +00:00
namespace AscNet.GameServer.Handlers
{
2023-11-13 12:10:02 +00:00
#region MsgPackScheme
#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
2023-12-07 00:49:17 +00:00
public enum RewardType
2023-11-24 13:01:26 +00:00
{
Item = 1,
Character = 2,
Equip = 3,
Fashion = 4,
BaseEquip = 5,
Furniture = 9,
HeadPortrait = 10,
DormCharacter = 11,
ChatEmoji = 12,
WeaponFashion = 13,
Collection = 14,
Background = 15,
Pokemon = 16,
Partner = 17,
Nameplate = 18,
RankScore = 20,
Medal = 21,
DrawTicket = 22
}
[MessagePackObject(true)]
public class Operation
2023-12-02 10:54:49 +00:00
{
public bool? MoveOperated { get; set; }
public int MoveOperation { get; set; }
public int CameraRotationX { get; set; }
public int CameraRotationY { get; set; }
public int CameraInput { get; set; }
public long IncId { get; set; }
public int[] ClickOperation { get; set; }
public int[] SpecialOperation { get; set; }
}
2023-10-14 17:16:45 +00:00
[MessagePackObject(true)]
public class NpcHp
{
public int CharacterId { get; set; }
public int NpcId { get; set; }
public int Type { get; set; }
public int Level { get; set; }
public List<int> BuffIds { get; set; }
public Dictionary<int, dynamic> AttrTable { get; set; }
2023-10-14 17:16:45 +00:00
}
[MessagePackObject(true)]
public partial class NpcDpsTable
2023-10-14 17:16:45 +00:00
{
public int Value { get; set; }
public int MaxValue { get; set; }
public int RoleId { get; set; }
public int NpcId { get; set; }
public int CharacterId { get; set; }
public int DamageTotal { get; set; }
public int DamageNormal { get; set; }
public List<int> DamageMagic { get; set; } = new();
2023-10-14 17:16:45 +00:00
public int BreakEndure { get; set; }
public int Cure { get; set; }
public int Hurt { get; set; }
public int Type { get; set; }
public int Level { get; set; }
public List<int> BuffIds { get; set; } = new();
2023-10-14 17:16:45 +00:00
public dynamic AttrTable { get; set; }
}
2023-10-14 17:16:45 +00:00
[MessagePackObject(true)]
public class FightSettleResult
{
public bool IsWin { get; set; }
public bool IsForceExit { get; set; }
2023-11-13 12:10:02 +00:00
public uint StageId { get; set; }
2023-10-14 17:16:45 +00:00
public int StageLevel { get; set; }
public long FightId { get; set; }
2023-10-14 17:16:45 +00:00
public int RebootCount { get; set; }
public int AddStars { get; set; }
public long StartFrame { get; set; }
public long SettleFrame { get; set; }
public long PauseFrame { get; set; }
public long ExSkillPauseFrame { get; set; }
public long SettleCode { get; set; }
2023-10-14 17:16:45 +00:00
public int DodgeTimes { get; set; }
public int NormalAttackTimes { get; set; }
public int ConsumeBallTimes { get; set; }
public int StuntSkillTimes { get; set; }
public int PauseTimes { get; set; }
public int HighestCombo { get; set; }
public int DamagedTimes { get; set; }
public int MatrixTimes { get; set; }
public long HighestDamage { get; set; }
public long TotalDamage { get; set; }
public long TotalDamaged { get; set; }
public long TotalCure { get; set; }
public long[] PlayerIds { get; set; }
public dynamic[] PlayerData { get; set; }
public dynamic? IntToIntRecord { get; set; }
public dynamic? StringToIntRecord { get; set; }
public Dictionary<long, Operation> Operations { get; set; }
public long[] Codes { get; set; }
public long LeftTime { get; set; }
2023-10-14 17:16:45 +00:00
public Dictionary<int, NpcHp> NpcHpInfo { get; set; }
public Dictionary<int, NpcDpsTable> NpcDpsTable { get; set; }
public dynamic[] EventSet { get; set; }
public long DeathTotalMyTeam { get; set; }
public long DeathTotalEnemy { get; set; }
public Dictionary<int, int> DeathRecord { get; set; } = new();
public dynamic[] GroupDropDatas { get; set; }
public dynamic? EpisodeFightResults { get; set; }
public dynamic? CustomData { get; set; }
2023-10-14 17:16:45 +00:00
}
2023-12-02 10:54:49 +00:00
2023-10-14 17:16:45 +00:00
[MessagePackObject(true)]
public class FightSettleRequest
{
public FightSettleResult Result { get; set; }
}
2023-12-12 03:45:17 +00:00
[MessagePackObject(true)]
public class FightRebootRequest
{
public int FightId { get; set; }
public int RebootCount { get; set; }
}
[MessagePackObject(true)]
public class FightRebootResponse
{
public int Code { get; set; }
}
2023-11-13 12:10:02 +00:00
#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
#endregion
2023-10-14 17:16:45 +00:00
internal class FightModule
{
[RequestPacketHandler("PreFightRequest")]
public static void PreFightRequestHandler(Session session, Packet.Request packet)
{
PreFightRequest req = MessagePackSerializer.Deserialize<PreFightRequest>(packet.Content);
2023-10-14 17:34:14 +00:00
2023-12-10 02:01:51 +00:00
StageTable? stageTable = TableReaderV2.Parse<StageTable>().Find(x => x.StageId == req.PreFightData.StageId);
2023-11-11 07:28:21 +00:00
if (stageTable is null)
{
// FubenManagerCheckPreFightStageInfoNotFound
session.SendResponse(new PreFightResponse() { Code = 20003012 }, packet.Id);
return;
}
2023-12-09 14:01:06 +00:00
var levelControl = TableReaderV2.Parse<Table.V2.share.fuben.StageLevelControlTable>().Where(x => x.StageId == stageTable.StageId).OrderBy(x => Math.Abs(session.player.PlayerData.Level - x.MaxLevel)).FirstOrDefault();
2023-11-11 07:28:21 +00:00
PreFightResponse rsp = new()
{
Code = 0,
FightData = new()
{
Online = false,
FightId = req.PreFightData.StageId + (uint)Random.Shared.NextInt64(0, uint.MaxValue - req.PreFightData.StageId),
OnlineMode = 0,
Seed = (uint)Random.Shared.NextInt64(0, uint.MaxValue),
StageId = req.PreFightData.StageId,
2023-12-10 02:01:51 +00:00
RebootId = stageTable.RebootId ?? 0,
2023-12-12 08:13:09 +00:00
PassTimeLimit = stageTable.PassTimeLimit ?? 0,
2023-12-09 14:01:06 +00:00
StarsMark = 0,
MonsterLevel = levelControl?.MonsterLevel ?? new()
2023-11-11 07:28:21 +00:00
}
};
rsp.FightData.RoleData.Add(new()
{
Id = (uint)session.player.PlayerData.Id,
Camp = 1,
Name = session.player.PlayerData.Name,
IsRobot = false,
NpcData = new()
});
2023-11-24 13:01:26 +00:00
if (req.PreFightData?.CardIds is not null)
2023-11-11 07:28:21 +00:00
{
2023-11-24 13:01:26 +00:00
for (int i = 0; i < req.PreFightData.CardIds.Count; i++)
2023-11-11 07:28:21 +00:00
{
2023-11-24 13:01:26 +00:00
uint cardId = req.PreFightData.CardIds[i];
var characterData = session.character.Characters.FirstOrDefault(x => x.Id == cardId);
if (characterData is null)
continue;
rsp.FightData.RoleData.First(x => x.Id == session.player.PlayerData.Id).NpcData.Add(i, new
{
Character = characterData,
Equips = session.character.Equips.Where(x => x.CharacterId == cardId)
});
}
2023-11-11 07:28:21 +00:00
}
2023-12-10 02:01:51 +00:00
if (req.PreFightData?.CardIds is null || (req.PreFightData.CardIds.Count + stageTable.RobotId.Count) == 3)
{
int npcKey = rsp.FightData.RoleData.First(x => x.Id == session.player.PlayerData.Id).NpcData.Keys.Count;
foreach (var robotId in stageTable.RobotId)
{
RobotTable? robot = TableReaderV2.Parse<RobotTable>().Find(x => x.Id == robotId);
if (robot is null)
continue;
CharacterSkillTable? characterSkill = TableReaderV2.Parse<CharacterSkillTable>().Find(x => x.CharacterId == robot.CharacterId);
IEnumerable<int> skills = characterSkill?.SkillGroupId.SelectMany(x => TableReaderV2.Parse<CharacterSkillGroupTable>().Find(y => y.Id == x)?.SkillId ?? new List<int>()) ?? new List<int>();
List<EquipData> equips = new()
{
new()
{
TemplateId = (uint)robot.WeaponId,
Level = robot.WeaponLevel,
Breakthrough = robot.WeaponBeakThrough,
}
};
for (int i = 0; i < robot.WaferId.Count; i++)
{
equips.Add(new()
{
TemplateId = (uint)robot.WaferId[i],
Level = robot.WaferLevel[i],
Breakthrough = robot.WaferBreakThrough[i]
});
}
rsp.FightData.RoleData.First(x => x.Id == session.player.PlayerData.Id).NpcData.Add(npcKey, new
{
Character = new CharacterData()
{
Id = (uint)robot.CharacterId,
Level = robot.CharacterLevel,
Exp = 0,
Quality = robot.CharacterQuality,
InitQuality = robot.CharacterQuality,
Star = robot.CharacterStar,
Grade = robot.CharacterGrade,
2023-12-12 08:13:09 +00:00
SkillList = skills.Where(x => !robot.RemoveSkillId.Contains(x)).Select(x => new CharacterData.CharacterSkill() { Id = (uint)x, Level = Math.Min(robot.SkillLevel, TableReaderV2.Parse<CharacterSkillLevelEffectTable>().OrderByDescending(x => x.Level).FirstOrDefault(y => y.SkillId == x)?.Level ?? 1) }).ToList(),
2023-12-10 02:01:51 +00:00
FashionId = (uint)robot.FashionId,
CreateTime = 0,
TrustLv = 1,
TrustExp = 0,
Ability = robot.ShowAbility ?? 0,
LiberateLv = robot.LiberateLv ?? 0,
CharacterHeadInfo = new()
{
HeadFashionId = (uint)robot.FashionId
}
},
Equips = equips
});
npcKey++;
}
}
2023-12-07 11:37:38 +00:00
session.fight = new(req);
2023-10-14 17:34:14 +00:00
session.SendResponse(rsp, packet.Id);
2023-10-14 17:16:45 +00:00
}
2023-12-12 03:45:17 +00:00
[RequestPacketHandler("FightRebootRequest")]
public static void HandleFightRebootRequestHandler(Session session, Packet.Request packet)
{
FightRebootRequest req = MessagePackSerializer.Deserialize<FightRebootRequest>(packet.Content);
session.SendResponse(new FightRebootResponse(), packet.Id);
}
2023-10-14 17:16:45 +00:00
[RequestPacketHandler("TeamSetTeamRequest")]
public static void HandleTeamSetTeamRequestHandler(Session session, Packet.Request packet)
{
2023-12-02 10:54:49 +00:00
TeamSetTeamRequest req = MessagePackSerializer.Deserialize<TeamSetTeamRequest>(packet.Content);
session.player.TeamGroups[(int)session.player.PlayerData.CurrTeamId] = new()
{
CaptainPos = req.TeamData.CaptainPos,
FirstFightPos = req.TeamData.FirstFightPos,
TeamId = req.TeamData.TeamId,
TeamType = 1,
TeamName = req.TeamData.TeamName,
TeamData = req.TeamData.TeamData
};
2023-10-14 17:16:45 +00:00
session.SendResponse(new TeamSetTeamResponse(), packet.Id);
}
[RequestPacketHandler("EnterChallengeRequest")]
public static void HandleEnterChallengeRequestHandler(Session session, Packet.Request packet)
{
session.SendResponse(new EnterChallengeResponse(), packet.Id);
}
2023-10-14 17:16:45 +00:00
[RequestPacketHandler("FightSettleRequest")]
public static void FightSettleRequestHandler(Session session, Packet.Request packet)
{
FightSettleRequest req = MessagePackSerializer.Deserialize<FightSettleRequest>(packet.Content);
StageTable? stageTable = TableReaderV2.Parse<StageTable>().FirstOrDefault(x => x.StageId == req.Result.StageId);
2023-11-24 13:01:26 +00:00
if (stageTable is null)
{
// FightCheckManagerSettleCodeNotMatch
session.SendResponse(new FightSettleResponse() { Code = 20032004 }, packet.Id);
return;
}
2023-11-25 11:56:53 +00:00
2023-12-07 11:37:38 +00:00
int challengeCount = session.fight?.PreFight.PreFightData.ChallengeCount ?? 1;
stageTable.CardExp *= challengeCount;
stageTable.TeamExp *= challengeCount;
2023-11-24 13:01:26 +00:00
List<RewardGoods> rewards = new();
2023-12-07 11:37:38 +00:00
List<List<RewardGoods>> multiRewards = new();
2023-11-24 13:01:26 +00:00
List<RewardTable> rewardTables = TableReaderV2.Parse<RewardTable>().Where(x => session.stage.Stages.ContainsKey(req.Result.StageId) ? x.Id == stageTable.FinishDropId : (x.Id == stageTable.FinishDropId || x.Id == stageTable.FirstRewardId)).ToList();
2023-11-29 14:01:00 +00:00
if (rewardTables.Count == 0)
{
rewardTables.AddRange(TableReaderV2.Parse<RewardTable>().Where(x => session.stage.Stages.ContainsKey(req.Result.StageId) ? x.Id == stageTable.FinishRewardShow : (x.Id == stageTable.FinishRewardShow || x.Id == stageTable.FirstRewardShow)));
}
2023-11-24 13:01:26 +00:00
2023-11-25 11:56:53 +00:00
NotifyItemDataList notifyItemData = new();
notifyItemData.ItemDataList.Add(session.inventory.Do(Inventory.TeamExp, stageTable.TeamExp ?? 0));
2023-12-07 11:37:38 +00:00
for (int i = 0; i < challengeCount; i++)
2023-11-24 13:01:26 +00:00
{
2023-12-07 11:37:38 +00:00
foreach (var rewardGoodsId in rewardTables.SelectMany(x => x.SubIds))
2023-11-24 13:01:26 +00:00
{
2023-12-07 11:37:38 +00:00
RewardGoodsTable? rewardGood = TableReaderV2.Parse<RewardGoodsTable>().FirstOrDefault(x => x.Id == rewardGoodsId);
if (rewardGood is not null)
2023-11-24 13:01:26 +00:00
{
2023-12-07 11:37:38 +00:00
// Item type formula
int rewardTypeVal = (int)MathF.Floor((rewardGood.TemplateId > 0 ? rewardGood.TemplateId : rewardGood.Id) / 1000000) + 1;
RewardType rewardType = RewardType.Item;
try
{
rewardType = (RewardType)Enum.ToObject(typeof(RewardType), rewardTypeVal);
}
catch (Exception)
{
session.log.Error($"Failed to convert {rewardTypeVal} to {nameof(RewardType)} enum object!");
}
2023-11-24 13:01:26 +00:00
2023-12-07 11:37:38 +00:00
// TODO: Implement other types. Other types are behaving weirdly
if (rewardType == RewardType.Item)
{
2023-12-07 11:37:38 +00:00
ItemTable? itemData = TableReaderV2.Parse<ItemTable>().Find(x => x.Id == rewardGood.TemplateId);
if (itemData is not null)
{
2023-12-07 11:37:38 +00:00
// Custom handler for some items that aren't meant to be in the inventory.
DropHandlerDelegate? dropHandler = DropsHandlerFactory.GetDropHandler(itemData.Id);
if (itemData.IsHidden() && dropHandler is not null)
{
2023-12-07 11:37:38 +00:00
rewards.AddRange(dropHandler.Invoke(session, rewardGood.Count).Select(x => new RewardGoods()
{
Id = rewardGood.Id,
TemplateId = x.TemplateId,
Count = x.Count,
Level = x.Level,
RewardType = (int)x.Type,
Quality = x.Quality
}));
continue;
}
}
2023-12-07 11:37:38 +00:00
notifyItemData.ItemDataList.Add(session.inventory.Do(rewardGood.TemplateId, rewardGood.Count));
2023-11-24 13:06:14 +00:00
2023-12-07 11:37:38 +00:00
rewards.Add(new()
{
Id = rewardGood.Id,
TemplateId = rewardGood.TemplateId,
Count = rewardGood.Count,
RewardType = rewardTypeVal
});
}
2023-11-24 13:01:26 +00:00
}
}
2023-12-07 11:37:38 +00:00
multiRewards.Add(new List<RewardGoods>(rewards));
rewards.Clear();
2023-11-24 13:01:26 +00:00
}
2023-10-14 17:16:45 +00:00
2023-11-25 11:56:53 +00:00
session.SendPush(notifyItemData);
session.ExpSanityCheck();
if (stageTable.CardExp > 0)
{
Dictionary<int, long> team = session.player.TeamGroups[(int)session.player.PlayerData.CurrTeamId].TeamData;
NotifyCharacterDataList charData = new();
foreach (KeyValuePair<int, long> member in team)
{
2023-12-02 14:17:39 +00:00
if (member.Value > 0)
{
var character = session.character.AddCharacterExp((int)member.Value, stageTable.CardExp ?? 0, (int)session.player.PlayerData.Level);
if (character is not null)
charData.CharacterDataList.Add(character);
}
}
session.SendPush(charData);
}
2023-11-13 12:10:02 +00:00
StageDatum stageData = new()
{
StageId = req.Result.StageId,
StarsMark = 7,
Passed = true,
PassTimesToday = 0,
PassTimesTotal = 1,
BuyCount = 0,
Score = 0,
LastPassTime = (uint)DateTimeOffset.Now.ToUnixTimeSeconds(),
RefreshTime = (uint)DateTimeOffset.Now.ToUnixTimeSeconds(),
CreateTime = (uint)DateTimeOffset.Now.ToUnixTimeSeconds(),
BestRecordTime = 0,
LastRecordTime = 0,
BestCardIds = req.Result.NpcDpsTable.Where(x => x.Value.CharacterId > 0).Select(x => (long)x.Value.CharacterId).ToList(),
LastCardIds = req.Result.NpcDpsTable.Where(x => x.Value.CharacterId > 0).Select(x => (long)x.Value.CharacterId).ToList()
};
session.stage.AddStage(stageData);
2023-11-24 13:01:26 +00:00
FightSettleResponse fightSettleResponse = new()
{
Settle = new()
{
IsWin = true,
StageId = (uint)stageData.StageId,
StarsMark = (int)stageData.StarsMark,
2023-12-07 11:37:38 +00:00
RewardGoodsList = multiRewards.Count > 0 ? multiRewards.First() : rewards,
MultiRewardGoodsList = multiRewards,
2023-11-24 13:01:26 +00:00
NpcHpInfo = req.Result.NpcHpInfo,
2023-12-07 11:37:38 +00:00
ChallengeCount = challengeCount
2023-11-24 13:01:26 +00:00
}
};
2023-12-07 11:37:38 +00:00
session.fight = null;
2023-11-13 12:10:02 +00:00
session.SendPush(new NotifyStageData() { StageList = new() { stageData } });
2023-11-24 13:01:26 +00:00
session.SendResponse(fightSettleResponse, packet.Id);
2023-10-14 17:16:45 +00:00
}
}
}