Example #1
0
 public static void HandlePartyMemberBuffUpdate(S_PARTY_MEMBER_BUFF_UPDATE x)
 {
     foreach (var buff in x.Abnormals)
     {
         AbnormalityManager.BeginOrRefreshPartyMemberAbnormality(x.PlayerId, x.ServerId, buff.Id, buff.Duration, buff.Stacks);
     }
 }
        public static void HandleAbnormalityEnd(S_ABNORMALITY_END p)
        {
            if (!AbnormalityManager.EndAbnormality(p.TargetId, p.AbnormalityId)) return;
            if (p.TargetId.IsMe()) FlyingGuardianDataProvider.HandleAbnormal(p);

            if (!Settings.SettingsHolder.ClassWindowSettings.Enabled) return;
            AbnormalityManager.CurrentAbnormalityTracker?.CheckAbnormality(p);
        }
        public static void HandleAbnormalityRefresh(S_ABNORMALITY_REFRESH p)
        {
            AbnormalityManager.BeginAbnormality(p.AbnormalityId, p.TargetId, p.TargetId, p.Duration, p.Stacks);
            if (p.TargetId.IsMe()) FlyingGuardianDataProvider.HandleAbnormal(p);

            if (!Settings.SettingsHolder.ClassWindowSettings.Enabled) return;
            AbnormalityManager.CurrentAbnormalityTracker?.CheckAbnormality(p);
        }
Example #4
0
        public static void HandleAbnormalityEnd(S_ABNORMALITY_END p)
        {
            AbnormalityManager.EndAbnormality(p.TargetId, p.AbnormalityId);
            if (!SettingsManager.ClassWindowSettings.Enabled)
            {
                return;
            }

            switch (SessionManager.CurrentPlayer.Class)
            {
            case Class.Archer:
                Archer.CheckFocusEnd(p);
                Archer.CheckSniperEyeEnd(p);
                break;

            case Class.Warrior:
                Warrior.CheckBuffEnd(p);
                break;

            case Class.Lancer:
                Lancer.CheckLineHeldEnd(p);
                Lancer.CheckArushEnd(p);
                Lancer.CheckGshoutEnd(p);
                break;

            case Class.Mystic:
                Mystic.CheckBuffEnd(p);
                break;

            case Class.Brawler:
                Brawler.CheckBrawlerAbnormalEnd(p);
                break;

            case Class.Ninja:
                Ninja.CheckFocusEnd(p);
                break;

            case Class.Priest:
                Priest.CheckBuffEnd(p);
                break;

            case Class.Sorcerer:
                Sorcerer.CheckBuffEnd(p);
                break;

            case Class.Reaper:
                Reaper.CheckBuffEnd(p);
                break;

            case Class.Slayer:
                Slayer.CheckBuffEnd(p);
                break;

            case Class.Berserker:
                Berserker.CheckBuffEnd(p);
                break;
            }
        }
Example #5
0
        public static void HandleAbnormalityRefresh(S_ABNORMALITY_REFRESH p)
        {
            AbnormalityManager.BeginAbnormality(p.AbnormalityId, p.TargetId, p.Duration, p.Stacks);
            if (!SettingsManager.ClassWindowSettings.Enabled)
            {
                return;
            }
            switch (SessionManager.CurrentPlayer.Class)
            {
            case Class.Warrior:
                Warrior.CheckBuff(p);
                break;

            case Class.Archer:
                Archer.CheckFocus(p);
                Archer.CheckFocusX(p);
                Archer.CheckSniperEye(p);
                break;

            case Class.Lancer:
                Lancer.CheckLineHeld(p);
                break;

            case Class.Priest:
                Priest.CheckBuff(p);
                break;

            case Class.Mystic:
                Mystic.CheckBuff(p);
                break;

            case Class.Sorcerer:
                Sorcerer.CheckBuff(p);
                break;

            case Class.Reaper:
                Reaper.CheckBuff(p);
                break;

            case Class.Slayer:
                Slayer.CheckBuff(p);
                break;

            case Class.Berserker:
                Berserker.CheckBuff(p);
                break;

            case Class.Brawler:
                Brawler.CheckBrawlerAbnormal(p);
                break;
            }
        }
        public static void HandleAbnormalityBegin(S_ABNORMALITY_BEGIN p)
        {
            AbnormalityManager.BeginAbnormality(p.id, p.targetId, p.duration, p.stacks);

            switch (SessionManager.CurrentPlayer.Class)
            {
            case Class.Elementalist:
                Mystic.CheckHurricane(p);
                break;

            default:
                break;
            }
        }
Example #7
0
        public static void AddNpcAndAbnormalities()
        {
            EntityManager.SpawnNPC(950, 4000, 1, true, false, 36);
            var t  = new Timer(1);
            var id = 0U;
            var a  = true;

            t.Elapsed += (_, __) =>
            {
                if (true)
                {
                    AbnormalityManager.BeginAbnormality(id++, 1, 0, 500000, 1);
                }
                else
                {
                    AbnormalityManager.EndAbnormality(1, 100800);
                }
                a = !a;
            };
            t.Start();
        }
        public static void HandleLogin(S_LOGIN p)
        {
            SessionManager.CurrentPlayer.Class = p.CharacterClass;
            WindowManager.ReloadPositions();
            //S_IMAGE_DATA.LoadCachedImages(); //TODO: refactor this thing
            if (Settings.SettingsHolder.ClassWindowSettings.Enabled) ClassWindowViewModel.Instance.CurrentClass = p.CharacterClass;
            AbnormalityManager.SetAbnormalityTracker(p.CharacterClass);
            SessionManager.Server = BasicTeraData.Instance.Servers.GetServer(p.ServerId);
            if (!Settings.SettingsHolder.StatSent) App.SendUsageStat();
            Settings.SettingsHolder.LastRegion = SessionManager.Language;
            TimeManager.Instance.SetServerTimeZone(Settings.SettingsHolder.LastRegion);
            TimeManager.Instance.SetGuildBamTime(false);
            SessionManager.InitDatabases(Settings.SettingsHolder.LastRegion);
            SkillManager.Clear();
            CooldownWindowViewModel.Instance.LoadSkills(p.CharacterClass);
            WindowManager.FloatingButton.SetMoongourdButtonVisibility();
            EntityManager.ClearNPC();
            GroupWindowViewModel.Instance.ClearAll();
            ChatWindowManager.Instance.BlockedUsers.Clear();
            SessionManager.CurrentPlayer.ClearAbnormalities();

            SessionManager.LoadingScreen = true;
            SessionManager.Logged = true;
            SessionManager.Encounter = false;
            MessageFactory.Update();
            SessionManager.CurrentPlayer.EntityId = p.EntityId;
            SessionManager.CurrentPlayer.PlayerId = p.PlayerId;
            SessionManager.CurrentPlayer.ServerId = p.ServerId;
            SessionManager.CurrentPlayer.Name = p.Name;
            SessionManager.CurrentPlayer.Level = p.Level;
            SessionManager.SetPlayerLaurel(SessionManager.CurrentPlayer);
            WindowManager.Dashboard.VM.SetLoggedIn(p.PlayerId);
            SessionManager.GuildMembersNames.Clear();
            //if (Settings.Settings.LastRegion == "NA")
            //    Task.Delay(20000).ContinueWith(t => ChatWindowManager.Instance.AddTccMessage(App.ThankYou_mEME));

        }
Example #9
0
        public static void HandleAbnormalityBegin(S_ABNORMALITY_BEGIN p)
        {
            AbnormalityManager.BeginAbnormality(p.AbnormalityId, p.TargetId, p.Duration, p.Stacks);
            if (!SettingsManager.ClassWindowSettings.Enabled)
            {
                return;
            }
            switch (SessionManager.CurrentPlayer.Class)
            {
            case Class.Mystic:
                Mystic.CheckHurricane(p);
                Mystic.CheckBuff(p);
                break;

            case Class.Warrior:
                Warrior.CheckBuff(p);
                break;

            case Class.Valkyrie:
                Valkyrie.CheckRagnarok(p);
                break;

            case Class.Archer:
                Archer.CheckFocus(p);
                Archer.CheckFocusX(p);
                Archer.CheckSniperEye(p);
                break;

            case Class.Lancer:
                Lancer.CheckArush(p);
                Lancer.CheckGshout(p);
                Lancer.CheckLineHeld(p);
                break;

            case Class.Priest:
                Priest.CheckBuff(p);
                break;

            case Class.Brawler:
                Brawler.CheckBrawlerAbnormal(p);
                break;

            case Class.Ninja:
                Ninja.CheckFocus(p);
                break;

            case Class.Sorcerer:
                Sorcerer.CheckBuff(p);
                break;

            case Class.Reaper:
                Reaper.CheckBuff(p);
                break;

            case Class.Slayer:
                Slayer.CheckBuff(p);
                break;

            case Class.Berserker:
                Berserker.CheckBuff(p);
                break;
            }
        }
Example #10
0
 public static void HandlePartyMemberAbnormalRefresh(S_PARTY_MEMBER_ABNORMAL_REFRESH x)
 {
     AbnormalityManager.BeginOrRefreshPartyMemberAbnormality(x.PlayerId, x.ServerId, x.Id, x.Duration, x.Stacks);
 }
Example #11
0
 public static void HandlePartyMemberAbnormalDel(S_PARTY_MEMBER_ABNORMAL_DEL x)
 {
     AbnormalityManager.EndPartyMemberAbnormality(x.PlayerId, x.ServerId, x.Id);
 }
 public static void HandleAbnormalityRefresh(S_ABNORMALITY_REFRESH p)
 {
     AbnormalityManager.BeginAbnormality(p.AbnormalityId, p.TargetId, p.Duration, p.Stacks);
 }
 public static void HandleAbnormalityEnd(S_ABNORMALITY_END p)
 {
     AbnormalityManager.EndAbnormality(p.target, p.id);
 }