StarRailPS/DanhengServer-OpenSource
1
0
Fork 0
mirror of https://github.com/EggLinks/DanhengServer-OpenSource.git synced 2026-01-03 04:36:03 +08:00
Code Issues Packages Projects Releases Wiki Activity

Feature:Asynchronous Operation & Formatting Code

Browse Source 
- Now the async operation is enabled!
- Code formatted by Resharper plugin <3
This commit is contained in:
Somebody
2024-07-22 17:12:03 +08:00
parent e983375620
commit 87d228eb79
793 changed files with 34764 additions and 40190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
Command/Command/Cmd/CommandAccount.cs
View File

@@ -1,62 +1,50 @@
using EggLink.DanhengServer.Data.Custom;
using EggLink.DanhengServer.Data;
using EggLink.DanhengServer.Database.Account;
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Util;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using EggLink.DanhengServer.Database.Account;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("account", "Game.Command.Account.Desc", "Game.Command.Account.Usage", permission: "egglink.manage")]
public class CommandAccount : ICommand
{
[CommandInfo("account", "Game.Command.Account.Desc", "Game.Command.Account.Usage", permission: "egglink.manage")]
public class CommandAccount : ICommand
[CommandMethod("create")]
public async ValueTask CreateAccount(CommandArg arg)
{
[CommandMethod("create")]
public void CreateAccount(CommandArg arg)
if (arg.Args.Count < 2)
{
if (arg.Args.Count < 2)
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var account = arg.Args[1];
var uid = 0;
if (arg.Args.Count > 2)
if (!int.TryParse(arg.Args[2], out uid))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
await arg.SendMsg(I18nManager.Translate("Game.Command.Account.InvalidUid"));
return;
}
string account = arg.Args[1];
int uid = 0;
if (AccountData.GetAccountByUserName(account) != null)
{
await arg.SendMsg(string.Format(I18nManager.Translate("Game.Command.Account.DuplicateAccount"), account));
return;
}
if (arg.Args.Count > 2)
{
if (!int.TryParse(arg.Args[2], out uid))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Account.InvalidUid"));
return;
}
}
if (uid != 0 && AccountData.GetAccountByUid(uid) != null)
{
await arg.SendMsg(string.Format(I18nManager.Translate("Game.Command.Account.DuplicateUID"), uid));
return;
}
if (AccountData.GetAccountByUserName(account) != null)
{
arg.SendMsg(string.Format(I18nManager.Translate("Game.Command.Account.DuplicateAccount"), account));
return;
}
if (uid != 0 && AccountData.GetAccountByUid(uid) != null)
{
arg.SendMsg(string.Format(I18nManager.Translate("Game.Command.Account.DuplicateUID"), uid));
return;
}
try
{
AccountHelper.CreateAccount(account, uid);
arg.SendMsg(I18nManager.Translate("Game.Command.Account.CreateSuccess", account));
}
catch (Exception ex)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Account.CreateError", ex.Message));
return;
}
try
{
AccountHelper.CreateAccount(account, uid);
await arg.SendMsg(I18nManager.Translate("Game.Command.Account.CreateSuccess", account));
}
catch (Exception ex)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Account.CreateError", ex.Message));
}
}
}
}

359
Command/Command/Cmd/CommandAvatar.cs
View File

@@ -1,213 +1,218 @@
using EggLink.DanhengServer.Data;
using EggLink.DanhengServer.Database;
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Proto;
using EggLink.DanhengServer.Server.Packet.Send.Player;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("avatar", "Game.Command.Avatar.Desc", "Game.Command.Avatar.Usage")]
public class CommandAvatar : ICommand
{
[CommandInfo("avatar", "Game.Command.Avatar.Desc", "Game.Command.Avatar.Usage")]
public class CommandAvatar : ICommand
[CommandMethod("talent")]
public async ValueTask SetTalent(CommandArg arg)
{
[CommandMethod("talent")]
public void SetTalent(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 2)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
// change basic type
var avatarId = arg.GetInt(0);
var level = arg.GetInt(1);
if (level < 0 || level > 10)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.InvalidLevel",
I18nManager.Translate("Word.Talent")));
return;
}
var player = arg.Target.Player!;
if (avatarId == -1)
{
player.AvatarManager!.AvatarData.Avatars.ForEach(avatar =>
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 2)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var Player = arg.Target.Player!;
// change basic type
var avatarId = arg.GetInt(0);
var level = arg.GetInt(1);
if (level < 0 || level > 10)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.InvalidLevel", I18nManager.Translate("Word.Talent")));
return;
}
var player = arg.Target.Player!;
if (avatarId == -1)
{
player.AvatarManager!.AvatarData.Avatars.ForEach(avatar =>
if (avatar.HeroId > 0)
{
if (avatar.HeroId > 0)
avatar.SkillTreeExtra.TryGetValue(avatar.HeroId, out var hero);
hero ??= [];
var excel = GameData.AvatarConfigData[avatar.HeroId];
excel.SkillTree.ForEach(talent => { hero[talent.PointID] = Math.Min(level, talent.MaxLevel); });
}
else
{
avatar.Excel?.SkillTree.ForEach(talent =>
{
avatar.SkillTreeExtra.TryGetValue(avatar.HeroId, out var hero);
hero ??= [];
var excel = GameData.AvatarConfigData[avatar.HeroId];
excel.SkillTree.ForEach(talent =>
{
hero[talent.PointID] = Math.Min(level, talent.MaxLevel);
});
} else
{
avatar.Excel?.SkillTree.ForEach(talent =>
{
avatar.SkillTree![talent.PointID] = Math.Min(level, talent.MaxLevel);
});
}
});
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AllAvatarsLevelSet", I18nManager.Translate("Word.Talent"), level.ToString()));
// sync
player.SendPacket(new PacketPlayerSyncScNotify(player.AvatarManager.AvatarData.Avatars));
return;
}
var avatar = player.AvatarManager!.GetAvatar(avatarId);
if (avatar == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarNotFound"));
return;
}
avatar.Excel?.SkillTree.ForEach(talent =>
{
avatar.SkillTree![talent.PointID] = Math.Min(level, talent.MaxLevel);
avatar.SkillTree[talent.PointID] = Math.Min(level, talent.MaxLevel);
});
}
});
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AllAvatarsLevelSet",
I18nManager.Translate("Word.Talent"), level.ToString()));
// sync
player.SendPacket(new PacketPlayerSyncScNotify(avatar));
await player.SendPacket(new PacketPlayerSyncScNotify(player.AvatarManager.AvatarData.Avatars));
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarLevelSet", avatar.Excel?.Name?.Replace("{NICKNAME}", player.Data.Name) ?? avatarId.ToString(), I18nManager.Translate("Word.Talent"), level.ToString()));
return;
}
[CommandMethod("get")]
public void GetAvatar(CommandArg arg)
var avatar = player.AvatarManager!.GetAvatar(avatarId);
if (avatar == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
}
var id = arg.GetInt(0);
var excel = arg.Target.Player!.AvatarManager!.AddAvatar(id);
if (excel == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarFailedGet", id.ToString()));
return;
}
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarGet", excel.Name ?? id.ToString()));
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarNotFound"));
return;
}
[CommandMethod("rank")]
public void SetRank(CommandArg arg)
avatar.Excel?.SkillTree.ForEach(talent =>
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
avatar.SkillTree[talent.PointID] = Math.Min(level, talent.MaxLevel);
});
if (arg.BasicArgs.Count < 2)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
}
// sync
await player.SendPacket(new PacketPlayerSyncScNotify(avatar));
var id = arg.GetInt(0);
var rank = arg.GetInt(1);
if (rank < 0 || rank > 6)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.InvalidLevel", I18nManager.Translate("Word.Rank")));
return;
}
if (id == -1)
{
arg.Target.Player!.AvatarManager!.AvatarData.Avatars.ForEach(avatar =>
{
avatar.Rank = Math.Min(rank, 6);
});
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AllAvatarsLevelSet", I18nManager.Translate("Word.Rank"), rank.ToString()));
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarLevelSet",
avatar.Excel?.Name?.Replace("{NICKNAME}", player.Data.Name) ?? avatarId.ToString(),
I18nManager.Translate("Word.Talent"), level.ToString()));
}
// sync
arg.Target.SendPacket(new PacketPlayerSyncScNotify(arg.Target.Player!.AvatarManager.AvatarData.Avatars));
}
else
[CommandMethod("get")]
public async ValueTask GetAvatar(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1) await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
var id = arg.GetInt(0);
var excel = await arg.Target.Player!.AvatarManager!.AddAvatar(id);
if (excel == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarFailedGet", id.ToString()));
return;
}
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarGet", excel.Name ?? id.ToString()));
}
[CommandMethod("rank")]
public async ValueTask SetRank(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 2) await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
var id = arg.GetInt(0);
var rank = arg.GetInt(1);
if (rank < 0 || rank > 6)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.InvalidLevel",
I18nManager.Translate("Word.Rank")));
return;
}
if (id == -1)
{
arg.Target.Player!.AvatarManager!.AvatarData.Avatars.ForEach(avatar =>
{
var avatar = arg.Target.Player!.AvatarManager!.GetAvatar(id);
if (avatar == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarNotFound"));
return;
}
avatar.Rank = Math.Min(rank, 6);
});
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AllAvatarsLevelSet",
I18nManager.Translate("Word.Rank"), rank.ToString()));
// sync
arg.Target.SendPacket(new PacketPlayerSyncScNotify(avatar));
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarLevelSet", avatar.Excel?.Name?.Replace("{NICKNAME}", arg.Target.Player!.Data.Name) ?? id.ToString(), I18nManager.Translate("Word.Rank"), rank.ToString()));
}
// sync
await arg.Target.SendPacket(
new PacketPlayerSyncScNotify(arg.Target.Player!.AvatarManager.AvatarData.Avatars));
}
[CommandMethod("level")]
public void SetLevel(CommandArg arg)
else
{
if (arg.Target == null)
var avatar = arg.Target.Player!.AvatarManager!.GetAvatar(id);
if (avatar == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarNotFound"));
return;
}
if (arg.BasicArgs.Count < 2)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
avatar.Rank = Math.Min(rank, 6);
var id = arg.GetInt(0);
var level = arg.GetInt(1);
if (level < 1 || level > 80)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.InvalidLevel", I18nManager.Translate("Word.Avatar")));
return;
}
// sync
await arg.Target.SendPacket(new PacketPlayerSyncScNotify(avatar));
if (id == -1)
{
arg.Target.Player!.AvatarManager!.AvatarData.Avatars.ForEach(avatar =>
{
avatar.Level = Math.Min(level, 80);
avatar.Promotion = GameData.GetMinPromotionForLevel(avatar.Level);
});
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AllAvatarsLevelSet", I18nManager.Translate("Word.Avatar"), level.ToString()));
// sync
arg.Target.SendPacket(new PacketPlayerSyncScNotify(arg.Target.Player!.AvatarManager.AvatarData.Avatars));
}
else
{
var avatar = arg.Target.Player!.AvatarManager!.GetAvatar(id);
if (avatar == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarNotFound"));
return;
}
avatar.Level = Math.Min(level, 80);
avatar.Promotion = GameData.GetMinPromotionForLevel(avatar.Level);
// sync
arg.Target.SendPacket(new PacketPlayerSyncScNotify(avatar));
arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarLevelSet", avatar.Excel?.Name?.Replace("{NICKNAME}", arg.Target.Player!.Data.Name) ?? id.ToString(), I18nManager.Translate("Word.Avatar"), level.ToString()));
}
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarLevelSet",
avatar.Excel?.Name?.Replace("{NICKNAME}", arg.Target.Player!.Data.Name) ?? id.ToString(),
I18nManager.Translate("Word.Rank"), rank.ToString()));
}
}
}
[CommandMethod("level")]
public async ValueTask SetLevel(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 2)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var id = arg.GetInt(0);
var level = arg.GetInt(1);
if (level < 1 || level > 80)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.InvalidLevel",
I18nManager.Translate("Word.Avatar")));
return;
}
if (id == -1)
{
arg.Target.Player!.AvatarManager!.AvatarData.Avatars.ForEach(avatar =>
{
avatar.Level = Math.Min(level, 80);
avatar.Promotion = GameData.GetMinPromotionForLevel(avatar.Level);
});
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AllAvatarsLevelSet",
I18nManager.Translate("Word.Avatar"), level.ToString()));
// sync
await arg.Target.SendPacket(
new PacketPlayerSyncScNotify(arg.Target.Player!.AvatarManager.AvatarData.Avatars));
}
else
{
var avatar = arg.Target.Player!.AvatarManager!.GetAvatar(id);
if (avatar == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarNotFound"));
return;
}
avatar.Level = Math.Min(level, 80);
avatar.Promotion = GameData.GetMinPromotionForLevel(avatar.Level);
// sync
await arg.Target.SendPacket(new PacketPlayerSyncScNotify(avatar));
await arg.SendMsg(I18nManager.Translate("Game.Command.Avatar.AvatarLevelSet",
avatar.Excel?.Name?.Replace("{NICKNAME}", arg.Target.Player!.Data.Name) ?? id.ToString(),
I18nManager.Translate("Word.Avatar"), level.ToString()));
}
}
}

88
Command/Command/Cmd/CommandGive.cs
View File

@@ -1,53 +1,51 @@
using EggLink.DanhengServer.Data;
using EggLink.DanhengServer.Database;
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Proto;
using EggLink.DanhengServer.Server.Packet.Send.Others;
using EggLink.DanhengServer.Server.Packet.Send.Tutorial;
using Org.BouncyCastle.Ocsp;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("give", "Game.Command.Give.Desc", "Game.Command.Give.Usage")]
public class CommandGive : ICommand
{
[CommandInfo("give", "Game.Command.Give.Desc", "Game.Command.Give.Usage")]
public class CommandGive : ICommand
[CommandDefault]
public async ValueTask GiveItem(CommandArg arg)
{
[CommandDefault]
public void GiveItem(CommandArg arg)
var player = arg.Target?.Player;
if (player == null)
{
var player = arg.Target?.Player;
if (player == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count == 0)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
GameData.ItemConfigData.TryGetValue(arg.GetInt(0), out var itemData);
if (itemData == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Give.ItemNotFound"));
return;
}
arg.CharacterArgs.TryGetValue("x", out var str);
arg.CharacterArgs.TryGetValue("l", out var levelStr);
arg.CharacterArgs.TryGetValue("r", out var rankStr);
str ??= "1";
levelStr ??= "1";
rankStr ??= "1";
if (!int.TryParse(str, out var amount) || !int.TryParse(levelStr, out var level) || !int.TryParse(rankStr, out var rank))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
player.InventoryManager!.AddItem(arg.GetInt(0), amount, rank: Math.Min(rank, 5), level: Math.Max(Math.Min(level, 80), 1));
arg.SendMsg(I18nManager.Translate("Game.Command.Give.GiveItem", player.Uid.ToString(), amount.ToString(), itemData.Name ?? itemData.ID.ToString()));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count == 0)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
GameData.ItemConfigData.TryGetValue(arg.GetInt(0), out var itemData);
if (itemData == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Give.ItemNotFound"));
return;
}
arg.CharacterArgs.TryGetValue("x", out var str);
arg.CharacterArgs.TryGetValue("l", out var levelStr);
arg.CharacterArgs.TryGetValue("r", out var rankStr);
str ??= "1";
levelStr ??= "1";
rankStr ??= "1";
if (!int.TryParse(str, out var amount) || !int.TryParse(levelStr, out var level) ||
!int.TryParse(rankStr, out var rank))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
await player.InventoryManager!.AddItem(arg.GetInt(0), amount, rank: Math.Min(rank, 5),
level: Math.Max(Math.Min(level, 80), 1));
await arg.SendMsg(I18nManager.Translate("Game.Command.Give.GiveItem", player.Uid.ToString(), amount.ToString(),
itemData.Name ?? itemData.ID.ToString()));
}
}
}

366
Command/Command/Cmd/CommandGiveall.cs
View File

@@ -1,205 +1,197 @@
using EggLink.DanhengServer.Data;
using EggLink.DanhengServer.Database;
using EggLink.DanhengServer.Database.Inventory;
using EggLink.DanhengServer.Enums.Item;
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Server.Packet.Send.Player;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("giveall", "Game.Command.GiveAll.Desc", "Game.Command.GiveAll.Usage")]
public class CommandGiveall : ICommand
{
[CommandInfo("giveall", "Game.Command.GiveAll.Desc", "Game.Command.GiveAll.Usage")]
public class CommandGiveall : ICommand
[CommandMethod("0 avatar")]
public async ValueTask GiveAllAvatar(CommandArg arg)
{
[CommandMethod("0 avatar")]
public void GiveAllAvatar(CommandArg arg)
var player = arg.Target?.Player;
if (player == null)
{
var player = arg.Target?.Player;
if (player == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
arg.CharacterArgs.TryGetValue("r", out var rankStr);
arg.CharacterArgs.TryGetValue("l", out var levelStr);
rankStr ??= "1";
levelStr ??= "1";
if (!int.TryParse(rankStr, out var rank) || !int.TryParse(levelStr, out var level))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var avatarList = GameData.AvatarConfigData.Values;
foreach (var avatar in avatarList)
{
if (player.AvatarManager!.GetAvatar(avatar.AvatarID) == null)
{
player.InventoryManager!.AddItem(avatar.AvatarID, 1, false, sync:false);
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Level = Math.Max(Math.Min(level, 80), 0);
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Promotion = GameData.GetMinPromotionForLevel(Math.Max(Math.Min(level, 80), 0));
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Rank = Math.Max(Math.Min(rank, 6), 0);
} else
{
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Level = Math.Max(Math.Min(level, 80), 0);
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Promotion = GameData.GetMinPromotionForLevel(Math.Max(Math.Min(level, 80), 0));
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Rank = Math.Max(Math.Min(rank, 6), 0);
}
}
player.SendPacket(new PacketPlayerSyncScNotify(player.AvatarManager!.AvatarData.Avatars));
arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems", I18nManager.Translate("Word.Avatar"), "1"));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
[CommandMethod("0 equipment")]
public void GiveAllLightcone(CommandArg arg)
arg.CharacterArgs.TryGetValue("r", out var rankStr);
arg.CharacterArgs.TryGetValue("l", out var levelStr);
rankStr ??= "1";
levelStr ??= "1";
if (!int.TryParse(rankStr, out var rank) || !int.TryParse(levelStr, out var level))
{
var player = arg.Target?.Player;
if (player == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
arg.CharacterArgs.TryGetValue("r", out var rankStr);
arg.CharacterArgs.TryGetValue("l", out var levelStr);
arg.CharacterArgs.TryGetValue("x", out var amountStr);
rankStr ??= "1";
levelStr ??= "1";
amountStr ??= "1";
if (!int.TryParse(rankStr, out var rank) || !int.TryParse(levelStr, out var level) || !int.TryParse(amountStr, out var amount))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var lightconeList = GameData.EquipmentConfigData.Values;
var items = new List<ItemData>();
for (int i = 0; i < amount; i++)
{
foreach (var lightcone in lightconeList)
{
var item = player.InventoryManager!.AddItem(lightcone.EquipmentID, 1, false, Math.Max(Math.Min(rank, 5), 0), Math.Max(Math.Min(level, 80), 0), sync:false);
if (item != null)
items.Add(item);
}
}
player.SendPacket(new PacketPlayerSyncScNotify(items));
arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems", I18nManager.Translate("Word.Equipment"), amount.ToString()));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
[CommandMethod("0 material")]
public void GiveAllMaterial(CommandArg arg)
{
var player = arg.Target?.Player;
if (player == null)
var avatarList = GameData.AvatarConfigData.Values;
foreach (var avatar in avatarList)
if (player.AvatarManager!.GetAvatar(avatar.AvatarID) == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
await player.InventoryManager!.AddItem(avatar.AvatarID, 1, false, sync: false);
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Level = Math.Max(Math.Min(level, 80), 0);
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Promotion =
GameData.GetMinPromotionForLevel(Math.Max(Math.Min(level, 80), 0));
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Rank = Math.Max(Math.Min(rank, 6), 0);
}
else
{
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Level = Math.Max(Math.Min(level, 80), 0);
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Promotion =
GameData.GetMinPromotionForLevel(Math.Max(Math.Min(level, 80), 0));
player.AvatarManager!.GetAvatar(avatar.AvatarID)!.Rank = Math.Max(Math.Min(rank, 6), 0);
}
arg.CharacterArgs.TryGetValue("x", out var amountStr);
amountStr ??= "1";
if (!int.TryParse(amountStr, out var amount))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
await player.SendPacket(new PacketPlayerSyncScNotify(player.AvatarManager!.AvatarData.Avatars));
var materialList = GameData.ItemConfigData.Values;
var items = new List<ItemData>();
foreach (var material in materialList)
{
if (material.ItemMainType == Enums.Item.ItemMainTypeEnum.Material)
{
items.Add(new()
{
ItemId = material.ID,
Count = amount
});
}
}
player.InventoryManager!.AddItems(items, false);
arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems", I18nManager.Translate("Word.Material"), amount.ToString()));
}
[CommandMethod("0 relic")]
public void GiveAllRelic(CommandArg arg)
{
var player = arg.Target?.Player;
if (player == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
arg.CharacterArgs.TryGetValue("l", out var levelStr);
levelStr ??= "1";
if (!int.TryParse(levelStr, out var level))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
arg.CharacterArgs.TryGetValue("x", out var amountStr);
amountStr ??= "1";
if (!int.TryParse(amountStr, out var amount))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var relicList = GameData.RelicConfigData.Values;
var items = new List<ItemData>();
for (int i = 0; i < amount; i++)
{
foreach (var relic in relicList)
{
var item = player.InventoryManager!.AddItem(relic.ID, amount, false, 1, Math.Max(Math.Min(level, relic.MaxLevel), 1), sync: false);
if (item != null)
items.Add(item);
}
}
player.SendPacket(new PacketPlayerSyncScNotify(items));
arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems", I18nManager.Translate("Word.Relic"), amount.ToString()));
}
[CommandMethod("0 unlock")]
public void GiveAllUnlock(CommandArg arg)
{
var player = arg.Target?.Player;
if (player == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var materialList = GameData.ItemConfigData.Values;
foreach (var material in materialList)
{
if (material.ItemMainType == Enums.Item.ItemMainTypeEnum.Usable)
{
if (material.ItemSubType == Enums.Item.ItemSubTypeEnum.HeadIcon || material.ItemSubType == Enums.Item.ItemSubTypeEnum.PhoneTheme || material.ItemSubType == Enums.Item.ItemSubTypeEnum.ChatBubble)
{
player.InventoryManager!.AddItem(material.ID, 1, false);
}
}
}
arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems", I18nManager.Translate("Word.Unlock"), "1"));
}
await arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems",
I18nManager.Translate("Word.Avatar"), "1"));
}
}
[CommandMethod("0 equipment")]
public async ValueTask GiveAllLightcone(CommandArg arg)
{
var player = arg.Target?.Player;
if (player == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
arg.CharacterArgs.TryGetValue("r", out var rankStr);
arg.CharacterArgs.TryGetValue("l", out var levelStr);
arg.CharacterArgs.TryGetValue("x", out var amountStr);
rankStr ??= "1";
levelStr ??= "1";
amountStr ??= "1";
if (!int.TryParse(rankStr, out var rank) || !int.TryParse(levelStr, out var level) ||
!int.TryParse(amountStr, out var amount))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var lightconeList = GameData.EquipmentConfigData.Values;
var items = new List<ItemData>();
for (var i = 0; i < amount; i++)
foreach (var lightcone in lightconeList)
{
var item = await player.InventoryManager!.AddItem(lightcone.EquipmentID, 1, false,
Math.Max(Math.Min(rank, 5), 0), Math.Max(Math.Min(level, 80), 0), false);
if (item != null)
items.Add(item);
}
await player.SendPacket(new PacketPlayerSyncScNotify(items));
await arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems",
I18nManager.Translate("Word.Equipment"), amount.ToString()));
}
[CommandMethod("0 material")]
public async ValueTask GiveAllMaterial(CommandArg arg)
{
var player = arg.Target?.Player;
if (player == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
arg.CharacterArgs.TryGetValue("x", out var amountStr);
amountStr ??= "1";
if (!int.TryParse(amountStr, out var amount))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var materialList = GameData.ItemConfigData.Values;
var items = new List<ItemData>();
foreach (var material in materialList)
if (material.ItemMainType == ItemMainTypeEnum.Material)
items.Add(new ItemData
{
ItemId = material.ID,
Count = amount
});
await player.InventoryManager!.AddItems(items, false);
await arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems",
I18nManager.Translate("Word.Material"), amount.ToString()));
}
[CommandMethod("0 relic")]
public async ValueTask GiveAllRelic(CommandArg arg)
{
var player = arg.Target?.Player;
if (player == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
arg.CharacterArgs.TryGetValue("l", out var levelStr);
levelStr ??= "1";
if (!int.TryParse(levelStr, out var level))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
arg.CharacterArgs.TryGetValue("x", out var amountStr);
amountStr ??= "1";
if (!int.TryParse(amountStr, out var amount))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var relicList = GameData.RelicConfigData.Values;
var items = new List<ItemData>();
for (var i = 0; i < amount; i++)
foreach (var relic in relicList)
{
var item = await player.InventoryManager!.AddItem(relic.ID, amount, false, 1,
Math.Max(Math.Min(level, relic.MaxLevel), 1), false);
if (item != null)
items.Add(item);
}
await player.SendPacket(new PacketPlayerSyncScNotify(items));
await arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems",
I18nManager.Translate("Word.Relic"), amount.ToString()));
}
[CommandMethod("0 unlock")]
public async ValueTask GiveAllUnlock(CommandArg arg)
{
var player = arg.Target?.Player;
if (player == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var materialList = GameData.ItemConfigData.Values;
foreach (var material in materialList)
if (material.ItemMainType == ItemMainTypeEnum.Usable)
if (material.ItemSubType == ItemSubTypeEnum.HeadIcon ||
material.ItemSubType == ItemSubTypeEnum.PhoneTheme ||
material.ItemSubType == ItemSubTypeEnum.ChatBubble)
await player.InventoryManager!.AddItem(material.ID, 1, false);
await arg.SendMsg(I18nManager.Translate("Game.Command.GiveAll.GiveAllItems",
I18nManager.Translate("Word.Unlock"), "1"));
}
}

44
Command/Command/Cmd/CommandHelp.cs
View File

@@ -1,34 +1,24 @@
using EggLink.DanhengServer.Internationalization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("help", "Game.Command.Help.Desc", "Game.Command.Help.Usage")]
public class CommandHelp : ICommand
{
[CommandInfo("help", "Game.Command.Help.Desc", "Game.Command.Help.Usage")]
public class CommandHelp : ICommand
[CommandDefault]
public async ValueTask Help(CommandArg arg)
{
[CommandDefault]
public void Help(CommandArg arg)
{
var commands = CommandManager.Instance?.CommandInfo.Values;
arg.SendMsg(I18nManager.Translate("Game.Command.Help.Commands"));
if (commands == null)
{
return;
}
var commands = CommandManager.Instance?.CommandInfo.Values;
await arg.SendMsg(I18nManager.Translate("Game.Command.Help.Commands"));
if (commands == null) return;
foreach (var command in commands)
{
var msg = $"/{command.Name} - {I18nManager.Translate(command.Description)}\n\n{I18nManager.Translate(command.Usage)}";
if (command.Permission != "")
{
msg += $"\n\n{I18nManager.Translate("Game.Command.Help.CommandPermission")} {command.Permission}";
}
arg.SendMsg(msg);
}
foreach (var command in commands)
{
var msg =
$"/{command.Name} - {I18nManager.Translate(command.Description)}\n\n{I18nManager.Translate(command.Usage)}";
if (command.Permission != "")
msg += $"\n\n{I18nManager.Translate("Game.Command.Help.CommandPermission")} {command.Permission}";
await arg.SendMsg(msg);
}
}
}
}

117
Command/Command/Cmd/CommandHero.cs
View File

@@ -2,74 +2,67 @@
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Proto;
using EggLink.DanhengServer.Server.Packet.Send.Avatar;
using EggLink.DanhengServer.Server.Packet.Send.Player;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("hero", "Game.Command.Hero.Desc", "Game.Command.Hero.Usage")]
public class CommandHero : ICommand
{
[CommandInfo("hero", "Game.Command.Hero.Desc", "Game.Command.Hero.Usage")]
public class CommandHero : ICommand
[CommandMethod("0 gender")]
public async ValueTask ChangeGender(CommandArg arg)
{
[CommandMethod("0 gender")]
public void ChangeGender(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var gender = (Gender)arg.GetInt(0);
if (gender == Gender.None)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Hero.GenderNotSpecified"));
return;
}
var player = arg.Target!.Player!;
player.Data.CurrentGender = gender;
player.ChangeHeroBasicType(HeroBasicTypeEnum.Warrior);
player.SendPacket(new PacketGetHeroBasicTypeInfoScRsp(player));
arg.SendMsg(I18nManager.Translate("Game.Command.Hero.GenderChanged"));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
[CommandMethod("0 type")]
public void ChangeType(CommandArg arg)
if (arg.BasicArgs.Count < 1)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
arg.SendMsg("");
return;
}
var gender = (HeroBasicTypeEnum)arg.GetInt(0);
if (gender == 0)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Hero.HeroTypeNotSpecified"));
return;
}
var player = arg.Target!.Player!;
player.ChangeHeroBasicType(gender);
arg.SendMsg(I18nManager.Translate("Game.Command.Hero.HeroTypeChanged"));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var gender = (Gender)arg.GetInt(0);
if (gender == Gender.None)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Hero.GenderNotSpecified"));
return;
}
var player = arg.Target!.Player!;
player.Data.CurrentGender = gender;
await player.ChangeHeroBasicType(HeroBasicTypeEnum.Warrior);
await player.SendPacket(new PacketGetHeroBasicTypeInfoScRsp(player));
await arg.SendMsg(I18nManager.Translate("Game.Command.Hero.GenderChanged"));
}
}
[CommandMethod("0 type")]
public async ValueTask ChangeType(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var gender = (HeroBasicTypeEnum)arg.GetInt(0);
if (gender == 0)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Hero.HeroTypeNotSpecified"));
return;
}
var player = arg.Target!.Player!;
await player.ChangeHeroBasicType(gender);
await arg.SendMsg(I18nManager.Translate("Game.Command.Hero.HeroTypeChanged"));
}
}

33
Command/Command/Cmd/CommandKick.cs
View File

@@ -1,27 +1,22 @@
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Server.Packet.Send.Player;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("kick", "Game.Command.Kick.Desc", "Game.Command.Kick.Usage", permission: "egglink.manage")]
public class CommandKick : ICommand
{
[CommandInfo("kick", "Game.Command.Kick.Desc", "Game.Command.Kick.Usage", permission: "egglink.manage")]
public class CommandKick : ICommand
[CommandDefault]
public async ValueTask Kick(CommandArg arg)
{
[CommandDefault]
public void Kick(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
arg.Target.SendPacket(new PacketPlayerKickOutScNotify());
arg.SendMsg(I18nManager.Translate("Game.Command.Kick.PlayerKicked", arg.Target.Player!.Data.Name!));
arg.Target.Stop();
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
await arg.Target.SendPacket(new PacketPlayerKickOutScNotify());
await arg.SendMsg(I18nManager.Translate("Game.Command.Kick.PlayerKicked", arg.Target.Player!.Data.Name!));
arg.Target.Stop();
}
}
}

64
Command/Command/Cmd/CommandLineup.cs
View File

@@ -1,45 +1,37 @@
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Server.Packet.Send.Lineup;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("lineup", "Game.Command.Lineup.Desc", "Game.Command.Lineup.Usage")]
public class CommandLineup : ICommand
{
[CommandInfo("lineup", "Game.Command.Lineup.Desc", "Game.Command.Lineup.Usage")]
public class CommandLineup : ICommand
[CommandMethod("0 mp")]
public async ValueTask SetLineupMp(CommandArg arg)
{
[CommandMethod("0 mp")]
public void SetLineupMp(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var count = arg.GetInt(0);
arg.Target.Player!.LineupManager!.GainMp(count == 0 ? 2: count);
arg.SendMsg(I18nManager.Translate("Game.Command.Lineup.PlayerGainedMp", Math.Min(count, 2).ToString()));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
[CommandMethod("0 heal")]
public void HealLineup(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var player = arg.Target.Player!;
foreach (var avatar in player.LineupManager!.GetCurLineup()!.AvatarData!.Avatars)
{
avatar.CurrentHp = 10000;
}
player.SendPacket(new PacketSyncLineupNotify(player.LineupManager.GetCurLineup()!));
arg.SendMsg(I18nManager.Translate("Game.Command.Lineup.HealedAllAvatars"));
}
var count = arg.GetInt(0);
await arg.Target.Player!.LineupManager!.GainMp(count == 0 ? 2 : count);
await arg.SendMsg(I18nManager.Translate("Game.Command.Lineup.PlayerGainedMp", Math.Min(count, 2).ToString()));
}
}
[CommandMethod("0 heal")]
public async ValueTask HealLineup(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var player = arg.Target.Player!;
foreach (var avatar in player.LineupManager!.GetCurLineup()!.AvatarData!.Avatars) avatar.CurrentHp = 10000;
await player.SendPacket(new PacketSyncLineupNotify(player.LineupManager.GetCurLineup()!));
await arg.SendMsg(I18nManager.Translate("Game.Command.Lineup.HealedAllAvatars"));
}
}

58
Command/Command/Cmd/CommandMail.cs
View File

@@ -1,39 +1,33 @@
using EggLink.DanhengServer.Internationalization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Command.Cmd
namespace EggLink.DanhengServer.Command.Command.Cmd;
[CommandInfo("mail", "Game.Command.Mail.Desc", "Game.Command.Mail.Usage", permission: "")]
public class CommandMail : ICommand
{
[CommandInfo("mail", "Game.Command.Mail.Desc", "Game.Command.Mail.Usage", permission: "")]
public class CommandMail : ICommand
[CommandDefault]
public async ValueTask Mail(CommandArg arg)
{
[CommandDefault]
public void Mail(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.Args.Count < 5)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var sender = arg.Args[0];
var title = arg.Args[1];
var content = arg.Args[2];
var templateId = int.Parse(arg.Args[3]);
var expiredDay = int.Parse(arg.Args[4]);
arg.Target.Player!.MailManager!.SendMail(sender, title, content, templateId, expiredDay);
arg.SendMsg(I18nManager.Translate("Game.Command.Mail.MailSent"));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.Args.Count < 5)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var sender = arg.Args[0];
var title = arg.Args[1];
var content = arg.Args[2];
var templateId = int.Parse(arg.Args[3]);
var expiredDay = int.Parse(arg.Args[4]);
await arg.Target.Player!.MailManager!.SendMail(sender, title, content, templateId, expiredDay);
await arg.SendMsg(I18nManager.Translate("Game.Command.Mail.MailSent"));
}
}
}

359
Command/Command/Cmd/CommandMission.cs
View File

@@ -1,191 +1,182 @@
using EggLink.DanhengServer.Internationalization;
using System.Collections.Generic;
using System.Text;
using System.Text;
using EggLink.DanhengServer.Enums;
using EggLink.DanhengServer.Internationalization;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("mission", "Game.Command.Mission.Desc", "Game.Command.Mission.Usage")]
public class CommandMission : ICommand
{
[CommandInfo("mission", "Game.Command.Mission.Desc", "Game.Command.Mission.Usage")]
public class CommandMission : ICommand
[CommandMethod("0 pass")]
public async ValueTask PassRunningMission(CommandArg arg)
{
[CommandMethod("0 pass")]
public void PassRunningMission(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var mission = arg.Target!.Player!.MissionManager!;
var count = mission.GetRunningSubMissionIdList().Count;
mission.GetRunningSubMissionIdList().ForEach(mission.FinishSubMission);
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.AllRunningMissionsFinished", count.ToString()));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
[CommandMethod("0 finish")]
public void FinishRunningMission(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
if (!int.TryParse(arg.BasicArgs[0], out var missionId))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.InvalidMissionId"));
return;
}
var mission = arg.Target!.Player!.MissionManager!;
mission.FinishSubMission(missionId);
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.MissionFinished", missionId.ToString()));
}
[CommandMethod("0 running")]
public void ListRunningMission(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var mission = arg.Target!.Player!.MissionManager!;
var runningMissions = mission.GetRunningSubMissionList();
if (runningMissions.Count == 0)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.NoRunningMissions"));
return;
}
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.RunningMissions"));
Dictionary<int, List<int>> missionMap = [];
foreach (var m in runningMissions)
{
if (!missionMap.TryGetValue(m.MainMissionID, out List<int>? value))
{
value = [];
missionMap[m.MainMissionID] = value;
}
value.Add(m.ID);
}
var possibleStuckIds = new List<int>();
var morePossibleStuckIds = new List<int>();
foreach (var list in missionMap)
{
arg.SendMsg($"{I18nManager.Translate("Game.Command.Mission.MainMission")} {list.Key}：");
var sb = new StringBuilder();
foreach (var id in list.Value)
{
sb.Append($"{id}、");
if (id.ToString().StartsWith("10"))
{
possibleStuckIds.Add(id);
var info = mission.GetSubMissionInfo(id);
if (info != null && info.FinishType == Enums.MissionFinishTypeEnum.PropState)
{
morePossibleStuckIds.Add(id);
}
}
}
sb.Remove(sb.Length - 1, 1);
arg.SendMsg(sb.ToString());
}
if (morePossibleStuckIds.Count > 0)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.PossibleStuckMissions"));
var sb = new StringBuilder();
foreach (var id in morePossibleStuckIds)
{
sb.Append($"{id}、");
}
sb.Remove(sb.Length - 1, 1);
arg.SendMsg(sb.ToString());
}
else if (possibleStuckIds.Count > 0)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.PossibleStuckMissions"));
var sb = new StringBuilder();
foreach (var id in possibleStuckIds)
{
sb.Append($"{id}、");
}
sb.Remove(sb.Length - 1, 1);
arg.SendMsg(sb.ToString());
}
}
[CommandMethod("0 reaccept")]
public void ReAcceptMission(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
if (!int.TryParse(arg.BasicArgs[0], out var missionId))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.InvalidMissionId"));
return;
}
var mission = arg.Target!.Player!.MissionManager!;
mission.ReAcceptMainMission(missionId);
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.MissionReAccepted", missionId.ToString()));
}
[CommandMethod("0 finishmain")]
public void FinishMainMission(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
if (!int.TryParse(arg.BasicArgs[0], out var missionId))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.InvalidMissionId"));
return;
}
var mission = arg.Target!.Player!.MissionManager!;
mission.FinishMainMission(missionId);
arg.SendMsg(I18nManager.Translate("Game.Command.Mission.MissionFinished", missionId.ToString()));
}
var mission = arg.Target!.Player!.MissionManager!;
var count = mission.GetRunningSubMissionIdList().Count;
foreach (var id in mission.GetRunningSubMissionIdList()) await mission.FinishSubMission(id);
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.AllRunningMissionsFinished", count.ToString()));
}
}
[CommandMethod("0 finish")]
public async ValueTask FinishRunningMission(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
if (!int.TryParse(arg.BasicArgs[0], out var missionId))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.InvalidMissionId"));
return;
}
var mission = arg.Target!.Player!.MissionManager!;
await mission.FinishSubMission(missionId);
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.MissionFinished", missionId.ToString()));
}
[CommandMethod("0 running")]
public async ValueTask ListRunningMission(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var mission = arg.Target!.Player!.MissionManager!;
var runningMissions = mission.GetRunningSubMissionList();
if (runningMissions.Count == 0)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.NoRunningMissions"));
return;
}
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.RunningMissions"));
Dictionary<int, List<int>> missionMap = [];
foreach (var m in runningMissions)
{
if (!missionMap.TryGetValue(m.MainMissionID, out var value))
{
value = [];
missionMap[m.MainMissionID] = value;
}
value.Add(m.ID);
}
var possibleStuckIds = new List<int>();
var morePossibleStuckIds = new List<int>();
foreach (var list in missionMap)
{
await arg.SendMsg($"{I18nManager.Translate("Game.Command.Mission.MainMission")} {list.Key}：");
var sb = new StringBuilder();
foreach (var id in list.Value)
{
sb.Append($"{id}、");
if (!id.ToString().StartsWith("10")) continue;
possibleStuckIds.Add(id);
var info = mission.GetSubMissionInfo(id);
if (info?.FinishType == MissionFinishTypeEnum.PropState) morePossibleStuckIds.Add(id);
}
sb.Remove(sb.Length - 1, 1);
await arg.SendMsg(sb.ToString());
}
if (morePossibleStuckIds.Count > 0)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.PossibleStuckMissions"));
var sb = new StringBuilder();
foreach (var id in morePossibleStuckIds) sb.Append($"{id}、");
sb.Remove(sb.Length - 1, 1);
await arg.SendMsg(sb.ToString());
}
else if (possibleStuckIds.Count > 0)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.PossibleStuckMissions"));
var sb = new StringBuilder();
foreach (var id in possibleStuckIds) sb.Append($"{id}、");
sb.Remove(sb.Length - 1, 1);
await arg.SendMsg(sb.ToString());
}
await Task.CompletedTask;
}
[CommandMethod("0 reaccept")]
public async ValueTask ReAcceptMission(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
if (!int.TryParse(arg.BasicArgs[0], out var missionId))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.InvalidMissionId"));
return;
}
var mission = arg.Target!.Player!.MissionManager!;
await mission.ReAcceptMainMission(missionId);
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.MissionReAccepted", missionId.ToString()));
}
[CommandMethod("0 finishmain")]
public async ValueTask FinishMainMission(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 1)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
if (!int.TryParse(arg.BasicArgs[0], out var missionId))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.InvalidMissionId"));
return;
}
var mission = arg.Target!.Player!.MissionManager!;
await mission.FinishMainMission(missionId);
await arg.SendMsg(I18nManager.Translate("Game.Command.Mission.MissionFinished", missionId.ToString()));
}
}

34
Command/Command/Cmd/CommandRaid.cs
View File

@@ -1,27 +1,21 @@
using EggLink.DanhengServer.Internationalization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Command.Cmd
namespace EggLink.DanhengServer.Command.Command.Cmd;
[CommandInfo("raid", "Game.Command.Raid.Desc", "Game.Command.Raid.Usage", permission: "")]
public class CommandRaid : ICommand
{
[CommandInfo("raid", "Game.Command.Raid.Desc", "Game.Command.Raid.Usage", permission: "")]
public class CommandRaid : ICommand
[CommandMethod("0 leave")]
public async ValueTask Leave(CommandArg arg)
{
[CommandMethod("0 leave")]
public void Leave(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
arg.Target.Player!.RaidManager!.LeaveRaid(false);
arg.SendMsg(I18nManager.Translate("Game.Command.Raid.Leaved"));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
await arg.Target.Player!.RaidManager!.LeaveRaid(false);
await arg.SendMsg(I18nManager.Translate("Game.Command.Raid.Leaved"));
}
}
}

268
Command/Command/Cmd/CommandRelic.cs
View File

@@ -2,148 +2,138 @@
using EggLink.DanhengServer.Database.Inventory;
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Util;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("relic", "Game.Command.Relic.Desc", "Game.Command.Relic.Usage")]
public class CommandRelic : ICommand
{
[CommandInfo("relic", "Game.Command.Relic.Desc", "Game.Command.Relic.Usage")]
public class CommandRelic : ICommand
[CommandDefault]
public async ValueTask GiveRelic(CommandArg arg)
{
[CommandDefault]
public void GiveRelic(CommandArg arg)
var player = arg.Target?.Player;
if (player == null)
{
var player = arg.Target?.Player;
if (player == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 3)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
arg.CharacterArgs.TryGetValue("x", out var str);
arg.CharacterArgs.TryGetValue("l", out var levelStr);
str ??= "1";
levelStr ??= "1";
if (!int.TryParse(str, out var amount) || !int.TryParse(levelStr, out var level))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
GameData.RelicConfigData.TryGetValue(int.Parse(arg.BasicArgs[0]), out var itemConfig);
GameData.ItemConfigData.TryGetValue(int.Parse(arg.BasicArgs[0]), out var itemConfigExcel);
if (itemConfig == null || itemConfigExcel == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Relic.RelicNotFound"));
return;
}
GameData.RelicSubAffixData.TryGetValue(itemConfig.SubAffixGroup, out var subAffixConfig);
GameData.RelicMainAffixData.TryGetValue(itemConfig.MainAffixGroup, out var mainAffixConfig);
if (subAffixConfig == null || mainAffixConfig == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Relic.RelicNotFound"));
return;
}
int startIndex = 1;
int mainAffixId;
if (arg.BasicArgs[1].Contains(':'))
{
// random main affix
mainAffixId = mainAffixConfig.Keys.ToList().RandomElement();
}
else
{
mainAffixId = int.Parse(arg.BasicArgs[1]);
if (!mainAffixConfig.ContainsKey(mainAffixId))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Relic.InvalidMainAffixId"));
return;
}
startIndex++;
}
var remainLevel = 5;
var subAffixes = new List<(int, int)>();
for (var i = startIndex; i < arg.BasicArgs.Count; i++)
{
var subAffix = arg.BasicArgs[i].Split(':');
if (subAffix.Length != 2 || !int.TryParse(subAffix[0], out var subId) || !int.TryParse(subAffix[1], out var subLevel))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
if (!subAffixConfig.ContainsKey(subId))
{
arg.SendMsg(I18nManager.Translate("Game.Command.Relic.InvalidSubAffixId"));
return;
}
subAffixes.Add((subId, subLevel));
remainLevel -= subLevel - 1;
}
if (subAffixes.Count < 4)
{
// random sub affix
var subAffixGroup = itemConfig.SubAffixGroup;
var subAffixGroupConfig = GameData.RelicSubAffixData[subAffixGroup];
var subAffixGroupKeys = subAffixGroupConfig.Keys.ToList();
while (subAffixes.Count < 4)
{
var subId = subAffixGroupKeys.RandomElement();
if (subAffixes.Any(x => x.Item1 == subId))
{
continue;
}
if (remainLevel <= 0)
{
subAffixes.Add((subId, 1));
}
else
{
var subLevel = Random.Shared.Next(1, Math.Min(remainLevel + 1, 5)) + 1;
subAffixes.Add((subId, subLevel));
remainLevel -= subLevel - 1;
}
}
}
var itemData = new ItemData()
{
ItemId = int.Parse(arg.BasicArgs[0]),
Level = Math.Max(Math.Min(level, 9999), 1),
UniqueId = ++player.InventoryManager!.Data.NextUniqueId,
MainAffix = mainAffixId,
Count = 1,
};
foreach (var (subId, subLevel) in subAffixes)
{
subAffixConfig.TryGetValue(subId, out var subAffix);
var aff = new ItemSubAffix(subAffix!, 1);
for (var i = 1; i < subLevel; i++)
{
aff.IncreaseStep(subAffix!.StepNum);
}
itemData.SubAffixes.Add(aff);
}
for (var i = 0; i < amount; i++)
{
player.InventoryManager!.AddItem(itemData, notify: false);
}
arg.SendMsg(I18nManager.Translate("Game.Command.Relic.RelicGiven", player.Uid.ToString(), amount.ToString(), itemConfigExcel.Name ?? itemData.ItemId.ToString(), itemData.MainAffix.ToString()));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.BasicArgs.Count < 3)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
arg.CharacterArgs.TryGetValue("x", out var str);
arg.CharacterArgs.TryGetValue("l", out var levelStr);
str ??= "1";
levelStr ??= "1";
if (!int.TryParse(str, out var amount) || !int.TryParse(levelStr, out var level))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
GameData.RelicConfigData.TryGetValue(int.Parse(arg.BasicArgs[0]), out var itemConfig);
GameData.ItemConfigData.TryGetValue(int.Parse(arg.BasicArgs[0]), out var itemConfigExcel);
if (itemConfig == null || itemConfigExcel == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Relic.RelicNotFound"));
return;
}
GameData.RelicSubAffixData.TryGetValue(itemConfig.SubAffixGroup, out var subAffixConfig);
GameData.RelicMainAffixData.TryGetValue(itemConfig.MainAffixGroup, out var mainAffixConfig);
if (subAffixConfig == null || mainAffixConfig == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Relic.RelicNotFound"));
return;
}
var startIndex = 1;
int mainAffixId;
if (arg.BasicArgs[1].Contains(':'))
{
// random main affix
mainAffixId = mainAffixConfig.Keys.ToList().RandomElement();
}
else
{
mainAffixId = int.Parse(arg.BasicArgs[1]);
if (!mainAffixConfig.ContainsKey(mainAffixId))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Relic.InvalidMainAffixId"));
return;
}
startIndex++;
}
var remainLevel = 5;
var subAffixes = new List<(int, int)>();
for (var i = startIndex; i < arg.BasicArgs.Count; i++)
{
var subAffix = arg.BasicArgs[i].Split(':');
if (subAffix.Length != 2 || !int.TryParse(subAffix[0], out var subId) ||
!int.TryParse(subAffix[1], out var subLevel))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
if (!subAffixConfig.ContainsKey(subId))
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Relic.InvalidSubAffixId"));
return;
}
subAffixes.Add((subId, subLevel));
remainLevel -= subLevel - 1;
}
if (subAffixes.Count < 4)
{
// random sub affix
var subAffixGroup = itemConfig.SubAffixGroup;
var subAffixGroupConfig = GameData.RelicSubAffixData[subAffixGroup];
var subAffixGroupKeys = subAffixGroupConfig.Keys.ToList();
while (subAffixes.Count < 4)
{
var subId = subAffixGroupKeys.RandomElement();
if (subAffixes.Any(x => x.Item1 == subId)) continue;
if (remainLevel <= 0)
{
subAffixes.Add((subId, 1));
}
else
{
var subLevel = Random.Shared.Next(1, Math.Min(remainLevel + 1, 5)) + 1;
subAffixes.Add((subId, subLevel));
remainLevel -= subLevel - 1;
}
}
}
var itemData = new ItemData
{
ItemId = int.Parse(arg.BasicArgs[0]),
Level = Math.Max(Math.Min(level, 9999), 1),
UniqueId = ++player.InventoryManager!.Data.NextUniqueId,
MainAffix = mainAffixId,
Count = 1
};
foreach (var (subId, subLevel) in subAffixes)
{
subAffixConfig.TryGetValue(subId, out var subAffix);
var aff = new ItemSubAffix(subAffix!, 1);
for (var i = 1; i < subLevel; i++) aff.IncreaseStep(subAffix!.StepNum);
itemData.SubAffixes.Add(aff);
}
for (var i = 0; i < amount; i++) await player.InventoryManager!.AddItem(itemData, false);
await arg.SendMsg(I18nManager.Translate("Game.Command.Relic.RelicGiven", player.Uid.ToString(),
amount.ToString(), itemConfigExcel.Name ?? itemData.ItemId.ToString(), itemData.MainAffix.ToString()));
}
}
}

46
Command/Command/Cmd/CommandReload.cs
View File

@@ -1,31 +1,29 @@
using EggLink.DanhengServer.Data;
using EggLink.DanhengServer.Data.Custom;
using EggLink.DanhengServer.Internationalization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("reload", "Game.Command.Reload.Desc", "Game.Command.Reload.Usage", permission: "egglink.manage")]
public class CommandReload : ICommand
{
[CommandInfo("reload", "Game.Command.Reload.Desc", "Game.Command.Reload.Usage", permission: "egglink.manage")]
public class CommandReload : ICommand
[CommandMethod("0 banner")]
public async ValueTask ReloadBanner(CommandArg arg)
{
[CommandMethod("0 banner")]
public void ReloadBanner(CommandArg arg)
{
// Reload the banners
GameData.BannersConfig = ResourceManager.LoadCustomFile<BannersConfig>("Banner", "Banners") ?? new();
arg.SendMsg(I18nManager.Translate("Game.Command.Reload.ConfigReloaded", I18nManager.Translate("Word.Banner")));
}
[CommandMethod("0 activity")]
public void ReloadActivity(CommandArg arg)
{
// Reload the activities
GameData.ActivityConfig = ResourceManager.LoadCustomFile<ActivityConfig>("Activity", "ActivityConfig") ?? new();
arg.SendMsg(I18nManager.Translate("Game.Command.Reload.ConfigReloaded", I18nManager.Translate("Word.Activity")));
}
// Reload the banners
GameData.BannersConfig =
ResourceManager.LoadCustomFile<BannersConfig>("Banner", "Banners") ?? new BannersConfig();
await arg.SendMsg(I18nManager.Translate("Game.Command.Reload.ConfigReloaded",
I18nManager.Translate("Word.Banner")));
}
}
[CommandMethod("0 activity")]
public async ValueTask ReloadActivity(CommandArg arg)
{
// Reload the activities
GameData.ActivityConfig = ResourceManager.LoadCustomFile<ActivityConfig>("Activity", "ActivityConfig") ??
new ActivityConfig();
await arg.SendMsg(I18nManager.Translate("Game.Command.Reload.ConfigReloaded",
I18nManager.Translate("Word.Activity")));
}
}

251
Command/Command/Cmd/CommandRogue.cs
View File

@@ -2,138 +2,165 @@
using EggLink.DanhengServer.Data.Excel;
using EggLink.DanhengServer.Game.Rogue.Scene.Entity;
using EggLink.DanhengServer.Internationalization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("rogue", "Game.Command.Rogue.Desc", "Game.Command.Rogue.Usage")]
public class CommandRogue : ICommand
{
[CommandInfo("rogue", "Game.Command.Rogue.Desc", "Game.Command.Rogue.Usage")]
public class CommandRogue : ICommand
[CommandMethod("0 money")]
public async ValueTask GetMoney(CommandArg arg)
{
[CommandMethod("0 money")]
public void GetMoney(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var count = arg.GetInt(0);
arg.Target.Player!.RogueManager!.GetRogueInstance()?.GainMoney(count);
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerGainedMoney", count.ToString()));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
[CommandMethod("0 buff")]
public void GetBuff(CommandArg arg)
var count = arg.GetInt(0);
var instance = arg.Target.Player!.RogueManager?.GetRogueInstance();
if (instance == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var id = arg.GetInt(0);
if (id == -1)
{
var buffList = new List<RogueBuffExcel>();
foreach (var buff in GameData.RogueBuffData.Values)
{
if (buff.IsAeonBuff || buff.MazeBuffLevel == 2) continue;
buffList.Add(buff);
}
arg.Target.Player!.RogueManager!.GetRogueInstance()?.AddBuffList(buffList);
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerGainedAllItems", I18nManager.Translate("Word.Buff")));
}
else
{
GameData.RogueMazeBuffData.TryGetValue(id, out var buff);
if (buff == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.ItemNotFound", I18nManager.Translate("Word.Buff")));
return;
}
arg.Target.Player!.RogueManager!.GetRogueInstance()?.AddBuff(buff.ID, buff.Lv);
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerGainedItem", I18nManager.Translate("Word.Buff"), buff.Name ?? id.ToString()));
}
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerNotInRogue"));
return;
}
[CommandMethod("0 miracle")]
public void GetMiracle(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var id = arg.GetInt(0);
await instance.GainMoney(count);
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerGainedMoney", count.ToString()));
}
GameData.RogueMiracleData.TryGetValue(id, out var miracle);
if (miracle == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.ItemNotFound", I18nManager.Translate("Word.Miracle")));
return;
}
arg.Target.Player!.RogueManager!.GetRogueInstance()?.AddMiracle(id);
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerGainedItem", I18nManager.Translate("Word.Miracle"), miracle.Name ?? id.ToString()));
[CommandMethod("0 buff")]
public async ValueTask GetBuff(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
[CommandMethod("0 enhance")]
public void GetEnhance(CommandArg arg)
var instance = arg.Target.Player!.RogueManager?.GetRogueInstance();
if (instance == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var id = arg.GetInt(0);
if (id == -1)
{
foreach (var enhance in GameData.RogueBuffData.Values)
{
arg.Target.Player!.RogueManager!.GetRogueInstance()?.EnhanceBuff(enhance.MazeBuffID);
}
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerEnhancedAllBuffs"));
}
else
{
GameData.RogueMazeBuffData.TryGetValue(id, out var buff);
if (buff == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.ItemNotFound", I18nManager.Translate("Word.Buff")));
return;
}
arg.Target.Player!.RogueManager!.GetRogueInstance()?.EnhanceBuff(buff.ID);
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerEnhancedBuff", buff.Name ?? id.ToString()));
}
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerNotInRogue"));
return;
}
[CommandMethod("0 unstuck")]
public void Unstuck(CommandArg arg)
var id = arg.GetInt(0);
if (id == -1)
{
if (arg.Target == null)
var buffList = new List<RogueBuffExcel>();
foreach (var buff in GameData.RogueBuffData.Values)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
if (buff.IsAeonBuff || buff.MazeBuffLevel == 2) continue;
buffList.Add(buff);
}
await instance.AddBuffList(buffList);
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerGainedAllItems",
I18nManager.Translate("Word.Buff")));
}
else
{
GameData.RogueMazeBuffData.TryGetValue(id, out var buff);
if (buff == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.ItemNotFound",
I18nManager.Translate("Word.Buff")));
return;
}
var player = arg.Target.Player!;
foreach (var npc in player.SceneInstance!.Entities.Values)
{
if (npc is RogueNpc rNpc)
{
if (rNpc.RogueNpcId > 0)
{
player.SceneInstance!.RemoveEntity(rNpc);
}
}
}
await instance.AddBuff(buff.ID, buff.Lv);
arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerUnstuck"));
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerGainedItem",
I18nManager.Translate("Word.Buff"), buff.Name ?? id.ToString()));
}
}
}
[CommandMethod("0 miracle")]
public async ValueTask GetMiracle(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var instance = arg.Target.Player!.RogueManager?.GetRogueInstance();
if (instance == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerNotInRogue"));
return;
}
var id = arg.GetInt(0);
GameData.RogueMiracleData.TryGetValue(id, out var miracle);
if (miracle == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.ItemNotFound",
I18nManager.Translate("Word.Miracle")));
return;
}
await instance.AddMiracle(id);
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerGainedItem",
I18nManager.Translate("Word.Miracle"), miracle.Name ?? id.ToString()));
}
[CommandMethod("0 enhance")]
public async ValueTask GetEnhance(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var instance = arg.Target.Player!.RogueManager?.GetRogueInstance();
if (instance == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerNotInRogue"));
return;
}
var id = arg.GetInt(0);
if (id == -1)
{
foreach (var enhance in GameData.RogueBuffData.Values) await instance.EnhanceBuff(enhance.MazeBuffID);
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerEnhancedAllBuffs"));
}
else
{
GameData.RogueMazeBuffData.TryGetValue(id, out var buff);
if (buff == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.ItemNotFound",
I18nManager.Translate("Word.Buff")));
return;
}
await instance.EnhanceBuff(buff.ID);
await arg.SendMsg(
I18nManager.Translate("Game.Command.Rogue.PlayerEnhancedBuff", buff.Name ?? id.ToString()));
}
}
[CommandMethod("0 unstuck")]
public async ValueTask Unstuck(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var player = arg.Target.Player!;
foreach (var npc in player.SceneInstance!.Entities.Values)
if (npc is RogueNpc rNpc && rNpc.RogueNpcId > 0)
await player.SceneInstance!.RemoveEntity(rNpc);
await arg.SendMsg(I18nManager.Translate("Game.Command.Rogue.PlayerUnstuck"));
}
}

297
Command/Command/Cmd/CommandScene.cs
View File

@@ -1,164 +1,153 @@
using EggLink.DanhengServer.Enums.Scene;
using EggLink.DanhengServer.Game.Scene.Entity;
using EggLink.DanhengServer.Internationalization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("scene", "Game.Command.Scene.Desc", "Game.Command.Scene.Usage")]
public class CommandScene : ICommand
{
[CommandInfo("scene", "Game.Command.Scene.Desc", "Game.Command.Scene.Usage")]
public class CommandScene : ICommand
[CommandMethod("0 group")]
public async ValueTask GetLoadedGroup(CommandArg arg)
{
[CommandMethod("0 group")]
public void GetLoadedGroup(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var scene = arg.Target!.Player!.SceneInstance!;
var loadedGroup = new List<int>();
foreach (var group in scene.Entities)
{
if (!loadedGroup.Contains(group.Value.GroupID))
{
loadedGroup.Add(group.Value.GroupID);
}
}
arg.SendMsg(I18nManager.Translate("Game.Command.Scene.LoadedGroups", string.Join(", ", loadedGroup)));
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
[CommandMethod("0 prop")]
public void GetProp(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var scene = arg.Target!.Player!.SceneInstance!;
EntityProp? prop = null;
foreach (var entity in scene.GetEntitiesInGroup<EntityProp>(arg.GetInt(0)))
{
if (entity.PropInfo.ID == arg.GetInt(1))
{
prop = entity;
break;
}
}
if (prop == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Scene.PropNotFound"));
return;
}
prop.SetState((PropStateEnum)arg.GetInt(2));
arg.SendMsg(I18nManager.Translate("Game.Command.Scene.PropStateChanged", prop.PropInfo.ID.ToString(), prop.State.ToString()));
}
[CommandMethod("0 remove")]
public void RemoveEntity(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var scene = arg.Target!.Player!.SceneInstance!;
scene.Entities.TryGetValue(arg.GetInt(0), out var entity);
if (entity == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Scene.EntityNotFound"));
return;
}
scene.RemoveEntity(entity);
arg.SendMsg(I18nManager.Translate("Game.Command.Scene.EntityRemoved", entity.EntityID.ToString()));
}
[CommandMethod("0 unlockall")]
public void UnlockAll(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var scene = arg.Target!.Player!.SceneInstance!;
foreach (var entity in scene.Entities.Values)
{
if (entity is EntityProp prop)
{
if (prop.Excel.PropStateList.Contains(PropStateEnum.Open))
prop.SetState(PropStateEnum.Open);
}
}
arg.SendMsg(I18nManager.Translate("Game.Command.Scene.AllPropsUnlocked"));
}
[CommandMethod("0 change")]
public void ChangeScene(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.GetInt(0) == 0)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var player = arg.Target!.Player!;
player.EnterScene(arg.GetInt(0), 0, true);
arg.SendMsg(I18nManager.Translate("Game.Command.Scene.SceneChanged", arg.GetInt(0).ToString()));
}
[CommandMethod("0 reload")]
public void ReloadScene(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var player = arg.Target!.Player!;
player.EnterScene(player.Data.EntryId, 0, true);
arg.SendMsg(I18nManager.Translate("Game.Command.Scene.SceneReloaded"));
}
[CommandMethod("0 reset")]
public void ResetFloor(CommandArg arg)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var floorId = arg.GetInt(0);
if (floorId == 0)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var player = arg.Target!.Player!;
if (player.SceneData?.ScenePropData.TryGetValue(floorId, out var _) == true)
{
player.SceneData.ScenePropData[floorId] = [];
}
if (player.SceneData?.FloorSavedData.TryGetValue(floorId, out var _) == true)
{
player.SceneData.FloorSavedData[floorId] = [];
}
arg.SendMsg(I18nManager.Translate("Game.Command.Scene.SceneReset", floorId.ToString()));
}
var scene = arg.Target!.Player!.SceneInstance!;
var loadedGroup = new List<int>();
foreach (var group in scene.Entities)
if (!loadedGroup.Contains(group.Value.GroupID))
loadedGroup.Add(group.Value.GroupID);
await arg.SendMsg(I18nManager.Translate("Game.Command.Scene.LoadedGroups", string.Join(", ", loadedGroup)));
}
}
[CommandMethod("0 prop")]
public async ValueTask GetProp(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var scene = arg.Target!.Player!.SceneInstance!;
EntityProp? prop = null;
foreach (var entity in scene.GetEntitiesInGroup<EntityProp>(arg.GetInt(0)))
if (entity.PropInfo.ID == arg.GetInt(1))
{
prop = entity;
break;
}
if (prop == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Scene.PropNotFound"));
return;
}
await prop.SetState((PropStateEnum)arg.GetInt(2));
await arg.SendMsg(I18nManager.Translate("Game.Command.Scene.PropStateChanged", prop.PropInfo.ID.ToString(),
prop.State.ToString()));
}
[CommandMethod("0 remove")]
public async ValueTask RemoveEntity(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var scene = arg.Target!.Player!.SceneInstance!;
scene.Entities.TryGetValue(arg.GetInt(0), out var entity);
if (entity == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Scene.EntityNotFound"));
return;
}
await scene.RemoveEntity(entity);
await arg.SendMsg(I18nManager.Translate("Game.Command.Scene.EntityRemoved", entity.EntityID.ToString()));
}
[CommandMethod("0 unlockall")]
public async ValueTask UnlockAll(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var scene = arg.Target!.Player!.SceneInstance!;
foreach (var entity in scene.Entities.Values)
if (entity is EntityProp prop)
if (prop.Excel.PropStateList.Contains(PropStateEnum.Open))
await prop.SetState(PropStateEnum.Open);
await arg.SendMsg(I18nManager.Translate("Game.Command.Scene.AllPropsUnlocked"));
}
[CommandMethod("0 change")]
public async ValueTask ChangeScene(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
if (arg.GetInt(0) == 0)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var player = arg.Target!.Player!;
await player.EnterScene(arg.GetInt(0), 0, true);
await arg.SendMsg(I18nManager.Translate("Game.Command.Scene.SceneChanged", arg.GetInt(0).ToString()));
}
[CommandMethod("0 reload")]
public async ValueTask ReloadScene(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var player = arg.Target!.Player!;
await player.EnterScene(player.Data.EntryId, 0, true);
await arg.SendMsg(I18nManager.Translate("Game.Command.Scene.SceneReloaded"));
}
[CommandMethod("0 reset")]
public async ValueTask ResetFloor(CommandArg arg)
{
if (arg.Target == null)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var floorId = arg.GetInt(0);
if (floorId == 0)
{
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.InvalidArguments"));
return;
}
var player = arg.Target!.Player!;
if (player.SceneData?.ScenePropData.TryGetValue(floorId, out var _) == true)
player.SceneData.ScenePropData[floorId] = [];
if (player.SceneData?.FloorSavedData.TryGetValue(floorId, out var _) == true)
player.SceneData.FloorSavedData[floorId] = [];
await arg.SendMsg(I18nManager.Translate("Game.Command.Scene.SceneReset", floorId.ToString()));
}
}

75
Command/Command/Cmd/CommandUnlockAll.cs
View File

@@ -1,51 +1,46 @@
using EggLink.DanhengServer.Data;
using EggLink.DanhengServer.Database;
using EggLink.DanhengServer.Enums;
using EggLink.DanhengServer.Game.Scene.Entity;
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Proto;
using EggLink.DanhengServer.Server.Packet.Send.Player;
namespace EggLink.DanhengServer.Command.Cmd
namespace EggLink.DanhengServer.Command.Cmd;
[CommandInfo("unlockall", "Game.Command.UnlockAll.Desc", "Game.Command.UnlockAll.Usage")]
public class CommandUnlockAll : ICommand
{
[CommandInfo("unlockall", "Game.Command.UnlockAll.Desc", "Game.Command.UnlockAll.Usage")]
public class CommandUnlockAll : ICommand
[CommandMethod("0 mission")]
public async ValueTask UnlockAllMissions(CommandArg arg)
{
[CommandMethod("0 mission")]
public void UnlockAllMissions(CommandArg arg)
if (arg.Target == null)
{
if (arg.Target == null)
{
arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var player = arg.Target!.Player!;
var missionManager = player.MissionManager!;
foreach (var mission in GameData.SubMissionData.Values)
{
missionManager.Data.SetSubMissionStatus(mission.SubMissionID, MissionPhaseEnum.Finish);
}
foreach (var mission in GameData.MainMissionData.Values)
{
missionManager.Data.SetMainMissionStatus(mission.MainMissionID, MissionPhaseEnum.Finish);
}
if (player.Data.CurrentGender == Gender.Man)
{
player.Data.CurrentGender = Gender.Man;
player.Data.CurBasicType = 8001;
} else
{
player.Data.CurrentGender = Gender.Woman;
player.Data.CurBasicType = 8002;
player.AvatarManager!.GetHero()!.HeroId = 8002;
}
arg.SendMsg(I18nManager.Translate("Game.Command.UnlockAll.AllMissionsUnlocked"));
arg.Target!.Player!.SendPacket(new PacketPlayerKickOutScNotify());
arg.Target!.Stop();
await arg.SendMsg(I18nManager.Translate("Game.Command.Notice.PlayerNotFound"));
return;
}
var player = arg.Target!.Player!;
var missionManager = player.MissionManager!;
foreach (var mission in GameData.SubMissionData.Values)
missionManager.Data.SetSubMissionStatus(mission.SubMissionID, MissionPhaseEnum.Finish);
foreach (var mission in GameData.MainMissionData.Values)
missionManager.Data.SetMainMissionStatus(mission.MainMissionID, MissionPhaseEnum.Finish);
if (player.Data.CurrentGender == Gender.Man)
{
player.Data.CurrentGender = Gender.Man;
player.Data.CurBasicType = 8001;
}
else
{
player.Data.CurrentGender = Gender.Woman;
player.Data.CurBasicType = 8002;
player.AvatarManager!.GetHero()!.HeroId = 8002;
}
await arg.SendMsg(I18nManager.Translate("Game.Command.UnlockAll.AllMissionsUnlocked"));
await arg.Target!.Player!.SendPacket(new PacketPlayerKickOutScNotify());
arg.Target!.Stop();
}
}
}

111
Command/Command/CommandArg.cs
View File

@@ -1,85 +1,70 @@
using EggLink.DanhengServer.Server;
using EggLink.DanhengServer.Util;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command
namespace EggLink.DanhengServer.Command;
public class CommandArg
{
public class CommandArg
public CommandArg(string raw, ICommandSender sender, Connection? con = null)
{
public string Raw { get; }
public List<string> Args { get; } = [];
public List<string> BasicArgs { get; } = [];
public Dictionary<string, string> CharacterArgs { get; } = [];
public Connection? Target { get; set; }
public ICommandSender Sender { get; }
public CommandArg(string raw, ICommandSender sender, Connection? con = null)
Raw = raw;
Sender = sender;
var args = raw.Split(' ');
foreach (var arg in args)
{
Raw = raw;
Sender = sender;
var args = raw.Split(' ');
foreach (var arg in args)
if (string.IsNullOrEmpty(arg)) continue;
var character = arg[0];
if (!int.TryParse(character.ToString(), out var _) && character != '-')
{
if (string.IsNullOrEmpty(arg))
try
{
continue;
CharacterArgs.Add(arg[..1], arg[1..]);
Args.Add(arg);
}
var character = arg[0];
if (!int.TryParse(character.ToString(), out var _) && character != '-')
{
try
{
CharacterArgs.Add(arg[..1], arg[1..]);
Args.Add(arg);
} catch
{
BasicArgs.Add(arg);
Args.Add(arg);
}
}
else
catch
{
BasicArgs.Add(arg);
Args.Add(arg);
}
}
if (con != null)
else
{
Target = con;
}
CharacterArgs.TryGetValue("@", out var target);
if (target != null)
{
var connection = Listener.Connections.Values.ToList().Find(item => item.Player?.Uid.ToString() == target);
if (connection != null)
{
Target = connection;
}
BasicArgs.Add(arg);
Args.Add(arg);
}
}
public int GetInt(int index)
{
if (BasicArgs.Count <= index)
{
return 0;
}
_ = int.TryParse(BasicArgs[index], out int res);
return res;
}
public void SendMsg(string msg)
{
Sender.SendMsg(msg);
}
if (con != null) Target = con;
public override string ToString()
CharacterArgs.TryGetValue("@", out var target);
if (target != null)
{
return $"BasicArg: {BasicArgs.ToArrayString()}. CharacterArg: {CharacterArgs.ToJsonString()}.";
var connection = Listener.Connections.Values.ToList().Find(item => item.Player?.Uid.ToString() == target);
if (connection != null) Target = connection;
}
}
}
public string Raw { get; }
public List<string> Args { get; } = [];
public List<string> BasicArgs { get; } = [];
public Dictionary<string, string> CharacterArgs { get; } = [];
public Connection? Target { get; set; }
public ICommandSender Sender { get; }
public int GetInt(int index)
{
if (BasicArgs.Count <= index) return 0;
_ = int.TryParse(BasicArgs[index], out var res);
return res;
}
public async ValueTask SendMsg(string msg)
{
await Sender.SendMsg(msg);
}
public override string ToString()
{
return $"BasicArg: {BasicArgs.ToArrayString()}. CharacterArg: {CharacterArgs.ToJsonString()}.";
}
}

337
Command/Command/CommandManager.cs
View File

@@ -1,194 +1,187 @@
using EggLink.DanhengServer.Database;
using EggLink.DanhengServer.GameServer.Command;
using System.Reflection;
using EggLink.DanhengServer.Internationalization;
using EggLink.DanhengServer.Proto;
using EggLink.DanhengServer.Server;
using EggLink.DanhengServer.Util;
using Spectre.Console;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace EggLink.DanhengServer.Command
namespace EggLink.DanhengServer.Command;
public class CommandManager
{
public class CommandManager
public static CommandManager? Instance { get; private set; }
public Dictionary<string, ICommand> Commands { get; } = [];
public Dictionary<string, CommandInfo> CommandInfo { get; } = [];
public Logger Logger { get; } = new("CommandManager");
public Connection? Target { get; set; }
public void RegisterCommand()
{
public static CommandManager? Instance { get; private set; }
public Dictionary<string, ICommand> Commands { get; } = [];
public Dictionary<string, CommandInfo> CommandInfo { get; } = [];
public Logger Logger { get; } = new Logger("CommandManager");
public Connection? Target { get; set; } = null;
public void RegisterCommand()
Instance = this;
foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
{
Instance = this;
foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
var attr = type.GetCustomAttribute<CommandInfo>();
if (attr != null)
{
var attr = type.GetCustomAttribute<CommandInfo>();
if (attr != null)
var instance = Activator.CreateInstance(type);
if (instance is ICommand command)
{
var instance = Activator.CreateInstance(type);
if (instance is ICommand command)
{
Commands.Add(attr.Name, command);
CommandInfo.Add(attr.Name, attr);
}
}
}
Logger.Info(I18nManager.Translate("Server.ServerInfo.RegisterItem", Commands.Count.ToString(), I18nManager.Translate("Word.Command")));
}
public void Start()
{
while (true)
{
try
{
string? input = AnsiConsole.Ask<string>("> ");
if (string.IsNullOrEmpty(input))
{
continue;
}
HandleCommand(input, new ConsoleCommandSender(Logger));
}
catch
{
Logger.Error(I18nManager.Translate("Game.Command.Notice.InternalError"));
Commands.Add(attr.Name, command);
CommandInfo.Add(attr.Name, attr);
}
}
}
public void HandleCommand(string input, ICommandSender sender)
{
Logger.Info(I18nManager.Translate("Server.ServerInfo.RegisterItem", Commands.Count.ToString(),
I18nManager.Translate("Word.Command")));
}
public void Start()
{
while (true)
try
{
var cmd = input.Split(' ')[0];
var tempTarget = Target;
if (sender is ConsoleCommandSender)
{
if (cmd.StartsWith('@'))
{
var target = cmd[1..];
var con = Listener.Connections.Values.ToList().Find(item => item.Player?.Uid.ToString() == target);
if (con != null)
{
Target = con;
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.TargetFound", target, con.Player!.Data.Name!));
}
else
{
// offline or not exist
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.TargetNotFound", target));
}
return;
}
} else
{
// player
tempTarget = Listener.GetActiveConnection(sender.GetSender());
if (tempTarget == null)
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.TargetNotFound", sender.GetSender().ToString()));
return;
}
}
if (tempTarget != null && !tempTarget.IsOnline)
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.TargetOffline", tempTarget.Player!.Uid.ToString(), tempTarget.Player!.Data.Name!));
tempTarget = null;
}
if (Commands.TryGetValue(cmd, out var command))
{
var split = input.Split(' ').ToList();
split.RemoveAt(0);
var arg = new CommandArg(split.JoinFormat(" ", ""), sender, tempTarget);
// judge permission
if (arg.Target?.Player?.Uid != sender.GetSender() && !sender.HasPermission("command.others"))
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.NoPermission"));
return;
}
// find the proper method with attribute CommandMethod
var isFound = false;
CommandInfo info = CommandInfo[cmd];
if (!sender.HasPermission(info.Permission))
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.NoPermission"));
return;
}
foreach (var method in command.GetType().GetMethods())
{
var attr = method.GetCustomAttribute<CommandMethod>();
if (attr != null)
{
var canRun = true;
foreach (var condition in attr.Conditions)
{
if (split.Count <= condition.Index)
{
canRun = false;
break;
}
if (!split[condition.Index].Equals(condition.ShouldBe))
{
canRun = false;
break;
}
}
if (canRun)
{
isFound = true;
method.Invoke(command, [arg]);
break;
}
}
}
if (!isFound)
{
// find the default method with attribute CommandDefault
foreach (var method in command.GetType().GetMethods())
{
var attr = method.GetCustomAttribute<CommandDefault>();
if (attr != null)
{
isFound = true;
method.Invoke(command, [arg]);
break;
}
}
if (!isFound)
{
if (info != null)
{
sender.SendMsg(I18nManager.Translate(info.Usage));
}
else
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.CommandNotFound"));
}
}
}
}
else
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.CommandNotFound"));
}
var input = AnsiConsole.Ask<string>("> ");
if (string.IsNullOrEmpty(input)) continue;
HandleCommand(input, new ConsoleCommandSender(Logger));
}
catch
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.InternalError"));
Logger.Error(I18nManager.Translate("Game.Command.Notice.InternalError"));
}
}
public void HandleCommand(string input, ICommandSender sender)
{
try
{
var cmd = input.Split(' ')[0];
var tempTarget = Target;
if (sender is ConsoleCommandSender)
{
if (cmd.StartsWith('@'))
{
var target = cmd[1..];
var con = Listener.Connections.Values.ToList().Find(item => item.Player?.Uid.ToString() == target);
if (con != null)
{
Target = con;
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.TargetFound", target,
con.Player!.Data.Name!));
}
else
{
// offline or not exist
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.TargetNotFound", target));
}
return;
}
}
else
{
// player
tempTarget = Listener.GetActiveConnection(sender.GetSender());
if (tempTarget == null)
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.TargetNotFound",
sender.GetSender().ToString()));
return;
}
}
if (tempTarget != null && !tempTarget.IsOnline)
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.TargetOffline",
tempTarget.Player!.Uid.ToString(), tempTarget.Player!.Data.Name!));
tempTarget = null;
}
if (Commands.TryGetValue(cmd, out var command))
{
var split = input.Split(' ').ToList();
split.RemoveAt(0);
var arg = new CommandArg(split.JoinFormat(" ", ""), sender, tempTarget);
// judge permission
if (arg.Target?.Player?.Uid != sender.GetSender() && !sender.HasPermission("command.others"))
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.NoPermission"));
return;
}
// find the proper method with attribute CommandMethod
var isFound = false;
var info = CommandInfo[cmd];
if (!sender.HasPermission(info.Permission))
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.NoPermission"));
return;
}
foreach (var method in command.GetType().GetMethods())
{
var attr = method.GetCustomAttribute<CommandMethod>();
if (attr != null)
{
var canRun = true;
foreach (var condition in attr.Conditions)
{
if (split.Count <= condition.Index)
{
canRun = false;
break;
}
if (!split[condition.Index].Equals(condition.ShouldBe))
{
canRun = false;
break;
}
}
if (canRun)
{
isFound = true;
method.Invoke(command, [arg]);
break;
}
}
}
if (!isFound)
{
// find the default method with attribute CommandDefault
foreach (var method in command.GetType().GetMethods())
{
var attr = method.GetCustomAttribute<CommandDefault>();
if (attr != null)
{
isFound = true;
method.Invoke(command, [arg]);
break;
}
}
if (!isFound)
{
if (info != null)
sender.SendMsg(I18nManager.Translate(info.Usage));
else
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.CommandNotFound"));
}
}
}
else
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.CommandNotFound"));
}
}
catch
{
sender.SendMsg(I18nManager.Translate("Game.Command.Notice.InternalError"));
}
}
}
}