void HandleListenEvent()
{
if (ListenEvent != null)
{
ListenEvent.Invoke();
}
}
private void OnListenEventReceived(ListenEvent e)
{
if (ListenEventReceived != null)
{
ListenEventReceived.Invoke(this, e);
}
}
public override void Send(ListenEvent ev)
{
if (!string.IsNullOrEmpty(m_Name) &&
ev.Name != m_Name)
{
return;
}
if (m_ID != UUID.Zero)
{
if (m_ID.Equals(UUID.Zero))
{
/* expected ID matches UUID.Zero, so we want to receive every possible UUID */
}
else if (!m_ID.Equals(ev.ID))
{
return;
}
}
if (!string.IsNullOrEmpty(m_Message) &&
ev.Message != m_Message)
{
return;
}
if (IsActive)
{
m_Send(ev);
}
}
public void Send(ListenEvent ev)
{
double sayDistanceSquared = m_Handler.SayDistance * m_Handler.SayDistance;
double shoutDistanceSquared = m_Handler.ShoutDistance * m_Handler.ShoutDistance;
double whisperDistanceSquared = m_Handler.WhisperDistance * m_Handler.WhisperDistance;
foreach (ChatServiceInterface.Listener listener in Listeners)
{
try
{
switch (ev.Type)
{
case ListenEvent.ChatType.Region:
case ListenEvent.ChatType.DebugChannel:
case ListenEvent.ChatType.Broadcast:
listener.Send(ev);
break;
case ListenEvent.ChatType.Say:
SendToListener(listener, ev, sayDistanceSquared);
break;
case ListenEvent.ChatType.Shout:
SendToListener(listener, ev, shoutDistanceSquared);
break;
case ListenEvent.ChatType.Whisper:
SendToListener(listener, ev, whisperDistanceSquared);
break;
case ListenEvent.ChatType.OwnerSay:
if (listener.GetUUID().Equals(ev.TargetID))
{
listener.Send(ev);
}
break;
case ListenEvent.ChatType.StartTyping:
case ListenEvent.ChatType.StopTyping:
if (!listener.IsAgent)
{
/* listener is not an agent, so no typing messages */
}
else
{
SendToListener(listener, ev, sayDistanceSquared);
}
break;
default:
break;
}
}
catch
{
/* ignore in the rare case that an object is part died */
}
}
}
protected void ChatPassLocalNeighbors(ListenEvent le)
{
if (le.Type != ListenEvent.ChatType.Say &&
le.Type != ListenEvent.ChatType.Shout &&
le.Type != ListenEvent.ChatType.Whisper)
{
/* only pass those above */
return;
}
var activelist = m_ChatPassInEnableSetToLocal ? m_ChatPassInEnableLocal : m_ChatPassInEnableGlobal;
foreach (var kvp in Neighbors)
{
SceneInterface remoteScene;
var m_TryGetScene = TryGetScene;
if (!(activelist.Count == 0 || activelist.Contains(le.ID) || activelist.Contains(UUID.Zero)))
{
continue;
}
if (kvp.Value.RemoteCircuit != null)
{
Vector3 newPosition = le.GlobalPosition + kvp.Value.RemoteOffset;
if (newPosition.X >= -le.Distance &&
newPosition.Y >= -le.Distance &&
newPosition.X <= kvp.Value.RemoteRegionData.Size.X + le.Distance &&
newPosition.Y <= kvp.Value.RemoteRegionData.Size.Y + le.Distance)
{
kvp.Value.RemoteCircuit.SendMessage(new ChatPass
{
ChatType = (ChatType)(byte)le.Type,
Name = le.Name,
Message = le.Message,
Position = newPosition,
ID = le.ID,
SourceType = (ChatSourceType)(byte)le.SourceType,
OwnerID = le.OwnerID,
Channel = le.Channel
});
}
}
else if (m_TryGetScene != null && m_TryGetScene(kvp.Key, out remoteScene))
{
Vector3 newPosition = le.GlobalPosition + kvp.Value.RemoteOffset;
if (newPosition.X >= -le.Distance &&
newPosition.Y >= -le.Distance &&
newPosition.X <= kvp.Value.RemoteRegionData.Size.X + le.Distance &&
newPosition.Y <= kvp.Value.RemoteRegionData.Size.Y + le.Distance)
{
remoteScene.SendChatPass(new ListenEvent(le)
{
OriginSceneID = ID,
GlobalPosition = newPosition
});
}
}
}
}
/// <summary>
/// 移除监听事件
/// </summary>
/// <param name="name"></param>
/// <param name="listenEvent"></param>
public static void DetachObseverEvent(string name, ListenEvent listenEvent)
{
_Subject _subject;
if (subjects.TryGetValue(name, out _subject))
{
_subject.listen -= listenEvent;
}
}
/// <summary>
/// 添加监听事件
/// </summary>
/// <param name="name"></param>
/// <param name="listenEvent"></param>
public static void AttachObseverEvent(string name, ListenEvent listenEvent)
{
_Subject _subject;
if (!subjects.TryGetValue(name, out _subject))
{
AttachSubject(name);
}
subjects.TryGetValue(name, out _subject);
_subject.listen += listenEvent;
}
private void DebugChannelLog(ListenEvent ev)
{
if (ev.TargetID != UUID.Zero)
{
m_DebugChatLog.InfoFormat("{0} ({1}, {2} at {5}) to {6}: {3}: {4}", ev.Name, ev.ID, ev.SourceType.ToString(), ev.Type.ToString(), ev.Message, ev.GlobalPosition.ToString(), ev.TargetID);
}
else
{
m_DebugChatLog.InfoFormat("{0} ({1}, {2} at {5}): {3}: {4}", ev.Name, ev.ID, ev.SourceType.ToString(), ev.Type.ToString(), ev.Message, ev.GlobalPosition.ToString());
}
}
public bool Listen(string address, int port)
{
m_Port = port;
m_SocketId = UNET.NetworkTransport.AddHost(new SocketContract(m_ConnectionConfig, m_MaxConnection), m_Port, address);
if (IsActive)
{
ListenEvent?.Invoke();
}
return(this.IsActive);
}
public void ChatPassInbound(UUID fromRegionID, ListenEvent ev)
{
if (ev.Type != ListenEvent.ChatType.Say &&
ev.Type != ListenEvent.ChatType.Shout &&
ev.Type != ListenEvent.ChatType.Whisper)
{
/* only pass those above */
return;
}
var activelist = m_ChatPassInEnableSetToLocal ? m_ChatPassInEnableLocal : m_ChatPassInEnableGlobal;
if (activelist.Count == 0 || activelist.Contains(UUID.Zero) || activelist.Contains(ev.ID))
{
SendChatPass(ev);
}
}
/// <summary>
/// 启动SOCKET服务
/// </summary>
public void Start()
{
try
{
Buffer = new BufferManage(MaxListen, BufferSize);
Server.Listen(MaxListen);
ListenEvent?.Invoke(null, new ListenEventArgs {
Message = Server.LocalEndPoint.ToString()
});
StartAccept(null);
}
catch (Exception e)
{
Log.WriteLog(e.TargetSite + "->" + e.Message, LogType.ERROR);
}
}
public override void Send(ListenEvent ev)
{
if (m_Name != null)
{
if ((m_RegexBitfield & 1) != 0)
{
if (!m_Name.IsMatch(ev.Name))
{
return;
}
}
else if (m_NamePlain != ev.Name)
{
return;
}
}
if (m_ID != UUID.Zero)
{
if (m_ID.Equals(UUID.Zero))
{
/* expected ID matches UUID.Zero, so we want to receive every possible UUID */
}
else if (!m_ID.Equals(ev.ID))
{
return;
}
}
if (m_Message != null)
{
if ((m_RegexBitfield & 2) != 0)
{
if (!m_Message.IsMatch(ev.Message))
{
return;
}
}
else if (m_MessagePlain != ev.Message)
{
return;
}
}
if (IsActive)
{
m_Send(ev);
}
}
private void OnChatReceive(ListenEvent ev)
{
if (ev.ID == ID)
{
/* if it is this npc, ignore the chat event */
return;
}
foreach (KeyValuePair <UUID, RwLockedDictionary <UUID, int> > kvp in m_ScriptedChatListeners)
{
ObjectPart part;
ObjectPartInventoryItem item;
if (CurrentScene.Primitives.TryGetValue(kvp.Key, out part))
{
foreach (KeyValuePair <UUID, int> kvpinner in kvp.Value)
{
if (part.Inventory.TryGetValue(kvpinner.Key, out item))
{
ScriptInstance instance = item.ScriptInstance;
/* Translate listen event to mapped channel */
instance?.PostEvent(new ListenEvent
{
ButtonIndex = ev.ButtonIndex,
Channel = kvpinner.Value,
Distance = ev.Distance,
GlobalPosition = ev.GlobalPosition,
ID = ev.ID,
Message = ev.Message,
Name = ev.Name,
OriginSceneID = ev.OriginSceneID,
OwnerID = ev.OwnerID,
SourceType = ev.SourceType,
TargetID = ev.TargetID,
Type = ev.Type
});
}
}
}
else
{
m_ScriptedChatListeners.Remove(kvp.Key);
}
}
}
public override void Send(ListenEvent ev)
{
ChannelInfo ci;
if (m_Channels.TryGetValue(ev.Channel, out ci))
{
ci.Send(ev);
}
if (ev.Channel != ListenEvent.DEBUG_CHANNEL)
{
switch (ev.Type)
{
case ListenEvent.ChatType.Say:
ev.Distance = SayDistance;
break;
case ListenEvent.ChatType.Shout:
ev.Distance = ShoutDistance;
break;
case ListenEvent.ChatType.Whisper:
ev.Distance = WhisperDistance;
break;
case ListenEvent.ChatType.Region:
break;
default:
return;
}
if (ev.SourceType == ListenEvent.ChatSourceType.Object &&
ev.OriginSceneID == UUID.Zero)
{
foreach (Listener li in m_ChatPass)
{
li.Send(ev);
}
}
}
}
private void SendToListener(ChatServiceInterface.Listener listener, ListenEvent ev, double maxDistanceSquared)
{
Func <UUID> getowner = listener.GetOwner;
Func <UGI> getGroup = listener.GetGroup;
if ((ev.GlobalPosition - listener.GetPosition()).LengthSquared > maxDistanceSquared &&
!listener.IsIgnorePosition)
{
/* too far so no listening */
}
else if (listener.LimitToSameGroup && getGroup != null && ev.Group != null && ev.Group.Equals(getGroup()))
{
/* ignore group mismatch */
}
else if (listener.LimitToSameOwner && getowner != null && getowner() != ev.OwnerID)
{
/* ignore owner mismatch */
}
else if (ev.TargetID == UUID.Zero ||
ev.TargetID == listener.GetUUID())
{
listener.Send(ev);
}
}
protected override void SendChatPass(ListenEvent le)
{
ChatServiceInterface chatService = m_ChatService;
chatService?.Send(le);
}
public abstract void Send(ListenEvent ev);
public void RouteChat(ListenEvent ev)
{
m_ChatService?.Send(ev);
}
void HandleListenEvent()
{
ListenEvent?.Invoke();
}
public virtual void Listener_ListenEventReceived(object sender, ListenEvent e)
{
Add(e.Message);
}
protected virtual void SendChatPass(ListenEvent le)
{
}
public string Localize(ListenEvent le, CultureInfo currentCulture) => string.Format(m_NlsRefObject.GetLanguageString(currentCulture, m_NlsId, m_NlsDefMessage), m_Param);
protected override void OnCircuitSpecificPacketReceived(MessageType mType, UDPPacket p)
{
/* we know the message type now, so we have to decode it when possible */
switch (mType)
{
case MessageType.ScriptDialogReply:
/* nothing to do */
case MessageType.ChatFromViewer:
/* nothing to do */
case MessageType.TransferRequest:
/* nothing to do */
break;
case MessageType.ChatPass:
{
var ev = new ListenEvent
{
Channel = p.ReadInt32(),
GlobalPosition = p.ReadVector3f(),
ID = p.ReadUUID(),
OwnerID = p.ReadUUID(),
Name = p.ReadStringLen8(),
SourceType = (ListenEvent.ChatSourceType)p.ReadUInt8(),
Type = (ListenEvent.ChatType)p.ReadUInt8()
};
/* radius */
p.ReadFloat();
/* simaccess */ p.ReadUInt8();
ev.Message = p.ReadStringLen16();
var scene = Scene;
if (scene != null)
{
ev.OriginSceneID = scene.ID;
scene.ChatPassInbound(RemoteSceneID, ev);
}
}
break;
default:
Func <UDPPacket, Message> del;
if (m_PacketDecoder.PacketTypes.TryGetValue(mType, out del))
{
var m = del(p);
/* we got a decoder, so we can make use of it */
m.CircuitAgentID = new UUID(RemoteSceneID);
try
{
m.CircuitAgentOwner = UGUI.Unknown;
m.CircuitSessionID = SessionID;
m.CircuitSceneID = new UUID(RemoteSceneID);
}
catch
{
/* this is a specific error that happens only during logout */
return;
}
/* we keep the circuit relatively dumb so that we have no other logic than how to send and receive messages to the remote sim.
* It merely collects delegates to other objects as well to call specific functions.
*/
Action <Message> mdel;
if (m_MessageRouting.TryGetValue(m.Number, out mdel))
{
mdel(m);
}
else if (m.Number == MessageType.ImprovedInstantMessage)
{
var im = (ImprovedInstantMessage)m;
if (im.CircuitAgentID != im.AgentID ||
im.CircuitSessionID != im.SessionID)
{
break;
}
if (m_IMMessageRouting.TryGetValue(im.Dialog, out mdel))
{
mdel(m);
}
else
{
m_Log.DebugFormat("Unhandled im message {0} received", im.Dialog.ToString());
}
}
else if (m.Number == MessageType.GenericMessage)
{
var genMsg = (GenericMessage)m;
if (m_GenericMessageRouting.TryGetValue(genMsg.Method, out mdel))
{
mdel(m);
}
else
{
m_Log.DebugFormat("Unhandled generic message {0} received", genMsg.Method);
}
}
else if (m.Number == MessageType.GodlikeMessage)
{
var genMsg = (GodlikeMessage)m;
if (m_GodlikeMessageRouting.TryGetValue(genMsg.Method, out mdel))
{
mdel(m);
}
else
{
m_Log.DebugFormat("Unhandled godlike message {0} received", genMsg.Method);
}
}
else
{
m_Log.DebugFormat("Unhandled message type {0} received", m.Number.ToString());
}
}
else
{
/* Ignore we have no decoder for that */
}
break;
}
}
