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));
}
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);
}
private void Init()
{
Connections = new List <ClientConnectionInfo>();
Logger.Initialize();
LoginManager = new LoginManager(this);
EventNotifyManager = new EventNotifyManager(this);
PacketHandlerManager = new PacketHandlerManager(this);
PacketSenderManager = new PacketSenderManager(this);
ConsoleManager = new ConsoleManager(this);
ConfigManager = new ConfigManager();
DatabaseManager = new DatabaseManager(this);
EncryptionManager = new EncryptionManager();
Worlds = new List <World>
{
new World(0, "Castle", this) //Just for testing
};
ConsoleUtils.Info("Running {0} world instances", Worlds.Count);
var managers = new List <IGameManager>();
managers.AddRange(Worlds.Select(w => w.EntityManager));
managers.Add(LoginManager);
managers.Add(EventNotifyManager);
EventBus = new EventBus(managers);
_host = new Host();
_host.InitializeServer(ConfigManager.Settings.Port, ConfigManager.Settings.MaxPlayers);
_host.SetChannelLimit(5);
ConsoleUtils.Info("Successfully set up and running");
}
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;
}
}
var answer = new SynchVersionAns(game.getPlayers(), Config.version, "CLASSIC", mapId);
return(PacketHandlerManager.getInstace().sendPacket(peer, answer, Channel.CHL_S2C));
}
public static void notifyMinionSpawned(Minion m, TeamId team)
{
var ms = new MinionSpawn(m);
PacketHandlerManager.getInstace().broadcastPacketTeam(team, ms, Channel.CHL_S2C);
notifySetHealth(m);
}
public bool Init()
{
// 文件位置
if (Application.isEditor)
{
Framework.Instance.SetWritableRootDir(Application.temporaryCachePath);
Framework.Instance.SetStreamAssetsRootDir(Application.streamingAssetsPath);
}
else
{
Framework.Instance.SetWritableRootDir(Application.temporaryCachePath);
Framework.Instance.SetStreamAssetsRootDir(Application.streamingAssetsPath);
}
// console输出
LoggerSystem.Instance.SetConsoleLogger(new Alkaid.Logger(UnityEngine.Debug.Log));
// 网络
PacketFormat pf = new PacketFormat();
PacketHandlerManager pm = new PacketHandlerManager();
NetSystem.Instance.RegisterConnector((int)NetCtr.Lobby, ConnectionType.TCP, pf, pm, ConnectedCallback, null, DisConnectedCallback, null);
// NetSystem.Instance.RegisterConnector((int)NetCtr.Room, ConnectionType.TCP, pf, pm, conne)
return(Framework.Instance.Init());
}
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 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);
}
/// <summary>
/// The class constructon
/// </summary>
/// <param name="packetHandlers">PacketHandlers to use</param>
public Plexer(APacketHandler[] packetHandlers)
{
Clients = new List <Client>();
ToAddClients = new List <Client>();
ToUpgrade = new List <Client>();
PacketHandler = new PacketHandlerManager(packetHandlers);
}
private unsafe Sniffer()
{
var listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 5478);
listener.Start();
new Thread(new ThreadStart(() =>
{
while (true)
{
var c = listener.AcceptTcpClient();
writer = new BinaryWriter(c.GetStream());
reader = new BinaryReader(c.GetStream());
}
})).Start();
new Thread(new ThreadStart(() =>
{
while (true)
{
try
{
var p = Receive();
if (p == null)
{
continue;
}
var players = game.getPlayers();
if (players.Count < 1)
{
return;
}
var player = players[0];
if (player.Item2 == null || player.Item2.getPeer() == null)
{
return;
}
if (p.s2c)
{
if (p.broadcast)
{
PacketHandlerManager.getInstace().broadcastPacket(p.data, IntWarsSharp.Core.Logic.PacketHandlers.Channel.CHL_S2C);
}
else
{
PacketHandlerManager.getInstace().sendPacket(player.Item2.getPeer(), p.data, IntWarsSharp.Core.Logic.PacketHandlers.Channel.CHL_S2C);
}
}
else
{
PacketHandlerManager.getInstace().handlePacket(player.Item2.getPeer(), p.data, IntWarsSharp.Core.Logic.PacketHandlers.Channel.CHL_C2S);
}
}
catch { reader = null; }
}
})).Start();
}
public ControllerPacketHandler(NetController net, BaseGameController logic)
{
PacketHandlerManager = net.PacketHandlers;
module = logic;
PacketHandlerManager.Register(2, OnSyncServerTime);
}
public static void notifyChampionDie(Champion die, Unit killer, int goldFromKill)
{
var cd = new ChampionDie(die, killer, goldFromKill);
PacketHandlerManager.getInstace().broadcastPacket(cd, Channel.CHL_S2C);
notifyChampionDeathTimer(die);
}
public ControllerPacketHandler(NetController net, BaseLoginController logic)
{
PacketHandlerManager = net.PacketHandlers;
module = logic;
PacketHandlerManager.Register(1001, OnLoginServerResult);
PacketHandlerManager.Register(1003, OnCreatePlayerResult);
}
public DummyGame()
{
_blowfish = new BlowFish(Encoding.Default.GetBytes("UnitTests stinks"));
_packetHandlerManager = new PacketHandlerManager(this);
_map = new Map(this, 1, 1, 1, true, 1);
_packetNotifier = new PacketNotifier(this);
_server = new Host();
_server.Create(12345, 123);
}
public ControllerPacketHandler(NetController net, BaseSceneController logic)
{
PacketHandlerManager = net.PacketHandlers;
module = logic;
PacketHandlerManager.Register(1101, OnEnterSceneInfo);
PacketHandlerManager.Register(1102, OnSpriteEnter);
PacketHandlerManager.Register(1103, OnSpriteMove);
PacketHandlerManager.Register(1104, OnSpriteLeave);
}
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 void notifyLeaveVision(GameObject o, TeamId team)
{
var lv = new LeaveVision(o);
PacketHandlerManager.getInstace().broadcastPacketTeam(team, lv, Channel.CHL_S2C);
// Not exactly sure what this is yet
var c = o as Champion;
if (o == null)
{
var deleteObj = new DeleteObjectFromVision(o);
PacketHandlerManager.getInstace().broadcastPacketTeam(team, deleteObj, Channel.CHL_S2C);
}
}
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);
}
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 static void notifyUpdatedStats(Unit u, bool partial = true)
{
//if (u is Monster)
// return;
var us = new SpawnParticle.UpdateStats(u, partial);
var t = u as Turret;
if (t != null)
{
PacketHandlerManager.getInstace().broadcastPacket(us, Channel.CHL_LOW_PRIORITY, ENet.PacketFlags.Unsequenced);
return;
}
if (!partial)
{
PacketHandlerManager.getInstace().broadcastPacketTeam(u.getTeam(), us, Channel.CHL_LOW_PRIORITY, ENet.PacketFlags.Unsequenced);
}
else
{
PacketHandlerManager.getInstace().broadcastPacketVision(u, us, Channel.CHL_LOW_PRIORITY, ENet.PacketFlags.Unsequenced);
}
}
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 static void notifyEnterVision(GameObject o, TeamId team)
{
var m = o as Minion;
if (m != null)
{
var eva = new EnterVisionAgain(m);
PacketHandlerManager.getInstace().broadcastPacketTeam(team, eva, Channel.CHL_S2C);
notifySetHealth(m);
return;
}
var c = o as Champion;
// TODO: Fix bug where enemy champion is not visible to user when vision is acquired until the enemy champion moves
if (c != null)
{
var eva = new EnterVisionAgain(c);
PacketHandlerManager.getInstace().broadcastPacketTeam(team, eva, Channel.CHL_S2C);
notifySetHealth(c);
return;
}
}
public static void notifyTeleport(Unit u, float _x, float _y)
{
// Can't teleport to this point of the map
if (!map.isWalkable(_x, _y))
{
_x = MovementVector.targetXToNormalFormat(u.getPosition().X);
_y = MovementVector.targetYToNormalFormat(u.getPosition().Y);
}
else
{
u.setPosition(_x, _y);
//TeleportRequest first(u.getNetId(), u.teleportToX, u.teleportToY, true);
//sendPacket(currentPeer, first, Channel.CHL_S2C);
_x = MovementVector.targetXToNormalFormat(_x);
_y = MovementVector.targetYToNormalFormat(_y);
}
var second = new TeleportRequest(u.getNetId(), _x, _y, false);
PacketHandlerManager.getInstace().broadcastPacketVision(u, second, Channel.CHL_S2C);
}
private void NetLoop()
{
while (!_stopRequested)
{
while (_host.Service(ConfigManager.Settings.HostEventTimeout, out Event enetEvent))
{
switch (enetEvent.Type)
{
case EventType.Connect:
ConsoleUtils.Info("Client connected on {0}", enetEvent.Peer.GetRemoteAddress());
Connections.Add(new ClientConnectionInfo(enetEvent.Peer));
break;
case EventType.Receive:
PacketHandlerManager.HandleData(enetEvent.Packet.GetBytes(), GetConnectionInfoByPeer(enetEvent.Peer));
enetEvent.Packet.Dispose();
break;
case EventType.Disconnect:
ConsoleUtils.Info("Client on {0} disconnected", enetEvent.Peer.GetRemoteAddress());
var destroyRequest = new EntityEvent(EntityEventType.EntityDestroyRequest)
{
EntityID = GetConnectionInfoByPeer(enetEvent.Peer).Player.EntityID
};
EventBus.PublishEvent(destroyRequest);
Connections.Remove(GetConnectionInfoByPeer(enetEvent.Peer));
break;
default:
ConsoleUtils.Warning("Invalid event called");
break;
}
}
Thread.Sleep(1);
}
_host.Dispose();
}
public static void notifyDash(Unit u, float _x, float _y, float dashSpeed)
{
// TODO: Fix dash: it stays in the current location and doesn't hit a wall if the target location can't be reached
float _z = u.getZ();
/*if (!map.isWalkable(_x, _y)) {
* _x = u.getPosition().X;
* _y = u.getPosition().Y;
* }
* else {
* // Relative coordinates to dash towards
* float newX = _x;
* float newY = _y;
* _z -= map.getHeightAtLocation(_x, _y);
* _x = u.getPosition().X - _x;
* _y = u.getPosition().Y - _y;
*
* u.setPosition(newX, newY);
* }*/
var dash = new Dash(u, _x, _y, dashSpeed);
PacketHandlerManager.getInstace().broadcastPacketVision(u, dash, Channel.CHL_S2C);
}
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));
}
/// <summary>
/// Adds packet handler.
/// </summary>
/// <param name="op"></param>
/// <param name="handler"></param>
protected void AddPacketHandler(int op, PacketHandlerManager<ChannelClient>.PacketHandlerFunc handler)
{
ChannelServer.Instance.Server.Handlers.Add(op, handler);
}
/// <summary>
/// Adds packet handler.
/// </summary>
/// <param name="op"></param>
/// <param name="handler"></param>
protected void AddPacketHandler(int op, PacketHandlerManager <ChannelClient> .PacketHandlerFunc handler)
{
ChannelServer.Instance.Server.Handlers.Add(op, handler);
}
public void UnReg()
{
PacketHandlerManager.Unregister((ushort)emPacket_Battle.em_SC_PreBattle);
}
public void Reg()
{
PacketHandlerManager.Register((ushort)emPacket_Battle.em_SC_PreBattle, ResPreBattle);
}
