public IEnumerable <StatePacket> StepBuffer()
{
DecrementBufferFrames();
outputPackets.Clear();
// If the buffer is too large, it is better to flush multiple packets all at once
// to catch up to the sender. This will cause popping, but is preferable to perpetually
// lagging behind.
// If this is happening too frequently, the buffer delayFrames should be increased.
while (buffer.Count > delayFrames)
{
StatePacket output = buffer[buffer.Count - 1];
outputPackets.Add(output);
Debug.Log($"Buffer is size {buffer.Count}; <b><color=orange>Flushing</color></b> packet with remote frame <b>{output.remoteFrame}</b>. " +
$"<i>(Buffer is now size {buffer.Count - 1}.)</i>", LogType.JitterBuffer);
buffer.RemoveAt(buffer.Count - 1);
DecrementBufferFrames();
}
if (buffer.Count > 0 && buffer[buffer.Count - 1].bufferFramesRemaining <= 0)
{
StatePacket output = buffer[buffer.Count - 1];
outputPackets.Add(output);
buffer.RemoveAt(buffer.Count - 1);
Debug.Log($"<b><color=cyan>Removing</color></b> packet with remote frame <b>{output.remoteFrame}</b> from jitter buffer. " +
$"<i>(Buffer is now size {buffer.Count}.)</i>", LogType.JitterBuffer);
}
return(outputPackets);
}
/// <summary>
/// Delete the path in the tree
/// </summary>
/// <param name="path">The path which want to delete</param>
public static bool Delete(string path)
{
CheckConnect();
StatePacket packet = new StatePacket(path, StatePacket.Type.Delete, Serializer.SerializeToBytes("delete data"));
return(_clients.Aggregate(true, (current, client) => current & client.Send <bool>(packet)));
}
public void PollEvents()
{
netManager.PollEvents();
while (remote != null && queuedStatePackets.Count > 0)
{
StatePacket packet = queuedStatePackets.Dequeue();
ProcessStatePacket(packet);
}
if (role != Role.ListenClient && debug != null && debug.settings.simulateLatency)
{
foreach (StatePacket packet in debug.GetAllReadyPackets())
{
ReadStatePacket(packet);
}
}
if (settings.UseJitterBuffer)
{
foreach (JitterBuffer jitterBuffer in jitterBuffersByPeerId.Values)
{
foreach (var packet in jitterBuffer.StepBuffer())
{
remote.ReadState(packet.reader, packet.remoteFrame, settings.DiscardOutOfOrderPackets);
}
}
}
}
/// <summary>
/// Put the path into the tree
/// </summary>
/// <param name="path">The path which want to store</param>
/// <param name="data"></param>
public static bool Put <T>(string path, T data)
{
CheckConnect();
StatePacket packet = new StatePacket(path, StatePacket.Type.Add, Serializer.SerializeToBytes(data));
Logger.Info("put path " + path);
return(_clients.Aggregate(true, (current, client) => current & client.Send <bool>(packet)));
}
/// <summary>
/// Is the path exist
/// </summary>
/// <param name="path">the full path</param>
/// <returns>true is exist, false is not</returns>
public static bool IsExist(string path)
{
CheckConnect();
StatePacket packet = new StatePacket(path, StatePacket.Type.IsExists, Serializer.SerializeToBytes("Check is exist"));
bool isExist = _clients[0].Send <bool>(packet);
return(isExist);
}
// //////////////////////////////////////////////// Initial Setting Members...
public void AddAMember(string pName, float pTimerSet, string pType = "Normal")
{
StateGame newObj;
if (pType == "Packet")
newObj = new StatePacket (pName, pTimerSet);
else
newObj = new StateGame (pName, pTimerSet);
arrState.Add (newObj);
}
private void ProcessStatePacket(StatePacket packet)
{
if (debug != null && debug.settings.simulateLatency)
{
debug.InsertDelayedReader(UnityEngine.Random.Range(debug.settings.minLatency, debug.settings.maxLatency) / (float)1000, packet);
}
else
{
ReadStatePacket(packet);
}
}
/// <summary>
/// Get available supervisors
/// </summary>
/// <param name="path"></param>
/// <param name="data"></param>
/// <param name="needRecord"></param>
/// <returns></returns>
public static IEnumerable <string> GetAvailableSupervisors(string path, Object data, bool needRecord = true)
{
CheckConnect();
StatePacket supervisorPacket = new StatePacket("/root/supervisor/score/", StatePacket.Type.GetAvailavleWorker, Serializer.SerializeToBytes("Null"));
Object obj = _clients[0].Send <Object>(supervisorPacket);
if (obj != null)
{
return((IEnumerable <string>)obj);
}
return(null);
}
public static void Rename(string path, string nodeName)
{
CheckConnect();
StatePacket packet = new StatePacket(path, StatePacket.Type.Rename,
Encoding.UTF8.GetBytes(nodeName))
{
WaiteCallBack = false
};
//1207
_clients[0].Send <bool>(packet);
}
private void ReadStatePacket(StatePacket packet)
{
if (settings.UseJitterBuffer)
{
jitterBuffersByPeerId[packet.PeerID].Insert(packet.PacketReader);
}
else
{
int frame = packet.PacketReader.GetInt();
remote.ReadState(packet.PacketReader, frame, settings.DiscardOutOfOrderPackets);
}
}
public void AddAMemberAndEntryAction(string pName, float pTimerSet, string pType, FunctionPointer pEntry)
{
StateGame newObj;
if (pType == "Packet")
newObj = new StatePacket (pName, pTimerSet);
else
newObj = new StateGame (pName, pTimerSet);
arrState.Add (newObj);
StateGame lastGame = (StateGame)arrState [arrState.Count - 1];
lastGame.mEntryAction = pEntry;
}
public bool TryGetPacket(out StatePacket reader, int currentFrame)
{
if (buffer.Count > 0 && currentFrame - buffer[buffer.Count - 1].localArrivalFrame >= delayFrames)
{
reader = buffer[buffer.Count - 1];
buffer.RemoveAt(buffer.Count - 1);
return(true);
}
reader = null;
return(false);
}
public void Tick(float deltaTime)
{
if (Remote != null && queuedStatePackets.Count > 0)
{
StatePacket packet = queuedStatePackets.Dequeue();
Remote.Read(packet.PacketReader, packet.Frame, settings.DiscardOutOfOrderPackets);
}
StatefulWorld.Instance.Tick(deltaTime);
SendState();
}
/// <summary>
/// Get children of the <param name="path"/>
/// </summary>
/// <returns></returns>
public static IEnumerable <string> GetChildren(string path)
{
CheckConnect();
StatePacket packet = new StatePacket(path, StatePacket.Type.Children, Serializer.SerializeToBytes("get children"));
List <string> obj = _clients[0].Send <List <string> >(packet);
if (obj == null)
{
return(new List <string>());
}
obj.Sort();
return(obj);
}
// //////////////////////////////////////////////// Initial Setting Members...
public void AddAMember(string pName, float pTimerSet, string pType = "Normal")
{
StateGame newObj;
if (pType == "Packet")
{
newObj = new StatePacket(pName, pTimerSet);
}
else
{
newObj = new StateGame(pName, pTimerSet);
}
arrState.Add(newObj);
}
/// <summary>
/// Get data by path
/// </summary>
/// <param name="path">the path that data stored</param>
/// <returns>return data</returns>
public static T Get <T>(string path)
{
try
{
CheckConnect();
StatePacket packet = new StatePacket(path, StatePacket.Type.Get, Serializer.SerializeToBytes("get data"));
T obj = _clients[0].Send <T>(packet);
return(obj);
}
catch (Exception exception)
{
Logger.Error(exception);
return(default(T));
}
}
/// <summary>
/// Get the Xbox360Button for the given string
/// </summary>
/// <param name="packet">that we received from the server</param>
/// <returns></returns>
public static Xbox360Button StateToXbox360Button(StatePacket packet)
{
return(packet.Offset switch
{
"Buttons0" => Xbox360Button.A,
"Buttons1" => Xbox360Button.B,
"Buttons2" => Xbox360Button.X,
"Buttons3" => Xbox360Button.Y,
"Buttons4" => Xbox360Button.LeftShoulder,
"Buttons5" => Xbox360Button.RightShoulder,
"Buttons6" => Xbox360Button.Back,
"Buttons7" => Xbox360Button.Start,
"Buttons8" => Xbox360Button.Left,
"Buttons9" => Xbox360Button.Right,
_ => null
});
/// <summary>
/// Set a button from the given packet
/// </summary>
/// <param name="packet">data to use for setting button</param>
public void SetButton(StatePacket packet)
{
//Get the button from the packet data
var button = ControllerUtils.StateToXbox360Button(packet);
//if we got an incompatible button, return
if (button == null)
{
return;
}
//get whether the button was pressed
var pressed = (packet.Value == 128);
//set the given button
_controller.SetButtonState(button, pressed);
}
public bool HandlePacket(Peer peer, byte[] data)
{
if (_game.IsRunning)
{
return(true);
}
_game.IncrementReadyPlayers();
if (_game.PlayersReady == _playerManager.GetPlayers().Count)
{
var start = new StatePacket(PacketCmdS2C.PKT_S2C_StartGame);
_game.PacketHandlerManager.broadcastPacket(start, Channel.CHL_S2C);
foreach (var player in _playerManager.GetPlayers())
{
if (player.Item2.Peer == peer && !player.Item2.IsMatchingVersion)
{
var dm = new DebugMessage("Your client version does not match the server. Check the server log for more information.");
_game.PacketHandlerManager.sendPacket(peer, dm, Channel.CHL_S2C);
}
_game.PacketNotifier.notifyUpdatedStats(player.Item2.Champion, false);
}
_game.Start();
}
if (_game.IsRunning)
{
foreach (var p in _playerManager.GetPlayers())
{
var map = _game.Map;
map.AddObject(p.Item2.Champion);
// Send the initial game time sync packets, then let the map send another
float gameTime = map.GameTime / 1000.0f;
var timer = new GameTimer(gameTime); // 0xC1
_game.PacketHandlerManager.sendPacket(p.Item2.Peer, timer, Channel.CHL_S2C);
var timer2 = new GameTimerUpdate(gameTime); // 0xC2
_game.PacketHandlerManager.sendPacket(p.Item2.Peer, timer2, Channel.CHL_S2C);
}
}
return(true);
}
public bool HandlePacket(Peer peer, byte[] data, Game game)
{
if (game.IsStarted())
{
return(true);
}
game.IncrementReadyPlayers();
if (game.GetReadyPlayers() == game.GetPlayers().Count)
{
var start = new StatePacket(PacketCmdS2C.PKT_S2C_StartGame);
game.PacketHandlerManager.broadcastPacket(start, Channel.CHL_S2C);
foreach (var player in game.GetPlayers())
{
if (player.Item2.GetPeer() == peer && !player.Item2.IsVersionMatch())
{
var dm = new DebugMessage("Your client version does not match the server. Check the server log for more information.");
game.PacketHandlerManager.sendPacket(peer, dm, Channel.CHL_S2C);
}
game.PacketNotifier.notifyUpdatedStats(player.Item2.GetChampion(), false);
}
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
game.PacketHandlerManager.sendPacket(p.Item2.GetPeer(), timer, Channel.CHL_S2C);
var timer2 = new GameTimerUpdate(gameTime); // 0xC2
game.PacketHandlerManager.sendPacket(p.Item2.GetPeer(), timer2, Channel.CHL_S2C);
}
}
return(true);
}
public void AddAMemberAndEntryAction(string pName, float pTimerSet, string pType, FunctionPointer pEntry)
{
StateGame newObj;
if (pType == "Packet")
{
newObj = new StatePacket(pName, pTimerSet);
}
else
{
newObj = new StateGame(pName, pTimerSet);
}
arrState.Add(newObj);
StateGame lastGame = (StateGame)arrState [arrState.Count - 1];
lastGame.mEntryAction = pEntry;
}
public void Tick(float deltaTime)
{
bool keepTrying = true;
while (Remote != null && queuedStatePackets.Count > 0 && keepTrying)
{
int count = queuedStatePackets.Count;
keepTrying = false;
for (int i = 0; i < count; i++)
{
StatePacket packet = queuedStatePackets.Dequeue();
if (packet.Frame <= StatefulWorld.Instance.Frame + 1)
{
Remote.ReadStateAndTick(packet.PacketReader, packet.Frame, deltaTime, settings.DiscardOutOfOrderPackets);
keepTrying = 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 void Insert(NetPacketReader statePacketReader, int currentFrame)
{
// TODO: What to do when the buffer gets too large, for any reason?
// Maybe fast forward and apply multiple per frame?
if (buffer.Count > 200)
{
return;
}
int frame = statePacketReader.GetInt();
StatePacket packet = new StatePacket()
{
remoteFrame = frame,
localArrivalFrame = currentFrame,
reader = statePacketReader
};
// Iterate through the buffer to determine where the new packet should be placed.
for (int i = 0; i < buffer.Count + 1; i++)
{
// If the packet has arrived in order with respect to all elements in the buffer, its
// remote frame should be larger than all other elements in the buffer, and it will
// be inserted at the front of the buffer.
if (i == buffer.Count || packet.remoteFrame > buffer[i].remoteFrame)
{
buffer.Insert(i, packet);
break;
}
// If the packet arrived out of order with respect to the next packet in the buffer,
// swap arrival frames with the next packet. This allows the buffer to more accurately represent
// the cadence that the packets were sent.
else
{
int tempArrivalFrame = packet.localArrivalFrame;
packet.localArrivalFrame = buffer[i].localArrivalFrame;
buffer[i].localArrivalFrame = tempArrivalFrame;
}
}
}
/// <summary>
/// Set the value of the axis to the given one
/// </summary>
/// <param name="state">The state to use for setting the controller</param>
public void SetAxis(StatePacket state)
{
//convert the state to a controller axis
var axis = ControllerUtils.StateToXbox360Axis(state);
try
{
var src = state.Value - MaxValue;
//convert the ushort value to a short
var value = src > (ushort)MaxValue
? MaxValue
: (short)src;
//NOTE: 0 is the middle point, values go from (-32768 => 32768)
//set the value of the axis from the controller
_controller.SetAxisValue(axis, value);
}
catch (Exception e)
{
Logger.LogError(e.Message);
}
}
public void Insert(NetPacketReader statePacketReader)
{
int frame = statePacketReader.GetInt();
StatePacket packet = new StatePacket()
{
remoteFrame = frame,
bufferFramesRemaining = buffer.Count > 0 ? buffer[0].bufferFramesRemaining + 1 : delayFrames,
reader = statePacketReader
};
// Iterate through the buffer to determine where the new packet should be placed.
for (int i = 0; i < buffer.Count + 1; i++)
{
// If the packet has arrived in order with respect to all elements in the buffer, its
// remote frame should be larger than all other elements in the buffer, and it will
// be inserted at the front of the buffer.
if (i == buffer.Count || packet.remoteFrame > buffer[i].remoteFrame)
{
buffer.Insert(i, packet);
break;
}
// If the packet arrived out of order with respect to the next packet in the buffer,
// swap arrival frames with the next packet. This allows the buffer to more accurately represent
// the cadence that the packets were sent.
else
{
int tempArrivalFrame = packet.bufferFramesRemaining;
packet.bufferFramesRemaining = buffer[i].bufferFramesRemaining;
buffer[i].bufferFramesRemaining = tempArrivalFrame;
}
}
Debug.Log($"<color=yellow><b>Inserting</b></color> packet with remote frame <b>{packet.remoteFrame}</b> into jitter buffer. " +
$"<i>(Buffer is now size {buffer.Count}.)</i>", LogType.JitterBuffer);
}
public void NotifySpawnEnd(int userId)
{
var endSpawnPacket = new StatePacket(PacketCmd.PKT_S2C_END_SPAWN);
_packetHandlerManager.SendPacket(userId, endSpawnPacket, Channel.CHL_S2C);
}
public void NotifyGameStart()
{
var start = new StatePacket(PacketCmd.PKT_S2C_START_GAME);
_packetHandlerManager.BroadcastPacket(start, Channel.CHL_S2C);
}
public override bool HandlePacket(Peer peer, byte[] data)
{
var start = new StatePacket2(PacketCmd.PKT_S2C_StartSpawn);
_game.PacketHandlerManager.sendPacket(peer, start, Channel.CHL_S2C);
_logger.LogCoreInfo("Spawning map");
int playerId = 0;
foreach (var p in _playerManager.GetPlayers())
{
var spawn = new HeroSpawn(p.Item2, playerId++);
_game.PacketHandlerManager.sendPacket(peer, spawn, Channel.CHL_S2C);
var info = new AvatarInfo(p.Item2);
_game.PacketHandlerManager.sendPacket(peer, info, Channel.CHL_S2C);
}
var peerInfo = _playerManager.GetPeerInfo(peer);
var bluePill = _itemManager.GetItemType(_game.Map.MapGameScript.BluePillId);
var itemInstance = peerInfo.Champion.getInventory().SetExtraItem(7, bluePill);
var buyItem = new BuyItemResponse(peerInfo.Champion, itemInstance);
_game.PacketHandlerManager.sendPacket(peer, buyItem, Channel.CHL_S2C);
// Runes
byte runeItemSlot = 14;
foreach (var rune in peerInfo.Champion.RuneList._runes)
{
var runeItem = _itemManager.GetItemType(rune.Value);
var newRune = peerInfo.Champion.getInventory().SetExtraItem(runeItemSlot, runeItem);
_playerManager.GetPeerInfo(peer).Champion.GetStats().AddModifier(runeItem);
runeItemSlot++;
}
// Not sure why both 7 and 14 skill slot, but it does not seem to work without it
var skillUp = new SkillUpResponse(peerInfo.Champion.NetId, 7, 1, (byte)peerInfo.Champion.getSkillPoints());
_game.PacketHandlerManager.sendPacket(peer, skillUp, Channel.CHL_GAMEPLAY);
skillUp = new SkillUpResponse(peerInfo.Champion.NetId, 14, 1, (byte)peerInfo.Champion.getSkillPoints());
_game.PacketHandlerManager.sendPacket(peer, skillUp, Channel.CHL_GAMEPLAY);
peerInfo.Champion.GetStats().setSpellEnabled(7, true);
peerInfo.Champion.GetStats().setSpellEnabled(14, true);
peerInfo.Champion.GetStats().setSummonerSpellEnabled(0, true);
peerInfo.Champion.GetStats().setSummonerSpellEnabled(1, true);
var objects = _game.ObjectManager.GetObjects();
foreach (var kv in objects)
{
if (kv.Value is LaneTurret)
{
var turret = kv.Value as LaneTurret;
var turretSpawn = new TurretSpawn(turret);
_game.PacketHandlerManager.sendPacket(peer, turretSpawn, Channel.CHL_S2C);
// Fog Of War
var fogOfWarPacket = new FogUpdate2(turret, _networkIdManager);
_game.PacketHandlerManager.broadcastPacketTeam(turret.Team, fogOfWarPacket, Channel.CHL_S2C);
// To suppress game HP-related errors for enemy turrets out of vision
var setHealthPacket = new SetHealth(turret);
_game.PacketHandlerManager.sendPacket(peer, setHealthPacket, Channel.CHL_S2C);
foreach (var item in turret.Inventory)
{
if (item == null)
{
continue;
}
_game.PacketNotifier.NotifyItemBought(turret, item as Item);
}
continue;
}
else if (kv.Value is LevelProp)
{
var levelProp = kv.Value as LevelProp;
var levelPropSpawnPacket = new LevelPropSpawn(levelProp);
_game.PacketHandlerManager.sendPacket(peer, levelPropSpawnPacket, Channel.CHL_S2C);
continue;
}
else if (kv.Value is Champion)
{
var champion = kv.Value as Champion;
if (champion.IsVisibleByTeam(peerInfo.Champion.Team))
{
var enterVisionPacket = new EnterVisionAgain(champion);
_game.PacketHandlerManager.sendPacket(peer, enterVisionPacket, Channel.CHL_S2C);
}
}
else if (kv.Value is Inhibitor || kv.Value is Nexus)
{
var inhibtor = kv.Value as AttackableUnit;
var minionSpawnPacket = new MinionSpawn2(inhibtor.NetId);
_game.PacketHandlerManager.sendPacket(peer, minionSpawnPacket, Channel.CHL_S2C);
var setHealthPacket = new SetHealth(inhibtor.NetId);
_game.PacketHandlerManager.sendPacket(peer, setHealthPacket, Channel.CHL_S2C);
continue;
}
else if (kv.Value is Projectile)
{
var projectile = kv.Value as Projectile;
if (projectile.IsVisibleByTeam(peerInfo.Champion.Team))
{
var spawnProjectilePacket = new SpawnProjectile(projectile);
_game.PacketHandlerManager.sendPacket(peer, spawnProjectilePacket, Channel.CHL_S2C);
}
continue;
}
else
{
_logger.LogCoreWarning("Object of type: " + kv.Value.GetType() + " not handled in HandleSpawn.");
}
}
// TODO shop map specific?
// Level props are just models, we need button-object minions to allow the client to interact with it
if (peerInfo != null && peerInfo.Team == TeamId.TEAM_BLUE)
{
// Shop (blue team)
var minionSpawnPacket = new MinionSpawn2(0xff10c6db);
_game.PacketHandlerManager.sendPacket(peer, minionSpawnPacket, Channel.CHL_S2C);
var setHealthPacket = new SetHealth(0xff10c6db);
_game.PacketHandlerManager.sendPacket(peer, setHealthPacket, Channel.CHL_S2C);
}
else if (peerInfo != null && peerInfo.Team == TeamId.TEAM_PURPLE)
{
// Shop (purple team)
var minionSpawnPacket = new MinionSpawn2(0xffa6170e);
_game.PacketHandlerManager.sendPacket(peer, minionSpawnPacket, Channel.CHL_S2C);
var setHealthPacket = new SetHealth(0xffa6170e);
_game.PacketHandlerManager.sendPacket(peer, setHealthPacket, Channel.CHL_S2C);
}
var endSpawnPacket = new StatePacket(PacketCmd.PKT_S2C_EndSpawn);
return(_game.PacketHandlerManager.sendPacket(peer, endSpawnPacket, Channel.CHL_S2C));
}
public bool HandlePacket(Peer peer, byte[] data)
{
var start = new StatePacket2(PacketCmdS2C.PKT_S2C_StartSpawn);
_game.PacketHandlerManager.sendPacket(peer, start, Channel.CHL_S2C);
_logger.LogCoreInfo("Spawning map");
int playerId = 0;
foreach (var p in _playerManager.GetPlayers())
{
var spawn = new HeroSpawn(p.Item2, playerId++);
_game.PacketHandlerManager.sendPacket(peer, spawn, Channel.CHL_S2C);
var info = new PlayerInfo(p.Item2);
_game.PacketHandlerManager.sendPacket(peer, info, Channel.CHL_S2C);
}
var peerInfo = _playerManager.GetPeerInfo(peer);
var bluePill = _itemManager.GetItemType(_game.Map.GetBluePillId());
var itemInstance = peerInfo.Champion.getInventory().SetExtraItem(7, bluePill);
var buyItem = new BuyItemAns(peerInfo.Champion, itemInstance);
_game.PacketHandlerManager.sendPacket(peer, buyItem, Channel.CHL_S2C);
// Runes
byte runeItemSlot = 14;
foreach (var rune in peerInfo.Champion.RuneList._runes)
{
var runeItem = _itemManager.GetItemType(rune.Value);
var newRune = peerInfo.Champion.getInventory().SetExtraItem(runeItemSlot, runeItem);
_playerManager.GetPeerInfo(peer).Champion.GetStats().AddBuff(runeItem);
runeItemSlot++;
}
// Not sure why both 7 and 14 skill slot, but it does not seem to work without it
var skillUp = new SkillUpPacket(peerInfo.Champion.NetId, 7, 1, (byte)peerInfo.Champion.getSkillPoints());
_game.PacketHandlerManager.sendPacket(peer, skillUp, Channel.CHL_GAMEPLAY);
skillUp = new SkillUpPacket(peerInfo.Champion.NetId, 14, 1, (byte)peerInfo.Champion.getSkillPoints());
_game.PacketHandlerManager.sendPacket(peer, skillUp, Channel.CHL_GAMEPLAY);
peerInfo.Champion.GetStats().setSpellEnabled(7, true);
peerInfo.Champion.GetStats().setSpellEnabled(14, true);
peerInfo.Champion.GetStats().setSummonerSpellEnabled(0, true);
peerInfo.Champion.GetStats().setSummonerSpellEnabled(1, true);
var objects = _game.Map.GetObjects();
foreach (var kv in objects)
{
if (kv.Value is LaneTurret)
{
var t = kv.Value as LaneTurret;
var turretSpawn = new TurretSpawn(t);
_game.PacketHandlerManager.sendPacket(peer, turretSpawn, Channel.CHL_S2C);
// Fog Of War
var fow = new FogUpdate2(t);
_game.PacketHandlerManager.broadcastPacketTeam(t.Team, fow, Channel.CHL_S2C);
// To suppress game HP-related errors for enemy turrets out of vision
var sh = new SetHealth(t);
_game.PacketHandlerManager.sendPacket(peer, sh, Channel.CHL_S2C);
foreach (var item in t.Inventory)
{
if (item == null)
{
continue;
}
_game.PacketNotifier.notifyItemBought(t, item as Item);
}
continue;
}
else if (kv.Value is LevelProp)
{
var lp = kv.Value as LevelProp;
var lpsPacket = new LevelPropSpawn(lp);
_game.PacketHandlerManager.sendPacket(peer, lpsPacket, Channel.CHL_S2C);
}
else if (kv.Value is Inhibitor || kv.Value is Nexus)
{
var inhib = kv.Value as Unit;
var ms = new MinionSpawn2(inhib.NetId);
_game.PacketHandlerManager.sendPacket(peer, ms, Channel.CHL_S2C);
var sh = new SetHealth(inhib.NetId);
_game.PacketHandlerManager.sendPacket(peer, sh, Channel.CHL_S2C);
}
}
// TODO shop map specific?
// Level props are just models, we need button-object minions to allow the client to interact with it
if (peerInfo != null && peerInfo.Team == TeamId.TEAM_BLUE)
{
// Shop (blue team)
var ms1 = new MinionSpawn2(0xff10c6db);
_game.PacketHandlerManager.sendPacket(peer, ms1, Channel.CHL_S2C);
var sh1 = new SetHealth(0xff10c6db);
_game.PacketHandlerManager.sendPacket(peer, sh1, Channel.CHL_S2C);
}
else if (peerInfo != null && peerInfo.Team == TeamId.TEAM_PURPLE)
{
// Shop (purple team)
var ms1 = new MinionSpawn2(0xffa6170e);
_game.PacketHandlerManager.sendPacket(peer, ms1, Channel.CHL_S2C);
var sh1 = new SetHealth(0xffa6170e);
_game.PacketHandlerManager.sendPacket(peer, sh1, Channel.CHL_S2C);
}
var end = new StatePacket(PacketCmdS2C.PKT_S2C_EndSpawn);
return(_game.PacketHandlerManager.sendPacket(peer, end, Channel.CHL_S2C));
}
public unsafe bool HandlePacket(ENetPeer *peer, byte[] data, Game game)
{
var start = new StatePacket2(PacketCmdS2C.PKT_S2C_StartSpawn);
bool p1 = PacketHandlerManager.getInstace().sendPacket(peer, start, Channel.CHL_S2C);
Logger.LogCoreInfo("Spawning map");
int playerId = 0;
ClientInfo playerInfo = null;
foreach (var p in game.getPlayers())
{
if (p.Item2.getPeer() == peer)
{
playerInfo = p.Item2;
}
var spawn = new HeroSpawn(p.Item2, playerId++);
PacketHandlerManager.getInstace().sendPacket(peer, spawn, Channel.CHL_S2C);
var info = new PlayerInfo(p.Item2);
PacketHandlerManager.getInstace().sendPacket(peer, info, Channel.CHL_S2C);
p.Item2.getChampion().getStats().setSummonerSpellEnabled(0, true);
p.Item2.getChampion().getStats().setSummonerSpellEnabled(1, true);
// TODO: Recall slot
}
var objects = game.getMap().getObjects();
foreach (var kv in objects)
{
var t = kv.Value as Turret;
if (t != null)
{
var turretSpawn = new TurretSpawn(t);
PacketHandlerManager.getInstace().sendPacket(peer, turretSpawn, Channel.CHL_S2C);
// To suppress game HP-related errors for enemy turrets out of vision
var sh = new SetHealth(t);
PacketHandlerManager.getInstace().sendPacket(peer, sh, Channel.CHL_S2C);
continue;
}
var lp = kv.Value as LevelProp;
if (lp != null)
{
var lpsPacket = new SpawnParticle.LevelPropSpawn(lp);
PacketHandlerManager.getInstace().sendPacket(peer, lpsPacket, Channel.CHL_S2C);
}
}
// Level props are just models, we need button-object minions to allow the client to interact with it
//if (playerInfo != null && playerInfo.getTeam() == TeamId.TEAM_BLUE)
{
// Shop (blue team)
var ms1 = new MinionSpawn2(0xff10c6db);
PacketHandlerManager.getInstace().sendPacket(peer, ms1, Channel.CHL_S2C);
var sh1 = new SetHealth2(0xff10c6db);
PacketHandlerManager.getInstace().sendPacket(peer, sh1, Channel.CHL_S2C);
// Vision for hardcoded objects
// Top inhib
var ms2 = new MinionSpawn2(0xffd23c3e);
PacketHandlerManager.getInstace().sendPacket(peer, ms2, Channel.CHL_S2C);
var sh2 = new SetHealth2(0xffd23c3e);
PacketHandlerManager.getInstace().sendPacket(peer, sh2, Channel.CHL_S2C);
// Mid inhib
var ms3 = new MinionSpawn2(0xff4a20f1);
PacketHandlerManager.getInstace().sendPacket(peer, ms3, Channel.CHL_S2C);
var sh3 = new SetHealth2(0xff4a20f1);
PacketHandlerManager.getInstace().sendPacket(peer, sh3, Channel.CHL_S2C);
// Bottom inhib
var ms4 = new MinionSpawn2(0xff9303e1);
PacketHandlerManager.getInstace().sendPacket(peer, ms4, Channel.CHL_S2C);
var sh4 = new SetHealth2(0xff9303e1);
PacketHandlerManager.getInstace().sendPacket(peer, sh4, Channel.CHL_S2C);
// Nexus
var ms5 = new MinionSpawn2(0xfff97db5);
PacketHandlerManager.getInstace().sendPacket(peer, ms5, Channel.CHL_S2C);
var sh5 = new SetHealth2(0xfff97db5);
PacketHandlerManager.getInstace().sendPacket(peer, sh5, Channel.CHL_S2C);
}
// else if (playerInfo != null && playerInfo.getTeam() == TeamId.TEAM_PURPLE)
{
// Shop (purple team)
var ms1 = new MinionSpawn2(0xffa6170e);
PacketHandlerManager.getInstace().sendPacket(peer, ms1, Channel.CHL_S2C);
var sh1 = new SetHealth2(0xffa6170e);
PacketHandlerManager.getInstace().sendPacket(peer, sh1, Channel.CHL_S2C);
// Vision for hardcoded objects
// Top inhib
var ms2 = new MinionSpawn2(0xff6793d0);
PacketHandlerManager.getInstace().sendPacket(peer, ms2, Channel.CHL_S2C);
var sh2 = new SetHealth2(0xff6793d0);
PacketHandlerManager.getInstace().sendPacket(peer, sh2, Channel.CHL_S2C);
// Mid inhib
var ms3 = new MinionSpawn2(0xffff8f1f);
PacketHandlerManager.getInstace().sendPacket(peer, ms3, Channel.CHL_S2C);
var sh3 = new SetHealth2(0xffff8f1f);
PacketHandlerManager.getInstace().sendPacket(peer, sh3, Channel.CHL_S2C);
// Bottom inhib
var ms4 = new MinionSpawn2(0xff26ac0f);
PacketHandlerManager.getInstace().sendPacket(peer, ms4, Channel.CHL_S2C);
var sh4 = new SetHealth2(0xff26ac0f);
PacketHandlerManager.getInstace().sendPacket(peer, sh4, Channel.CHL_S2C);
// Nexus
var ms5 = new MinionSpawn2(0xfff02c0f);
PacketHandlerManager.getInstace().sendPacket(peer, ms5, Channel.CHL_S2C);
var sh5 = new SetHealth2(0xfff02c0f);
PacketHandlerManager.getInstace().sendPacket(peer, sh5, Channel.CHL_S2C);
}
var end = new StatePacket(PacketCmdS2C.PKT_S2C_EndSpawn);
bool p2 = PacketHandlerManager.getInstace().sendPacket(peer, end, Channel.CHL_S2C);
return(p1 && p2);
}
public bool HandlePacket(Peer peer, byte[] data)
{
var peerInfo = _playerManager.GetPeerInfo(peer);
if (!peerInfo.IsDisconnected)
{
_game.IncrementReadyPlayers();
}
/* if (_game.IsRunning)
* return true; */
if (_game.PlayersReady == _playerManager.GetPlayers().Count)
{
var start = new StatePacket(PacketCmd.PKT_S2C_StartGame);
_game.PacketHandlerManager.broadcastPacket(start, Channel.CHL_S2C);
foreach (var player in _playerManager.GetPlayers())
{
if (player.Item2.Peer == peer && !player.Item2.IsMatchingVersion)
{
var dm = new DebugMessage("Your client version does not match the server. Check the server log for more information.");
_game.PacketHandlerManager.sendPacket(peer, dm, Channel.CHL_S2C);
}
_game.PacketNotifier.NotifySetHealth(player.Item2.Champion);
_game.PacketNotifier.NotifyUpdatedStats(player.Item2.Champion, false);
}
_game.Start();
}
if (_game.IsRunning)
{
var map = _game.Map;
if (peerInfo.IsDisconnected)
{
foreach (var player in _playerManager.GetPlayers())
{
if (player.Item2.Team == peerInfo.Team)
{
var heroSpawnPacket = new HeroSpawn2(player.Item2.Champion);
_game.PacketHandlerManager.sendPacket(peer, heroSpawnPacket, Channel.CHL_S2C);
/* This is probably not the best way
* of updating a champion's level, but it works */
var levelUpPacket = new LevelUp(player.Item2.Champion);
_game.PacketHandlerManager.sendPacket(peer, levelUpPacket, Channel.CHL_S2C);
if (_game.IsPaused)
{
var pausePacket = new PauseGame((int)_game.PauseTimeLeft, true);
_game.PacketHandlerManager.sendPacket(peer, pausePacket, Channel.CHL_S2C);
}
}
}
peerInfo.IsDisconnected = false;
_game.PacketNotifier.NotifyUnitAnnounceEvent(UnitAnnounces.SummonerReconnected, peerInfo.Champion);
// Send the initial game time sync packets, then let the map send another
float gameTime = map.GameTime / 1000.0f;
var timer = new GameTimer(gameTime); // 0xC1
_game.PacketHandlerManager.sendPacket(peer, timer, Channel.CHL_S2C);
var timer2 = new GameTimerUpdate(gameTime); // 0xC2
_game.PacketHandlerManager.sendPacket(peer, timer2, Channel.CHL_S2C);
return(true);
}
foreach (var p in _playerManager.GetPlayers())
{
map.AddObject(p.Item2.Champion);
// Send the initial game time sync packets, then let the map send another
float gameTime = map.GameTime / 1000.0f;
var timer = new GameTimer(gameTime); // 0xC1
_game.PacketHandlerManager.sendPacket(p.Item2.Peer, timer, Channel.CHL_S2C);
var timer2 = new GameTimerUpdate(gameTime); // 0xC2
_game.PacketHandlerManager.sendPacket(p.Item2.Peer, timer2, Channel.CHL_S2C);
}
}
return(true);
}
