/// <summary>
/// Adds reference to a(n) <see cref="IGroupMember"/>.
/// </summary>
public bool AddReference(IGroupMember referenceMember)
{
// if the reference is not in our member's list just return
// this can happen if a member logs out before being kicked out and logs back in
var referenceMemberGuid = referenceMember.Guid;
if (!members.Exists(m => m.Guid == referenceMember.Guid))
{
return(false);
}
// we need to re-check to make sure that there aren't any exisiting subscription for the member
if (memberReferences.ContainsKey(referenceMemberGuid))
{
return(false);
}
// setting the reference's group
referenceMember.Group = this;
// add the reference
this.DoAddReference(referenceMember);
// TODO: Send it via an event channel
// notifying player online
if (IsFormed)
{
foreach (var world in social.Worlds)
{
world.GroupManager.UpdateMemberStatus(guid, referenceMember.Guid, OnlineStatus.Online);
}
}
return(true);
}
/// <summary>
/// Removes a member's reference
/// </summary>
public bool AddReference(IGroupMember referenceMember)
{
// if the reference is not in our member's list just return
// this can happen if a member logs out before being kicked out and logs back in
var referenceMemberGuid = referenceMember.Guid;
if (!members.Exists(m => m.Guid == referenceMember.Guid))
{
return(false);
}
// we need to re-check to make sure that there aren't any exisiting subscription for the member
if (memberReferences.ContainsKey(referenceMemberGuid))
{
return(false);
}
// setting up the disconnection subscription
var disconnectSubscription = referenceMember.OnDisconnect.Subscribe(world.PrimaryFiber, () => this.Member_OnDisconnect(referenceMember.Guid));
// setting up regular updates at a not-so-frequent interval
// this way all members will receive updates from group members regardless of their current zone
var updateSubscription = world.PrimaryFiber.ScheduleOnInterval(() => this.PublishGroupUpdateFrom(referenceMember), 2000);
// adding the new reference
var newReference = new Reference <IGroupMember>(referenceMember, updateSubscription, disconnectSubscription);
this.memberReferences.Add(referenceMember.Guid, newReference);
return(true);
}
/// <summary>
/// Sends group invite to a player
/// </summary>
public bool SendInviteTo(IGroupMember memberToInvite)
{
// player is already in a group
if (memberToInvite.InGroup())
{
return(false);
}
// if the player has already been invited or we already sent that player an invite
if (memberToInvite.InvitingGroup != null || memberToInvite.InvitingGroup == this)
{
return(false);
}
this.sentInvites.Add(memberToInvite);
// setting the player's inviting group to this
// so if another groups sees this it will ignore an invite to that player
memberToInvite.InvitingGroup = this;
// send the invitation request
memberToInvite.Peer.SendEvent(new GroupInviteReceived {
Inviter = leader.Name
}, new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
return(true);
}
private static GroupMemberViewModel MapToMemberViewModel(IGroupMember m, GroupModel groupModel, Guid currentUserId)
{
var viewModel = m.Map <GroupMemberViewModel>();
viewModel.IsGroupAdmin = IsGroupCreator(m.Id, groupModel);
viewModel.CanUnsubscribe = viewModel.GroupMember.Id == currentUserId && currentUserId != groupModel.CreatorId;
return(viewModel);
}
/// <summary>
/// Adds reference to a(n) <see cref="IGroupMember"/>.
/// </summary>
void DoAddReference(IGroupMember referenceMember)
{
// setting up the disconnection subscription
var disconnectSubscription = referenceMember.OnDisconnect.Subscribe(social.PrimaryFiber, () => this.Member_OnDisconnect(referenceMember.Guid));
// adding the new reference
var newReference = new Reference <IGroupMember>(referenceMember, disconnectSubscription);
this.memberReferences.Add(referenceMember.Guid, newReference);
}
public GroupMemberController(IGroup group,
IGroupMember groupMember,
IMember member,
ILookUp lookUp)
{
this.groupBusiness = group;
this.groupMemberBusiness = groupMember;
this.memberBusiness = member;
this.lookUpBusiness = lookUp;
}
public virtual T Map(IGroupMember member)
{
var searchableUser = member.Map <T>();
searchableUser.Url = _intranetUserContentProvider.GetProfilePage().Url.AddIdParameter(member.Id).ToLinkModel();
searchableUser.UserTagNames = _userTagService.Get(member.Id).Select(t => t.Text).ToList();
searchableUser.Groups = FillGroupInfo(member);
return(searchableUser);
}
/// <summary>
/// Forms a new group
/// </summary>
public void FormNewGroup(IGroupMember groupLeader)
{
// we are using the current zone id as the sub id so group ids created in different zones will not collide with each other
this.guid = new MmoGuid((byte)ObjectType.Group, GroupManager.Instance.GenerateGroupId());
this.leader = new GroupMemberStructure(groupLeader.Guid, groupLeader.Name);
// add the leader as our first member
this.AddMember(groupLeader);
// add the group to the group manager
GroupManager.Instance.AddGroup(this);
}
/// <summary>
/// Publishes a group update from a player
/// </summary>
void PublishGroupUpdateFrom(IGroupMember memberUpdated)
{
// if there is nothing to update just return
if (memberUpdated.MemberUpdateFlags == GroupMemberPropertyFlags.PROPERTY_FLAG_NONE)
{
return;
}
GroupMemberUpdate groupMemberUpdate = null;
foreach (var memberReference in memberReferences.Values)
{
// skip us
var member = memberReference.Object;
if (member.Guid == memberUpdated.Guid)
{
continue;
}
if (member.IsVisible(memberUpdated.Guid))
{
continue;
}
if (groupMemberUpdate == null)
{
groupMemberUpdate = new GroupMemberUpdate {
ObjectId = memberUpdated.Guid, Properties = memberUpdated.BuildGroupMemberProperties()
}
}
;
memberReference.Object.Peer.SendEvent(groupMemberUpdate, new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
// resetting the flags so the updates can resume from the start
memberUpdated.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_NONE;
}
/// <summary>
/// Called when a(n) group member has disconnected
/// </summary>
void Member_OnDisconnect(MmoGuid memberGuid)
{
this.RemoveReference(memberGuid);
}
protected virtual IEnumerable <SearchableMemberGroupInfo> FillGroupInfo(IGroupMember user)
{
var userGroups = _groupService.GetMany(user.GroupIds);
return(userGroups.Select(ug =>
{
var isCreator = ug.CreatorId == user.Id;
var groupInfo = new SearchableMemberGroupInfo()
{
GroupId = ug.Id,
IsCreator = isCreator,
IsAdmin = isCreator || _groupMemberService.IsMemberAdminOfGroup(user.Id, ug.Id)
};
return groupInfo;
}));
}
/// <summary>
/// Removes an invite from a player
/// </summary>
public void RemoveInvite(IGroupMember member, bool notifyClient)
{
// don't have an invite? just return
if (!sentInvites.Remove(member))
{
return;
}
// notify the client if requested
if (notifyClient)
{
member.Peer.SendEvent(new GroupInviteCancelled(), new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
// resetting the inviting group
// so other groups can invite that player
member.InvitingGroup = null;
}
/// <summary>
/// Adds xp for all the visible members
/// </summary>
public void GainXp(IGroupMember memberGained, int amount)
{
var actualXpGain = (int)(amount * ServerGameSettings.XP_MULTIPLIER_IN_GROUP);
foreach (var reference in memberReferences.Values)
{
var member = reference.Object;
if (member == memberGained)
{
continue;
}
// only add xp for players who are within the range of the xp gainer
if (memberGained.IsVisible(memberGained.Guid))
{
member.GainXp(actualXpGain);
}
}
memberGained.GainXp(actualXpGain);
}
public virtual bool IsGroupMember(Guid groupId, IGroupMember member)
{
return(member.GroupIds.Contains(groupId));
}
public MemberRequestException(IGroupMember member, ApiKey apiKey, ErrorCode errorCode, Endpoint endpoint)
: base(apiKey, errorCode, endpoint, member != null ? $"{{GroupId:{member.group_id},MemberId:{member.member_id}}}" : null)
{
_member = member;
}
public void DetachMember(IGroupMember groupMember)
{
this.GroupMembers.Remove(groupMember);
this.NotifyMembers($"Member has been removed in the group. The member name is {groupMember.Name}");
}
public void AttachMember(IGroupMember groupMember)
{
this.GroupMembers.Add(groupMember);
this.NotifyMembers($"New Member has been added in the group. The member name is {groupMember.Name}");
}
public ManageGroupController(IGroup group, IGroupMember groupMember, ITeacher teacher)
{
_group = group;
_groupMember = groupMember;
_teacher = teacher;
}
/// <summary>
/// Adds a(n) <see cref="IGroupMember"/> to the group.
/// </summary>
public bool AddMember(IGroupMember memberToAdd)
{
if (memberToAdd.InGroup())
{
return(false);
}
if (members.Count >= GlobalGameSettings.MAX_GROUP_MEMBERS)
{
return(false);
}
var memberToAddInfo = new GroupMemberStructure(memberToAdd.Guid, memberToAdd.Name);
this.members.Add(memberToAddInfo);
// this will set the member's current group to this
memberToAdd.Group = this;
// only send updates if there are more than one player in the group
// a group of one means its just the leader waiting for the other player to accept the invite
if (members.Count > 1)
{
// sending the player the group info so it can setup the group
var groupInit = new GroupInit {
GroupData = new GroupStructure(guid, leader.Guid)
};
memberToAdd.Peer.SendEvent(groupInit, new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
// if the group chat channel has not been registered yet, register it
// doing it this way will only create the channel if there are more than one players in the group
if (!IsFormed)
{
// creating the group in every worlds
foreach (var world in social.Worlds)
{
world.GroupManager.FormGroup(guid, leader);
}
// TODO: Send it via an event channel
// send any remaining players the init message (usually the leader)
foreach (var memberReference in memberReferences.Values)
{
memberReference.Object.Peer.SendEvent(groupInit, new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
// create our chat channel
this.CreateChatChannel();
// mark the group formed
this.IsFormed = true;
}
// TODO: Send it via an event channel
// adding the member in every world groups
if (IsFormed)
{
foreach (var world in social.Worlds)
{
world.GroupManager.AddMember(guid, memberToAddInfo);
}
}
foreach (var profile in members)
{
// skip us
if (profile.Guid == memberToAdd.Guid)
{
continue;
}
Reference <IGroupMember> reference;
if (memberReferences.TryGetValue(profile.Guid, out reference))
{
var activeMember = reference.Object;
activeMember.Peer.SendEvent(
new GroupMemberAdded
{
GroupMemberData = new GroupMemberStructure(memberToAdd.Guid.Id, memberToAdd.Name)
},
new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
memberToAdd.Peer.SendEvent(
new GroupMemberAdded
{
GroupMemberData = new GroupMemberStructure(activeMember.Guid.Id, activeMember.Name)
},
new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
else
{
memberToAdd.Peer.SendEvent(
new GroupMemberAddedInactive
{
GroupMemberData = new GroupMemberStructure(profile.Guid.Id, profile.Name)
},
new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
}
// if the chat channel is available join the new user to it
if (channelId > 0)
{
this.social.ChatManager.JoinChannel(memberToAdd.SessionId, this.channelId);
}
}
// adding the member reference to send updates
this.DoAddReference(memberToAdd);
return(true);
}
public GroupMember()
{
dal = DataAccess.CreateGroupMember();
}
/// <summary>
/// Adds a(n) <see cref="IGroupMember"/> to the group.
/// </summary>
public bool AddMember(IGroupMember memberToAdd)
{
if (memberToAdd.InGroup())
{
return(false);
}
if (members.Count >= GlobalGameSettings.MAX_GROUP_MEMBERS)
{
return(false);
}
var memberInfo = new GroupMemberStructure(memberToAdd.Guid, memberToAdd.Name);
this.members.Add(memberInfo);
// this will set the member's current group to this
memberToAdd.Group = this;
// only send updates if there are more than one player in the group
// seriously what is there to send if its only one player
// a group of one means its just the leader waiting for the other player to accept the invite
if (memberReferences.Count > 0)
{
foreach (var memberReference in memberReferences.Values)
{
// skip us
var member = memberReference.Object;
var memberGuid = member.Guid;
var memberToAddGuid = memberToAdd.Guid;
if (memberGuid == memberToAddGuid)
{
continue;
}
if (!member.IsVisible(memberToAddGuid))
{
// otherwise we need to manually build the updates
memberToAdd.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_ALL;
var properties = memberToAdd.BuildGroupMemberProperties();
memberToAdd.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_NONE;
// send the updates only if there is properties to send
if (properties != null)
{
var groupMemberUpdate = new GroupMemberUpdate
{
ObjectId = memberToAddGuid,
Properties = properties
};
member.Peer.SendEvent(groupMemberUpdate, new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
}
if (!memberToAdd.IsVisible(memberGuid))
{
// otherwise we need to manually build the updates
member.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_ALL;
var properties = member.BuildGroupMemberProperties();
member.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_NONE;
// send the updates only if there is properties to send
if (properties != null)
{
var groupMemberUpdate = new GroupMemberUpdate
{
ObjectId = memberGuid,
Properties = properties
};
memberToAdd.Peer.SendEvent(groupMemberUpdate, new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
}
}
}
// adding the member reference to send updates
this.AddReference(memberToAdd);
return(true);
}
