Пример #1
0
        public void AddSpellShortcut(int slot, short spellId)
        {
            if (!this.IsSlotFree(slot, ShortcutBarEnum.SPELL_SHORTCUT_BAR))
            {
                this.RemoveShortcut(ShortcutBarEnum.SPELL_SHORTCUT_BAR, slot);
            }
            SpellShortcut spellShortcut = new SpellShortcut(this.Owner.Record, slot, spellId);

            this.m_spellShortcuts.Add(slot, spellShortcut);
            ShortcutHandler.SendShortcutBarRefreshMessage(this.Owner.Client, ShortcutBarEnum.SPELL_SHORTCUT_BAR, spellShortcut);
        }
Пример #2
0
        public void CreateCharacter(WorldClient client, string name, sbyte breedId, bool sex, IEnumerable <int> colors, int headId, Action successCallback, Action <CharacterCreationResultEnum> failCallback)
        {
            if ((long)client.Characters.Count >= (long)((ulong)MaxCharacterSlot) && client.UserGroup.Role <= RoleEnum.Player)
            {
                failCallback(CharacterCreationResultEnum.ERR_TOO_MANY_CHARACTERS);
            }
            else
            {
                if (this.DoesNameExist(name))
                {
                    failCallback(CharacterCreationResultEnum.ERR_NAME_ALREADY_EXISTS);
                }
                else
                {
                    if (!m_nameCheckerRegex.IsMatch(name))
                    {
                        failCallback(CharacterCreationResultEnum.ERR_INVALID_NAME);
                    }
                    else
                    {
                        Breed breed = Singleton <BreedManager> .Instance.GetBreed((int)breedId);

                        if (breed == null || !client.Account.CanUseBreed((int)breedId) || !Singleton <BreedManager> .Instance.IsBreedAvailable((int)breedId))
                        {
                            failCallback(CharacterCreationResultEnum.ERR_NOT_ALLOWED);
                        }
                        else
                        {
                            Head head = Singleton <BreedManager> .Instance.GetHead(headId);

                            if ((ulong)head.Breed != (ulong)((long)breedId) || head.Gender == 1u != sex)
                            {
                                failCallback(CharacterCreationResultEnum.ERR_NO_REASON);
                            }
                            else
                            {
                                ActorLook look  = breed.GetLook(sex ? SexTypeEnum.SEX_FEMALE : SexTypeEnum.SEX_MALE, true);
                                int       num   = 0;
                                uint[]    array = (!sex) ? breed.MaleColors : breed.FemaleColors;
                                foreach (int current in colors)
                                {
                                    if (array.Length > num)
                                    {
                                        look.AddColor(num + 1, (current == -1) ? Color.FromArgb((int)array[num]) : Color.FromArgb(current));
                                    }
                                    num++;
                                }
                                short[] skins = head.Skins;
                                for (int i = 0; i < skins.Length; i++)
                                {
                                    short skin = skins[i];
                                    look.AddSkin(skin);
                                }
                                CharacterRecord record;
                                using (Transaction transaction = Database.GetTransaction())
                                {
                                    record = new CharacterRecord(breed)
                                    {
                                        Experience       = Singleton <ExperienceManager> .Instance.GetCharacterLevelExperience(breed.StartLevel),
                                        Name             = name,
                                        Sex              = sex ? SexTypeEnum.SEX_FEMALE : SexTypeEnum.SEX_MALE,
                                        Head             = headId,
                                        EntityLook       = look,
                                        CreationDate     = DateTime.Now,
                                        LastUsage        = new DateTime?(DateTime.Now),
                                        AlignmentSide    = AlignmentSideEnum.ALIGNMENT_NEUTRAL,
                                        WarnOnConnection = true,
                                        WarnOnLevel      = true
                                    };
                                    Database.Insert(record);
                                    IOrderedEnumerable <BreedSpell> source =
                                        from spell in breed.Spells
                                        where spell.ObtainLevel <= (int)breed.StartLevel
                                        orderby spell.ObtainLevel, spell.Spell
                                    select spell;
                                    int num2 = 0;
                                    foreach (CharacterSpellRecord current2 in
                                             from learnableSpell in source
                                             select Singleton <SpellManager> .Instance.CreateSpellRecord(record, Singleton <SpellManager> .Instance.GetSpellTemplate(learnableSpell.Spell)))
                                    {
                                        Database.Insert(current2);
                                        SpellShortcut poco = new SpellShortcut(record, num2, (short)current2.SpellId);
                                        Database.Insert(poco);
                                        num2++;
                                    }
                                    foreach (PlayerItemRecord current3 in
                                             from startItem in breed.Items
                                             select startItem.GenerateItemRecord(record))
                                    {
                                        Database.Insert(current3);
                                    }
                                    this.OnCreatingCharacter(record);
                                    if (client.Characters == null)
                                    {
                                        client.Characters = new List <CharacterRecord>();
                                    }
                                    client.Characters.Insert(0, record);
                                    transaction.Complete();
                                }
                                IPCAccessor.Instance.SendRequest(new AddCharacterMessage(client.Account.Id, record.Id), delegate(CommonOKMessage x)
                                {
                                    successCallback();
                                }, delegate(IPCErrorMessage x)
                                {
                                    this.Database.Delete(record);
                                    failCallback(CharacterCreationResultEnum.ERR_NO_REASON);
                                });
                                logger.Debug("Character {0} created", record.Name);
                            }
                        }
                    }
                }
            }
        }
Пример #3
0
        public void CreateCharacter(WorldClient client, string name, sbyte breedId, bool sex,
                                    IEnumerable <int> colors, int headId, Action successCallback, Action <CharacterCreationResultEnum> failCallback)
        {
            WorldServer.Instance.IOTaskPool.EnsureContext();

            if (client.Characters.Count(x => !x.IsDeleted) >= MaxCharacterSlot && client.UserGroup.Role <= RoleEnum.Player)
            {
                failCallback(CharacterCreationResultEnum.ERR_TOO_MANY_CHARACTERS);
                return;
            }

            if (DoesNameExist(name))
            {
                failCallback(CharacterCreationResultEnum.ERR_NAME_ALREADY_EXISTS);
                return;
            }

            if (!client.UserGroup.IsGameMaster && !m_nameCheckerRegex.IsMatch(name))
            {
                failCallback(CharacterCreationResultEnum.ERR_INVALID_NAME);
                return;
            }

            var breed = BreedManager.Instance.GetBreed(breedId);

            if (breed == null ||
                !client.Account.CanUseBreed(breedId) || !BreedManager.Instance.IsBreedAvailable(breedId))
            {
                failCallback(CharacterCreationResultEnum.ERR_NOT_ALLOWED);
                return;
            }

            var head = BreedManager.Instance.GetHead(headId);

            if (head.Breed != breedId || head.Gender == 1 != sex)
            {
                failCallback(CharacterCreationResultEnum.ERR_NO_REASON);
                return;
            }

            var look        = breed.GetLook(sex ? SexTypeEnum.SEX_FEMALE : SexTypeEnum.SEX_MALE, true);
            var i           = 0;
            var breedColors = !sex ? breed.MaleColors : breed.FemaleColors;

            foreach (var color in colors)
            {
                if (breedColors.Length > i)
                {
                    look.AddColor(i + 1, color == -1 ? Color.FromArgb((int)breedColors[i]) : Color.FromArgb(color));
                }

                i++;
            }

            foreach (var skin in head.Skins)
            {
                look.AddSkin(skin);
            }

            CharacterRecord record;

            using (var transaction = Database.GetTransaction())
            {
                record = new CharacterRecord(breed)
                {
                    Experience       = ExperienceManager.Instance.GetCharacterLevelExperience((byte)breed.StartLevel),
                    Name             = name,
                    Sex              = sex ? SexTypeEnum.SEX_FEMALE : SexTypeEnum.SEX_MALE,
                    Head             = headId,
                    DefaultLook      = look,
                    LastLook         = look,
                    CreationDate     = DateTime.Now,
                    LastUsage        = DateTime.Now,
                    AlignmentSide    = AlignmentSideEnum.ALIGNMENT_NEUTRAL,
                    WarnOnConnection = true,
                    WarnOnLevel      = true,
                    PlayerLifeStatus = PlayerLifeStatusEnum.STATUS_ALIVE_AND_KICKING,
                    Energy           = 10000,
                    EnergyMax        = 10000
                };

                Database.Insert(record);

                // add items here

                var spellsToLearn = from spell in breed.Spells
                                    where spell.ObtainLevel <= breed.StartLevel
                                    orderby spell.ObtainLevel, spell.Spell ascending
                select spell;

                var slot = 0;
                foreach (var spellRecord in spellsToLearn.Select(learnableSpell => SpellManager.Instance.CreateSpellRecord(record,
                                                                                                                           SpellManager.Instance.
                                                                                                                           GetSpellTemplate(
                                                                                                                               learnableSpell.
                                                                                                                               Spell))))
                {
                    Database.Insert(spellRecord);

                    var shortcut = new SpellShortcut(record, slot, (short)spellRecord.SpellId);
                    Database.Insert(shortcut);
                    slot++;
                }

                foreach (var itemRecord in breed.Items.Select(startItem => startItem.GenerateItemRecord(record)))
                {
                    Database.Insert(itemRecord);
                }

                OnCreatingCharacter(record);

                if (client.Characters == null)
                {
                    client.Characters = new List <CharacterRecord>();
                }

                client.Characters.Insert(0, record);
                transaction.Complete();
            }

            IPCAccessor.Instance.SendRequest(new AddCharacterMessage(client.Account.Id, record.Id),
                                             x => successCallback(),
                                             x =>
            {
                // todo cascade
                Database.Delete(record);
                failCallback(CharacterCreationResultEnum.ERR_NO_REASON);
            });
            ;

            logger.Debug("Character {0} created", record.Name);
        }