public void SendNonPipeMessage <T>(T message) { Packet packet = SerializeWriter.ToBinary <T>(message); packet.InstanceId = 0L; this.client.Transmit(packet); }
public void BurnGaugeBroadcast() { using (BurnDataContext burnDataContext = new BurnDataContext()) { try { int num = burnDataContext.AddAllUserEventCount(new int?(-99), new int?(0), new DateTime?(DateTime.MaxValue)); BurnJackpot burnJackpot = MMOChannelContents.GetBurnJackpot(); if (burnJackpot != null) { if (this.LatestBurnGauge != num) { this.LatestBurnGauge = num; foreach (KeyValuePair <long, Channel> keyValuePair in this.channels) { Channel value = keyValuePair.Value; PacketMessage message = new PacketMessage { Data = SerializeWriter.ToBinary <ServiceCore.EndPointNetwork.BurnGauge>(new ServiceCore.EndPointNetwork.BurnGauge(num, burnJackpot.JackpotStart, burnJackpot.MaxReward)) }; value.BroadcastToColhenLobby(message); } } } } catch (Exception ex) { Log <MMOChannelService> .Logger.Error("burn gauge broadcasting error", ex); } } }
public void RegisterTcpClientHolder(Devcat.Core.Net.TcpClient tcpClient) { tcpClient.ConnectionSucceed += delegate(object sender, EventArgs evt) { string text = string.Format("[Peer {0}:{1}]", tcpClient.LocalEndPoint.Address.ToString(), tcpClient.LocalEndPoint.Port.ToString()); Log <DSService> .Logger.WarnFormat("{0} Connect ", text); object typeConverter = DSService.Instance.MessageHandlerFactory.GetTypeConverter(); tcpClient.Transmit(SerializeWriter.ToBinary(typeConverter)); DSHostConnectionQuery value = new DSHostConnectionQuery(); tcpClient.Transmit(SerializeWriter.ToBinary <DSHostConnectionQuery>(value)); TcpClientHolder tcpClientHolder = new TcpClientHolder(); tcpClientHolder.BindTcpClient(tcpClient); tcpClientHolder.TimeoutShedID = Scheduler.Schedule(this.Thread, Job.Create <TcpClientHolder>(new Action <TcpClientHolder>(this.UnregisterTcpClientHolder), tcpClientHolder), 30000); this.TcpClientHolders.Add(tcpClientHolder); }; tcpClient.ExceptionOccur += delegate(object sender, EventArgs <Exception> evt) { string text = string.Format("[Peer {0}:{1}]", tcpClient.LocalEndPoint.Address.ToString(), tcpClient.LocalEndPoint.Port.ToString()); Log <DSService> .Logger.ErrorFormat("{0} ExceptionOccur", text); DSLog.AddLog(-1, null, -1L, -1, "ExceptionOccur", text); }; tcpClient.ConnectionFail += delegate(object sender, EventArgs <Exception> evt) { string text = string.Format("[Peer {0}:{1}]", tcpClient.LocalEndPoint.Address.ToString(), tcpClient.LocalEndPoint.Port.ToString()); Log <DSService> .Logger.ErrorFormat("{0} ConnectionFail", text); DSLog.AddLog(-1, null, -1L, -1, "ConnectionFail", text); }; }
public void Serialize(SerializeWriter writer) { // Determine how to serialize this object, so that it can be send via the Socket Stream writer.Write(x); writer.Write(y); writer.WriteText(z); }
public void ProcessMessage(object message) { if (this.ID == 0L && !(message is Identify)) { Log <Client> .Logger.ErrorFormat("client should send Identify first : [{0}]", message); this.client.Transmit(SerializeWriter.ToBinary <IdentifyFailed>(new IdentifyFailed("GameUI_Heroes_Channel_Error_IdentifyFail"))); this.client.Disconnect(); return; } if (message is Identify) { Identify identify = message as Identify; if (!this.parent.VerifyKey(identify.ID, identify.Key)) { this.client.Transmit(SerializeWriter.ToBinary <IdentifyFailed>(new IdentifyFailed("GameUI_Heroes_Channel_Error_KeyMismatch"))); this.client.Disconnect(); return; } this.ID = identify.ID; this.parent.IdentifyClient(this); } if (this.Player != null && message is ServiceCore.EndPointNetwork.IMessage) { this.Player.ProcessMessage(message as ServiceCore.EndPointNetwork.IMessage); } }
public Packet(ushort id) { Writer = new SerializeWriter(new MemoryStream()); Id = id; Writer.Write(id); }
public Test() { this.thread = new JobProcessor(); this.thread.Start(); this.host1 = new Acceptor(this.thread); this.host2 = new Acceptor(this.thread); this.host2.OnAccepted += delegate(Peer peer) { peer.PipeOpen += delegate(Peer _, Pipe pipe) { pipe.PacketReceived += delegate(Packet packet) { Log <Test> .Logger.DebugFormat("receive {0}", packet.Length); }; }; }; this.host1.Start(10000); this.host2.Start(10001); Peer peer2 = Peer.CreateClient(this.host1, new TcpClient()); peer2.Connected += delegate(Peer peer) { peer.InitPipe().SendPacket(SerializeWriter.ToBinary <Test.TestMessage>(new Test.TestMessage { Y = "asd" })); }; peer2.Connect(new IPEndPoint(IPAddress.Loopback, 10001)); }
public void SendMessage <T>(T message) { if (this.TcpClient != null) { this.TcpClient.Transmit(SerializeWriter.ToBinary <T>(message)); } }
public static bool EndEvent(string name, string scriptend, string msgend, AdminClientServicePeer peer) { EventDataContext.StartProcessing(); Event @event = EventDataContext.GetEvent(name); if (@event == null) { if (peer != null) { peer.Transmit(SerializeWriter.ToBinary <AdminReportNotifyMessage>(new AdminReportNotifyMessage(NotifyCode.ERROR, string.Format("Event is Not Registered ! - \"{0}\"", name)))); } return(false); } if (scriptend != null) { @event.EndScript = scriptend; } if (msgend != null) { @event.EndMessage = msgend; } EventDataContext.EndEvent(name); EventDataContext.RemoveEvent(name); if (peer != null) { string msg = EventDataContext.SendEventListAndDetail(name, "Event is Ended !", false); peer.Transmit(SerializeWriter.ToBinary <AdminReportNotifyMessage>(new AdminReportNotifyMessage(NotifyCode.SUCCESS, msg))); } return(true); }
private void OnData(IAsyncResult result) { try { _bytesToRead -= _ns.EndRead(result); if (_bytesToRead > 0) { _ns.BeginRead(_buffer, _buffer.Length - _bytesToRead, _bytesToRead, OnData, null); return; } // Combine the buffer for packetId and the data because we encrypt those together, we have to combine and decrypt them together _buffer = packetId.Concat(_buffer).ToArray(); // Decrypt the buffer to retrieve the actual packetId and the data if (_crypt != null) { _buffer = this._crypt.Decrypt(_buffer).ToArray(); } var id = BitConverter.ToUInt16(_buffer, 0); var data = new SerializeReader(new MemoryStream(_buffer.Skip(2).ToArray())); var hexDump = SerializeWriter.HexDump(_buffer.Skip(2).ToArray()); //Console.WriteLine("{0}", hexDump); _buffer = new byte[4]; _bytesToRead = _buffer.Length; _ns.BeginRead(_buffer, 0, 4, OnHeader, null); } catch (Exception ex) { Console.Error.WriteLine(ex); } }
public void SendMessage <T>(T message) { if (this.client.Connected) { this.client.Transmit(SerializeWriter.ToBinary <T>(message)); } }
public void Serialize(SerializeWriter writer) { foreach (Mastery mastery in Masteries) { writer.Write(mastery.Exp); } }
public void QueryUnderingList(string Text, long selectedEID) { if (Text == this.parent.ServicesString) { this.currentTarget = new EntityGraphIdentifier { category = "ReportService", entityID = (long)EntityGraphNode.ServiceEntityID }; this.peer.Transmit(SerializeWriter.ToBinary <RequestLookUpInfoMessage>(new RequestLookUpInfoMessage("ReportService"))); return; } string[] array = Text.Split(this.parent.delim); if (array.Length == 3) { this.currentTarget = new EntityGraphIdentifier { serviceID = int.Parse(array[1]), entityID = (long)EntityGraphNode.ServiceEntityID }; } else { this.currentTarget = new EntityGraphIdentifier { serviceID = int.Parse(array[1]), entityID = (long.Parse(array[2]) << 32) + long.Parse(array[3]) }; } this.peer.Transmit(SerializeWriter.ToBinary <RequestUnderingListMessage>(new RequestUnderingListMessage(this.currentTarget, selectedEID))); }
public void SendMsg <T>(T msg) { Console.WriteLine("Sending a {0}", typeof(T)); Packet p = SerializeWriter.ToBinary <T>(msg); client.Transmit(p); }
public static SendPacketUserDS Create <T>(T serializeObject) where T : IMessage { Log <SendPacketUserDS> .Logger.InfoFormat("SendPacketUserDS create : [{0}]", serializeObject); Packet packet = SerializeWriter.ToBinary <T>(serializeObject); return(new SendPacketUserDS(packet)); }
public void RequestConsoleCommand(string text, bool isServerCommand) { this.peer.Transmit(SerializeWriter.ToBinary <AdminBroadcastConsoleCommandMessage>(new AdminBroadcastConsoleCommandMessage { commandString = text, isServerCommand = isServerCommand })); }
public static BroadcastPacket Create <T>(T serializeObject) where T : IMessage { Log <BroadcastPacket> .Logger.InfoFormat("BroadcastPacket create : [{0}]", serializeObject); Packet packet = SerializeWriter.ToBinary <T>(serializeObject); return(new BroadcastPacket(packet)); }
public void Send <T>(T msg) { if (this.thread != Thread.CurrentThread.ManagedThreadId) { Log <Pipe> .Logger.FatalFormat("Thread Unsafe code Send<T> : [{0} != {1} ({2})]", this.thread, Thread.CurrentThread.ManagedThreadId, typeof(T)); } this.SendPacket(SerializeWriter.ToBinary <T>(msg)); }
public void Serialize(SerializeWriter writer) { writer.Write(Id); writer.WriteText(Name, false); writer.WriteText(Message, false); writer.Write(Image.Length); writer.Write(Image); }
public void RequestStopService(string target, bool state) { this.peer.Transmit(SerializeWriter.ToBinary <AdminRequestEmergencyStopMessage>(new AdminRequestEmergencyStopMessage { TargetService = target, TargetState = state })); }
public HotSpringInfo(ICollection <HotSpringPotionEffectInfo> hotSpringPotionEffectInfos, int townID) { this.HotSpringPotionEffectInfos = hotSpringPotionEffectInfos; this.binaryMessage = new PacketMessage { Data = SerializeWriter.ToBinary <HotSpringRequestInfoResultChannelMessage>(new HotSpringRequestInfoResultChannelMessage(this.HotSpringPotionEffectInfos, townID)) }; }
public void Serialize(SerializeWriter writer) { writer.WriteTextStatic(Token, 44); writer.Write(IsCorrect); writer.Write(Step); writer.Write((int)Item.Item); writer.Write(Timeout); }
/// <summary> /// 将UI序列化到指定的文件 /// 需要外部捕获异常 /// </summary> /// <param name="packageName">资源包名称</param> /// <param name="fileName">文件名称</param> /// <param name="windowToSerialize">指定序列化那个窗体(包含其所有的子窗体)</param> public void Serialize(string packageName, string fileName, Window windowToSerialize) { //XmlSerializeWriter writer = new XmlSerializeWriter("F:/Test.nui"); NXmlSerializeDataWriter writer = new NXmlSerializeDataWriter(packageName, fileName); SerializeWriter serializer = new SerializeWriter(writer); serializer.Serialize(windowToSerialize); writer.Close(); }
private void SendLog() { string value; while (this.tcpClient.Connected && this.logQueue.TryDequeue(out value)) { this.tcpClient.Transmit(SerializeWriter.ToBinary <string>(value)); } }
public void RequestKick(string uid, string cid) { if (cid == "") { this.peer.Transmit(SerializeWriter.ToBinary <AdminRequestKickMessage>(new AdminRequestKickMessage(uid, true))); return; } this.peer.Transmit(SerializeWriter.ToBinary <AdminRequestKickMessage>(new AdminRequestKickMessage(cid, false))); }
public void Serialize(SerializeWriter writer) { writer.Write(Id); writer.Write(Name); writer.Write(Questions.Count); foreach (Question question in Questions) { writer.Write(question); } }
public void RequestItemFestival(string ItemClass, int Amount, string Message, bool IsCafe) { this.peer.Transmit(SerializeWriter.ToBinary <AdminItemFestivalEventMessage>(new AdminItemFestivalEventMessage { Amount = Amount, ItemClass = ItemClass, Message = Message, IsCafe = IsCafe })); }
public virtual byte[] GetBytes() { using (var ms = new MemoryStream()) { using (var bs = new SerializeWriter(ms)) { } return(ms.ToArray()); } }
public void Serialize(SerializeWriter writer) { writer.WriteTextStatic(Token, 44); writer.Write(Score); writer.Write(AnswerCorrectly); writer.Write(Experience); writer.Write(CurrentExperience); writer.Write(CurrentLevel); writer.Write(LootCount); }
public override byte[] GetBytes() { using (var ms = new MemoryStream()) { using (var sw = new SerializeWriter(ms)) { sw.Write(0); } return(ms.ToArray()); } }