private void HandlePartyMembersChanged(object sender, LuaEventArgs args)
 {
     if (!IsInGroup)
     {
         Logging.WriteDebug("You left the group");
         haveWeChecked = false;
     }
     else if (IamTheTank || LazyRaiderSettings.Instance.NoTank)
     {
         Logging.WriteDebug("You are acting as Tank, no leader needed");
         haveWeChecked = true;
     }
     else if (RaFHelper.Leader == null)
     {
         Log("Joined party -- need to find tank");
         haveWeChecked = false;
     }
     else if (GroupMembers.Contains(RaFHelper.Leader))
     {
         Logging.WriteDebug("Party Members Changed - Tank still in group");
     }
     else
     {
         Log("Tank left group, no tank currently");
         RaFHelper.ClearLeader();
         haveWeChecked = false;
     }
 }
        private void btnSetLeader_Click(object sender, EventArgs e)
        {
            if (listView.SelectedItems.Count == 0)
            {
                MessageBox.Show("Choose a Player before clicking Set Leader");
                listView.Focus();
            }
            else
            {
                WoWPlayer chosenPlayer = (WoWPlayer)listView.SelectedItems[0].Tag;
                try
                {
                    if (chosenPlayer != null)
                    {
                        RaFHelper.SetLeader(chosenPlayer);
                        LazyRaider.IamTheTank = false;
                        Logging.Write(Color.Blue, "[LazyRaider] Tank set to {0}, max health {1}", LazyRaider.Safe_UnitName(RaFHelper.Leader), RaFHelper.Leader.MaxHealth);
                    }
                    else // == null
                    {
                        RaFHelper.ClearLeader();
                        LazyRaider.IamTheTank = true;
                        Logging.Write(Color.Blue, "[LazyRaider] selected -ME-, leader cleared");
                    }
                }
                catch
                {
                    listView.SelectedItems[0].Remove();
                }

                this.Hide();
            }
        }
        public static void Clear()
        {
            LazyRaider.Dlog("Tank.Clear:  cleared tank");

            RaFHelper.ClearLeader();
            Tank.Guid = 0;
        }
        private void btnClose_Click(object sender, EventArgs e)
        {
            if (chkRunWithoutTank.Checked)
            {
                if (RaFHelper.Leader != null)
                {
                    Logging.Write(Color.Blue, "[LazyRaider] selected -ME-, leader cleared");
                }
                RaFHelper.ClearLeader();
            }

            this.Hide();
        }
        private static RunStatus DetectTheTank()
        {
            IamTheTank = false;
            if (RaFHelper.Leader != null && invalidDelegate == null)
            {
                invalidDelegate = new ObjectInvalidateDelegate(Leader_OnInvalidate);
                RaFHelper.Leader.OnInvalidate += invalidDelegate;
            }

            if (RaFHelper.Leader != null && !RaFHelper.Leader.IsValid)
            {
                Log(Color.Blue, "Tank invalid, resetting");
                RaFHelper.ClearLeader();
            }

            if (IsInGroup && RaFHelper.Leader == null)
            {
                IamTheTank = (GetGroupRoleAssigned(Me) == WoWPartyMember.GroupRole.Tank);
                if (IamTheTank || LazyRaiderSettings.Instance.NoTank)
                {
                    Log(Color.Blue, "Tank set to -ME-, max health {0}", Me.MaxHealth);
                    return(RunStatus.Failure);
                }

                foreach (WoWPlayer p in GroupMembers)
                {
                    if (GetGroupRoleAssigned(p) == WoWPartyMember.GroupRole.Tank)
                    {
                        RaFHelper.SetLeader(p);
                        Log(Color.Blue, "Tank set to {0}, max health {1}", RaFHelper.Leader.Class, RaFHelper.Leader.MaxHealth);
                        return(RunStatus.Failure);
                    }
                }

                WoWPlayer tank = (from p in GroupMembers orderby p.MaxHealth descending where !p.IsMe select p).FirstOrDefault();
                if (tank != null)
                {
                    RaFHelper.SetLeader(tank);
                    Log(Color.Blue, "Tank set to {0}, max health {1}", RaFHelper.Leader.Class, RaFHelper.Leader.MaxHealth);
                    return(RunStatus.Failure);
                }
            }

            if (IsInGroup)
            {
                Log(Color.Red, "Could not find suitable unit to Tank!");
            }

            haveWeChecked = true;
            return(RunStatus.Failure);
        }
        private static bool DoWeNeedToFindLeader()
        {
            // check flag that helps avoid spamming check
            if (haveWeChecked)
            {
                return(false);
            }

            if (RaFHelper.Leader != null && !RaFHelper.Leader.IsValid)
            {
                RaFHelper.ClearLeader();
            }

            return(RaFHelper.Leader == null && !Battlegrounds.IsInsideBattleground && IsInGroup);
        }
        public static void SetAsLeader(ulong guidNew)
        {
            WoWPlayer p = null;

            Tank.Guid = guidNew;

            if (Tank.Guid != 0)
            {
                p = Tank.Current.ToPlayer();
            }

            if (p == null)
            {
                LazyRaider.Dlog("Tank.SetAsLeader:  out of range and cannot resolve {0}", LazyRaider.Safe_UnitName(Tank.Current));
                RaFHelper.ClearLeader();
            }
            else
            {
                LazyRaider.Dlog("Tank.SetAsLeader:  setting tank {0}", LazyRaider.Safe_UnitName(p));
                RaFHelper.SetLeader(p);
                invalidDelegate = new ObjectInvalidateDelegate(RaFLeader_OnInvalidate);
                RaFHelper.Leader.OnInvalidate += invalidDelegate;
            }
        }
 static void Leader_OnInvalidate()
 {
     RaFHelper.ClearLeader();
     invalidDelegate = null;
     haveWeChecked   = false;
 }
 public static void RaFLeader_OnInvalidate()
 {
     LazyRaider.Dlog("RaFLeader_OnInvalidate: tank reference now invalid, resetting");
     RaFHelper.ClearLeader();
     invalidDelegate = null;
 }
Beispiel #10
0
        private static bool SyncTankWithRaFLeader()
        {
            try
            {
                // check if Tank we saved is now in range
                if (Tank.Current != null && Tank.Current.ToPlayer() != null)
                {
                    Dlog("SyncTankWithRaFLeader: Tank now in range, so setting RaFHelper");
                    Tank.SetAsLeader();
                    return(false);
                }

                // otherwise, tank out of range pointer for WoWPlayer so clear
                if (RaFHelper.Leader != null)
                {
                    Dlog("SyncTankWithRaFLeader: Tank doesn't match RaFHelper so clearing");
                    RaFHelper.ClearLeader();
                }

                // user wants to control choosing new when we lost tank
                if (!LazyRaiderSettings.Instance.AutoTankSelect)
                {
                    if (haveFoundTankAtGroupForming)
                    {
                        return(false);
                    }
                }

                // have Tank, so keep it until user changes
                if (Tank.Current != null && Tank.Current.IsOnline)
                {
                    return(false);
                }

                WoWPartyMember tank = (from pm in GroupMemberInfos
                                       where GetGroupRoleAssigned(pm) == WoWPartyMember.GroupRole.Tank &&
                                       pm.Guid != Me.Guid &&
                                       pm.IsOnline &&
                                       pm.ToPlayer() != null
                                       orderby pm.Location3D.Distance(Me.Location) ascending
                                       select pm).FirstOrDefault();
                if (tank != null)
                {
                    haveFoundTankAtGroupForming = true;

                    Tank.Current = tank;
                    Log("Tank set to {0} based upon role", LazyRaider.Safe_UnitName(Tank.Current));
                    TreeRoot.StatusText = String.Format("[lr] tank is {0}", Safe_UnitName(tank));
                    return(true);
                }

#if DONT_SET_BY_MAX_HEALTH_FOR_NOW
                tank = (from pm in GroupMemberInfos
                        where pm.Guid != Me.Guid &&
                        pm.IsOnline &&
                        pm.ToPlayer() != null
                        orderby pm.HealthMax descending
                        select pm).FirstOrDefault();
                if (tank != null)
                {
                    Log("Tank set to {0} based upon Max Health", tank.ToPlayer().Class);
                    Tank.Current        = tank;
                    TreeRoot.StatusText = String.Format("[lr] tank is {0}", Safe_UnitName(tank));
                    return(true);
                }
#endif
                return(false);
            }
            catch
            {
                return(true);
            }
        }