private void ConvertCsObj(object csObj, IMPObject mpObj)
{
Type type = csObj.GetType();
string fullName = type.FullName;
if (!(mpObj is Serializable))
{
throw new Exception(string.Concat("Cannot serialize object: ", csObj, ", type: ", fullName, " -- It doesn't implement the SerializableSFSType interface"));
}
IMPArray val = MPArray.NewInstance();
mpObj.PutUtfString(CLASS_MARKER_KEY, fullName);
mpObj.PutMPArray(CLASS_FIELDS_KEY, val);
foreach (FieldInfo info in type.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance))
{
string name = info.Name;
object obj2 = info.GetValue(csObj);
IMPObject obj3 = MPObject.NewInstance();
MPDataWrapper wrapper = WrapField(obj2);
if (wrapper != null)
{
obj3.PutUtfString(FIELD_NAME_KEY, name);
obj3.Put(FIELD_VALUE_KEY, wrapper);
val.AddMPObject(obj3);
}
else
{
throw new Exception(string.Concat("Cannot serialize field of object: ", csObj, ", field: ", name, ", type: ", info.GetType().Name, " -- unsupported type!"));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="requestObject"></param>
private void DispatchRequest(IMPObject requestObject)
{
IMessage message = new Message();
if (requestObject.IsNull(CONTROLLER_ID))
{
throw new Exception("Request rejected: No Controller ID in request!");
}
if (requestObject.IsNull(ACTION_ID))
{
throw new Exception("Request rejected: No Action ID in request!");
}
message.Id = Convert.ToInt32(requestObject.GetShort(ACTION_ID));
message.Content = requestObject.GetMPObject(PARAM_ID);
message.IsUDP = requestObject.ContainsKey(UDP_PACKET_ID);
if (message.IsUDP)
{
message.PacketId = requestObject.GetLong(UDP_PACKET_ID);
}
int @byte = requestObject.GetByte(CONTROLLER_ID);
IController controller = this.bitSwarm.GetController(@byte);
if (controller == null)
{
throw new Exception("Cannot handle server response. Unknown controller, id: " + @byte);
}
controller.HandleMessage(message);
}
//---------------------------------- Class Mapping -------------------------------------
//*********************************** Class to MPObject *********************************
private IMPObject Cs2Mp(object csObj)
{
IMPObject sfsObj = MPObject.NewInstance();
ConvertCsObj(csObj, sfsObj);
return(sfsObj);
}
private IMPObject UnrollDictionary(IDictionary dict)
{
IMPObject obj2 = MPObject.NewInstance();
IEnumerator enumerator = dict.Keys.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
string current = (string)enumerator.Current;
MPDataWrapper val = WrapField(dict[current]);
if (val == null)
{
throw new Exception(string.Concat("Cannot serialize field of dictionary with key: ", current, ", ", dict[current], " -- unsupported type!"));
}
obj2.Put(current, val);
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
return(obj2);
}
/// <summary>
///
/// </summary>
/// <param name="ip"></param>
/// <param name="port"></param>
public void Connect(string ip, int port)
{
MPNetClient mpnet = new MPNetClient(m_PrefabConnecterId);
mpnet.Connect(ip, port);
mpnet.AddEventListener(MPEvent.CONNECTION, delegate(BaseEvent evt)
{
IMPObject par = evt.Params;
if ((bool)par["success"])
{
IMPObject mpo = MPObject.NewInstance();
mpo["test1"] = 22;
mpo["test2"] = 22;
mpo["test3"] = 33;
LuaTable table = mpo.ToLuaTable();
GTLib.NetManager.DispatchLuaEvent("conn1", table);
}
else
{
GTLib.NetManager.DispatchLuaEvent("lost1", null);
}
});
mpnet.AddEventListener(MPEvent.CONNECTION_LOST, delegate(BaseEvent evt)
{
GTLib.NetManager.KillConnection(m_PrefabConnecterId);
GTLib.NetManager.DispatchLuaEvent("lost1", null);
});
GTLib.NetManager.AddMPNetClient(mpnet);
}
private void Test(IMPObject parameters)
{
Hashtable rdata = new Hashtable();
rdata["c"] = parameters.GetUtfString("c");
DispatchEvent(new MPEvent(Program.EVENT_TEST + m_PrefabConnecterId, rdata));
}
public void ConnectTest(string ip, int port)
{
MPNetClient mpnet = new MPNetClient(m_PrefabConnecterId);
mpnet.Connect(ip, port);
mpnet.AddEventListener(MPEvent.CONNECTION, delegate(BaseEvent evt)
{
IMPObject par = evt.Params;
if ((bool)par["success"])
{
DispatchEvent(new MPEvent(CSTestManager.EVENT_CONNECT + m_PrefabConnecterId));
}
else
{
DispatchEvent(new MPEvent(CSTestManager.EVENT_CONNECT_LOST + m_PrefabConnecterId));
}
});
mpnet.AddEventListener(MPEvent.CONNECTION_LOST, delegate(BaseEvent evt)
{
GTLib.NetManager.KillConnection(m_PrefabConnecterId);
DispatchEvent(new MPEvent(CSTestManager.EVENT_CONNECT_LOST + m_PrefabConnecterId));
});
GTLib.NetManager.AddMPNetClient(mpnet);
}
private object UnwrapField(MPDataWrapper wrapper)
{
object obj2 = null;
int type = wrapper.Type;
if (type <= (int)MPDataType.UTF_STRING)
{
return(wrapper.Data);
}
switch (type)
{
case (int)MPDataType.MP_ARRAY:
return(RebuildArray(wrapper.Data as IMPArray));
case (int)MPDataType.MP_OBJECT:
{
IMPObject data = wrapper.Data as IMPObject;
if (data.ContainsKey(CLASS_MARKER_KEY) && data.ContainsKey(CLASS_FIELDS_KEY))
{
return(Cs2Mp(data));
}
return(RebuildDict(wrapper.Data as IMPObject));
}
case (int)MPDataType.CLASS:
obj2 = wrapper.Data;
break;
}
return(obj2);
}
private void FnLogout(IMessage msg)
{
mpnet.HandleLogout();
IMPObject content = msg.Content;
mpnet.DispatchEvent(new MPEvent(MPEvent.LOGOUT));
}
/// <summary>
///
/// </summary>
/// <param name="mpnet"></param>
/// <param name="cmd"></param>
/// <param name="parameters"></param>
internal void HandleExtension(MPNetClient mpnet, string cmd, IMPObject parameters)
{
if (extensionMessages.ContainsKey(mpnet.Id))
{
Hashtable messages = extensionMessages[mpnet.Id];
ExtensionMessageDelegate delegate2 = messages[cmd] as ExtensionMessageDelegate;
if (delegate2 != null)
{
try
{
delegate2(parameters);
}
catch (Exception exception)
{
throw new Exception(string.Concat("Error extension handler [", cmd, "]: ", exception.Message, " ", exception.StackTrace), exception);
}
}
}
if (luaExtensionMessages.ContainsKey(mpnet.Id))
{
Hashtable messages = luaExtensionMessages[mpnet.Id];
LuaFunction delegate2 = messages[cmd] as LuaFunction;
if (delegate2 != null)
{
delegate2.Call(parameters.ToLuaTable());
}
}
}
public BaseRequest(int id)
{
mpo = MPObject.NewInstance();
targetController = 0;
isEncrypted = false;
this.id = id;
}
public BaseRequest(RequestType tp)
{
mpo = MPObject.NewInstance();
targetController = 0;
isEncrypted = false;
id = (int)tp;
}
public override void HandleMessage(IMessage message)
{
if (mpnet.Debug)
{
log.Info(message.ToString());
}
IMPObject content = message.Content;
//Hashtable data = new Hashtable();
//data["cmd"] = content.GetUtfString(KEY_CMD);
//data["params"] = content.GetMPObject(KEY_PARAMS);
//if (message.IsUDP)
//{
//data["packetId"] = message.PacketId;
//}
//MPEvent evt = new MPEvent(MPEvent.EXTENSION_RESPONSE, data);
string cmd = content.GetUtfString(KEY_CMD);
IMPObject parameters = content.GetMPObject(KEY_PARAMS);
if (message.IsUDP)
{
parameters.PutLong("packetId", message.PacketId);
}
mpnet.HandleExtension(cmd, parameters);
//mpnet.DispatchEvent(new MPEvent(MPEvent.EXTENSION_RESPONSE, data));
}
internal ByteArray Object2Binary(IMPObject obj)
{
ByteArray buffer = new ByteArray();
buffer.WriteByte(Convert.ToByte(MPDataType.MP_OBJECT));
buffer.WriteShort(Convert.ToInt16(obj.Size()));
return(Obj2bin(obj, buffer));
}
private void FnLogout(IMessage msg)
{
mpnet.HandleLogout();
IMPObject content = msg.Content;
Hashtable data = new Hashtable();
mpnet.DispatchEvent(new MPEvent(MPEvent.LOGOUT, data));
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
public BaseEvent(string type)
{
this.type = type;
if (arguments == null)
{
arguments = MPObject.NewInstance();
}
}
private MPDataWrapper DecodeObject(ByteArray buffer)
{
MPDataType type = (MPDataType)Convert.ToInt32(buffer.ReadByte());
switch (type)
{
case MPDataType.NULL:
return(BinDecode_NULL(buffer));
case MPDataType.BOOL:
return(BinDecode_BOOL(buffer));
case MPDataType.BYTE:
return(BinDecode_BYTE(buffer));
case MPDataType.BYTE_ARRAY:
return(BinDecode_BYTE_ARRAY(buffer));
case MPDataType.SHORT:
return(BinDecode_SHORT(buffer));
case MPDataType.INT:
return(BinDecode_INT(buffer));
case MPDataType.LONG:
return(BinDecode_LONG(buffer));
case MPDataType.FLOAT:
return(BinDecode_FLOAT(buffer));
case MPDataType.DOUBLE:
return(BinDecode_DOUBLE(buffer));
case MPDataType.UTF_STRING:
return(BinDecode_UTF_STRING(buffer));
case MPDataType.MP_ARRAY:
buffer.Position--;
return(new MPDataWrapper(MPDataType.MP_ARRAY, DecodeMPArray(buffer)));
}
if (type != MPDataType.MP_OBJECT)
{
throw new Exception("Unknow MPDataType ID: " + type);
}
buffer.Position--;
IMPObject mpObj = DecodeMPObject(buffer);
byte num = Convert.ToByte(MPDataType.MP_OBJECT);
object data = mpObj;
if (mpObj.ContainsKey(CLASS_MARKER_KEY) && mpObj.ContainsKey(CLASS_FIELDS_KEY))
{
num = Convert.ToByte(MPDataType.CLASS);
data = Mp2Cs(mpObj);
}
return(new MPDataWrapper(num, data));
}
private Hashtable RebuildDict(IMPObject mpObj)
{
Hashtable hashtable = new Hashtable();
foreach (string str in mpObj.GetKeys())
{
hashtable[str] = UnwrapField(mpObj.GetData(str));
}
return(hashtable);
}
private ByteArray Obj2bin(IMPObject obj, ByteArray buffer)
{
foreach (string str in obj.GetKeys())
{
MPDataWrapper data = obj.GetData(str);
buffer = EncodeMPObjectKey(buffer, str);
buffer = EncodeObject(buffer, data.Type, data.Data);
}
return(buffer);
}
private void Init(string extCmd, IMPObject parameters, bool useUDP)
{
base.targetController = 1;
this.extCmd = extCmd;
this.parameters = parameters;
this.useUDP = useUDP;
if (parameters == null)
{
parameters = new MPObject();
}
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
public void OnPacketWrite(IMessage message)
{
IMPObject obj2 = null;
if (message.IsUDP)
{
obj2 = PrepareUDPPacket(message);
}
else
{
obj2 = PrepareTCPPacket(message);
}
message.Content = obj2;
ioHandler.OnDataWrite(message);
}
private void ConvertMPObject(IMPArray fieldList, object csObj, Type objType)
{
for (int i = 0; i < fieldList.Size(); i++)
{
IMPObject sFSObject = fieldList.GetMPObject(i);
string utfString = sFSObject.GetUtfString(FIELD_NAME_KEY);
MPDataWrapper data = sFSObject.GetData(FIELD_VALUE_KEY);
object obj3 = UnwrapField(data);
FieldInfo field = objType.GetField(utfString, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if (field == null)
{
throw new Exception(string.Format("The deserialized class ({0}) doesn't contain the field: {1}", objType.FullName, utfString));
}
field.SetValue(csObj, obj3);
}
}
/// <summary>
///
/// </summary>
/// <param name="bt"></param>
private void OnUDPData(byte[] bt)
{
ByteArray ba = new ByteArray(bt);
if (ba.BytesAvailable < 4)
{
log.Warn("Too small UDP packet. Len: " + ba.Length);
}
else
{
bool flag = (ba.ReadByte() & 0x20) > 0;
short num2 = ba.ReadShort();
if (num2 != ba.BytesAvailable)
{
string str = string.Concat("Insufficient UDP data. Expected: ", num2, ", got: ", ba.BytesAvailable);
log.Warn(str);
}
else
{
ByteArray array2 = new ByteArray(ba.ReadBytes(ba.BytesAvailable));
if (flag)
{
array2.Uncompress();
}
IMPObject packet = MPObject.NewFromBinaryData(array2);
if (packet.ContainsKey("h"))
{
if (!initSuccess)
{
StopTimer();
locked = false;
initSuccess = true;
Hashtable data = new Hashtable();
data["success"] = true;
mpnet.DispatchEvent(new MPEvent(MPEvent.UDP_INIT, data));
}
}
else
{
mpnet.GetSocketEngine().IoHandler.Codec.OnPacketRead(packet);
}
}
}
}
//*********************************** MPObject to Class *********************************
private object Mp2Cs(IMPObject mpObj)
{
if (!mpObj.ContainsKey(CLASS_MARKER_KEY) || !mpObj.ContainsKey(CLASS_FIELDS_KEY))
{
throw new Exception("The MPObject passed does not represent any serialized class.");
}
string utfString = mpObj.GetUtfString(CLASS_MARKER_KEY);
Type type = Type.GetType(utfString);
if (type == null)
{
throw new Exception("Cannot find type: " + utfString);
}
object csObj = Activator.CreateInstance(type);
if (!(csObj is Serializable))
{
throw new Exception(string.Concat("Cannot deserialize object: ", csObj, ", type: ", utfString, " -- It doesn't implement the Serializable interface"));
}
ConvertMPObject(mpObj.GetMPArray(CLASS_FIELDS_KEY), csObj, type);
return(csObj);
}
private void FnLogin(IMessage msg)
{
IMPObject content = msg.Content;
Hashtable data = new Hashtable();
if (content.IsNull(BaseRequest.KEY_ERROR_CODE))
{
mpnet.MySelf = new MPUser(content.GetInt(LoginRequest.KEY_ID), content.GetUtfString(LoginRequest.KEY_USER_NAME));
mpnet.MySelf.PrivilegeId = content.GetShort(LoginRequest.KEY_PRIVILEGE_ID);
mpnet.SetReconnectionSeconds(content.GetShort(LoginRequest.KEY_RECONNECTION_SECONDS));
mpnet.MySelf.PrivilegeId = content.GetShort(LoginRequest.KEY_PRIVILEGE_ID);
data["user"] = mpnet.MySelf;
data["data"] = content.GetMPObject(LoginRequest.KEY_PARAMS);
MPEvent evt = new MPEvent(MPEvent.LOGIN, data);
mpnet.DispatchEvent(evt);
}
else
{
short code = content.GetShort(BaseRequest.KEY_ERROR_CODE);
data["errorCode"] = code;
mpnet.DispatchEvent(new MPEvent(MPEvent.LOGIN_ERROR, data));
}
}
/// <summary>
///
/// </summary>
/// <param name="evt"></param>
public void HandleHandShake(IMPObject parameters)
{
IMPObject obj2 = parameters;
if (obj2.IsNull(BaseRequest.KEY_ERROR_CODE))
{
sessionToken = obj2.GetUtfString(HandshakeRequest.KEY_SESSION_TOKEN);
bitSwarm.CompressionThreshold = obj2.GetInt(HandshakeRequest.KEY_COMPRESSION_THRESHOLD);
bitSwarm.MaxMessageSize = obj2.GetInt(HandshakeRequest.KEY_MAX_MESSAGE_SIZE);
if (Debug)
{
log.Debug(string.Format("Handshake response: tk => {0}, ct => {1}", sessionToken, bitSwarm.CompressionThreshold));
}
if (bitSwarm.IsReconnecting)
{
bitSwarm.IsReconnecting = false;
DispatchEvent(new MPEvent(MPEvent.CONNECTION_RESUME));
}
else
{
isConnecting = false;
Hashtable data = new Hashtable();
data["success"] = true;
DispatchEvent(new MPEvent(MPEvent.CONNECTION, data));
}
}
else
{
short errorCode = obj2.GetShort(BaseRequest.KEY_ERROR_CODE);
Hashtable hashtable2 = new Hashtable();
hashtable2["success"] = false;
hashtable2["errorCode"] = errorCode;
DispatchEvent(new MPEvent(MPEvent.CONNECTION, hashtable2));
}
}
/// <summary>
///
/// </summary>
/// <param name="packet"></param>
public void OnPacketRead(IMPObject packet)
{
DispatchRequest(packet);
}
public ExtensionRequest(string extCmd, IMPObject parameters, bool useUDP)
: base(RequestType.CallExtension)
{
this.Init(extCmd, parameters, useUDP);
}
/// <summary>
///
/// </summary>
/// <param name="packet"></param>
public void OnPacketRead(ByteArray packet)
{
IMPObject requestObject = MPObject.NewFromBinaryData(packet);
DispatchRequest(requestObject);
}
/// <summary>
///
/// </summary>
/// <param name="parameters"></param>
public void ExtensionTest(IMPObject parameters)
{
SendExtensionRequest("test", parameters, true);
}
