public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var emotion = new EmotionPacket(data);
//for later use -> tracking, etc.
switch (emotion.id)
{
case 0:
//dance
//Logging->writeLine("dance");
break;
case 1:
//taunt
//Logging->writeLine("taunt");
break;
case 2:
//laugh
//Logging->writeLine("laugh");
break;
case 3:
//joke
//Logging->writeLine("joke");
break;
}
var response = new EmotionPacket(emotion.id, emotion.netId);
return PacketHandlerManager.getInstace().broadcastPacket(response, Channel.CHL_S2C);
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var sell = new SellItem(data);
var client = game.getPeerInfo(peer);
var i = game.getPeerInfo(peer).getChampion().getInventory().getItemSlot(sell.slotId);
if (i == null)
return false;
float sellPrice = i.getTemplate().getTotalPrice() * i.getTemplate().getSellBackModifier();
client.getChampion().getStats().setGold(client.getChampion().getStats().getGold() + sellPrice);
if (i.getTemplate().getMaxStack() > 1)
{
i.decrementStacks();
PacketNotifier.notifyRemoveItem(client.getChampion(), sell.slotId, i.getStacks());
if (i.getStacks() == 0)
client.getChampion().getInventory().removeItem(sell.slotId);
}
else
{
PacketNotifier.notifyRemoveItem(client.getChampion(), sell.slotId, 0);
client.getChampion().getInventory().removeItem(sell.slotId);
}
return true;
}
private static async Task SendPacket25(ENetPeer peer)
{
if ((peer.Data as Player).HaveGrowID == true)
{
await peer.OnAddNotification("", "`wWarning from `4System`0: You have been auto banned by system for using : Cheat Engine!", "audio/open_hub.wav");
peer.DisconnectLater(0);
foreach (ENetPeer currentPeer in Peers)
{
if (currentPeer.State != ENetPeerState.Connected)
{
continue;
}
await currentPeer.OnConsoleMessage("`4** `$" + (peer.Data as Player).RawName + " `4AUTO-BANNED BY SYSTEM **`o(`$/rules `oto view rules)");
await currentPeer.OnPlayPositioned("audio/beep.wav");
}
await Task.CompletedTask;
}
else
{
peer.DisconnectLater(0);
}
}
private void HandleUnreliable(ENetPeer peer, ENetProtocolSendUnreliable packet, byte[] data)
{
if (peer.State != ENetPeerState.Connected && peer.State != ENetPeerState.DisconnectLater) return;
var channel = peer.Channels[packet.Header.ChannelID];
if (DropSequencedData(channel, packet.Header) || packet.UnreliableSequenceNumber <= channel.IncomingSequenceNumber) return;
}
private void HandleReliable(ENetPeer peer, ENetProtocol packet, bool isFragment, byte[] data)
{
if (peer.State != ENetPeerState.Connected && peer.State != ENetPeerState.DisconnectLater) return;
var channel = peer.Channels[packet.Header.ChannelID];
if (DropSequencedData(channel, packet.Header) || packet.Header.ReliableSequenceNumber == channel.IncomingSequenceNumber) return;
if (!isFragment && packet.Header.ReliableSequenceNumber == (channel.IncomingSequenceNumber + 1))
{
if (OnData != null) OnData(peer, data);
channel.IncomingSequenceNumber++;
return;
}
lock (channel.IncomingCommandLock)
{
var command = new ENetIncomingCommand(packet.Header.ReliableSequenceNumber);
var existingCommand = channel.IncomingCommands.Find(command); //Establish if we already have the packet
if (existingCommand != null && !isFragment) return; //We already have the command, ignore it
else if (existingCommand != null)
{
if (existingCommand.Value.FragmentsRemaining == 0) return;
}
if (isFragment)
{
command.FragmentsRemaining = packet.SendFragment.FragmentCount - 1;
}
if(packet.Header.ReliableSequenceNumber == (channel.IncomingSequenceNumber + 1))channel.IncomingCommands.AddFirst()
}
}
public void SendPacketRaw(int type, byte[] data, ENetPeer peer, ENetPacketFlags flag = ENetPacketFlags.Reliable)
{
byte[] packetData = new byte[data.Length + 5];
Array.Copy(BitConverter.GetBytes(type), packetData, 4);
Array.Copy(data, 0, packetData, 4, data.Length);
SendData(packetData, peer);
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var click = new Click(data);
Logger.LogCoreInfo("Object " + game.getPeerInfo(peer).getChampion().getNetId() + " clicked on " + click.targetNetId);
return true;
}
private ENetEvent(ENetPeer peer, ENetPacket?packet, uint data, ENetEventType type)
{
Peer = peer;
Packet = packet !;
Data = data;
Type = type;
}
public static void ConnectToServer(ref ENetPeer peer, UserData userData = null, bool FirstInitialUseOfBot = false)
{
Console.WriteLine("Internal proxy client is attempting a connection to server...");
string ip = globalUserData.Growtopia_IP;
int port = globalUserData.Growtopia_Port;
if (peer == null)
{
peer = client.Connect(new IPEndPoint(IPAddress.Parse(ip), port), 2, 0);
}
else
{
if (peer.IsNull)
{
peer = client.Connect(new IPEndPoint(IPAddress.Parse(ip), port), 2, 0);
}
else if (peer.State != ENetPeerState.Connected)
{
peer = client.Connect(new IPEndPoint(IPAddress.Parse(ip), port), 2, 0);
}
else
{
// peer = client.Connect(new IPEndPoint(IPAddress.Parse(ip), port), 2, 0);
globalUserData.awaitingReconnect = true;
peer.Disconnect(0);
//In this case, we will want the realPeer to be disconnected first
// sub server switching, most likely.
peer = client.Connect(new IPEndPoint(IPAddress.Parse(ip), port), 2, 0);
}
}
}
private static async void Server_OnConnect(object sender, ENetConnectEventArgs connectEventArgs)
{
int count = 1;
//WorldDatabase.GetWorld("START");
//WorldDatabase.GetWorld("ADMIN");
//WorldDatabase.GetWorld("HELLO");
ENetPeer Peer = connectEventArgs.Peer;
Console.WriteLine("Peer connected. IP : " + Peer.RemoteEndPoint.Address);
foreach (var currentPeer in Peers)
{
if (currentPeer.State != ENetPeerState.Connected)
{
continue;
}
if (currentPeer.RemoteEndPoint.Equals(Peer.RemoteEndPoint))
{
count++;
}
}
Peer.Data = new Player();
if (count > 3)
{
await Peer.OnConsoleMessage("`oToo many accounts are logged in this IP. Please try again later.");
}
else
{
await Peer.SendData(1, BitConverter.GetBytes(0), 1);
Peers.Add(Peer);
}
connectEventArgs.Peer.OnReceive += Peer_OnReceive;
connectEventArgs.Peer.OnDisconnect += Peer_OnDisconnect;
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var spell = new CastSpell(data);
//Todo spellslot 0-3 qwer, 4-5 d f, 6-11 items
// There are some bits triggering this
if ((spell.spellSlotType & 0x0F) > 0)
{
Logger.LogCoreInfo("Summoner Spell Cast");
Logger.LogCoreInfo("Type: " + spell.spellSlotType.ToString("x") + ", Slot " + spell.spellSlot + ", coord " + spell.x + " ; " + spell.y + ", coord2 " + spell.x2 + ", " + spell.y2 + ", target NetId " + spell.targetNetId.ToString("x"));
return true;
}
var futureProjNetId = Game.GetNewNetID();
var spellNetId = Game.GetNewNetID();
var targetObj = game.getMap().getObjectById(spell.targetNetId);
var targetUnit = targetObj as Unit;
var s = game.getPeerInfo(peer).getChampion().castSpell(spell.spellSlot, spell.x, spell.y, targetUnit, futureProjNetId, spellNetId);
if (s == null)
return false;
var response = new CastSpellAns(s, spell.x, spell.y, futureProjNetId, spellNetId);
PacketHandlerManager.getInstace().broadcastPacket(response, Channel.CHL_S2C);
return true;
}
public static async Task SendPacketType(this ENetPeer peer, int id, PlayerMoving pMov,
PlayerMoving data2, World world)
{
switch (id)
{
case 25:
await SendPacket25(peer);
break;
case 7:
await SendPacket7(peer, pMov, world);
break;
case 10:
await SendPacket10(peer, pMov);
break;
case 18:
await SendPacket18(peer, pMov);
break;
case 3:
await SendPacket3(peer, data2);
break;
default:
break;
}
}
private static async Task SendPacket7(ENetPeer peer, PlayerMoving pMov, World world)
{
if (pMov.PunchX < 0 || pMov.PunchY < 0 || pMov.PunchX > 100 || pMov.PunchY > 100)
{
return;
}
if ((peer.Data as Player).World == " EXIT")
{
return;
}
int x = pMov.PunchX;
int y = pMov.PunchY;
int tile = world.Items[x + (y * world.Width)].Foreground;
if (tile == 6)
{
await peer.SendLeave();
(peer.Data as Player).World = "EXIT";
await peer.SendWorldOffers();
}
else if (tile == 410 || tile == 1832 || tile == 1770)
{
(peer.Data as Player).CpX = x * 32;
(peer.Data as Player).CpY = y * 32;
}
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var version = new SynchVersion(data);
//Logging->writeLine("Client version: %s", version->version);
var mapId = Config.gameConfig.map;
Logger.LogCoreInfo("Current map: " + mapId);
bool versionMatch = true;
// Version might be an invalid value, currently it trusts the client
if (version.version != Config.version)
{
versionMatch = false;
Logger.LogCoreWarning("Client " + version.version + " does not match Server " + Config.version);
}
else
{
Logger.LogCoreInfo("Accepted client version (" + version.version + ")");
}
foreach (var player in game.getPlayers())
{
if (player.Item1 == peer->address.host)
{
player.Item2.setVersionMatch(versionMatch);
break;
}
}
int map;
if (!int.TryParse(mapId, out map))
map = 1;
var answer = new SynchVersionAns(game.getPlayers(), Config.version, "CLASSIC", map);
return PacketHandlerManager.getInstace().sendPacket(peer, answer, Channel.CHL_S2C);
}
private void SwitchServers(ref ENetPeer peer, string ip, int port, int lmode = 0, int userid = 0, int token = 0)
{
MainForm.globalUserData.Growtopia_IP = ip;
MainForm.globalUserData.Growtopia_Port = port;
isSwitchingServers = true;
MainForm.ConnectToServer(ref peer);
}
public static void Client_OnConnect(ENetPeer peer)
{
peer.Timeout(1000, 4000, 6000);
//peer.PingInterval(TimeSpan.FromMilliseconds(1000));
realPeer = peer;
globalUserData.connectIDReal++;
}
private void SwitchServers(ref ENetPeer peer, string ip, int port, int lmode = 0, int userid = 0, int token = 0)
{
Proxyhelper.globalUserData.Growtopia_IP = token < 0 ? Proxyhelper.globalUserData.Growtopia_Master_IP : ip;
Proxyhelper.globalUserData.Growtopia_Port = token < 0 ? Proxyhelper.globalUserData.Growtopia_Master_Port : port;
isSwitchingServers = true;
Proxyhelper.ConnectToServer(ref peer, Proxyhelper.globalUserData);
}
public Player(ENetPeer peer)
{
Pos = Vector2.Zero;
Clothes = new Clothes();
Inventory = new Inventory(this);
peer.SetUserData(this);
Peer = peer;
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var peerInfo = game.getPeerInfo(peer);
if (peerInfo == null || peerInfo.getChampion().isDashing() || peerInfo.getChampion().isDead())
return true;
var request = new MovementReq(data);
var vMoves = new List<Vector2>();//readWaypoints(request.moveData, request.coordCount, game.getMap());
vMoves.Add(new Vector2(peerInfo.getChampion().getX(), peerInfo.getChampion().getY()));
vMoves.Add(new Vector2(request.x, request.y)); // TODO
switch (request.type)
{
case MoveType.STOP:
{
//TODO anticheat, currently it trusts client 100%
peerInfo.getChampion().setPosition(request.x, request.y);
float x = ((request.x) - game.getMap().getWidth()) / 2;
float y = ((request.y) - game.getMap().getHeight()) / 2;
for (var i = 0; i < vMoves.Count; i++)
{
var v = vMoves[i];
v.X = (short)request.x;
v.Y = (short)request.y;
}
Logger.LogCoreInfo("Stopped at x: " + request.x + ", y: " + request.y);
break;
}
case MoveType.EMOTE:
//Logging->writeLine("Emotion");
return true;
case MoveType.ATTACKMOVE:
peerInfo.getChampion().setMoveOrder(MoveOrder.MOVE_ORDER_ATTACKMOVE);
break;
case MoveType.MOVE:
peerInfo.getChampion().setMoveOrder(MoveOrder.MOVE_ORDER_MOVE);
break;
}
// Sometimes the client will send a wrong position as the first one, override it with server data
vMoves[0] = new Vector2(peerInfo.getChampion().getX(), peerInfo.getChampion().getY());
peerInfo.getChampion().setWaypoints(vMoves);
var u = game.getMap().getObjectById(request.targetNetId) as Unit;
if (u == null)
{
peerInfo.getChampion().setTargetUnit(null);
return true;
}
peerInfo.getChampion().setTargetUnit(u);
return true;
}
private void animaButton2_Click(object sender, EventArgs e)
{
eNet = new ENetHost(1, 2);
eNet.OnConnect += Client_OnConnect;
eNet.CompressWithRangeCoder();
eNet.ChecksumWithCRC32();
eNet.StartServiceThread();
eNetP = eNet.Connect(new System.Net.IPEndPoint(IPAddress.Parse(Growtopia_Master_IP), Growtopia_Master_Port), 2, 0);
}
public unsafe void TestSetAndGetUserDataPeer()
{
var nativePeer = new NativeENetPeer();
var peer = new ENetPeer(&nativePeer);
var data = 1399;
peer.SetUserData(data);
Assert.IsTrue(peer.TryGetUserData <int>(out var data2));
Assert.AreEqual(data, data2);
}
private static async void Peer_OnDisconnect(object sender, uint e)
{
ENetPeer peer = sender as ENetPeer;
Console.WriteLine("Peer disconnected");
await peer.SendLeave();
peer.Data = null;
Peers.Remove(peer);
}
public static async Task UpdateDoor(ENetPeer peer, int foreground, int x, int y, string text)
{
try
{
PlayerMoving sign = new PlayerMoving
{
PacketType = 0x3,
CharacterState = 0x0,
X = x,
Y = y,
PunchX = x,
PunchY = y,
NetID = -1,
PlantingTree = foreground
};
await SendPacketRaw(4, PlayerMovingPack(sign), 56, 0, peer);
int hmm = 8; int text_len = text.Length; int lol = 0; int wut = 5; int yeh = hmm + 3 + 1; int idk = 15 + text_len;
int is_locked = 0; int bubble_type = 1; int ok = 52 + idk; int kek = ok + 4; int yup = ok - 8 - idk; int magic = 56;
int wew = ok + 5 + 4; int wow = magic + 4 + 5; int four = 4;
byte[] data = new byte[kek]; byte[] p = new byte[wew];
for (int i = 0; i < kek; i++)
{
data[i] = 0;
}
Array.Copy(BitConverter.GetBytes(wut), 0, data, 0, four);
Array.Copy(BitConverter.GetBytes(hmm), 0, data, yeh, four);
Array.Copy(BitConverter.GetBytes(x), 0, data, yup, 4);
Array.Copy(BitConverter.GetBytes(y), 0, data, yup + 4, 4);
Array.Copy(BitConverter.GetBytes(idk), 0, data, 4 + yup + 4, four);
Array.Copy(BitConverter.GetBytes(foreground), 0, data, magic, 2);
Array.Copy(BitConverter.GetBytes(lol), 0, data, four + magic, four);
Array.Copy(BitConverter.GetBytes(bubble_type), 0, data, magic + 4 + four, 1);
Array.Copy(BitConverter.GetBytes(text_len), 0, data, wow, 2);
Array.Copy(Encoding.ASCII.GetBytes(text), 0, data, 2 + wow, text_len);
Array.Copy(BitConverter.GetBytes(is_locked), 0, data, ok, four);
Array.Copy(BitConverter.GetBytes(four), 0, p, 0, four);
Array.Copy(data, 0, p, four, kek);
foreach (ENetPeer currentPeer in Peers)
{
if (currentPeer.State != ENetPeerState.Connected)
{
continue;
}
if (peer.InWorld(currentPeer))
{
currentPeer.Send(p, 0, ENetPacketFlags.Reliable);
}
}
}
catch
{
Console.WriteLine("error in updatedoor");
}
}
public static async Task SendGrowScanDialog(ENetPeer peer)
{
World world = peer.GetWorld();
List <int> items = new List <int>();
List <int> itemscount = new List <int>();
for (int i = 0; i < world.Width * world.Height; i++)
{
int fg = world.Items[i].Foreground;
int bg = world.Items[i].Background;
if (fg == 0 && bg == 0)
{
continue;
}
else if (fg == 8 || fg == 6)
{
continue;
}
if (items.Contains(fg))
{
itemscount[items.IndexOf(fg)]++;
}
else
{
if (fg != 0)
{
items.Add(fg);
itemscount.Add(1);
}
}
if (items.Contains(bg))
{
itemscount[items.IndexOf(bg)]++;
}
else
{
if (bg != 0)
{
items.Add(bg);
itemscount.Add(1);
}
}
}
string dd = new Dialog().SetDefaultColor()
.AddLabelWithIcon("Found items : ", 6016, false)
.AddSmallSpacer()
.Result;
for (int i = 0; i < items.Count; i++)
{
dd += new Dialog().AddLabelWithIcon(ItemsData[items[i]].Name + " : " + itemscount[i], items[i], true).Result;
}
dd += new Dialog().AddSmallSpacer().EndDialog("a", "Back", "");
await peer.OnDialogRequest(dd);
}
public Player(ENetPeer peer)
{
Peer = peer;
Peer.OnReceive += OnReceive;
Peer.Data = this;
Inventory.InventorySize = 16;
Inventory.AddItem(ItemId.i18_Fist, 1);
Inventory.AddItem(ItemId.i32_Wrench, 1);
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var loadInfo = new PingLoadInfo(data);
var peerInfo = game.getPeerInfo(peer);
if (peerInfo == null)
return false;
var response = new PingLoadInfo(loadInfo, peerInfo.userId);
//Logging->writeLine("loaded: %f, ping: %f, %f", loadInfo->loaded, loadInfo->ping, loadInfo->f3);
return PacketHandlerManager.getInstace().broadcastPacket(response, Channel.CHL_LOW_PRIORITY, PacketFlags.None);
}
public static async Task SendDialogAsync(ENetPeer peer, World world, string act)
{
try
{
bool registerDialog = false;
string growid = "", password = "", email = "", discord = "";
foreach (var a in act.Split("\n".ToCharArray()))
{
var info = a.Split('|');
var button = info[0] == "buttonClicked" ? info[1] : "";
if (info[0] == "dialog_name" && info[1] == "creategrowid")
{
registerDialog = true;
}
if (registerDialog)
{
if (info[0] == "growid")
{
growid = info[1];
}
else if (info[0] == "password")
{
password = info[1];
}
else if (info[0] == "email")
{
email = info[1];
}
else if (info[0] == "discord")
{
discord = info[1];
}
}
if (button.Contains("findbutton"))
{
int id = Convert.ToInt32(button.Substring(10));
var item = ItemsData[id];
InventoryItems inv = new InventoryItems
{
ItemID = id,
ItemCount = 1
};
(peer.Data as Player).PlayerInventory.Items = (peer.Data as Player).PlayerInventory.Items.Append(inv).ToArray();
await peer.SendInventory((peer.Data as Player).PlayerInventory);
}
}
if (registerDialog)
{
await peer.CreateGrowID(growid, password, email, discord);
}
}
catch (Exception e) { Console.WriteLine(e.Source + " " + e.TargetSite); }
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var request = new SwapItems(data);
if (request.slotFrom > 6 || request.slotTo > 6)
return false;
game.getPeerInfo(peer).getChampion().getInventory().swapItems(request.slotFrom, request.slotTo);
PacketNotifier.notifyItemsSwapped(game.getPeerInfo(peer).getChampion(), request.slotFrom, request.slotTo);
return true;
}
public void SendData(byte[] data, ENetPeer peer, ENetPacketFlags flag = ENetPacketFlags.Reliable)
{
if (peer == null)
{
return;
}
if (peer.State != ENetPeerState.Connected)
{
return;
}
peer.Send((byte)rand.Next(0, 1), data, flag);
}
int checkPeerUsability(ENetPeer peer)
{
if (peer.IsNull)
{
return(-1);
}
if (peer.State != ENetPeerState.Connected)
{
return(-3);
}
return(0);
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var request = new BuyItemReq(data);
var itemTemplate = ItemManager.getInstance().getItemTemplateById(request.id);
if (itemTemplate == null)
return false;
var recipeParts = game.getPeerInfo(peer).getChampion().getInventory().getAvailableRecipeParts(itemTemplate);
var price = itemTemplate.getTotalPrice();
ItemInstance i;
if (recipeParts.Count == 0)
{
if (game.getPeerInfo(peer).getChampion().getStats().getGold() < price)
{
return true;
}
i = game.getPeerInfo(peer).getChampion().getInventory().addItem(itemTemplate);
if (i == null)
{ // Slots full
return false;
}
}
else
{
foreach (var instance in recipeParts)
price -= instance.getTemplate().getTotalPrice();
if (game.getPeerInfo(peer).getChampion().getStats().getGold() < price)
return false;
foreach (var instance in recipeParts)
{
game.getPeerInfo(peer).getChampion().getStats().unapplyStatMods(instance.getTemplate().getStatMods());
PacketNotifier.notifyRemoveItem(game.getPeerInfo(peer).getChampion(), instance.getSlot(), 0);
game.getPeerInfo(peer).getChampion().getInventory().removeItem(instance.getSlot());
}
i = game.getPeerInfo(peer).getChampion().getInventory().addItem(itemTemplate);
}
game.getPeerInfo(peer).getChampion().getStats().setGold(game.getPeerInfo(peer).getChampion().getStats().getGold() - price);
game.getPeerInfo(peer).getChampion().getStats().applyStatMods(itemTemplate.getStatMods());
PacketNotifier.notifyItemBought(game.getPeerInfo(peer).getChampion(), i);
return true;
}
private void Host_OnConnect(object sender, ENetConnectEventArgs e)
{
proxyPeer = e.Peer;
e.Peer.OnReceive += Peer_OnReceive;
e.Peer.OnDisconnect += Peer_OnDisconnect;
AppendLog("A new client connected from {0} " + e.Peer.RemoteEndPoint);
e.Peer.Timeout(30000, 25000, 30000);
AppendLog("Connecting to gt servers...");
ConnectToServer();
}
private static void Main(string[] args)
{
ManagedENet.Startup();
Console.WriteLine("Setting up Local Server");
LocalServer = new ENetHost(new IPEndPoint(IPAddress.Any, 17091), 1024, 10, 0, 0);
LocalServer.ChecksumWithCRC32();
LocalServer.CompressWithRangeCoder();
LocalServer.OnConnect += (sender, eventArgs) =>
{
LogClient("Connected!");
RemotePeer = RemoteServer.Connect(RemoteEndpoint, 1, 0);
RemotePeer.OnReceive += (o, packet) =>
{
SendToClient(packet);
};
eventArgs.Peer.OnReceive += (o, packet) =>
{
SendToRemote(packet);
};
eventArgs.Peer.OnDisconnect += (o, u) =>
{
RemotePeer.DisconnectNow(0);
LogClient("Disconnected!");
};
};
LocalServer.StartServiceThread();
Console.WriteLine("Setting up Remote Server");
RemoteServer = new ENetHost(1, 10);
RemoteServer.ChecksumWithCRC32();
RemoteServer.CompressWithRangeCoder();
RemoteServer.OnConnect += (sender, eventArgs) => LogServer("Connected!");
RemoteServer.StartServiceThread();
while (true)
{
Thread.Sleep(5);
}
}
private ENetPeer? HandleConnect(IPEndPoint from, ENetProtocolConnect packet)
{
lock (connectionLock)
{
foreach (var peer in Peers)
{
if (peer.Value.Address.Equals(from) && peer.Value.SessionID == packet.SessionID) return null;
}
ushort peerId;
if (!AvailablePeerIds.TryDequeue(out peerId)) return null; //No peers available within the client limit
ENetPeer newPeer = new ENetPeer(from, peerId, packet, ChannelLayout);
((IDictionary)Peers).Add(peerId, newPeer);
return newPeer;
}
}
private void animaButton5_Click(object sender, EventArgs e)
{
animaTextBox4.Enabled = false;
animaTextBox3.Enabled = false;
animaButton6.Enabled = false;
animaButton5.Enabled = false;
ManagedENet.Startup();
eNet = new ENetHost(1, 2);
eNet.OnConnect += Client_OnConnect;
eNet.CompressWithRangeCoder();
eNet.ChecksumWithCRC32();
eNet.StartServiceThread();
eNetP = eNet.Connect(new System.Net.IPEndPoint(IPAddress.Parse(Growtopia_Master_IP), Growtopia_Master_Port), 2, 0);
updatestatus("Connected!", 2);
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var request = new SpawnParticle.ViewRequest(data);
var answer = new SpawnParticle.ViewAnswer(request);
if (request.requestNo == 0xFE)
{
answer.setRequestNo(0xFF);
}
else
{
answer.setRequestNo(request.requestNo);
}
PacketHandlerManager.getInstace().sendPacket(peer, answer, Channel.CHL_S2C, PacketFlags.None);
return true;
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var skillUpPacket = new SkillUpPacket(data);
//!TODO Check if can up skill? :)
var s = game.getPeerInfo(peer).getChampion().levelUpSpell(skillUpPacket.skill);
if (s == null)
return false;
var skillUpResponse = new SkillUpPacket(game.getPeerInfo(peer).getChampion().getNetId(), skillUpPacket.skill, (byte)s.getLevel(), (byte)s.getOwner().getSkillPoints());
PacketHandlerManager.getInstace().sendPacket(peer, skillUpResponse, Channel.CHL_GAMEPLAY);
game.getPeerInfo(peer).getChampion().getStats().setSpellEnabled(skillUpPacket.skill, true);
return true;
}
private void Host_OnConnect(object sender, ENetConnectEventArgs e)
{
if (IsClient)
{
m_Peer = e.Peer;
chatBox.Enabled = true;
WriteLog("Connected");
}
else
{
WriteLog("Peer connected from {0}", e.Peer.RemoteEndPoint);
}
e.Peer.OnReceive += Peer_OnReceive;
e.Peer.OnDisconnect += Peer_OnDisconnect;
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var heartbeat = new HeartBeat(data);
float diff = heartbeat.ackTime - heartbeat.receiveTime;
if (heartbeat.receiveTime > heartbeat.ackTime)
{
Logger.LogCoreWarning("Player " + game.getPeerInfo(peer).userId + " sent an invalid heartbeat - Timestamp error (diff: " + diff);
}
else
{
// Logger.LogCoreInfo("Player %d sent heartbeat (diff: %.f)", peerInfo(peer)->userId, diff);
}
return true;
}
public static async Task SendNothingHappened(ENetPeer peer, int x, int y)
{
PlayerMoving data = new PlayerMoving
{
NetID = (peer.Data as Player).NetID,
PacketType = 0x8,
PlantingTree = 0
};
data.NetID = -1;
data.X = x;
data.Y = y;
data.PunchX = x;
data.PunchY = y;
await SendPacketRaw(4, PlayerMovingPack(data), 56, 0, peer);
}
public static async Task SendRandomItems(ENetPeer peer, int x, int y, int items, World world)
{
try
{
Random r = new Random();
int rarity = ItemsData[items].Rarity / 3;
int a = x / 32, b = y / 32;
if (rarity <= 5)
{
rarity = 3;
}
int gems = r.Next(0, rarity);
int rand = r.Next(0, 20);
if (rand > 10)
{
await SendGems(peer, x, y, 0, gems, world);
}
else if (rand > 4 && rand <= 10)
{
DroppedItem drop = new DroppedItem
{
ItemID = items + 1,
ItemCount = 1,
ItemName = ""
};
world.Items[a + b * world.Width].DroppedItems.Add(drop);
await peer.SendDrop(-1, x, y, items + 1, 1, 0);
}
else
{
DroppedItem drop = new DroppedItem
{
ItemID = items,
ItemCount = 1,
ItemName = ItemsData[items + 1].Name
};
world.Items[a + b * world.Width].DroppedItems.Add(drop);
await peer.SendDrop(-1, x, y, items, 1, 0);
}
}
catch (Exception e) { Console.WriteLine("RandomItems error : " + e.Message); }
}
public void SendPacketRaw(int type, byte[] data, ENetPeer peer, ENetPacketFlags flag = ENetPacketFlags.Reliable)
{
if (peer == null)
{
return;
}
if (peer.IsNull)
{
return;
}
if (peer.State != ENetPeerState.Connected)
{
return;
}
byte[] packetData = new byte[data.Length + 5];
Array.Copy(BitConverter.GetBytes(type), packetData, 4);
Array.Copy(data, 0, packetData, 4, data.Length);
SendData(packetData, peer);
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
game.IncrementReadyPlayers();
if (game.getReadyPlayers() == game.getPlayers().Count)
{
var start = new StatePacket(PacketCmdS2C.PKT_S2C_StartGame);
PacketHandlerManager.getInstace().broadcastPacket(start, Channel.CHL_S2C);
foreach (var player in game.getPlayers())
{
if (player.Item2.getPeer() == peer && !player.Item2.isVersionMatch())
{
var dm = new SpawnParticle.DebugMessage("Your client version does not match the server. Check the server log for more information.");
PacketHandlerManager.getInstace().sendPacket(peer, dm, Channel.CHL_S2C);
}
}
game.setStarted(true);
}
if (game.isStarted())
{
foreach (var p in game.getPlayers())
{
var map = game.getMap();
map.addObject(p.Item2.getChampion());
// Send the initial game time sync packets, then let the map send another
float gameTime = map.getGameTime() / 1000.0f;
var timer = new GameTimer(gameTime); // 0xC1
PacketHandlerManager.getInstace().sendPacket(p.Item2.getPeer(), timer, Channel.CHL_S2C);
var timer2 = new GameTimerUpdate(gameTime); // 0xC2
PacketHandlerManager.getInstace().sendPacket(p.Item2.getPeer(), timer2, Channel.CHL_S2C);
}
}
return true;
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
//Builds team info
var screenInfo = new LoadScreenInfo(game.getPlayers());
bool pInfo = PacketHandlerManager.getInstace().sendPacket(peer, screenInfo, Channel.CHL_LOADING_SCREEN);
//For all players send this info
bool bOk = false;
foreach (var player in game.getPlayers())
{
var loadName = new LoadScreenPlayerName(player);
var loadChampion = new LoadScreenPlayerChampion(player);
bool pName = PacketHandlerManager.getInstace().sendPacket(peer, loadName, Channel.CHL_LOADING_SCREEN);
bool pHero = PacketHandlerManager.getInstace().sendPacket(peer, loadChampion, Channel.CHL_LOADING_SCREEN);
bOk = (pName && pHero);
if (!bOk)
break;
}
return (pInfo && bOk);
}
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
// players[0].Item1 = peer->address.host; //temp
// players[0].Item2.setPeer(enetEvent.peer);
var keyCheck = new KeyCheck(data);
var userId = (long)BlowFishCS.BlowFishCS.Decrypt2(game.getBlowfish(), (ulong)keyCheck.checkId);
if (userId != keyCheck.userId)
return false;
var playerNo = 0;
foreach (var p in game.getPlayers())
{
var player = p.Item2;
if (player.userId == userId)
{
if (player.getPeer() != null)
{
Logger.LogCoreWarning("Ignoring new player " + userId + ", already connected!");
return false;
}
//TODO: add at least port or smth
p.Item1 = peer->address.host;
player.setPeer(peer);
var response = new KeyCheck(keyCheck.userId, playerNo);
bool bRet = PacketHandlerManager.getInstace().sendPacket(peer, response, Channel.CHL_HANDSHAKE);
handleGameNumber(player, peer, null);//Send 0x91 Packet?
return true;
}
++playerNo;
}
return false;
}
static extern void native_peer_timeout(ENetPeer* peer, uint timeoutLimit, uint timeoutMinimum, uint timeoutMaximum);
static extern void native_peer_disconnect_later(ENetPeer* peer, uint data);
static extern void native_peer_ping(ENetPeer* peer);
static extern void native_peer_ping_interval(ENetPeer* peer, uint pingInterval);
static extern ENetPacket* native_peer_receive(ENetPeer* peer, out byte channelID);
static extern void native_peer_reset(ENetPeer* peer);
public unsafe bool HandlePacket(ENetPeer* peer, byte[] data, Game game)
{
var ping = new AttentionPing(data);
var response = new AttentionPingAns(game.getPeerInfo(peer), ping);
return PacketHandlerManager.getInstace().broadcastPacketTeam(game.getPeerInfo(peer).getTeam(), response, Channel.CHL_S2C);
}
static extern int native_peer_send(ENetPeer* peer, byte channelID, ENetPacket* packet);
public static extern void enet_peer_ping(ENetPeer* peer);
public static extern ENetPacket* enet_peer_receive(ENetPeer* peer, out byte channelID);
public static extern void enet_peer_reset(ENetPeer* peer);
public static extern int enet_peer_send(ENetPeer* peer, byte channelID, ENetPacket* packet);
public static extern void enet_peer_throttle_configure(ENetPeer* peer, uint interval, uint acceleration, uint deceleration);
public override void peer_timeout(ENetPeer* peer, uint timeoutLimit, uint timeoutMinimum, uint timeoutMaximum)
{
native_peer_timeout(peer, timeoutLimit, timeoutMinimum, timeoutMaximum);
}
public static extern void enet_peer_disconnect_now(ENetPeer* peer, uint data);
