/// <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); } }