void onSystemAddServer(FunapiRpcPeer peer, FunDedicatedServerRpcMessage msg)
{
FunDedicatedServerRpcMessage response = new FunDedicatedServerRpcMessage();
response.type = msg.type;
response.xid = msg.xid;
response.is_request = false;
peer.Send(response);
FunDedicatedServerRpcSystemMessage sysmsg = FunapiDSRpcMessage.GetMessage <FunDedicatedServerRpcSystemMessage>(msg, MessageType.ds_rpc_sys);
if (string.IsNullOrEmpty(sysmsg.data))
{
return;
}
Dictionary <string, object> data = FunapiDSRpcMessage.ParseJson(sysmsg.data) as Dictionary <string, object>;
if (data.ContainsKey("id") && data.ContainsKey("ip") && data.ContainsKey("port"))
{
string peer_id = data["id"] as string;
string ip = data["ip"] as string;
ushort port = Convert.ToUInt16(data["port"]);
if (!peer_list_.Exists(peer_id))
{
FunDebug.Log("[Peer:{0}:{1}] Added. ({2})", ip, port, peer_id);
onConnect(ip, port);
}
}
}
void onPeerMessage(FunapiRpcPeer peer, FunDedicatedServerRpcMessage msg)
{
string type = msg.type;
if (system_handlers_.ContainsKey(type))
{
system_handlers_[type](peer, msg);
return;
}
if (!msg.is_request)
{
return;
}
lock (handler_lock_)
{
if (handlers_.ContainsKey(type))
{
FunDedicatedServerRpcMessage response = handlers_[type](type, msg);
if (response != null)
{
response.type = type;
response.xid = msg.xid;
response.is_request = false;
peer.Send(response);
}
return;
}
}
FunDebug.Log("[RPC] handler not found '{0}'", type);
}
void setMaster(FunapiRpcPeer peer)
{
if (peer == null)
{
return;
}
master_peer_ = peer;
FunDebug.Log("[Peer:{0}:{1}] Set Master: {2}", peer.addr.host, peer.addr.port, peer.peer_id);
FunDedicatedServerRpcSystemMessage sysmsg = new FunDedicatedServerRpcSystemMessage();
if (!string.IsNullOrEmpty(option_.Tag))
{
sysmsg.data = string.Format("{{ \"tag\" : \"{0}\" }}", option_.Tag);
}
FunDedicatedServerRpcMessage response = FunapiDSRpcMessage.CreateMessage(sysmsg, MessageType.ds_rpc_sys);
string xid = Guid.NewGuid().ToString("N");
response.type = kRpcMasterMessageType;
response.xid = Encoding.UTF8.GetBytes(xid);
response.is_request = true;
peer.Send(response);
}
FunDedicatedServerRpcMessage onEcho(string type, FunDedicatedServerRpcMessage request)
{
EchoDedicatedServerRpcMessage echo = new EchoDedicatedServerRpcMessage();
echo.message = "echo from client";
return(FunapiDSRpcMessage.CreateMessage(echo, MessageType.echo_ds_rpc));;
}
void parseMessages()
{
lock (message_lock_)
{
while (true)
{
if (next_decoding_offset_ >= received_size_ - 4)
{
// Not enough bytes. Wait for more bytes to come.
break;
}
int length = 0;
if (BitConverter.IsLittleEndian)
{
byte[] bytes = new byte [4];
Buffer.BlockCopy(receive_buffer_, next_decoding_offset_, bytes, 0, 4);
Array.Reverse(bytes); // gets big endian
length = (int)BitConverter.ToUInt32(bytes, 0);
}
else
{
length = (int)BitConverter.ToUInt32(receive_buffer_, next_decoding_offset_);
}
if (length > 0)
{
int offset = next_decoding_offset_ + 4;
if (received_size_ - offset < length)
{
// Need more bytes for a message body. Waiting.
break;
}
object obj = FunapiDSRpcMessage.Deserialize(new ArraySegment <byte>(receive_buffer_, offset, length));
if (obj != null)
{
FunDedicatedServerRpcMessage msg = obj as FunDedicatedServerRpcMessage;
messages_.Enqueue(msg);
#if ENABLE_DEBUG
StringBuilder log = new StringBuilder();
log.AppendFormat("[Peer:{0}] [S->C] type={1}, length={2} ", peer_id_, msg.type, length);
FunapiDSRpcMessage.DebugString(msg, log);
FunDebug.LogDebug(log.ToString());
#endif
}
next_decoding_offset_ = offset + length;
}
else
{
next_decoding_offset_ += 4;
}
}
}
}
public void Send(FunDedicatedServerRpcMessage message)
{
lock (send_lock_)
{
send_queue_.Enqueue(message);
}
sendPendingMessages();
}
void decodeMessages()
{
lock (message_lock_)
{
while (messages_.Count > 0)
{
FunDedicatedServerRpcMessage msg = messages_.Dequeue();
recv_handler_(this, msg);
}
}
}
public static void DebugString(FunDedicatedServerRpcMessage msg, StringBuilder log)
{
foreach (MessageType msg_type in Enum.GetValues(typeof(MessageType)))
{
object _msg = null;
Type type = MessageTable.GetType(msg_type);
bool succeed = Extensible.TryGetValue(serializer_, type, msg,
(int)msg_type, DataFormat.Default, true, out _msg);
if (succeed)
{
var json = JObject.FromObject(_msg);
log.Append(prettyJsonString(json));
debugString((IExtensible)_msg, type, log);
}
}
}
void onSystemMaster(FunapiRpcPeer peer, FunDedicatedServerRpcMessage msg)
{
// Get peer id list from peer list
List <string> old_peers = new List <string>();
peer_list_.ForEach(delegate(FunapiRpcPeer p)
{
old_peers.Add(p.peer_id);
});
old_peers.Remove(peer.peer_id);
FunDedicatedServerRpcSystemMessage sysmsg = FunapiDSRpcMessage.GetMessage <FunDedicatedServerRpcSystemMessage>(msg, MessageType.ds_rpc_sys);
List <object> server_list = FunapiDSRpcMessage.ParseJson(sysmsg.data) as List <object>;
foreach (Dictionary <string, object> data in server_list)
{
if (data.ContainsKey("id") && data.ContainsKey("ip") && data.ContainsKey("port"))
{
string peer_id = data["id"] as string;
string ip = data["ip"] as string;
ushort port = Convert.ToUInt16(data["port"]);
if (!peer_list_.Exists(peer_id))
{
FunDebug.Log("[Peer:{0}:{1}] Added. ({2})", ip, port, peer_id);
onConnect(ip, port);
}
else
{
old_peers.Remove(peer_id);
}
}
}
// Remove invalid peers from peer list
foreach (string peer_id in old_peers)
{
FunapiRpcPeer p = peer_list_.Get(peer_id);
if (p.state != FunapiRpcPeer.State.kDisconnected)
{
p.Close(true);
}
peer_list_.Remove(p);
}
}
void onSystemRemoveServer(FunapiRpcPeer peer, FunDedicatedServerRpcMessage msg)
{
FunDedicatedServerRpcMessage response = new FunDedicatedServerRpcMessage();
response.type = msg.type;
response.xid = msg.xid;
response.is_request = false;
peer.Send(response);
FunDedicatedServerRpcSystemMessage sysmsg = FunapiDSRpcMessage.GetMessage <FunDedicatedServerRpcSystemMessage>(msg, MessageType.ds_rpc_sys);
if (string.IsNullOrEmpty(sysmsg.data))
{
return;
}
Dictionary <string, object> data = FunapiDSRpcMessage.ParseJson(sysmsg.data) as Dictionary <string, object>;
string peer_id = "";
if (data.ContainsKey("id"))
{
peer_id = data["id"] as string;
}
if (string.IsNullOrEmpty(peer_id))
{
return;
}
if (peer_list_.Exists(peer_id))
{
FunapiRpcPeer del_peer = peer_list_.Get(peer_id);
FunDebug.Log("[Peer:{0}:{1}] Removed. ({2})", del_peer.addr.host, del_peer.addr.port, peer_id);
peer_list_.Remove(del_peer.uid);
if (del_peer == master_peer_)
{
onMasterDisconnected(del_peer);
}
}
}
FunDedicatedServerRpcMessage onNavRequest(string type, FunDedicatedServerRpcMessage request)
{
NavRequest req = FunapiDSRpcMessage.GetMessage <NavRequest>(request, MessageType.nav_request);
// NavMeshAgent.CalculatePath(req.destination, path);
NavReply reply = new NavReply();
// For the test
Vector3[] corners = new [] { Vector3.zero, Vector3.one, Vector3.back };
for (int i = 0; i < corners.Length; ++i)
{
NavVector3 point = new NavVector3();
point.x = corners[i].x;
point.y = corners[i].y;
point.z = corners[i].z;
reply.waypoints.Add(point);
}
return(FunapiDSRpcMessage.CreateMessage(reply, MessageType.nav_reply));
}
public static T GetMessage <T> (FunDedicatedServerRpcMessage msg, MessageType msg_type)
{
try
{
object _msg = null;
Extensible.TryGetValue(serializer_, MessageTable.GetType(msg_type), msg,
(int)msg_type, DataFormat.Default, true, out _msg);
FunDebug.Assert(_msg != null, "TryGetValue() failed. Please check the message type.");
return((T)_msg);
}
catch (Exception e)
{
Type type = MessageTable.GetType(msg_type);
FunDebug.LogError("FunapiDSRpcMessage.GetMessage - Failed to decode '{0}' ({1})\n{2}",
type, msg_type, e.ToString());
}
return(default(T));
}
void onSystemInfo(FunapiRpcPeer peer, FunDedicatedServerRpcMessage msg)
{
FunDedicatedServerRpcSystemMessage sysmsg = new FunDedicatedServerRpcSystemMessage();
if (!string.IsNullOrEmpty(option_.Tag))
{
sysmsg.data = string.Format("{{ \"tag\" : \"{0}\" }}", option_.Tag);
}
FunDedicatedServerRpcMessage response = FunapiDSRpcMessage.CreateMessage(sysmsg, MessageType.ds_rpc_sys);
response.type = msg.type;
response.xid = msg.xid;
response.is_request = false;
peer.Send(response);
sysmsg = FunapiDSRpcMessage.GetMessage <FunDedicatedServerRpcSystemMessage>(msg, MessageType.ds_rpc_sys);
if (string.IsNullOrEmpty(sysmsg.data))
{
return;
}
Dictionary <string, object> data = FunapiDSRpcMessage.ParseJson(sysmsg.data) as Dictionary <string, object>;
string peer_id = "";
if (data.ContainsKey("id"))
{
peer_id = data["id"] as string;
}
if (peer_id.Length > 0)
{
peer.SetPeerId(peer_id);
if (master_peer_ == null)
{
setMaster(peer);
}
}
}
public static FunDedicatedServerRpcMessage CreateMessage(object msg, MessageType msg_type)
{
if (msg is Enum)
{
msg = (Int32)msg;
}
try
{
FunDedicatedServerRpcMessage _msg = new FunDedicatedServerRpcMessage();
Extensible.AppendValue(serializer_, _msg, (int)msg_type, DataFormat.Default, msg);
return(_msg);
}
catch (Exception e)
{
Type type = MessageTable.GetType(msg_type);
FunDebug.LogError("FunapiDSRpcMessage.CreateMessage - Failed to create '{0}' ({1})\n{2}",
type, msg_type, e.ToString());
}
return(null);
}
public static object GetMessage(FunDedicatedServerRpcMessage msg, MessageType msg_type)
{
return(GetMessage <object>(msg, msg_type));
}
public static bool TryGetExtension_ds_rpc_sys(this FunDedicatedServerRpcMessage message, out FunDedicatedServerRpcSystemMessage value)
{
return(ProtoBuf.Extensible.TryGetValue(message, (int)ExtendedMessageFieldNumber.FunDedicatedServerRpcMessage_ds_rpc_sys, out value));
}
public static void AppendExtension_ds_rpc_sys(this FunDedicatedServerRpcMessage message, FunDedicatedServerRpcSystemMessage value)
{
ProtoBuf.Extensible.AppendValue(message, (int)ExtendedMessageFieldNumber.FunDedicatedServerRpcMessage_ds_rpc_sys, value);
}
