/// <summary>
/// Checks whether the given target exists in this group and whether the given requestMember has the given privs
/// </summary>
public GroupResult CheckAction(GroupMember requestMember, GroupMember target, string targetName, GroupPrivs reqPrivs)
{
GroupResult err;
if (target == null || (target.Group) != requestMember.Group)
{
// Character is offline or doesn't exist
err = GroupResult.NotInYourParty;
}
else if ((reqPrivs == GroupPrivs.Leader && m_leader != requestMember) ||
(reqPrivs == GroupPrivs.MainAsisstant && !requestMember.IsAtLeastMainAssistant) ||
(reqPrivs == GroupPrivs.Assistant && !requestMember.IsAtLeastAssistant))
{
err = GroupResult.DontHavePermission;
targetName = string.Empty;
}
else
{
return(GroupResult.NoError);
}
var requester = requestMember.Character;
if (requester != null)
{
GroupHandler.SendResult(requester.Client, err, targetName);
}
return(err);
}
private static bool CheckMemberInGroup(Character requester, Group group, uint memberLowId)
{
if (group[memberLowId] != null)
{
return(true);
}
GroupHandler.SendResult(requester.Client, GroupResult.NotInYourParty);
return(false);
}
private static bool CheckSameGroup(Character requester, Character character)
{
if (requester.Group != character.Group)
{
GroupHandler.SendResult(requester.Client, GroupResult.NotInYourParty, character.Name);
return(false);
}
return(true);
}
/// <summary>
/// Check whether the given inviter may invite the given target
/// </summary>
public static GroupResult CheckInvite(Character inviter, out Character target, string targetName)
{
GroupResult err;
var inviterMember = inviter.GroupMember;
var group = inviterMember != null ? inviterMember.Group : null;
Character targetChar = World.GetCharacter(targetName, true);
if (group != null && group.IsFull)
{
// your group is full
err = GroupResult.GroupIsFull;
target = null;
targetName = string.Empty;
}
else if ((inviterMember != null && !inviterMember.IsAtLeastAssistant))
{
target = null;
err = GroupResult.DontHavePermission;
}
else if (group != null && group.Flags.HasFlag(GroupFlags.Raid) && targetChar != null && targetChar.IsAllowedLowLevelRaid && targetChar.Level < MinLevelToBeInvitedInRaid)
{
target = null;
err = GroupResult.RaidDisallowedByLevel;
}
else
{
target = World.GetCharacter(targetName, false);
if (target == null || inviter == target ||
(target.Role.IsStaff && !inviter.Role.IsStaff)) // cannot invite staff members without authorization
{
// Character is offline or doesn't exist
err = GroupResult.OfflineOrDoesntExist;
}
else if (inviter.Faction.Group != target.Faction.Group)
{
// you can't invite anyone from another faction
err = GroupResult.TargetIsUnfriendly;
}
else if (target.Group != null || target.IsInvitedToGroup)
{
err = GroupResult.AlreadyInGroup;
}
else if (target.IsIgnoring(inviter) && !inviter.Role.IsStaff)
{
err = GroupResult.TargetIsIgnoringYou;
}
else
{
return(GroupResult.NoError);
}
}
GroupHandler.SendResult(inviter.Client, err, GroupResultType.Invite, targetName);
return(err);
}
private static bool CheckMemberInGroup(Character requester, Group group, uint memberLowId)
{
GroupMember member = group[memberLowId];
if (member == null)
{
// you can't uninvite people not from your group
GroupHandler.SendResult(requester.Client, GroupResult.NotInYourParty);
return(false);
}
return(true);
}
public bool CheckFull(GroupMember member, SubGroup group)
{
if (group.IsFull)
{
var chr = member.Character;
if (chr != null)
{
GroupHandler.SendResult(chr.Client, GroupResultType.Invite, GroupResult.GroupIsFull);
}
return(false);
}
return(true);
}
/// <summary>
/// Called before the given member is removed to clean up everything related to the given member
/// </summary>
protected void OnMemberRemoved(GroupMember member)
{
Character chr = member.Character;
if (chr != null && chr.IsInWorld)
{
if (!chr.IsInContext)
{
chr.ExecuteInContext(() => OnMemberRemoved(member));
return;
}
GroupMemberHandler memberRemoved = MemberRemoved;
if (memberRemoved != null)
{
memberRemoved(member);
}
--m_Count;
SendEmptyUpdate(chr);
chr.GroupMember = null;
GroupHandler.SendResult(chr.Client, GroupResult.NoError);
member.SubGroup.RemoveMember(member);
member.Character = null;
if (chr.Map is BaseInstance)
{
BaseInstance instance = (BaseInstance)chr.Map;
chr.Map.CallDelayed(GroupInstanceKickDelayMillis, () =>
{
if (!chr.IsInWorld || chr.Map != instance || instance.CanEnter(chr))
{
return;
}
chr.TeleportToNearestGraveyard();
});
}
}
else
{
GroupMemberHandler memberRemoved = MemberRemoved;
if (memberRemoved != null)
{
memberRemoved(member);
}
--m_Count;
Singleton <GroupMgr> .Instance.OfflineChars.Remove(member.Id);
member.m_subGroup = null;
}
member.m_nextMember = null;
}
public bool CheckFull(GroupMember member, SubGroup group)
{
if (!group.IsFull)
{
return(true);
}
Character character = member.Character;
if (character != null)
{
GroupHandler.SendResult(character.Client, GroupResult.GroupIsFull);
}
return(false);
}
private static bool CheckIsLeader(GroupMember member)
{
if (!member.IsLeader)
{
// you dont have permission
var chr = member.Character;
if (chr != null)
{
GroupHandler.SendResult(chr.Client, GroupResult.DontHavePermission);
}
return(false);
}
return(true);
}
private static bool CheckIsLeader(GroupMember member)
{
if (member.IsLeader)
{
return(true);
}
Character character = member.Character;
if (character != null)
{
GroupHandler.SendResult((IPacketReceiver)character.Client, GroupResult.DontHavePermission);
}
return(false);
}
public bool CheckPrivs(GroupMember member, GroupPrivs reqPrivs)
{
if ((reqPrivs != GroupPrivs.Leader || m_leader == member) &&
(reqPrivs != GroupPrivs.MainAsisstant || member.IsAtLeastMainAssistant) &&
(reqPrivs != GroupPrivs.Assistant || member.IsAtLeastAssistant))
{
return(true);
}
Character character = member.Character;
if (character != null)
{
GroupHandler.SendResult(character.Client, GroupResult.DontHavePermission);
}
return(false);
}
public bool CheckPrivs(GroupMember member, GroupPrivs reqPrivs)
{
//var flags = member.Flags;
if ((reqPrivs == GroupPrivs.Leader && m_leader != member) ||
(reqPrivs == GroupPrivs.MainAsisstant && !member.IsAtLeastMainAssistant) ||
(reqPrivs == GroupPrivs.Assistant && !member.IsAtLeastAssistant))
{
var requester = member.Character;
if (requester != null)
{
GroupHandler.SendResult(requester.Client, GroupResultType.Swap, GroupResult.DontHavePermission);
}
return(false);
}
return(true);
}
public ICharacterSet GetCharacterSet(Character chr, bool asGroup)
{
if (asGroup)
{
Group group = chr.Group;
if (group == null || !group.IsLeader(chr))
{
GroupHandler.SendResult((IPacketReceiver)chr, GroupResult.DontHavePermission);
}
else
{
Character[] allCharacters = group.GetAllCharacters();
if (allCharacters.Length == 0)
{
return((ICharacterSet)chr);
}
if (allCharacters.Length > this._parentQueue.Template.MaxPlayersPerTeam)
{
BattlegroundHandler.SendBattlegroundError((IPacketReceiver)chr,
BattlegroundJoinError.GroupJoinedNotEligible);
return((ICharacterSet)null);
}
foreach (Character character in allCharacters)
{
if (character != null && character.Battlegrounds.IsDeserter)
{
BattlegroundHandler.SendBattlegroundError((IPacketReceiver)group,
BattlegroundJoinError.Deserter);
return((ICharacterSet)null);
}
}
SynchronizedCharacterList synchronizedCharacterList =
new SynchronizedCharacterList(this.Side.GetFactionGroup());
foreach (Character chr1 in allCharacters)
{
if (chr1.IsInWorld && (chr1.GodMode || this._parentQueue.CanEnter(chr1)))
{
synchronizedCharacterList.Add(chr1);
}
else
{
BattlegroundHandler.SendBattlegroundError((IPacketReceiver)chr1,
BattlegroundJoinError.GroupJoinedNotEligible);
}
}
return((ICharacterSet)synchronizedCharacterList);
}
}
else
{
if (!chr.Battlegrounds.IsDeserter)
{
return((ICharacterSet)chr);
}
BattlegroundHandler.SendBattlegroundError((IPacketReceiver)chr, BattlegroundJoinError.Deserter);
}
return((ICharacterSet)null);
}
public ICharacterSet GetCharacterSet(Character chr, bool asGroup)
{
// we are working with a non-synchronized Character object here
if (asGroup)
{
var group = chr.Group;
if (group == null || !group.IsLeader(chr))
{
// invalid request
GroupHandler.SendResult(chr, GroupResultType.Swap, GroupResult.DontHavePermission);
}
else
{
var chrs = group.GetAllCharacters();
// if no characters in the group, return the original character
if (chrs.Length == 0)
{
return(chr);
}
// make sure the group isn't bigger than the max team size for this BG
if (chrs.Length > _parentQueue.Template.MaxPlayersPerTeam)
{
BattlegroundHandler.SendBattlegroundError(chr, BattlegroundJoinError.GroupJoinedNotEligible);
return(null);
}
// make sure there are no deserters
foreach (Character groupChr in chrs)
{
if (groupChr != null && groupChr.Battlegrounds.IsDeserter)
{
BattlegroundHandler.SendBattlegroundError(group, BattlegroundJoinError.Deserter);
return(null);
}
}
var list = new SynchronizedCharacterList(Side.GetFactionGroup());
foreach (var groupChr in chrs)
{
if (groupChr.IsInWorld && (groupChr.GodMode || _parentQueue.CanEnter(groupChr)))
{
list.Add(groupChr);
}
else
{
// cannot join the same team
BattlegroundHandler.SendBattlegroundError(groupChr, BattlegroundJoinError.GroupJoinedNotEligible);
}
}
return(list);
}
}
else
{
// enqueue the character if they aren't a deserter
if (!chr.Battlegrounds.IsDeserter)
{
return(chr);
}
BattlegroundHandler.SendBattlegroundError(chr, BattlegroundJoinError.Deserter);
}
return(null);
}
/// <summary>
/// Called before the given member is removed to clean up everything related to the given member
/// </summary>
protected void OnMemberRemoved(GroupMember member)
{
var chr = member.Character;
if (chr != null && chr.IsInWorld)
{
if (!chr.IsInContext)
{
chr.ExecuteInContext(() => OnMemberRemoved(member));
return;
}
var handler = MemberRemoved;
if (handler != null)
{
handler(member);
}
m_Count--;
//Send an empty party list to the member
SendEmptyUpdate(chr);
chr.GroupMember = null;
// notify user:
// SendGroupDestroyed(chr);
GroupHandler.SendResult(chr.Client, GroupResultType.Leave, GroupResult.NoError);
//Remove the member from the subgroup
member.SubGroup.RemoveMember(member);
member.Character = null;
// Teleport out of group-owned instances within 1 minute
if (chr.Map is BaseInstance)
{
var instance = (BaseInstance)chr.Map;
chr.Map.CallDelayed(GroupInstanceKickDelayMillis, () =>
{
if (chr.IsInWorld && chr.Map == instance && !instance.CanEnter(chr))
{
// chr is still inside and not allowed
//chr.Map.TeleportOutside(chr);
chr.TeleportToNearestGraveyard();
}
});
}
}
else
{
var handler = MemberRemoved;
if (handler != null)
{
handler(member);
}
m_Count--;
GroupMgr.Instance.OfflineChars.Remove(member.Id);
member.m_subGroup = null;
}
member.m_nextMember = null;
}
