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);
}
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);
}
public ClientInfo getPeerInfo(ENetPeer *peer)
{
foreach (var player in players)
{
if (player.Item1 == peer->address.host)
{
return(player.Item2);
}
}
return(null);
}
bool handleDisconnect(ENetPeer *peer)
{
var peerinfo = getPeerInfo(peer);
if (peerinfo != null)
{
// TODO: Handle disconnect
Logger.LogCoreInfo("Player " + peerinfo.userId + " disconnected");
}
return(true);
}
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 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 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 bool handlePacket(ENetPeer *peer, ENetPacket *packet, Channel channelID)
{
if ((int)packet->dataLength >= 8)
{
if (game.getPeerInfo(peer) != null)
{
BlowFishCS.BlowFishCS.Decrypt1(game.getBlowfish(), (byte *)packet->data, new IntPtr((int)packet->dataLength - ((int)packet->dataLength % 8)));
}
}
var data = new byte[(int)packet->dataLength];
Marshal.Copy(packet->data, data, 0, data.Length);
return(handlePacket(peer, data, channelID));
}
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 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);
}
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));
}
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 void netLoop()
{
update();
var enetEvent = new ENetEvent();
while (true)
{
while (enet_host_service(_server, &enetEvent, 0) > 0)
{
switch (enetEvent.type)
{
case EventType.Connect:
//Logging->writeLine("A new client connected: %i.%i.%i.%i:%i", event.peer->address.host & 0xFF, (event.peer->address.host >> 8) & 0xFF, (event.peer->address.host >> 16) & 0xFF, (event.peer->address.host >> 24) & 0xFF, event.peer->address.port);
/* Set some defaults */
enetEvent.peer->mtu = PEER_MTU;
enetEvent.data = 0;
break;
case EventType.Receive:
currentPeer = enetEvent.peer;
if (!PacketHandlerManager.getInstace().handlePacket(enetEvent.peer, enetEvent.packet, (Channel)enetEvent.channelID))
{
//enet_peer_disconnect(event.peer, 0);
}
/* Clean up the packet now that we're done using it. */
enet_packet_destroy(enetEvent.packet);
break;
case EventType.Disconnect:
handleDisconnect(enetEvent.peer);
break;
}
}
Thread.Sleep((int)REFRESH_RATE);
}
}
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);
}
public bool sendPacket(ENetPeer *peer, byte[] source, Channel channelNo, PacketFlags flag = PacketFlags.Reliable)
{
////PDEBUG_LOG_LINE(Logging," Sending packet:\n");
//if(length < 300)
//printPacket(source, "Sent: ");
Sniffer.getInstance().Send(source, true);
fixed(byte *data = source)
{
if (source.Length >= 8)
{
BlowFishCS.BlowFishCS.Encrypt1(game.getBlowfish(), data, new IntPtr(source.Length - (source.Length % 8)));
}
var packet = enet_packet_create(new IntPtr(data), new IntPtr(source.Length), flag);
if (enet_peer_send(peer, (byte)channelNo, packet) < 0)
{
return(false);
}
}
return(true);
}
public static extern void enet_peer_throttle_configure(ENetPeer *peer, uint interval, uint acceleration, uint deceleration);
public void setPeer(ENetPeer* peer)
{
this.peer = peer;
}
public void setPeer(ENetPeer *peer)
{
this.peer = peer;
}
static extern void native_peer_timeout(ENetPeer *peer, uint timeoutLimit, uint timeoutMinimum, uint timeoutMaximum);
public void netLoop()
{
update();
var enetEvent = new ENetEvent();
while (true)
{
while (enet_host_service(_server, &enetEvent, 0) > 0)
{
switch (enetEvent.type)
{
case EventType.Connect:
//Logging->writeLine("A new client connected: %i.%i.%i.%i:%i", event.peer->address.host & 0xFF, (event.peer->address.host >> 8) & 0xFF, (event.peer->address.host >> 16) & 0xFF, (event.peer->address.host >> 24) & 0xFF, event.peer->address.port);
/* Set some defaults */
enetEvent.peer->mtu = PEER_MTU;
enetEvent.data = 0;
break;
case EventType.Receive:
currentPeer = enetEvent.peer;
if (!PacketHandlerManager.getInstace().handlePacket(enetEvent.peer, enetEvent.packet, (Channel)enetEvent.channelID))
{
//enet_peer_disconnect(event.peer, 0);
}
/* Clean up the packet now that we're done using it. */
enet_packet_destroy(enetEvent.packet);
break;
case EventType.Disconnect:
handleDisconnect(enetEvent.peer);
break;
}
}
Thread.Sleep((int)REFRESH_RATE);
}
}
public static extern void enet_peer_ping(ENetPeer *peer);
static extern void native_peer_disconnect_later(ENetPeer *peer, uint data);
static extern void native_peer_ping(ENetPeer *peer);
public static extern ENetPacket *enet_peer_receive(ENetPeer *peer, out byte channelID);
public static extern int enet_peer_send(ENetPeer *peer, byte channelID, ENetPacket *packet);
static extern void native_peer_ping_interval(ENetPeer *peer, uint pingInterval);
public static extern void enet_peer_reset(ENetPeer *peer);
static extern ENetPacket *native_peer_receive(ENetPeer *peer, out byte channelID);
public static extern void enet_peer_disconnect_later(ENetPeer *peer, uint data);
static extern void native_peer_reset(ENetPeer *peer);
unsafe bool handleGameNumber(ClientInfo client, ENetPeer *peer, ENetPacket *packet)
{
var world = new WorldSendGameNumber(1, client.getName());
return(PacketHandlerManager.getInstace().sendPacket(peer, world, Channel.CHL_S2C));
}
static extern int native_peer_send(ENetPeer *peer, byte channelID, ENetPacket *packet);
