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