コード例 #1
0
        public static bool CheckForDeletedCharacter(string accountName, GameClient client, int slot)
        {
            int charSlot = slot;

            if (accountName.EndsWith("-S"))
            {
                charSlot = 100 + slot;
            }
            else if (accountName.EndsWith("-N"))
            {
                charSlot = 200 + slot;
            }
            else if (accountName.EndsWith("-H"))
            {
                charSlot = 300 + slot;
            }

            DOLCharacters[] allChars = client.Account.Characters;

            if (allChars != null)
            {
                foreach (DOLCharacters character in allChars.ToArray())
                {
                    if (character.AccountSlot == charSlot && client.ClientState == GameClient.eClientState.CharScreen)
                    {
                        if (log.IsWarnEnabled)
                        {
                            log.WarnFormat("DB Character Delete:  Account {0}, Character: {1}, slot position: {2}, client slot {3}", accountName, character.Name, character.AccountSlot, slot);
                        }

                        var characterRealm = (eRealm)character.Realm;

                        if (allChars.Length < client.ActiveCharIndex && client.ActiveCharIndex > -1 && allChars[client.ActiveCharIndex] == character)
                        {
                            client.ActiveCharIndex = -1;
                        }


                        GameEventMgr.Notify(DatabaseEvent.CharacterDeleted, null, new CharacterEventArgs(character, client));

                        if (Properties.BACKUP_DELETED_CHARACTERS)
                        {
                            var backupCharacter = new DOLCharactersBackup(character);
                            backupCharacter.CustomParams.ForEach(param => GameServer.Database.AddObject(param));
                            GameServer.Database.AddObject(backupCharacter);

                            if (log.IsWarnEnabled)
                            {
                                log.WarnFormat("DB Character {0} backed up to DOLCharactersBackup and no associated content deleted.", character.ObjectId);
                            }
                        }
                        else
                        {
                            // delete associated data

                            try
                            {
                                var objs = GameServer.Database.SelectObjects <InventoryItem>("`OwnerID` = @OwnerID", new QueryParameter("@OwnerID", character.ObjectId));
                                GameServer.Database.DeleteObject(objs);
                            }
                            catch (Exception e)
                            {
                                if (log.IsErrorEnabled)
                                {
                                    log.ErrorFormat("Error deleting char items, char OID={0}, Exception:{1}", character.ObjectId, e);
                                }
                            }

                            // delete quests
                            try
                            {
                                var objs = GameServer.Database.SelectObjects <DBQuest>("`Character_ID` = @Character_ID", new QueryParameter("@Character_ID", character.ObjectId));
                                GameServer.Database.DeleteObject(objs);
                            }
                            catch (Exception e)
                            {
                                if (log.IsErrorEnabled)
                                {
                                    log.ErrorFormat("Error deleting char quests, char OID={0}, Exception:{1}", character.ObjectId, e);
                                }
                            }

                            // delete ML steps
                            try
                            {
                                var objs = GameServer.Database.SelectObjects <DBCharacterXMasterLevel>("`Character_ID` = @Character_ID", new QueryParameter("@Character_ID", character.ObjectId));
                                GameServer.Database.DeleteObject(objs);
                            }
                            catch (Exception e)
                            {
                                if (log.IsErrorEnabled)
                                {
                                    log.ErrorFormat("Error deleting char ml steps, char OID={0}, Exception:{1}", character.ObjectId, e);
                                }
                            }
                        }

                        string deletedChar = character.Name;

                        GameServer.Database.DeleteObject(character);
                        client.Account.Characters = null;
                        client.Player             = null;
                        GameServer.Database.FillObjectRelations(client.Account);

                        if (client.Account.Characters == null || client.Account.Characters.Length == 0)
                        {
                            if (log.IsInfoEnabled)
                            {
                                log.InfoFormat("Account {0} has no more chars. Realm reset!", client.Account.Name);
                            }

                            //Client has no more characters, so the client can choose the realm again!
                            client.Account.Realm = 0;
                        }

                        GameServer.Database.SaveObject(client.Account);

                        // Log deletion
                        AuditMgr.AddAuditEntry(client, AuditType.Character, AuditSubtype.CharacterDelete, "", deletedChar);

                        return(true);
                    }
                }
            }
            return(false);
        }
コード例 #2
0
ファイル: rearrange.cs プロジェクト: mywebext/DOL
        private void SetSlot(GameClient client, int sourceSlot, int targetSlot)
        {
            DOLCharacters source = null;
            DOLCharacters target = null;

            foreach (DOLCharacters character in client.Account.Characters)
            {
                if (source == null)
                {
                    if (character.AccountSlot == sourceSlot)
                    {
                        source = character;
                    }
                }

                if (target == null)
                {
                    if (character.AccountSlot == targetSlot)
                    {
                        target = character;
                    }
                }

                if (source != null && target != null)
                {
                    break;
                }
            }

            if (source == null)
            {
                EmptySlot(client, sourceSlot);
                return;
            }

            // It's important that we create a backup of each character before we start. If an error
            // occurs and / or the server crashes, we always have an character backup.
            DOLCharactersBackup sourceBackup = new DOLCharactersBackup(source);

            sourceBackup.DOLCharacters_ID += "-Rearranged"; // Easier for admins to find it.
            GameServer.Database.AddObject(sourceBackup);

            DOLCharactersBackup targetBackup = null;

            if (target != null)
            {
                targetBackup = new DOLCharactersBackup(target);
                targetBackup.DOLCharacters_ID += "-Rearranged"; // Easier for admins to find it.
                GameServer.Database.AddObject(targetBackup);
            }

            // Time to modify the slots.
            lock (client)
            {
                GameServer.Database.DeleteObject(source);
                if (target != null)
                {
                    GameServer.Database.DeleteObject(target);
                }

                source.AccountSlot = targetSlot;
                if (target != null)
                {
                    target.AccountSlot = sourceSlot;
                }

                GameServer.Database.AddObject(source);
                if (target != null)
                {
                    GameServer.Database.AddObject(target);
                }
            }

            GameServer.Database.DeleteObject(sourceBackup);
            if (targetBackup != null)
            {
                GameServer.Database.DeleteObject(targetBackup);
            }

            SlotChanged(client, source.Name, sourceSlot, source.AccountSlot);
        }