/// <summary>
/// Send a static RPC to the player. (prevents array allocation)
/// </summary>
/// <param name="rpcID"></param>
/// <param name="arg0"></param>
/// <param name="arg1"></param>
/// <param name="arg2"></param>
/// <param name="arg3"></param>
/// <param name="arg4"></param>
/// <param name="ordered"></param>
public void RPC(byte rpcID,
INetSerializable arg0,
INetSerializable arg1,
INetSerializable arg2,
INetSerializable arg3,
INetSerializable arg4,
bool ordered = true)
{
var size = 1;
size += arg0.AllocSize;
size += arg1.AllocSize;
size += arg2.AllocSize;
size += arg3.AllocSize;
size += arg4.AllocSize;
var message = CreateMessage(rpcID, size);
arg0.OnSerialize(message);
arg1.OnSerialize(message);
arg2.OnSerialize(message);
arg3.OnSerialize(message);
arg4.OnSerialize(message);
if (ordered)
{
SendMessage(message);
}
else
{
SendUnorderedMessage(message);
}
}
/// <summary>
/// get the allocation size from the specified serializing objects
/// </summary>
/// <param name="prealloc"></param>
/// <param name="towrite"></param>
public static void AllocSize(ref int prealloc, INetSerializable[] towrite)
{
foreach (var arg in towrite)
{
prealloc += arg.AllocSize;
}
}
public void RPC(byte rpcID, Player player,
INetSerializable arg0,
INetSerializable arg1,
INetSerializable arg2,
INetSerializable arg3,
INetSerializable arg4)
{
var size = DEFAULT_RPC_HEADER_SIZE;
size += arg0.AllocSize;
size += arg1.AllocSize;
size += arg2.AllocSize;
size += arg3.AllocSize;
size += arg4.AllocSize;
var msg = CreateMessage(size, rpcID);
arg0.OnSerialize(msg);
arg1.OnSerialize(msg);
arg2.OnSerialize(msg);
arg3.OnSerialize(msg);
arg4.OnSerialize(msg);
FinishRPCSend(player, msg);
}
protected virtual void Awake()
{
if (ViewId != 0)
{
NetP2pUnity.Instance.RegisterView(this);
}
_viewHandlers = GetComponents <INetViewHandler>();
_viewPeriodicSyncs = GetComponents <INetViewPeriodicSync>();
_viewRpcInvokables = GetComponents <IRpcInvokable>();
var serializerComp = GetComponents <INetSerializable>();
if (serializerComp.Length > 1)
{
Debug.LogError($"Found multiple INetSerializable in one gameobject. please delete only one left", gameObject);
}
if (serializerComp.Length > 0)
{
_serializer = serializerComp[0];
}
switch (_viewSyncType)
{
case NetViewSyncType.PositionAndRotation:
_posRotSync = new NetViewPosRotSync(this, _viewSyncInterval);
break;
}
}
private void SerializePacketInternal(NetDataWriter externalWriter, INetSerializable packet, bool prependLength)
{
byte value;
INetworkPacketSubSerializer <TData> networkPacketSubSerializer;
if (!this.TryGetPacketType(packet.GetType(), out value, out networkPacketSubSerializer))
{
return;
}
NetDataWriter netDataWriter = prependLength ? this._internalWriter : externalWriter;
netDataWriter.Put(value);
if (networkPacketSubSerializer != null)
{
networkPacketSubSerializer.Serialize(netDataWriter, packet);
}
else
{
packet.Serialize(netDataWriter);
}
if (prependLength)
{
externalWriter.PutVarUInt((uint)this._internalWriter.Length);
externalWriter.Put(this._internalWriter.Data, 0, this._internalWriter.Length);
this._internalWriter.Reset();
}
}
/// <summary>
/// write all the serializing objects to the stream
/// </summary>
/// <param name="msg"></param>
/// <param name="towrite"></param>
public static void WriteParams(ref NetOutgoingMessage msg, INetSerializable[] towrite)
{
foreach (var arg in towrite)
{
arg.OnSerialize(msg);
}
}
protected virtual void ValidateChild(INetSerializable child)
{
if ((this.Parent != null || this.Root == this) && child.Parent != this)
{
throw new InvalidOperationException();
}
}
protected override void SetParent(INetSerializable parent)
{
if (parent == null || parent.Root != base.Root)
{
reassigned.Clear();
}
base.SetParent(parent);
}
internal void SendToAll(INetSerializable data)
{
if (_server != null && _server.IsRunning && _server.PeersCount > 0)
{
Logger.Trace("Sending {0}", data);
_netPacketProcessor.SendKnown(_server, data, DeliveryMethod.ReliableOrdered);
}
}
internal void SendTo(NetPeer peer, INetSerializable data, DeliveryMethod deliveryMethod = DeliveryMethod.ReliableOrdered)
{
if (_server != null && _server.IsRunning && _server.PeersCount > 0)
{
// Logger.Debug("Sending {0}", data);
_netPacketProcessor.SendKnown(peer, data, DeliveryMethod.ReliableOrdered);
}
}
public void SendKnown(NetManager netManager, INetSerializable o, DeliveryMethod deliveryMethod = DeliveryMethod.ReliableOrdered)
{
using (var nw = new NetDataWriter())
{
WriteHash(o.GetType(), nw);
o.Serialize(nw);
netManager.SendToAll(nw, deliveryMethod);
}
}
public override void WriteFull(BinaryWriter writer)
{
for (int i = 0; i < fields.Count; i++)
{
INetSerializable netSerializable = fields[i];
writer.Push(Convert.ToString(i));
netSerializable.WriteFull(writer);
writer.Pop();
}
}
protected void ReadEvent(IReadMessage buffer, INetSerializable entity, Client sender = null)
{
var clientEntity = entity as IClientSerializable;
if (clientEntity == null)
{
return;
}
clientEntity.ServerRead(ClientNetObject.ENTITY_STATE, buffer, sender);
}
/// <summary>
/// Send a message to the specified recipients (prevents array allocation)
/// </summary>
/// <param name="rpcID"></param>
/// <param name="mode"></param>
/// <param name="arg0"></param>
/// <param name="arg1"></param>
/// <param name="arg2"></param>
/// <param name="arg3"> </param>
/// <param name="arg4"> </param>
public void RPC(byte rpcID, RPCMode mode,
INetSerializable arg0 = null,
INetSerializable arg1 = null,
INetSerializable arg2 = null,
INetSerializable arg3 = null,
INetSerializable arg4 = null)
{
var size = DEFAULT_RPC_HEADER_SIZE;
if (arg0 != null)
{
size += arg0.AllocSize;
}
if (arg1 != null)
{
size += arg1.AllocSize;
}
if (arg2 != null)
{
size += arg2.AllocSize;
}
if (arg3 != null)
{
size += arg3.AllocSize;
}
if (arg4 != null)
{
size += arg4.AllocSize;
}
var message = CreateMessage(size, rpcID);
if (arg0 != null)
{
arg0.OnSerialize(message);
}
if (arg1 != null)
{
arg1.OnSerialize(message);
}
if (arg2 != null)
{
arg2.OnSerialize(message);
}
if (arg3 != null)
{
arg3.OnSerialize(message);
}
if (arg4 != null)
{
arg4.OnSerialize(message);
}
FinishRPCSend(mode, message);
}
public NetWriter Write(INetSerializable serializable)
{
if (serializable == null)
{
Write(false);
return(this);
}
Write(true);
serializable.Serialize(this);
return(this);
}
public void Rpc(byte rpcId,
INetSerializable arg0)
{
int size = 0;
size += arg0.AllocSize;
var msg = StartMessage(Room, rpcId, ReliabilityMode.Ordered, size);
arg0.OnSerialize(msg);
SendMessage(msg, ReliabilityMode.Ordered);
}
public void AddField(INetSerializable field)
{
if (field.Parent != null)
{
throw new InvalidOperationException("Attempt to add a field to more than one tree");
}
if (base.Parent != null)
{
throw new InvalidOperationException("Cannot add new fields once this NetFields is part of a tree");
}
fields.Add(field);
}
public void Serialize(NetDataWriter writer, object messageData)
{
INetSerializable serializable = messageData as INetSerializable;
if (serializable != null)
{
serializable.Serialize(writer);
}
else
{
Debug.LogError("cant change INetSerializable");
}
}
//NetSerializer netSerializer = new NetSerializer();
public T Deserialize <T>(NetDataReader reader) where T : new()
{
T t = new T();
INetSerializable serializable = (INetSerializable)t;
serializable.Deserialize(reader);
//Debug.Log("Deserialize:" + JsonUtility.ToJson(serializable));
//Debug.Log("Deserialize:" + JsonUtility.ToJson(t));
t = (T)serializable;
//netSerializer.RegisterNestedType<T>();
//Debug.Log("Deserialize:" + JsonUtility.ToJson(t));
return(t);
}
protected virtual void SetParent(INetSerializable parent)
{
if (this.parent != parent)
{
this.minNextDirtyTime = 0U;
}
this.parent = parent;
if (parent != null)
{
this.Root = parent.Root;
this.SetChildParents();
}
else
{
this.ClearChildParents();
}
this.MarkClean();
}
//private NetDataWriter writer = null;
public byte[] Serialize(object msgType, object data)
{
NetDataWriter writer = new NetDataWriter(byteOrder);
writer.Reset();
writer.PutValue(msgType);
INetSerializable serializable = data as INetSerializable;
if (serializable != null)
{
serializable.Serialize(writer);
}
else
{
NetDebug.LogError("cant change INetSerializable");
}
return(writer.CopyData());
}
//private NetDataReader reader = null;
public object Deserialize(byte[] datas, out object msgType)
{
//NetDebug.Log("Deserialize收到消息：" + datas.Length);
NetDataReader reader = new NetDataReader(byteOrder);
reader.SetSource(datas, 0);
msgType = reader.GetString();
string msgT = msgType.ToString();
if (!typeDic.ContainsKey(msgT))
{
NetDebug.LogError("No msgType:" + msgType);
return(null);
}
Type type = typeDic[msgT];
INetSerializable serializable = (INetSerializable)ReflectionTool.CreateDefultInstance(type);
serializable.Deserialize(reader);
return(serializable);
}
public override void Write(BinaryWriter writer)
{
BitArray dirtyBits = new BitArray(fields.Count);
for (int j = 0; j < fields.Count; j++)
{
dirtyBits[j] = fields[j].Dirty;
}
writer.WriteBitArray(dirtyBits);
for (int i = 0; i < fields.Count; i++)
{
if (dirtyBits[i])
{
INetSerializable netSerializable = fields[i];
writer.Push(Convert.ToString(i));
netSerializable.Write(writer);
writer.Pop();
}
}
}
//public void Destroy()
//{
// CSEngineApp.App = null;
//}
public void SendAll(PacketType packetType, INetSerializable packet)
{
var netDataWriter = LiteNet.WriteSerializable(packetType, packet);
LiteNet._netManager.SendToAll(netDataWriter, DeliveryMethod.Unreliable);
}
private void OnRequestedCreateCharacter(ResponseHandlerData responseHandler, AckResponseCode responseCode, INetSerializable response)
{
if (responseCode == AckResponseCode.Timeout)
{
UISceneGlobal.Singleton.ShowMessageDialog(LanguageManager.GetText(UITextKeys.UI_LABEL_ERROR.ToString()), LanguageManager.GetText(UITextKeys.UI_ERROR_CONNECTION_TIMEOUT.ToString()));
return;
}
// Proceed response
ResponseCreateCharacterMessage castedResponse = response as ResponseCreateCharacterMessage;
switch (responseCode)
{
case AckResponseCode.Error:
string errorMessage = string.Empty;
switch (castedResponse.error)
{
case ResponseCreateCharacterMessage.Error.NotLoggedin:
errorMessage = LanguageManager.GetText(UITextKeys.UI_ERROR_NOT_LOGGED_IN.ToString());
break;
case ResponseCreateCharacterMessage.Error.InvalidData:
errorMessage = LanguageManager.GetText(UITextKeys.UI_ERROR_INVALID_DATA.ToString());
break;
case ResponseCreateCharacterMessage.Error.TooShortCharacterName:
errorMessage = LanguageManager.GetText(UITextKeys.UI_ERROR_CHARACTER_NAME_TOO_SHORT.ToString());
break;
case ResponseCreateCharacterMessage.Error.TooLongCharacterName:
errorMessage = LanguageManager.GetText(UITextKeys.UI_ERROR_CHARACTER_NAME_TOO_LONG.ToString());
break;
case ResponseCreateCharacterMessage.Error.CharacterNameAlreadyExisted:
errorMessage = LanguageManager.GetText(UITextKeys.UI_ERROR_CHARACTER_NAME_EXISTED.ToString());
break;
}
UISceneGlobal.Singleton.ShowMessageDialog(LanguageManager.GetText(UITextKeys.UI_LABEL_ERROR.ToString()), errorMessage);
break;
default:
if (eventOnCreateCharacter != null)
{
eventOnCreateCharacter.Invoke();
}
break;
}
}
public void OnRegister(ResponseHandlerData responseHandler, AckResponseCode responseCode, INetSerializable response)
{
Registering = false;
if (responseCode == AckResponseCode.Timeout)
{
UISceneGlobal.Singleton.ShowMessageDialog(LanguageManager.GetText(UITextKeys.UI_LABEL_ERROR.ToString()), LanguageManager.GetText(UITextKeys.UI_ERROR_CONNECTION_TIMEOUT.ToString()));
if (onRegisterFail != null)
{
onRegisterFail.Invoke();
}
return;
}
ResponseUserRegisterMessage castedResponse = response as ResponseUserRegisterMessage;
switch (responseCode)
{
case AckResponseCode.Error:
string errorMessage = string.Empty;
switch (castedResponse.error)
{
case ResponseUserRegisterMessage.Error.TooShortUsername:
errorMessage = LanguageManager.GetText(UITextKeys.UI_ERROR_USERNAME_TOO_SHORT.ToString());
break;
case ResponseUserRegisterMessage.Error.TooLongUsername:
errorMessage = LanguageManager.GetText(UITextKeys.UI_ERROR_USERNAME_TOO_LONG.ToString());
break;
case ResponseUserRegisterMessage.Error.TooShortPassword:
errorMessage = LanguageManager.GetText(UITextKeys.UI_ERROR_PASSWORD_TOO_SHORT.ToString());
break;
case ResponseUserRegisterMessage.Error.UsernameAlreadyExisted:
errorMessage = LanguageManager.GetText(UITextKeys.UI_ERROR_USERNAME_EXISTED.ToString());
break;
}
UISceneGlobal.Singleton.ShowMessageDialog(LanguageManager.GetText(UITextKeys.UI_LABEL_ERROR.ToString()), errorMessage);
if (onRegisterFail != null)
{
onRegisterFail.Invoke();
}
break;
default:
if (onRegisterSuccess != null)
{
onRegisterSuccess.Invoke();
}
break;
}
}
public abstract void CreateEntityEvent(INetSerializable entity, object[] extraData = null);
private void OnValidateAccessToken(ResponseHandlerData responseHandler, AckResponseCode responseCode, INetSerializable response)
{
if (responseCode == AckResponseCode.Success)
{
if (onValidateAccessTokenSuccess != null)
{
onValidateAccessTokenSuccess.Invoke();
}
}
}
private void RequestProceeded(long connectionId, uint requestId, AckResponseCode responseCode, INetSerializable response, SerializerDelegate responseSerializer)
{
// Write response
Writer.Reset();
Writer.PutPackedUShort(ResponseMessageType);
Writer.PutPackedUInt(requestId);
Writer.PutValue(responseCode);
Writer.Put(response);
if (responseSerializer != null)
{
responseSerializer.Invoke(Writer);
}
// Send response
SendMessage(connectionId, 0, DeliveryMethod.ReliableUnordered, Writer);
}
protected NetEntityEvent(INetSerializable serializableEntity, UInt16 id)
{
this.ID = id;
this.Entity = serializableEntity as Entity;
RefreshEntityID();
}
internal Player(Room room, INetSerializable netUserData)
{
Room = room;
NetUserData = netUserData;
}
/// <summary>
/// Send a static RPC to the player. (prevents array allocation)
/// </summary>
/// <param name="rpcID"></param>
/// <param name="arg0"></param>
/// <param name="arg1"></param>
/// <param name="arg2"></param>
/// <param name="arg3"></param>
/// <param name="arg4"></param>
/// <param name="ordered"></param>
public void RPC(byte rpcID,
INetSerializable arg0,
INetSerializable arg1,
INetSerializable arg2,
INetSerializable arg3,
INetSerializable arg4,
bool ordered = true)
{
var size = 1;
size += arg0.AllocSize;
size += arg1.AllocSize;
size += arg2.AllocSize;
size += arg3.AllocSize;
size += arg4.AllocSize;
var message = CreateMessage(rpcID, size);
arg0.OnSerialize(message);
arg1.OnSerialize(message);
arg2.OnSerialize(message);
arg3.OnSerialize(message);
arg4.OnSerialize(message);
if (ordered)
SendMessage(message);
else
SendUnorderedMessage(message);
}
private void OnUserLogout(ResponseHandlerData responseHandler, AckResponseCode responseCode, INetSerializable response)
{
if (responseCode == AckResponseCode.Success)
{
ClearHistory();
Next(uiLogin);
}
}
