public async Task <bool> Execute(GameServer server, Player plr, string[] args)
{
if (args.Length < 2)
{
plr.SendConsoleMessage(S4Color.Red + "Wrong Usage, possible usages:");
plr.SendConsoleMessage(S4Color.Red + "> seclevel <nickname> <level>");
return(true);
}
if (args.Length >= 2)
{
using (var db = AuthDatabase.Open())
{
var account = (await DbUtil.FindAsync <AccountDto>(db, statement => statement
.Include <BanDto>(join => join.LeftOuterJoin())
.Where($"{nameof(AccountDto.Nickname):C} = @Nickname")
.WithParameters(new { Nickname = args[0] }))).FirstOrDefault();
if (account == null)
{
plr.SendConsoleMessage(S4Color.Red + "Unknown player");
return(false);
}
if (byte.TryParse(args[1], out var level))
{
if (plr.Account.SecurityLevel <= (SecurityLevel)account.SecurityLevel)
{
plr.SendConsoleMessage($"You cannot change the seclevel of this player");
return(true);
}
if (plr.Account.SecurityLevel <= (SecurityLevel)level)
{
plr.SendConsoleMessage($"Your cannot use a higher level than you have");
return(true);
}
plr.SendConsoleMessage($"Changed {account.Nickname}'s seclevel to {args[1]}");
account.SecurityLevel = level;
DbUtil.Update(db, account);
var player = GameServer.Instance.PlayerManager.Get((ulong)account.Id);
player?.Session?.SendAsync(new ItemUseChangeNickAckMessage {
Result = 0
});
player?.Session?.SendAsync(
new ServerResultAckMessage(ServerResult.CreateNicknameSuccess));
}
else
{
plr.SendConsoleMessage(S4Color.Red + "Wrong Usage, possible usages:");
plr.SendConsoleMessage(S4Color.Red + "> seclevel <username> <level>");
plr.SendConsoleMessage(S4Color.Red + "> seclevel <level>");
}
}
}
return(true);
}
static async Task MainAsync(string[] args)
{
string host = "127.0.0.1", database = "mimic_auth", user = "******", pass = "******";
var builder = new DbContextOptionsBuilder();
builder.UseMySQL($"Server={host}; database={database}; UID={user}; password={pass}");
authDatabase = new AuthDatabase(builder.Options);
authDatabase.Database.EnsureDeleted();
try{
authDatabase.Database.EnsureCreated();
}catch (MySql.Data.MySqlClient.MySqlException mse) {
Debug.WriteLine(mse);
}
try
{
authDatabase.Accounts.Add(new AccountInfo {
username = "******", pass_hash = "1848c99bb0beb9ccba402c3c1ca703095216c65d"
});
authDatabase.SaveChanges();
}catch (Microsoft.EntityFrameworkCore.DbUpdateException due)
{
Debug.Write(due.GetBaseException());
}
var socketManager = new SocketManager <AuthHandler>();
await socketManager.StartAsync();
await Task.Delay(-1);
}
static async Task MainAsync(string[] args)
{
//Starting
string host = "127.0.0.1", database = "mimic_auth", user = "******", pass = "******";
var builder = new DbContextOptionsBuilder().UseMySQL($"Server={host}; database={database}; UID={user}; password={pass}");
authDatabase = new AuthDatabase(builder.Options);
authDatabase.Database.EnsureCreated();
database = "mimic_world";
builder = new DbContextOptionsBuilder().UseMySQL($"Server={host}; database={database}; UID={user}; password={pass}");
worldDatabase = new WorldDatabase(builder.Options);
worldDatabase.Database.EnsureCreated();
world = new World();
string ip = "0.0.0.0";
ushort port = 8085;
var socketManager = new SocketManager <WorldHandler>(ip, port);
await socketManager.StartAsync();
Console.Out.WriteLine("Started on " + ip + ":" + port);
//Started. Looping
InitWorldLoop();
//Stopping
}
public static void HandleSelectRealm(WorldSession session, ClientSelectRealm selectRealm)
{
ServerInfo server = ServerManager.Servers.SingleOrDefault(s => s.Model.Id == selectRealm.RealmId);
if (server == null)
{
throw new InvalidPacketValueException();
}
// clicking back or selecting the current realm also triggers this packet, client crashes if we don't ignore it
if (server.Model.Id == WorldServer.RealmId)
{
return;
}
byte[] sessionKey = RandomProvider.GetBytes(16u);
session.EnqueueEvent(new TaskEvent(AuthDatabase.UpdateAccountSessionKey(session.Account, sessionKey),
() =>
{
session.EnqueueMessageEncrypted(new ServerNewRealm
{
SessionKey = sessionKey,
GatewayData = new ServerNewRealm.Gateway
{
Address = server.Address,
Port = server.Model.Port
},
RealmName = server.Model.Name,
Type = (RealmType)server.Model.Type
});
}));
}
private static void InitialiseServerMessages()
{
ServerMessages = AuthDatabase.GetServerMessages()
.GroupBy(m => m.Index)
.Select(g => new ServerMessageInfo(g))
.ToImmutableList();
}
public static void HandleLoginStart(StsSession session, ClientLoginStartMessage loginStart)
{
session.EnqueueEvent(new TaskGenericEvent <Account>(AuthDatabase.GetAccountAsync(loginStart.LoginName),
account =>
{
if (account == null)
{
session.EnqueueMessageError(new ServerErrorMessage((int)ErrorCode.InvalidAccountNameOrPassword));
return;
}
session.Account = account;
byte[] s = account.S.ToByteArray();
byte[] v = account.V.ToByteArray();
session.KeyExchange = new Srp6Provider(account.Email, s, v);
byte[] B = session.KeyExchange.GenerateServerCredentials();
using (MemoryStream stream = new MemoryStream())
using (BinaryWriter writer = new BinaryWriter(stream))
{
writer.Write(s.Length);
writer.Write(s, 0, s.Length);
writer.Write(B.Length);
writer.Write(B, 0, B.Length);
session.EnqueueMessageOk(new ServerLoginStartMessage
{
KeyData = Convert.ToBase64String(stream.ToArray())
});
}
session.State = SessionState.LoginStart;
}));
}
public void Migrate()
{
log.Info("Applying database migrations...");
AuthDatabase?.Migrate();
CharacterDatabase?.Migrate();
}
public async Task <bool> Execute(GameServer server, Player plr, string[] args)
{
if (args.Length < 1)
{
plr.SendConsoleMessage(S4Color.Red + "Wrong Usage, possible usages:");
plr.SendConsoleMessage(S4Color.Red + "> /userkick <username>");
return(true);
}
var nickname = args[0];
using (var db = AuthDatabase.Open())
{
var account = (await DbUtil.FindAsync <AccountDto>(db, statement => statement
.Include <BanDto>(join => join.LeftOuterJoin())
.Where($"{nameof(AccountDto.Nickname):C} = @Nickname")
.WithParameters(new { Nickname = nickname }))
).FirstOrDefault();
if (account == null)
{
if (plr != null)
{
plr.SendConsoleMessage(S4Color.Red + "Unknown player");
}
else
{
CommandManager.Logger.Information("Unknown player");
}
return(true);
}
var targetplr = GameServer.Instance.PlayerManager.Get((ulong)account.Id);
if (targetplr == null)
{
if (plr != null)
{
plr.SendConsoleMessage(S4Color.Red + "Player is not online");
}
else
{
CommandManager.Logger.Information("Unknown player");
}
return(true);
}
targetplr.Disconnect();
if (plr != null)
{
plr.SendConsoleMessage(S4Color.Green + $"Player {account.Nickname} has been kicked forcefully");
}
else
{
CommandManager.Logger.Information("Unknown player");
}
}
return(true);
}
public TCManager()
{
var set = Settings.Default;
AuthDatabase = new AuthDatabase(set.DBHost, set.DBPort, set.DBUsername, set.DBPassword.DecryptString(Encoding.Unicode.GetBytes(Settings.Default.Entropy)).ToInsecureString(), set.DBAuthName);
CharDatabase = new CharDatabase(set.DBHost, set.DBPort, set.DBUsername, set.DBPassword.DecryptString(Encoding.Unicode.GetBytes(Settings.Default.Entropy)).ToInsecureString(), set.DBCharName);
WorldDatabase = new WorldDatabase(set.DBHost, set.DBPort, set.DBUsername, set.DBPassword.DecryptString(Encoding.Unicode.GetBytes(Settings.Default.Entropy)).ToInsecureString(), set.DBWorldName);
}
protected override void OnDisconnected(ProudSession session)
{
try
{
var gameSession = (GameSession)session;
if (gameSession.Player != null)
{
using (var db = AuthDatabase.Open())
{
var accountDto = DbUtil.Find <AccountDto>(db, statement => statement
.Include <BanDto>(join => join.LeftOuterJoin())
.Where($"{nameof(AccountDto.Id):C} = @Id")
.WithParameters(new { Id = gameSession.Player.Account.Id }))
.FirstOrDefault();
accountDto.IsConnect = false;
accountDto.IsServer = true;
db.Update(accountDto);
}
gameSession.Player.Room?.Leave(gameSession.Player);
gameSession.Player.Channel?.Leave(gameSession.Player);
gameSession.Player.Save();
PlayerManager.Remove(gameSession.Player);
Logger.ForAccount(gameSession.Player)
.Information($"Client {session.RemoteEndPoint} disconnected");
if (gameSession.Player.ChatSession != null)
{
Club.LogOff(gameSession.Player);
gameSession.Player.ChatSession.GameSession = null;
gameSession.Player.ChatSession.Dispose();
}
if (gameSession.Player.RelaySession != null)
{
gameSession.Player.RelaySession.GameSession = null;
gameSession.Player.RelaySession.Dispose();
}
gameSession.Player.Session = null;
gameSession.Player.ChatSession = null;
gameSession.Player.RelaySession = null;
gameSession.Player.Dispose();
gameSession.Player = null;
}
}
catch (Exception e)
{
Logger.Error(e.ToString());
}
base.OnDisconnected(session);
}
private static async Task <bool> IsNickAvailableAsync(string nickname)
{
var minLength = Config.Instance.Game.NickRestrictions.MinLength;
var maxLength = Config.Instance.Game.NickRestrictions.MaxLength;
var whitespace = Config.Instance.Game.NickRestrictions.WhitespaceAllowed;
var ascii = Config.Instance.Game.NickRestrictions.AsciiOnly;
if (string.IsNullOrWhiteSpace(nickname) || (!whitespace && nickname.Contains(" ")) ||
nickname.Length < minLength || nickname.Length > maxLength ||
(ascii && Encoding.UTF8.GetByteCount(nickname) != nickname.Length))
{
return(false);
}
// check for repeating chars example: (AAAHello, HeLLLLo)
var maxRepeat = Config.Instance.Game.NickRestrictions.MaxRepeat;
if (maxRepeat > 0)
{
var counter = 1;
var current = nickname[0];
for (var i = 1; i < nickname.Length; i++)
{
if (current != nickname[i])
{
if (counter > maxRepeat)
{
return(false);
}
counter = 0;
current = nickname[i];
}
counter++;
}
}
var now = DateTimeOffset.Now.ToUnixTimeSeconds();
using (var db = AuthDatabase.Open())
{
var nickExists = (await db.FindAsync <AccountDto>(statement => statement
.Where($"{nameof(AccountDto.Nickname):C} = @{nameof(nickname)}")
.WithParameters(new { nickname }))
.ConfigureAwait(false))
.Any();
var nickReserved = (await db.FindAsync <NicknameHistoryDto>(statement => statement
.Where($"{nameof(NicknameHistoryDto.Nickname):C} = @{nameof(nickname)} AND ({nameof(NicknameHistoryDto.ExpireDate):C} = -1 OR {nameof(NicknameHistoryDto.ExpireDate):C} > @{nameof(now)})")
.WithParameters(new { nickname, now }))
.ConfigureAwait(false))
.Any();
return(!nickExists && !nickReserved);
}
}
public async Task <bool> Execute(GameServer server, Player plr, string[] args)
{
if (args.Length < 1)
{
plr.SendConsoleMessage(S4Color.Red + "Wrong Usage, possible usages:");
plr.SendConsoleMessage(S4Color.Red + "> /search <username>");
return(true);
}
var nickname = args[0];
using (var db = AuthDatabase.Open())
{
var account = (await DbUtil.FindAsync <AccountDto>(db, statement => statement
.Include <BanDto>(join => join.LeftOuterJoin())
.Where($"{nameof(AccountDto.Nickname):C} = @Nickname")
.WithParameters(new { Nickname = nickname }))
).FirstOrDefault();
if (account == null)
{
plr.SendConsoleMessage(S4Color.Red + "Unknown player");
return(true);
}
var player = GameServer.Instance.PlayerManager.Get((ulong)account.Id);
if (player == null)
{
plr.SendConsoleMessage(S4Color.Red + "Player is not online");
return(true);
}
if (player.Channel?.Id > 0)
{
if (player.Room != null)
{
plr.SendConsoleMessage(
$"\"{player.Account.Nickname}\"is connecting to the room \"{player.Room.Id}\"in channel \"{player.Channel.Id}\"now");
}
else
{
plr.SendConsoleMessage(
$"\"{player.Account.Nickname}\"is waiting in channel {player.Channel.Id} now");
}
}
else
{
plr.SendConsoleMessage(
$"\"{player.Account.Nickname}\"is waiting in server \"{Config.Instance.Name}\"now");
}
}
return(true);
}
public static void HandleAccountDelete(WorldSession session, string[] parameters)
{
if (AuthDatabase.DeleteAccount(parameters[0]))
{
log.Info($"Account {parameters[0]} succesfully removed!");
}
else
{
log.Error($"Cannot find account with Email : {parameters[0]}");
}
}
public void Initialise(DatabaseConfiguration configuration)
{
if (configuration.Auth != null)
{
AuthDatabase = new AuthDatabase(configuration);
}
if (configuration.Character != null)
{
CharacterDatabase = new CharacterDatabase(configuration);
}
}
public static void HandleAccountCreate(WorldSession session, string[] parameters)
{
try
{
AuthDatabase.CreateAccount(parameters[0], parameters[1]);
log.Info($"Account {parameters[0]} succesfully created!");
}
catch (Exception exception)
{
log.Error(exception);
}
}
public bool Execute(GameServer server, Player plr, string[] args)
{
if (args.Length < 1)
{
plr.SendConsoleMessage(S4Color.Red + "Wrong Usage, possible usages:");
plr.SendConsoleMessage(S4Color.Red + "> seclevel <username> <level>");
return(true);
}
if (args.Length >= 2)
{
AccountDto account;
using (var db = AuthDatabase.Open())
{
account = (db.Find <AccountDto>(statement => statement
.Include <BanDto>(join => join.LeftOuterJoin())
.Where($"{nameof(AccountDto.Nickname):C} = @Nickname")
.WithParameters(new { Nickname = args[0] })))
.FirstOrDefault();
if (account == null)
{
plr.SendConsoleMessage(S4Color.Red + "Unknown player!");
return(true);
}
else
{
if (byte.TryParse(args[1], out var level))
{
plr.SendConsoleMessage(S4Color.Green + $"Changed {account.Nickname}'s seclevel to {args[1]}");
account.SecurityLevel = level;
db.Update(account);
var player = GameServer.Instance.PlayerManager.Get((ulong)account.Id);
player?.Session?.SendAsync(new ItemUseChangeNickAckMessage()
{
Result = 0
});
player?.Session?.SendAsync(new ServerResultAckMessage(ServerResult.CreateNicknameSuccess));
}
else
{
plr.SendConsoleMessage(S4Color.Red + "Wrong Usage, possible usages:");
plr.SendConsoleMessage(S4Color.Red + "> seclevel <username> <level>");
plr.SendConsoleMessage(S4Color.Red + "> seclevel <level>");
}
}
}
}
return(true);
}
public async Task HandleAccountCreate(CommandContext context, string subCommand, string[] parameters)
{
if (parameters.Length < 2)
{
await SendHelpAsync(context).ConfigureAwait(false);
return;
}
AuthDatabase.CreateAccount(parameters[0], parameters[1]);
await context.SendMessageAsync($"Account {parameters[0]} created successfully")
.ConfigureAwait(false);
}
public static void HandleRequestGameToken(StsSession session, RequestGameTokenMessage requestGameToken)
{
Guid guid = RandomProvider.GetGuid();
session.EnqueueEvent(new TaskEvent(AuthDatabase.UpdateAccountGameToken(session.Account, guid),
() =>
{
session.EnqueueMessageOk(new RequestGameTokenResponse
{
Token = guid.ToString()
});
}));
}
public IReadOnlyList <DBClubInfoDto> GetClubs()
{
var value = _cache.Get <IReadOnlyList <DBClubInfoDto> >(ResourceCacheType.Clubs);
if (value == null)
{
Logger.Information("Caching: Clubs");
Logger.Information("Caching...");
using (var db = GameDatabase.Open())
{
var clubs = DbUtil.Find <ClubDto>(db).ToList();
var clubPlayers = DbUtil.Find <ClubPlayerDto>(db).ToList();
var dbClubInfoList = new List <DBClubInfoDto>();
foreach (var clubDto in clubs)
{
var clubInfo = new DBClubInfoDto {
ClubDto = clubDto
};
var dbPlayerInfoList = new List <ClubPlayerInfo>();
foreach (var playerInfoDto in clubPlayers.Where(p => p.ClubId == clubDto.Id))
{
using (var dbC = AuthDatabase.Open())
{
var account = DbUtil.Find <AccountDto>(dbC, statement => statement
.Where($"{nameof(AccountDto.Id):C} = @{nameof(playerInfoDto.PlayerId)}")
.WithParameters(new { playerInfoDto.PlayerId }))
.FirstOrDefault();
dbPlayerInfoList.Add(new ClubPlayerInfo
{
AccountId = (ulong)playerInfoDto.PlayerId,
State = (ClubState)playerInfoDto.State,
Rank = (ClubRank)playerInfoDto.Rank,
Account = account
});
}
}
clubInfo.PlayerDto = dbPlayerInfoList.ToArray();
dbClubInfoList.Add(clubInfo);
}
value = dbClubInfoList.ToArray();
}
_cache.Set(ResourceCacheType.Clubs, value);
}
return(value);
}
public void UseChangeNickNameItem(GameSession session, CUseChangeNickNameItemReqMessage message)
{
var plr = session.Player;
var item = plr.Inventory[message.ItemId];
var nickname = new NicknameHistoryDto
{
AccountId = (int)plr.Account.Id,
Nickname = message.Nickname
};
switch (item.ItemNumber)
{
case 4000001: // Permanent NickName Change
nickname.ExpireDate = (long)(-1);
break;
case 4000002: // Remove NickName Change
session.SendAsync(new SServerResultInfoAckMessage(ServerResult.FailedToRequestTask));
break;
case 4000003: // 1 Day Nickname Change
nickname.ExpireDate = DateTimeOffset.Now.AddDays(1).ToUnixTimeSeconds();
break;
case 4000004: // 7 Day NickName Change
nickname.ExpireDate = DateTimeOffset.Now.AddDays(7).ToUnixTimeSeconds();
break;
case 4000005: // 30 Day NickName Change
nickname.ExpireDate = DateTimeOffset.Now.AddDays(30).ToUnixTimeSeconds();
break;
default:
session.SendAsync(new SServerResultInfoAckMessage(ServerResult.FailedToRequestTask));
return;
}
using (var auth = AuthDatabase.Open())
auth.Insert(nickname);
plr.Inventory.Remove(item);
session.SendAsync(new SUseChangeNickItemAckMessage
{
Result = 0,
Unk2 = 0,
Unk3 = message.Nickname
});
}
public async Task CreateNickHandler(GameServer server, GameSession session, CCreateNickReqMessage message)
{
if (session.Player == null || !string.IsNullOrWhiteSpace(session.Player.Account.Nickname))
{
session.Dispose();
return;
}
Logger.Info()
.Account(session)
.Message($"Creating nickname {message.Nickname}")
.Write();
if (!await IsNickAvailableAsync(message.Nickname).ConfigureAwait(false))
{
Logger.Error()
.Account(session)
.Message($"Nickname not available: {message.Nickname}")
.Write();
await session.SendAsync(new SCheckNickAckMessage(false))
.ConfigureAwait(false);
return;
}
session.Player.Account.Nickname = message.Nickname;
using (var db = AuthDatabase.Open())
{
var mapping = OrmConfiguration
.GetDefaultEntityMapping <AccountDto>()
.Clone()
.UpdatePropertiesExcluding(prop => prop.IsExcludedFromUpdates = true, nameof(AccountDto.Nickname));
await db.UpdateAsync(new AccountDto { Id = (int)session.Player.Account.Id, Nickname = message.Nickname },
statement => statement.WithEntityMappingOverride(mapping))
.ConfigureAwait(false);
}
//session.Send(new SCreateNickAckMessage { Nickname = msg.Nickname });
await session.SendAsync(new SServerResultInfoAckMessage(ServerResult.CreateNicknameSuccess))
.ConfigureAwait(false);
Logger.Info()
.Account(session)
.Message($"Created nickname {message.Nickname}")
.Write();
await LoginAsync(server, session)
.ConfigureAwait(false);
}
public void Configuration(IAppBuilder app)
{
AppLocalRootPath = HostingEnvironment.MapPath("~/");
var log4NetConfigFilePath = HostingEnvironment.MapPath("~/log4net.config");
if (AppLocalRootPath == null)
{
Console.WriteLine("Starting in self hosting mode");
AppLocalRootPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
log4NetConfigFilePath = Path.Combine(AppLocalRootPath, "log4net.config");
}
var logConfigFileInfo = new FileInfo(log4NetConfigFilePath);
if (logConfigFileInfo.Exists)
{
XmlConfigurator.ConfigureAndWatch(logConfigFileInfo);
}
else
{
XmlConfigurator.Configure();
}
ConfigureBackend(app);
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var identityConfiguration = new IdentityConfiguration(IdentityDatabaseContextFactory);
var task = identityConfiguration.EnsureDefaultUsersAndRolesAsync();
ConfigureAuth(app);
task.GetAwaiter().GetResult();
var properties = new AppProperties(app.Properties);
var token = properties.OnAppDisposing;
if (token != CancellationToken.None)
{
token.Register(() =>
{
Storage?.Dispose();
AuthDatabase?.Dispose();
Container?.Dispose();
});
}
}
public IReadOnlyList <DBClubInfoDto> GetClubs()
{
var value = _cache.Get <IReadOnlyList <DBClubInfoDto> >(ResourceCacheType.Clubs);
if (value == null)
{
Logger.Information("Caching...");
using (var db = GameDatabase.Open())
{
var Clubs = db.Find <ClubDto>().ToList();
var ClubPlayers = db.Find <ClubPlayerDto>().ToList();
var DBClubInfoList = new List <DBClubInfoDto>();
foreach (var clubDto in Clubs)
{
var ClubInfo = new DBClubInfoDto();
ClubInfo.ClubDto = clubDto;
var DBPlayerInfoList = new List <ClubPlayerInfo>();
foreach (var playerInfoDto in ClubPlayers.Where(p => p.ClubId == clubDto.Id))
{
AccountDto account;
using (var dbC = AuthDatabase.Open())
{
account = (dbC.Find <AccountDto>(statement => statement
.Where($"{nameof(AccountDto.Id):C} = @{nameof(playerInfoDto.PlayerId)}")
.WithParameters(new { playerInfoDto.PlayerId })))
.FirstOrDefault();
DBPlayerInfoList.Add(new ClubPlayerInfo()
{
AccountId = (ulong)playerInfoDto.PlayerId,
State = (ClubState)playerInfoDto.State,
IsMod = playerInfoDto.IsMod,
account = account,
});
}
}
ClubInfo.PlayerDto = DBPlayerInfoList.ToArray();
DBClubInfoList.Add(ClubInfo);
}
value = DBClubInfoList.ToArray();
}
_cache.Set(ResourceCacheType.Clubs, value);
}
return(value);
}
public void Migrate()
{
log.Info("Applying database migrations...");
try
{
AuthDatabase.Migrate();
CharacterDatabase.Migrate();
WorldDatabase.Migrate();
}
catch (Exception exception)
{
log.Fatal(exception);
throw;
}
}
public void Initialise(DatabaseConfig config)
{
if (config.Auth != null)
{
AuthDatabase = new AuthDatabase(config);
}
if (config.Character != null)
{
CharacterDatabase = new CharacterDatabase(config);
}
if (config.World != null)
{
WorldDatabase = new WorldDatabase(config);
}
}
public static void HandleHelloRealm(WorldSession session, ClientHelloRealm helloRealm)
{
// prevent packets from being processed until asynchronous account select task is complete
session.CanProcessPackets = false;
session.EnqueueEvent(new TaskGenericEvent <Account>(AuthDatabase.GetAccountAsync(helloRealm.Email, helloRealm.SessionKey),
account =>
{
if (account == null)
{
throw new InvalidPacketValueException($"Failed to find account, Id:{helloRealm.AccountId}, Email:{helloRealm.Email}, SessionKey:{helloRealm.SessionKey}!");
}
session.Initialise(account);
session.SetEncryptionKey(helloRealm.SessionKey);
session.CanProcessPackets = true;
}));
}
public async Task <bool> Execute(GameServer server, Player plr, string[] args)
{
if (args.Length < 2)
{
plr.SendConsoleMessage(S4Color.Red + "Wrong Usage, possible usages:");
plr.SendConsoleMessage(S4Color.Red + "> addap <nickname> <amount>");
return(true);
}
if (args.Length >= 2)
{
using (var db = AuthDatabase.Open())
{
var accountDto = (await DbUtil.FindAsync <AccountDto>(db, statement => statement
.Where($"{nameof(AccountDto.Nickname):C} = @Nickname")
.WithParameters(new { Nickname = args[0] }))).FirstOrDefault();
var playerDto = (await DbUtil.FindAsync <PlayerDto>(db, statement => statement
.Where($"{nameof(PlayerDto.Id):C} = @Id")
.WithParameters(new { Id = accountDto.Id }))).FirstOrDefault();
if (accountDto == null || playerDto == null)
{
plr.SendConsoleMessage(S4Color.Red + "Unknown player");
return(false);
}
int.TryParse(args[1], out var amount);
plr.SendConsoleMessage($"Added {args[1]} ap to {accountDto.Nickname}");
playerDto.AP += amount;
DbUtil.Update(db, playerDto);
var player = GameServer.Instance.PlayerManager.Get((ulong)playerDto.Id);
if (player != null)
{
player.AP += (uint)amount;
await player.SendAsync(new MoneyRefreshCashInfoAckMessage(player.PEN, player.AP));
}
}
}
return(true);
}
public static void HandleHelloAuth(AuthSession session, ClientHelloAuth helloAuth)
{
session.EnqueueEvent(new TaskGenericEvent <Account>(AuthDatabase.GetAccountAsync(helloAuth.Email, helloAuth.GameToken.Guid),
account =>
{
if (account == null)
{
// TODO: send error
return;
}
session.EnqueueMessageEncrypted(new ServerAuthAccepted());
session.EnqueueMessageEncrypted(new ServerRealmMessages
{
MessageGroup =
{
new ServerRealmMessages.Message
{
Index = 0,
Messages =
{
"Welcome to this NexusForever server!\nVisit: https://github.com/Rawaho/NexusForever"
}
}
}
});
byte[] sessionKey = RandomProvider.GetBytes(16u);
session.EnqueueEvent(new TaskEvent(AuthDatabase.UpdateAccountSessionKey(account, sessionKey),
() =>
{
ServerManager.ServerInfo server = ServerManager.Servers.First();
session.EnqueueMessageEncrypted(new ServerRealmInfo
{
AccountId = account.Id,
SessionKey = sessionKey,
Realm = server.Model.Name,
Host = server.Address,
Port = server.Model.Port,
Type = server.Model.Type
});
}));
}));
}
public async Task HandleAccountDeleteAsync(CommandContext context, string subCommand, string[] parameters)
{
if (parameters.Length < 1)
{
await SendHelpAsync(context).ConfigureAwait(false);
return;
}
if (AuthDatabase.DeleteAccount(parameters[0]))
{
await context.SendMessageAsync($"Account {parameters[0]} successfully removed!")
.ConfigureAwait(false);
}
else
{
await context.SendMessageAsync($"Cannot find account with Email: {parameters[0]}")
.ConfigureAwait(false);
}
}
public async Task <bool> Execute(GameServer server, Player plr, string[] args)
{
if (args.Length < 1)
{
plr.SendConsoleMessage(S4Color.Red + "Wrong Usage, possible usages:");
plr.SendConsoleMessage(S4Color.Red + "> /unban <username>");
return(true);
}
var nickname = args[0];
using (var db = AuthDatabase.Open())
{
var account = (await DbUtil.FindAsync <AccountDto>(db, statement => statement
.Include <BanDto>(join => join.LeftOuterJoin())
.Where($"{nameof(AccountDto.Nickname):C} = @Nickname")
.WithParameters(new { Nickname = nickname }))
).FirstOrDefault();
if (account == null)
{
plr.SendConsoleMessage(S4Color.Red + "Unknown player");
return(true);
}
foreach (var accountBan in account.Bans)
{
accountBan.Duration = 0;
DbUtil.UpdateAsync(db, accountBan);
}
await DbUtil.UpdateAsync(db, account);
CommandManager.Logger.Information(
$"{plr?.Account?.Nickname ?? "Unknown player"} has unbanned {account.Nickname}");
plr?.SendConsoleMessage(S4Color.Green + $"Unbanned {account.Nickname}");
}
return(true);
}
