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); }