public static async Task <string> PardonUser(string[] arguments) { if (arguments == null) { throw new ArgumentNullException(nameof(arguments), ResourceStrings.StandardCommandHandler_PardonUser_ArgumentsNullException); } if (arguments.Length != 1) { return($"{arguments[0]} <name>"); } var name = arguments[0]; await using var ctx = new UchuContext(); var user = await ctx.Users.FirstOrDefaultAsync(u => string.Equals(u.Username.ToUpper(), name.ToUpper())) .ConfigureAwait(false); if (user == null) { return($"No user with the username of: {name}"); } user.Banned = false; user.BannedReason = null; await ctx.SaveChangesAsync().ConfigureAwait(false); return($"Successfully pardoned {name}!"); }
public static string RemoveUser(string[] arguments) { if (arguments == null) { throw new ArgumentNullException(nameof(arguments), ResourceStrings.StandardCommandHandler_RemoveUser_ArgumentsNullException); } if (arguments.Length != 1) { return("removeuser <name>"); } var name = arguments[0]; using var ctx = new UchuContext(); var user = ctx.Users.FirstOrDefault(u => String.Equals(u.Username.ToUpper(), name.ToUpper())); if (user == null) { return($"No user with the username of: {name}"); } Console.Write(ResourceStrings.StandardCommandHandler_RemoveUser_ConfirmationMessage); if (Console.ReadLine() != name) { return("Deletion aborted"); } ctx.Users.Remove(user); ctx.SaveChanges(); return($"Successfully deleted user: {name}"); }
public static async Task SendGuildInformationAsync(Player player) { await using var ctx = new UchuContext(); var character = await ctx.Characters.FirstAsync(c => c.Id == player.Id); var guild = await ctx.Guilds.FirstOrDefaultAsync(g => g.Id == character.GuildId); if (guild == default) { player.CentralNoticeGui("You are not a member of a guild!"); return; } await UiHelper.SetGuildNameAsync(player, guild.Name); await player.MessageGuiAsync("ClearGuildMembers"); var members = await ctx.Characters.Where(c => c.GuildId == guild.Id).ToArrayAsync(); var index = 0; foreach (var member in members) { var memberPlayer = player.Zone.Players.FirstOrDefault(p => p.Id == member.Id); await UiHelper.AddGuildMemberAsync(player, index ++, new GuildMember { Name = member.Name, Online = memberPlayer != default, Rank = guild.CreatorId == member.Id ? "Owner" : "Member", Zone = ((ZoneId)member.LastZone).ToString() });
/// <summary> /// Loads specific uchu context information about the mission. /// </summary> private async Task LoadInstanceAsync(UchuContext context) { // Mission instance information var mission = await context.Missions .Include(m => m.Tasks) .ThenInclude(t => t.Values) .FirstOrDefaultAsync(m => m.CharacterId == Player.Id && m.MissionId == MissionId); // Start the mission if it hasn't been started, otherwise load the database information if (mission != default) { State = (MissionState)mission.State; CompletionCount = mission.CompletionCount; LastCompletion = mission.LastCompletion; foreach (var task in Tasks) { var taskInstance = mission.Tasks.FirstOrDefault(t => t.TaskId == task.TaskId); if (taskInstance == default) { continue; } task.LoadInstance(taskInstance); } } }
public async Task <object> CharacterList(string id) { var response = new CharacterListResponse(); if (!long.TryParse(id, out var userId)) { response.FailedReason = "invalid id"; return(response); } await using var ctx = new UchuContext(); var user = await ctx.Users.FirstOrDefaultAsync(u => u.Id == userId); if (user == default) { response.FailedReason = "not found"; return(response); } var characters = await ctx.Characters.Where(c => c.UserId == user.Id).ToArrayAsync(); response.Success = true; response.UserId = userId; response.Characters = characters.Select(c => c.Id.ToString()).ToList(); return(response); }
public static async Task <string> BanUser(string[] arguments) { if (arguments == null) { throw new ArgumentNullException(nameof(arguments), ResourceStrings.StandardCommandHandler_BanUser_ArgumentsNullException); } if (arguments.Length != 2) { return($"{arguments[0]} <name> <reason>"); } var name = arguments[0]; var reason = arguments[1]; await using var ctx = new UchuContext(); var user = await ctx.Users.FirstOrDefaultAsync(u => u.Username == name) .ConfigureAwait(false); if (user == null) { return($"No user with the username of: {name}"); } user.Banned = true; user.BannedReason = reason; await ctx.SaveChangesAsync().ConfigureAwait(false); return($"Successfully banned {name}!"); }
public async Task OnInteract(Player player) { var rocket = player.GetComponent <InventoryManagerComponent>()[InventoryType.Models].Items.FirstOrDefault( item => item.Lot == Lot.ModularRocket ); if (rocket == default) { Logger.Error($"Could not find a valid rocket for {player}"); return; } rocket.WorldState = ObjectWorldState.Attached; player.Message(new FireClientEventMessage { Associate = GameObject, Arguments = "RocketEquipped", Target = rocket, Sender = player }); await using var ctx = new UchuContext(); var character = await ctx.Characters.FirstAsync(c => c.Id == player.Id); character.LandingByRocket = true; await ctx.SaveChangesAsync(); }
public static async Task DeleteHandler(MailDelete packet, Player player) { var response = new DeleteConfirm { MailId = packet.MailId }; await using var ctx = new UchuContext(); var mail = await ctx.Mails.FirstOrDefaultAsync(m => m.Id == packet.MailId); if (mail == default) { response.Code = MailDeleteCode.MailNotFound; goto sendResponse; } response.Code = MailDeleteCode.Success; ctx.Mails.Remove(mail); sendResponse: await ctx.SaveChangesAsync(); player.Message(new ServerMailPacket { Id = ServerMailPacketId.DeleteConfirm, MailStruct = response }); }
internal Inventory(InventoryType inventoryType, InventoryManagerComponent managerComponent) { InventoryType = inventoryType; ManagerComponent = managerComponent; using var ctx = new UchuContext(); var playerCharacter = ctx.Characters .Include(c => c.Items) .First(c => c.CharacterId == managerComponent.GameObject.ObjectId); var inventoryItems = playerCharacter.Items .Where(item => (InventoryType)item.InventoryType == inventoryType) .ToList(); _items = inventoryItems.Select( i => Item.Instantiate(i.InventoryItemId, this) ).Where(item => !ReferenceEquals(item, default)).ToList(); _size = inventoryType != InventoryType.Items ? 1000 : playerCharacter.InventorySize; foreach (var item in _items) { Object.Start(item); } }
public Mission[] GetMissions() { using var ctx = new UchuContext(); return(ctx.Missions.Include(m => m.Tasks).ThenInclude(m => m.Values).Where( m => m.Character.CharacterId == GameObject.ObjectId ).ToArray()); }
public async Task LoadAsync() { await using var ctx = new UchuContext(); var missions = await ctx.Missions.Where( m => m.CharacterId == GameObject.Id ).ToArrayAsync(); MissionInstances = new List <MissionInstance>(); Player player = GameObject as Player; foreach (var mission in missions) { var instance = new MissionInstance(player, mission.MissionId); MissionInstances.Add(instance); await instance.LoadAsync(); } Listen(player.OnRespondToMission, async(MissionID, Reciever, RewardLOT) => { await RespondToMissionAsync(MissionID, Reciever, RewardLOT); }); }
public string RemoveUser(string[] arguments) { if (arguments.Length != 1) { return("removeuser <name>"); } var name = arguments[0]; using var ctx = new UchuContext(); var user = ctx.Users.FirstOrDefault(u => u.Username == name); if (user == null) { return($"No user with the username of: {name}"); } Console.Write("Write the username again to confirm deletion: "); if (Console.ReadLine() != name) { return("Deletion aborted"); } ctx.Users.Remove(user); ctx.SaveChanges(); return($"Successfully deleted user: {name}"); }
/// <summary> /// Loads all player missions, combining the cd client and uchu database into mission instances /// </summary> private async Task LoadAsync() { if (GameObject is Player player) { await using var uchuContext = new UchuContext(); // On load, load all the missions from database and store them in memory var missions = await uchuContext.Missions.Where( m => m.CharacterId == GameObject.Id ).ToArrayAsync(); foreach (var mission in missions) { var instance = new MissionInstance(mission.MissionId, player); await instance.LoadAsync(uchuContext); lock (Missions) { Missions.Add(instance); } } this._loaded = true; Listen(player.OnRespondToMission, async(missionId, receiver, rewardLot) => { await RespondToMissionAsync(missionId, receiver, rewardLot); }); } }
public async Task <object> PardonAccount(string accountName) { var response = new AccountPardonResponse(); if (string.IsNullOrWhiteSpace(accountName)) { response.FailedReason = "username null"; return(response); } await using (var ctx = new UchuContext()) { var user = await ctx.Users.FirstOrDefaultAsync(u => string.Equals(u.Username.ToUpper(), accountName.ToUpper())); if (user == default) { response.FailedReason = "not found"; return(response); } user.Banned = false; user.BannedReason = null; await ctx.SaveChangesAsync(); response.Success = true; response.Username = user.Username; } return(response); }
public async Task <string> SetGameMasterLevel(string[] arguments) { if (arguments.Length != 2) { return("gamemaster <username> <level>"); } var username = arguments[0]; await using var ctx = new UchuContext(); var user = await ctx.Users.FirstOrDefaultAsync(u => u.Username == username); if (user == default) { return($"No user with the username of: {username}"); } if (!Enum.TryParse <GameMasterLevel>(arguments[1], out var level)) { return("Invalid <level>"); } user.GameMasterLevel = (int)level; await ctx.SaveChangesAsync(); return$ "Successfully set {user.Username}'s Game Master " + $"level to {(GameMasterLevel) user.GameMasterLevel}"; }
/// <summary> /// Saves the game object by finding all <see cref="ISavableComponent"/> components and calling /// <see cref="SaveAsync"/> on them. /// </summary> /// <param name="continueSaving">Whether to allow saves after this save</param> /// <remarks> /// Note that once continueSaving has been set to false, this behavior can not be undone and the /// component is rendered useless. This is to ensure that after an important event (the player leaving the server) /// stuff is saved no more than once to prevent corruptions. /// </remarks> public async Task SaveAsync(bool continueSaving = true) { if (!_savable) { return; } await _lock.WaitAsync(); try { await using var uchuContext = new UchuContext(); foreach (var savableComponent in GameObject .GetAllComponents().Where(c => c is ISavableComponent)) { await((ISavableComponent)savableComponent).SaveAsync(uchuContext); } // This check has to be done twice in case of race conditions if (_savable) { await uchuContext.SaveChangesAsync(); } } finally { if (!continueSaving) { _savable = false; } _lock.Release(); } }
public async Task RenameCharacter(CharacterRenameRequest packet, IRakConnection connection) { var session = Server.SessionCache.GetSession(connection.EndPoint); await using var ctx = new UchuContext(); if (ctx.Characters.Any(c => c.Name == packet.Name || c.CustomName == packet.Name)) { connection.Send(new CharacterRenameResponse { ResponseId = CharacterRenamingResponse.NameAlreadyInUse } ); return; } var chr = await ctx.Characters.FindAsync(packet.CharacterId); chr.CustomName = packet.Name; chr.NameRejected = false; chr.LastActivity = DateTimeOffset.Now.ToUnixTimeSeconds(); await ctx.SaveChangesAsync(); connection.Send(new CharacterRenameResponse { ResponseId = CharacterRenamingResponse.Success } ); await SendCharacterList(connection, session.UserId); }
public async Task JoinWorld(JoinWorldRequest packet, IRakConnection connection) { UchuServer.SessionCache.SetCharacter(connection.EndPoint, packet.CharacterId); await using var ctx = new UchuContext(); var character = await ctx.Characters.FirstAsync(c => c.Id == packet.CharacterId); character.LastActivity = DateTimeOffset.Now.ToUnixTimeSeconds(); await ctx.SaveChangesAsync(); var zone = (ZoneId)character.LastZone; var requestZone = (ZoneId)(zone == 0 ? 1000 : zone); // We don't want to lock up the server on a world server request, as it may take time. var _ = Task.Run(async() => { // Request world server. var server = await ServerHelper.RequestWorldServerAsync(UchuServer, requestZone); if (server == default) { // If there's no server available, error var session = UchuServer.SessionCache.GetSession(connection.EndPoint); await SendCharacterList(connection, session.UserId); return; } // Send to world server. connection.Send(new ServerRedirectionPacket { Address = UchuServer.Host, Port = (ushort)server.Port }); }); }
public async Task RenameCharacter(CharacterRenameRequest packet, IRakConnection connection) { var session = UchuServer.SessionCache.GetSession(connection.EndPoint); await using var ctx = new UchuContext(); // Check if the name already exists and return proper response if so if (ctx.Characters.Any(c => c.Name == packet.Name || c.CustomName == packet.Name)) { connection.Send(new CharacterRenameResponse { ResponseId = CharacterRenamingResponse.NameAlreadyInUse } ); return; } // If the name is free, update accordingly and notify the client var chr = await ctx.Characters.FindAsync(packet.CharacterId); chr.CustomName = packet.Name; chr.NameRejected = false; chr.LastActivity = DateTimeOffset.Now.ToUnixTimeSeconds(); await ctx.SaveChangesAsync(); connection.Send(new CharacterRenameResponse { ResponseId = CharacterRenamingResponse.Success } ); await SendCharacterList(connection, session.UserId); }
/// <summary> /// Saves the mission inventory of the player /// </summary> /// <param name="context">The database context to save to</param> public async Task SaveAsync(UchuContext context) { if (!this._loaded) { return; } var character = await context.Characters.Where(c => c.Id == GameObject.Id) .Include(c => c.Missions) .ThenInclude(m => m.Tasks) .ThenInclude(t => t.Values) .FirstAsync(); foreach (var mission in AllMissions) { var savedMission = character.Missions .FirstOrDefault(m => m.MissionId == mission.MissionId); if (savedMission == default) { character.Missions.Add(CreateMissionFromMissionInstance(character, mission)); } else { UpdateMissionFromMissionInstance(savedMission, mission); } } Logger.Debug($"Saved mission inventory for {GameObject}"); }
public Mission[] GetCompletedMissions() { using var ctx = new UchuContext(); return(ctx.Missions.Include(m => m.Tasks).ThenInclude(m => m.Values).Where( m => m.Character.Id == GameObject.Id && m.CompletionCount > 0 ).ToArray()); }
public async Task <string> BanUser(string[] arguments) { if (arguments.Length != 2) { return($"{arguments[0]} <name> <reason>"); } var name = arguments[0]; var reason = arguments[1]; await using var ctx = new UchuContext(); var user = await ctx.Users.FirstOrDefaultAsync(u => u.Username == name); if (user == null) { return($"No user with the username of: {name}"); } user.Banned = true; user.BannedReason = reason; await ctx.SaveChangesAsync(); return($"Successfully banned {name}!"); }
private Player() { Listen(OnStart, async() => { Connection.Disconnected += reason => { Connection = default; Destroy(this); return(Task.CompletedTask); }; if (TryGetComponent <DestructibleComponent>(out var destructibleComponent)) { destructibleComponent.OnResurrect.AddListener(() => { GetComponent <Stats>().Imagination = 6; }); } await using var ctx = new UchuContext(); var character = await ctx.Characters .Include(c => c.UnlockedEmotes) .FirstAsync(c => c.CharacterId == ObjectId); foreach (var unlockedEmote in character.UnlockedEmotes) { await UnlockEmoteAsync(unlockedEmote.EmoteId); } });
public async Task <object> DeleteAccount(string accountName) { var response = new AccountDeleteResponse(); if (string.IsNullOrWhiteSpace(accountName)) { response.FailedReason = "username null"; return(response); } await using (var ctx = new UchuContext()) { var user = await ctx.Users.FirstOrDefaultAsync(u => u.Username == accountName); if (user == default) { response.FailedReason = "not found"; return(response); } ctx.Users.Remove(user); await ctx.SaveChangesAsync(); response.Success = true; response.Username = user.Username; } return(response); }
public async Task <object> AccountInfo(string accountName) { var response = new AccountInfoResponse(); if (string.IsNullOrWhiteSpace(accountName)) { response.FailedReason = "username null"; return(response); } await using (var ctx = new UchuContext()) { var user = await ctx.Users.FirstOrDefaultAsync(u => u.Username == accountName); if (user == default) { response.FailedReason = "not found"; return(response); } response.Success = true; response.Username = user.Username; response.Hash = user.Password; response.Id = user.Id; response.Banned = user.Banned; response.BannedReason = user.BannedReason; response.Level = user.GameMasterLevel; } return(response); }
public async Task ClientLoadCompleteHandler(ClientLoadCompletePacket packet, IRakConnection connection) { Logger.Information($"{connection.EndPoint}'s client load completed..."); var session = UchuServer.SessionCache.GetSession(connection.EndPoint); await using var ctx = new UchuContext(); var character = await ctx.Characters .Include(c => c.Flags) .Include(c => c.Items) .Include(c => c.User) .Include(c => c.Missions) .ThenInclude(m => m.Tasks) .ThenInclude(m => m.Values) .SingleAsync(c => c.Id == session.CharacterId); var zoneId = (ZoneId)character.LastZone; if (zoneId == 0) { zoneId = 1000; character.LastZone = zoneId; await ctx.SaveChangesAsync(); } Logger.Information("[55%] Setting session zone."); UchuServer.SessionCache.SetZone(connection.EndPoint, zoneId); // Zone should already be initialized at this point. Logger.Information("[55%] Getting zone from worldserver."); var zone = await((WorldUchuServer)UchuServer).GetZoneAsync(zoneId); // Send the character init XML data for this world to the client Logger.Information("[55%] Sending XML client info."); await SendCharacterXmlDataToClient(character, connection, session); Logger.Information("[55%] Constructing player."); var player = await Player.ConstructAsync(character, connection, zone); Logger.Information("[55%] Checking rocket landing conditions."); if (character.LandingByRocket) { Logger.Information("[55%] Player landed by rocket, saving changes."); character.LandingByRocket = false; await ctx.SaveChangesAsync(); } Logger.Information("[55%] Player is ready to join world."); player.Message(new PlayerReadyMessage { Associate = player }); Logger.Information("[55%] Server is done loading object."); player.Message(new DoneLoadingObjectsMessage { Associate = player }); }
public async Task <bool> HasMissionAsync(int id) { await using var ctx = new UchuContext(); return(await ctx.Missions.AnyAsync( m => m.CharacterId == GameObject.Id && m.MissionId == id )); }
public async Task <bool> HasCompletedAsync(int id) { await using var ctx = new UchuContext(); return(await ctx.Missions.AnyAsync( m => m.CharacterId == GameObject.Id && m.Id == id && m.State >= (int)MissionState.Completed )); }
public Mission[] GetActiveMissions() { using var ctx = new UchuContext(); return(ctx.Missions.Include(m => m.Tasks).ThenInclude(m => m.Values).Where( m => m.Character.CharacterId == GameObject.ObjectId && m.State == (int)MissionState.Active || m.State == (int)MissionState.CompletedActive ).ToArray()); }
public async Task ParseChatMessageHandler(ParseChatMessage message, Player player) { try { await player.Zone.OnChatMessage.InvokeAsync(player, message.Message); } catch { // Something went wrong with event } await using var ctx = new UchuContext(); var character = await ctx.Characters.Include(c => c.User).FirstAsync( c => c.Id == player.Id ); Console.WriteLine($"Message: {message.Message}"); if (message.Message.StartsWith('/')) { var response = await Server.HandleCommandAsync( message.Message, player, (GameMasterLevel)character.User.GameMasterLevel ); if (!string.IsNullOrWhiteSpace(response)) { player.SendChatMessage(response, PlayerChatChannel.Normal); } return; } if (((WorldServer)Server).Whitelist.CheckPhrase(message.Message).Any()) { return; } var transcript = new ChatTranscript { Author = character.Id, Message = message.Message, Receiver = 0, SentTime = DateTime.Now }; await ctx.ChatTranscript.AddAsync(transcript); await ctx.SaveChangesAsync(); foreach (var zonePlayer in player.Zone.Players) { zonePlayer.SendChatMessage(message.Message, PlayerChatChannel.Normal, player); } }