/// <summary>
/// Translate the specified member event into another
/// <see cref="MemberEventArgs"/> with a source set to this
/// service.
/// </summary>
/// <param name="evt">
/// The <b>MemberEventArgs</b>.
/// </param>
protected virtual void TranslateEvent(MemberEventArgs evt)
{
IService service = (IService)Service;
if (service == null)
{
// for the JOIN events, the Service property may not be set
// until after the "real" service is started
// (see synchronized block at the EnsureRunningService method)
// just wait till we are out of there
lock (this)
{
service = (IService)Service;
}
}
IService serviceSource = evt.Service;
// allow for post-mortem events
MemberEventArgs evtSafe = new MemberEventArgs(
service == serviceSource ? this : serviceSource,
evt.EventType,
evt.Member);
DispatchMemberEvent(evtSafe);
}
private void InvokeMemberEvent(MemberEventHandler handler, MemberEventArgs evt)
{
if (handler != null)
{
handler(this, evt);
}
}
/// <summary>
/// Invoked when an <see cref="IMember"/> has left the service.
/// </summary>
/// <param name="sender">
/// <see cref="IService"/> that raised an event.
/// </param>
/// <param name="evt">
/// An event which indicates that membership has changed.
/// </param>
public virtual void OnMemberLeft(object sender, MemberEventArgs evt)
{
if (InvalidationStrategy != CompositeCacheStrategyType.ListenNone)
{
ResetFrontMap();
}
}
private void Lobby_MemberLeft(object sender, MemberEventArgs e)
{
Dispatcher.Invoke(() => {
var player = PlayerList.Children.Cast <LobbyPlayer2>().FirstOrDefault(p => p.Member == e.Member);
PlayerList.Children.Remove(player);
});
}
void CreateProperty(MemberEventArgs e, PointerMono _pointer)
{
var property = (ScriptableProperty)e.scriptableMember;
var propertyMono = (MemberMono)CreateMonoObject(e.componentType, _pointer.transform);
AddValueGizmo(property.name, propertyMono.transform);
propertyMono.Init(property.propertyInfo, _pointer);
}
void CreateMethod(MemberEventArgs e, PointerMono _pointer)
{
var method = (ScriptableMethod)e.scriptableMember;
var methodMono = (MethodMono)CreateMonoObject(typeof(MethodMono), _pointer.transform);
AddValueGizmo(method.name, methodMono.transform);
methodMono.Init(method, _pointer);
}
private void Lobby_MemberJoined(object sender, MemberEventArgs e)
{
Dispatcher.Invoke(() => {
var invitee = e.Member as LobbyInvitee;
var member = e.Member as CustomLobbyMember;
if (member != null)
{
StackPanel stack;
if (member.Team == 0)
{
stack = BlueTeam;
}
else if (member.Team == 1)
{
stack = RedTeam;
}
else
{
throw new Exception("UNEXPECTED TEAM");
}
var player = new LobbyPlayer(member);
stack.Children.Add(player);
if (e.Member.IsMe)
{
RedJoin.Visibility = BlueJoin.Visibility = Visibility.Collapsed;
if (member.Team != 0)
{
BlueJoin.Visibility = Visibility.Visible;
}
if (member.Team != 1)
{
RedJoin.Visibility = Visibility.Visible;
}
}
Sort();
}
else
{
var player = new InvitedPlayer(invitee);
InviteList.Children.Add(player);
}
});
}
/// <summary>
/// Dispatch a <see cref="MemberEventArgs"/> to the registered
/// event handlers.
/// </summary>
/// <param name="evt">
/// <b>MemberEventArgs</b> to dispatch.
/// </param>
protected virtual void DispatchMemberEvent(MemberEventArgs evt)
{
switch (evt.EventType)
{
case MemberEventType.Joined:
InvokeMemberEvent(m_memberJoined, evt);
break;
case MemberEventType.Leaving:
InvokeMemberEvent(m_memberLeaving, evt);
break;
case MemberEventType.Left:
InvokeMemberEvent(m_memberLeft, evt);
break;
}
}
private void Lobby_MemberJoined(object sender, MemberEventArgs e)
{
Dispatcher.Invoke(() => {
var member = e.Member as TBDLobbyMember;
if (member != null)
{
var spots = new[] { Pos0, Pos1, Pos2, Pos3, Pos4 };
var player = new TBDPlayer(lobby.IsCaptain, member, 0);
spots[member.SlotID].Child = player;
}
else
{
Session.Log("Invite: " + e.Member.Name);
}
});
}
/// <summary>
/// Create and dispatch a new local <see cref="MemberEventArgs"/>
/// with the given type to the registered event handlers.
/// </summary>
/// <param name="eventType">
/// The type of <b>MemberEventArgs</b> to create and dispatch.
/// </param>
protected virtual void DispatchMemberEvent(MemberEventType eventType)
{
MemberEventArgs evt = new MemberEventArgs(this, eventType, OperationalContext.LocalMember);
switch (evt.EventType)
{
case MemberEventType.Joined:
InvokeMemberEvent(MemberJoined, evt);
break;
case MemberEventType.Leaving:
InvokeMemberEvent(MemberLeaving, evt);
break;
case MemberEventType.Left:
InvokeMemberEvent(MemberLeft, evt);
break;
}
}
private void Lobby_MemberChangedTeam(object sender, MemberEventArgs e)
{
Dispatcher.Invoke(() => {
var member = e.Member as CustomLobbyMember;
StackPanel src, dst;
if (member.Team == 1)
{
src = BlueTeam;
dst = RedTeam;
}
else if (member.Team == 0)
{
src = RedTeam;
dst = BlueTeam;
}
else
{
throw new Exception("UNEXPECTED TEAM");
}
var player = src.Children.Cast <LobbyPlayer>().FirstOrDefault(p => p.Member == member);
src.Children.Remove(player);
dst.Children.Add(player);
if (e.Member.IsMe)
{
RedJoin.Visibility = BlueJoin.Visibility = Visibility.Collapsed;
if (member.Team != 0)
{
BlueJoin.Visibility = Visibility.Visible;
}
if (member.Team != 1)
{
RedJoin.Visibility = Visibility.Visible;
}
}
Sort();
});
}
private void Lobby_MemberLeft(object sender, MemberEventArgs e)
{
Dispatcher.Invoke(() => {
var member = e.Member as CustomLobbyMember;
StackPanel stack;
if (member.Team == 0)
{
stack = BlueTeam;
}
else if (member.Team == 1)
{
stack = RedTeam;
}
else
{
throw new Exception("UNEXPECTED TEAM");
}
var player = stack.Children.Cast <LobbyPlayer>().FirstOrDefault(p => p.Member == e.Member);
stack.Children.Remove(player);
});
}
private void Lobby_MemberJoined(object sender, MemberEventArgs e)
{
Dispatcher.Invoke(() => {
var member = e.Member as QueueLobbyMember;
if (member != null)
{
var player = new LobbyPlayer2(lobby.IsCaptain, member, 0);
PlayerList.Children.Add(player);
var players = PlayerList.Children.Cast <LobbyPlayer2>().ToList();
foreach (var control in players)
{
PlayerList.Children.Remove(control);
int index = lobby.Members.IndexOf(control.Member);
PlayerList.Children.Insert(index, control);
}
}
else
{
var player = new InvitedPlayer(e.Member as LobbyInvitee);
InviteList.Children.Add(player);
}
});
}
/**
* listener to receive memberLeft event
*/
public void OnMemberLeft(object sender, MemberEventArgs evt)
{
fMemberLeft = true;
}
/// <summary>
/// Invoked when an <see cref="IMember"/> has left the service.
/// </summary>
/// <remarks>
/// Note: this event could be called during the service restart on
/// the local node in which case the listener's code should not
/// attempt to use any clustered cache or service functionality.
/// </remarks>
/// <param name="sender">
/// <see cref="IService"/> that raised an event.
/// </param>
/// <param name="evt">
/// An event which indicates that membership has changed.
/// </param>
public virtual void OnMemberLeft(object sender, MemberEventArgs evt)
{
TranslateEvent(evt);
}
public void OnCommunityMemberChanged(object sender, MemberEventArgs e)
{
Update(e.MemberId);
}
/// <summary>
/// Invoked when an <see cref="IMember"/> has joined the service.
/// </summary>
/// <remarks>
/// <p>
/// The most critical situation arises when a number of threads are
/// waiting for a local service restart, being blocked by a
/// <b>IService</b> object synchronization monitor. Since the Joined
/// event should be fired only once, it is called on a client thread
/// <b>while holding a synchronization monitor</b>. An attempt to use
/// other clustered service functionality during this local event
/// notification may result in a deadlock.</p>
/// </remarks>
/// <param name="sender">
/// <see cref="IService"/> that raised an event.
/// </param>
/// <param name="evt">
/// An event which indicates that membership has changed.
/// </param>
public virtual void OnMemberJoined(object sender, MemberEventArgs evt)
{
ResetFrontMap();
}
/// <summary>
/// Invoked when an <see cref="IMember"/> is leaving the service.
/// </summary>
/// <param name="sender">
/// <see cref="IService"/> that raised an event.
/// </param>
/// <param name="evt">
/// An event which indicates that membership has changed.
/// </param>
public virtual void OnMemberLeaving(object sender, MemberEventArgs evt)
{
}
