public async Task ProcessServerPackages()
{
var port = this.GetPortNumber(PacketServerPort);
var serializer = new BinarySerializer(BinarySerializationMethod.UnsafeSerialization);
using (var packetServer = new PacketServer(IPAddress.Any, port))
{
packetServer.Start();
using (var client = new TcpClient("localhost", port))
using (var stream = client.GetStream())
{
var packetSequence = PacketFixture.GetPacketSequence(PacketSequenceLength);
foreach (var packet in packetSequence)
{
await packetServer.SendPacket(packet).WithTimeOut(Timeout);
var answer = await serializer.Deserialize <Packet>(stream).WithTimeOut(Timeout);
Assert.AreEqual <PacketEx>(packet, answer);
}
}
}
}
public async Task ProcessServerPackagesSequence()
{
var port = this.GetPortNumber(PacketServerPort);
var serializer = new BinarySerializer(BinarySerializationMethod.UnsafeSerialization);
var queue = new WaitableQueue <Packet>();
using (var packetServer = new PacketServer(IPAddress.Any, port))
{
packetServer.OnNewPacketReceived += (sender, value) => queue.Enqueue(value);
packetServer.Start();
using (var client = new TcpClient("localhost", port))
using (var stream = client.GetStream())
{
var packetSequence = PacketFixture.GetPacketSequence(PacketSequenceLength);
foreach (var packet in packetSequence)
{
await serializer.Serialize(packet, stream).WithTimeOut(Timeout);
}
foreach (var packet in packetSequence)
{
var answer = await queue.Dequeue(Timeout);
Assert.AreEqual <PacketEx>(packet, answer);
}
}
}
}
public async Task ProcessDuplexExchange()
{
var port = this.GetPortNumber(PacketServerPort);
var serializer = new BinarySerializer(BinarySerializationMethod.UnsafeSerialization);
var queue = new WaitableQueue <Packet>();
using (var packetServer = new PacketServer(IPAddress.Any, port))
{
packetServer.OnNewPacketReceived += (sender, value) => queue.Enqueue(value);
packetServer.Start();
using (var client = new TcpClient("localhost", port))
using (var stream = client.GetStream())
{
var serverSequence = PacketFixture.GetPacketSequence(PacketSequenceLength);
var clientSequence = PacketFixture.GetPacketSequence(PacketSequenceLength);
foreach (var(serverPacket, clientPacket) in serverSequence.JoinByIndex(clientSequence))
{
await Task.WhenAll(packetServer.SendPacket(serverPacket),
serializer.Serialize(clientPacket, stream));
var results = await Task.WhenAll(queue.Dequeue(Timeout), serializer.Deserialize <Packet>(stream).WithTimeOut(Timeout));
Assert.AreEqual <PacketEx>(clientPacket, results[0]);
Assert.AreEqual <PacketEx>(serverPacket, results[1]);
}
}
}
}
private static void LogPacket(PacketServer packet)
{
try
{
if (!Directory.Exists("logs"))
{
Directory.CreateDirectory("logs");
}
var filename = $"logs/packet_log-{DateTime.Now:yyyy-M-d}.txt";
if (!File.Exists(filename))
{
File.Create(filename).Close();
}
using (StreamWriter w = File.AppendText(filename))
{
w.WriteLine($"[{DateTime.Now:yyyy-M-d H:mm:ss}] = Opcode: {(RealmCMD)packet.Opcode} [Length: {packet.Packet.Length}]");
w.Write(ByteArrayToHex(packet.Packet));
w.WriteLine();
w.WriteLine();
}
}
catch (Exception e)
{
var trace = new StackTrace(e, true);
Log.Print(LogType.Error, $"{e.Message}: {e.Source}\n{trace.GetFrame(trace.FrameCount - 1).GetFileName()}:{trace.GetFrame(trace.FrameCount - 1).GetFileLineNumber()}");
}
}
internal RealmServerSession(int connectionId, Socket connectionSocket)
{
ConnectionId = connectionId;
ConnectionSocket = connectionSocket;
DataBuffer = new byte[BufferSize];
try
{
Log.Print(LogType.RealmServer, $"Incoming connection from [{ConnectionRemoteIp}]");
ConnectionSocket.BeginReceive(DataBuffer, 0, DataBuffer.Length, SocketFlags.None, DataArrival, null);
}
catch (SocketException e)
{
var trace = new StackTrace(e, true);
Log.Print(LogType.Error, $"{e.Message}: {e.Source}\n{trace.GetFrame(trace.FrameCount - 1).GetFileName()}:{trace.GetFrame(trace.FrameCount - 1).GetFileLineNumber()}");
Disconnect();
}
Thread.Sleep(500);
// Connection Packet
using (PacketServer packet = new PacketServer(RealmCMD.SMSG_AUTH_CHALLENGE))
{
packet.WriteBytes(new byte[] { 0x33, 0x18, 0x34, 0xC8 });
SendPacket(packet);
}
}
public static void LogPacket(LogPacket type, PacketServer packet)
{
try
{
var logFilePath = $"logs/{type}_log-{DateTime.Now:yyyy-M-d}.txt";
var logFileInfo = new FileInfo(logFilePath);
var logDirInfo = new DirectoryInfo(logFileInfo.DirectoryName ?? throw new InvalidOperationException());
if (!logDirInfo.Exists)
{
logDirInfo.Create();
}
using (var fileStream = new FileStream(logFilePath, FileMode.Append))
{
using (var log = new StreamWriter(fileStream))
{
log.WriteLine(
$"[{DateTime.Now:yyyy-M-d H:mm:ss}] OPCode: {(RealmEnums) packet.Opcode} " + // (RealmCMD)
$"[Length: {packet.Packet.Length}]");
log.Write(Utils.ByteArrayToHex(packet.Packet));
log.WriteLine();
log.WriteLine();
}
}
}
catch (Exception e)
{
var trace = new StackTrace(e, true);
Print(LogType.Error,
$"{e.Message}: {e.Source}\n{trace.GetFrame(trace.FrameCount - 1).GetFileName()}:{trace.GetFrame(trace.FrameCount - 1).GetFileLineNumber()}");
}
}
public override void LoadData()
{
MyAPIGateway.Entities.OnEntityAdd += EntityAdded;
Instance = this;
Net.Register();
CachedPacketServer = new PacketServer();
CachedPacketClient = new PacketClient();
}
private static void MirrorRateTesting()
{
var server = new PacketServer(26657);
server.StartListening();
var client = new PacketClient("127.0.0.1", 26657);
var sw = Stopwatch.StartNew();
var pc = 0;
server.PacketReceived += (s, e) => mirror(e);
client.PacketReceived += (s, e) => mirror(e);
if (client.Connect())
{
client.Communicator.Send(new PingPacket());
}
else
{
throw new Exception("How?");
}
while (true)
{
Thread.Sleep(-1);
}
void mirror(PacketReceivedEventArgs e)
{
if (e.Packet is PingPacket pingPacket)
{
e.Connection.Communicator.Send(new PongPacket()
{
Value = pingPacket.Value + 1
});
}
else if (e.Packet is PongPacket pongPacket)
{
e.Connection.Communicator.Send(new PingPacket()
{
Value = pongPacket.Value + 1
});
}
if (e.Connection is PacketClient)
{
pc++;
if (sw.ElapsedMilliseconds > 1000)
{
Console.WriteLine($"Mirrored {pc} packets.");
pc = 0;
sw.Restart();
}
}
}
}
internal static void OnAttackSwing(RealmServerSession session, PacketReader handler)
{
ulong guid = handler.ReadUInt64();
PacketServer packet = new PacketServer(RealmCMD.SMSG_ATTACKSTART);
packet.Write(session.Entity.ObjectGuid.RawGuid);
packet.Write(session.Entity.ObjectGuid.RawGuid);
session.SendPacket(packet);
}
public void Start()
{
var build = $"League Sandbox Build {ServerContext.BuildDateString}";
Console.Title = build;
_logger.Debug(build);
_logger.Debug($"Yorick {_serverVersion}");
_logger.Info($"Game started on port: {_serverPort}");
var _packetServer = new PacketServer();
_packetServer.InitServer(_serverPort, _blowfishKey, _game, _game.RequestHandler, _game.ResponseHandler);
_game.Initialize(_config, _packetServer);
}
public void Initialize(Config config, PacketServer server)
{
_logger.Info("Loading Config.");
Config = config;
_gameScriptTimers = new List <GameScriptTimer>();
ChatCommandManager.LoadCommands();
ObjectManager = new ObjectManager(this);
Map = new Map(this);
ApiFunctionManager.SetGame(this);
ApiEventManager.SetGame(this);
IsRunning = false;
_logger.Info("Loading C# Scripts");
LoadScripts();
Map.Init();
_logger.Info("Add players");
foreach (var p in Config.Players)
{
((PlayerManager)PlayerManager).AddPlayer(p);
}
_pauseTimer = new Timer
{
AutoReset = true,
Enabled = false,
Interval = 1000
};
_pauseTimer.Elapsed += (sender, args) => PauseTimeLeft--;
PauseTimeLeft = 30 * 60; // 30 minutes
// TODO: GameApp should send the Response/Request handlers
_packetServer = server;
// TODO: switch the notifier with ResponseHandler
PacketNotifier = new PacketNotifier(_packetServer.PacketHandlerManager, Map.NavGrid);
InitializePacketHandlers();
_logger.Info("Game is ready.");
}
public void Initialize(ushort port, string blowfishKey, Config config)
{
_logger.Info("Loading Config.");
Config = config;
_gameScriptTimers = new List <GameScriptTimer>();
ChatCommandManager.LoadCommands();
ObjectManager = new ObjectManager(this);
Map = new Map(this);
ApiFunctionManager.SetGame(this);
ApiEventManager.SetGame(this);
IsRunning = false;
_logger.Info("Loading C# Scripts");
LoadScripts();
Map.Init();
_logger.Info("Add players");
foreach (var p in Config.Players)
{
((PlayerManager)PlayerManager).AddPlayer(p);
}
_pauseTimer = new Timer
{
AutoReset = true,
Enabled = false,
Interval = 1000
};
_pauseTimer.Elapsed += (sender, args) => PauseTimeLeft--;
PauseTimeLeft = 30 * 60; // 30 minutes
_packetServer = new PacketServer();
_packetServer.InitServer(port, blowfishKey, this);
PacketNotifier = new PacketNotifier(_packetServer.PacketHandlerManager, Map.NavGrid);
// TODO: make lib to only get API types and not byte[], start from removing this line
PacketReader = new PacketReader();
_logger.Info("Game is ready.");
}
public async Task ProcessDuplexExchangeConcurrent()
{
var port = this.GetPortNumber(PacketServerPort);
var serializer = new BinarySerializer(BinarySerializationMethod.UnsafeSerialization);
var queue = new WaitableQueue <Packet>();
using (var packetServer = new PacketServer(IPAddress.Any, port))
{
packetServer.OnNewPacketReceived += (sender, value) => queue.Enqueue(value);
packetServer.Start();
using (var client = new TcpClient("localhost", port))
using (var stream = client.GetStream())
{
var serverSequence = PacketFixture.GetPacketSequence(PacketSequenceLength);
Task serverTask = null;
foreach (var packet in serverSequence)
{
var task = packetServer.SendPacket(packet);
serverTask = serverTask?.ContinueWith(t => task).Unwrap() ?? task;
}
var clientSequence = PacketFixture.GetPacketSequence(PacketSequenceLength);
var clientTask = Task.CompletedTask;
foreach (var packet in clientSequence)
{
// ReSharper disable once AccessToDisposedClosure
clientTask = clientTask.ContinueWith(t => serializer.Serialize(packet, stream)).Unwrap();
}
await Task.WhenAll(serverTask, clientTask).WithTimeOut(Timeout);
foreach (var(serverPacket, clientPacket) in serverSequence.JoinByIndex(clientSequence))
{
var results = await Task.WhenAll(queue.Dequeue(Timeout), serializer.Deserialize <Packet>(stream).WithTimeOut(Timeout));
Assert.AreEqual <PacketEx>(clientPacket, results[0]);
Assert.AreEqual <PacketEx>(serverPacket, results[1]);
}
}
}
}
private static void Main()
{
try
{
LoadConfiguration();
}
catch (FormatException e)
{
Logger.Error("Unable to parse IPAddress: {0}", e.Message);
return;
}
catch (Exception e)
{
Logger.Error("Parameters loading failed: {0}", e.Message);
return;
}
try
{
var exitEvent = new ManualResetEvent(false);
var packetServer = new PacketServer(PacketServerIpAddress, PacketServerPort);
var proxyServer = new ProxyServer(ExternalServerIpAddress, ExternalServerPort)
{
PacketReceiver = packetServer
};
packetServer.Start();
proxyServer.Start();
Logger.Info($"Started packet server at {PacketServerIpAddress}:{PacketServerPort}");
Logger.Info($"Started proxy server at {ExternalServerIpAddress}:{ExternalServerPort}");
Logger.Info("Waiting for agent...");
exitEvent.WaitOne();
}
catch (Exception e)
{
Logger.Fatal(e);
}
}
internal static void OnAttackStop(RealmServerSession session, PacketReader handler)
{
PacketServer packet = new PacketServer(RealmCMD.SMSG_ATTACKSTOP);
packet.Write(session.Entity.ObjectGuid.RawGuid);
packet.Write(session.Entity.ObjectGuid.RawGuid);
packet.Write((int)0);
packet.Write((byte)0);
session.SendPacket(packet);
//SendAttackStop(client.Character.GUID, client.Character.TargetGUID, client)
//client.Character.attackState.AttackStop()
/*
* 'AttackerGUID stopped attacking victimGUID
* Dim SMSG_ATTACKSTOP As New PacketClass(OPCODES.SMSG_ATTACKSTOP)
* SMSG_ATTACKSTOP.AddPackGUID(attackerGUID)
* SMSG_ATTACKSTOP.AddPackGUID(victimGUID)
* SMSG_ATTACKSTOP.AddInt32(0)
* SMSG_ATTACKSTOP.AddInt8(0)
* client.Character.SendToNearPlayers(SMSG_ATTACKSTOP)
*/
}
public PacketServerViewModel(PacketServer server)
: base()
{
this.Server = server;
}
/// <summary>
///
/// </summary>
/// <param name="packet"></param>
internal void TransmitToAll(PacketServer packet)
{
Sessions.FindAll(s => s.Character != null).ForEach(s => s.SendPacket(packet));
}
internal void SendPacket(PacketServer packet)
{
LogPacket(packet);
SendPacket(packet.Opcode, packet.Packet);
}
public static void Main()
{
var ports = SerialPort.GetPortNames();
for (int i = 0; i < ports.Length; i++)
{
Console.WriteLine("{0}:{1}", i, ports[i]);
}
var strnum = Console.ReadKey().KeyChar.ToString();
int num = -1;
Console.WriteLine("\r\nOpening...");
if (int.TryParse(strnum, out num))
{
var sport = new SerialPort(ports[num], 9600, Parity.None, 8, StopBits.One);
sport.Encoding = Encoding.UTF8;
sport.NewLine = "\n";
sport.RtsEnable = true;
sport.DtrEnable = true;
sport.DiscardNull = false;
sport.ReadTimeout = 10000;
int counter = 0;
while (true)
{
try
{
if (sport.IsOpen)
sport.Close();
sport.Open();
break;
}
catch (Exception ex)
{
Console.WriteLine(counter);
System.Threading.Thread.Sleep(1000);
if (++counter > 10)
throw;
}
}
Console.WriteLine("opened successfully");
var server = new PacketServer(sport.BaseStream);
var dispatcher = new PacketDispatcher();
var cens = dispatcher.GetTrainCensor(new DeviceID() { ParentPart = 1, ModulePart = 1 });
server.AddAction(dispatcher);
cens.PacketReceived += new PacketReceivedDelegate((dev, args) => Console.WriteLine(dev.ToString()));
server.LoopStart();
while (true)
{
System.Threading.Thread.Sleep(100);
}
//bool sta = true, stab = false;
//var watch = new System.Diagnostics.Stopwatch();
//while (sport.IsOpen)
//{
// //char[] buf = new char[64];
// //sport.Read(buf, 0, 64);
// //var output = new string(buf, 16, 48);
// //Console.WriteLine(output);
// string context = "";// sport.ReadLine();
// byte[] buffer = new byte[256];
// sport.Read(buffer, 0, 8);
// int startIndex = 0;
// int tmp = 0;
// while (!int.TryParse(context[startIndex].ToString(), out tmp))
// startIndex++;
// var val = float.Parse(context.Substring(startIndex, context.Length - startIndex).Trim().Split(',')[0]);
// if (!stab && val <= 2.0)
// {
// Console.WriteLine("{0} detecting", DateTime.Now.ToString());
// stab = true;
// if (sta) // first
// {
// watch.Restart();
// sta = false;
// }
// else
// {
// watch.Stop();
// if (watch.Elapsed.TotalSeconds < 5.0)
// {
// Console.WriteLine("{0}sec. v={1}m/s", watch.Elapsed.TotalSeconds, 0.05 / watch.Elapsed.TotalSeconds);
// sta = true;
// }
// else
// {
// // modify meisuring position
// watch.Restart();
// sta = false ;
// }
// }
// }
// else if (stab && val > 2.0)
// {
// stab = false;
// Console.WriteLine("{0} detected", DateTime.Now.ToString());
// }
//}
}
}
internal void SendPacket(PacketServer packet)
{
SendPacket((byte)packet.Opcode, packet.Packet);
}
public void SendData(PacketServer packet)
{
SendData(packet.Packet, packet.Opcode.ToString());
}
public override void RegisterPacketServer(PacketServer server)
{
this._sweeperPacketServer = (SweeperPacketServer)server;
}
private static void Update()
{
while (true)
{
foreach (PlayerEntity player in Players)
{
#region Checa Players
foreach (PlayerEntity otherPlayer in Players)
{
// Ignore self
if (player == otherPlayer)
{
continue;
}
if (InRangeCheck(player, otherPlayer))
{
if (!player.KnownPlayers.Contains(otherPlayer))
{
SpawnPlayer(player, otherPlayer);
}
}
else
{
if (player.KnownPlayers.Contains(otherPlayer))
{
DespawnPlayer(player, otherPlayer);
}
}
}
#endregion
#region Checa Objetos para adicionar ao mapa
var objetos = MainForm.Database.GetGameObjects(player, MainForm.DistanciaFoda);
if (objetos.Any())
{
foreach (zoneObjeto objeto in objetos)
{
if (!player.KnownGameObjects.Contains(objeto))
{
SpawnObjeto(player, objeto);
}
}
}
#endregion
// NPC Spawns
// Update Packet
if (player.UpdateCount > 0)
{
PacketServer packet = UpdateObject.UpdateValues(player);
player.Session.SendPacket(packet);
WorldManager.SessionsWhoKnow(player).ForEach(s => s.SendPacket(packet));
}
}
// Fix????
Thread.Sleep(100);
}
// ReSharper disable once FunctionNeverReturns
}
