private static bool CanCast(GamePacket p)
{
var slot = (SpellSlot) p.ReadByte(6);
SpellState state;
if (slot == SpellSlot.Summoner1 || slot == SpellSlot.Summoner2)
{
state = ObjectManager.Player.Spellbook.CanUseSpell(slot);
}
else
{
state = ObjectManager.Player.Spellbook.CanUseSpell(slot);
}
return state == SpellState.Ready;
}
private static void Game_OnSendPacket(GamePacketEventArgs args)
{
if (_firstHeader == -1)
{
_firstHeader = args.GamePacket.Header.OpCode;
return;
}
if (_firstHeader != args.GamePacket.Header.OpCode && _toasterHeader == -1)
{
_toasterGamePacket = args.GamePacket;
_toasterHeader = args.GamePacket.Header.OpCode;
if (!_keyPressed)
{
args.Process = false;
}
return;
}
}
private static void OnGameProcessPacket(GamePacketEventArgs args)
{ //28 16 176 ??184
if (args.PacketData[0] == 41) //135no 100no 183no 34no 101 133 56yesss? 127 41yess
{
GamePacket gp = new GamePacket(args.PacketData);
//Console.WriteLine(Encoding.UTF8.GetString(args.PacketData, 0, args.PacketData.Length));
gp.Position = 1;
if (gp.ReadInteger() == Yasuo.Player.NetworkId /*&& Encoding.UTF8.GetString(args.PacketData, 0, args.PacketData.Length).Contains("Spell3")*/)
{
Console.WriteLine("----");
Yasuo.lastDash.to = Yasuo.Player.Position;
Yasuo.isDashigPro = false;
Yasuo.time = Game.Time - Yasuo.startDash;
}
/* for (int i = 1; i < gp.Size() - 4; i++)
* {
* gp.Position = i;
* if (gp.ReadInteger() == Yasuo.Player.NetworkId)
* {
* Console.WriteLine("Found: "+i);
* }
* }
*
* Console.WriteLine("End dash");
* Yasuo.Q.Cast(Yasuo.Player.Position);*/
}
/*if (args.PacketData[0] == 176) //135no 100no 183no 34no 101 133 56yesss? 127 41yess
* {
* GamePacket gp = new GamePacket(args.PacketData);
* //Console.WriteLine(Encoding.UTF8.GetString(args.PacketData, 0, args.PacketData.Length));
* gp.Position = 1;
* if (gp.ReadInteger() == Yasuo.Player.NetworkId)
* {
* Console.WriteLine("--- DAhs started Packets---");
* Yasuo.lastDash.from = Yasuo.Player.Position;
* Yasuo.isDashigPro = true;
* Yasuo.castFrom = Yasuo.Player.Position;
* Yasuo.startDash = Game.Time;
* }
* }*/
}
private static void ChangeSize(Int32 netId, Single size)
{
Obj_AI_Hero hero = ObjectManager.GetUnitByNetworkId <Obj_AI_Hero>(netId);
if (hero != null)
{
GamePacket p = new GamePacket(0xC4);
p.WriteInteger(0);
p.WriteInteger(SequenceId++);
p.WriteByte(0x1);
p.WriteByte(0x8);
p.WriteInteger(netId);
p.WriteInteger(0x800);
p.WriteByte(0x8);
p.WriteFloat(size);
p.Process();
SequenceId++;
}
}
public VoicePacketInfo Receive(GamePacket buffer)
{
//Debug.Log("Data packet received");
GamePacket received = packets.Dequeue();
VoicePacketInfo info = new VoicePacketInfo();
info.NetId = received.ReadULong(0);
info.Frequency = received.ReadUShort();
info.Channels = received.ReadByte();
info.Format = (AudioDataTypeFlag)received.ReadByte();
info.ValidPacketInfo = true;
buffer.WriteByteData(received, FirstPacketByteAvailable, 0, Mathf.Min(received.MaxCapacity, buffer.MaxCapacity));
received.DisposePacket();
return(info);
}
public void GamePacketReceiver_WithSession()
{
_correlation = Guid.NewGuid().ToString();
var factory = new ServiceBusMessagingFactory(_backboneConfiguration);
var receiver = new TestGamePacketReceiver(_configuration, factory);
receiver.OnGamePacketCompleted += Receiver_OnGamePacketCompleted;
receiver.OnListenerError += Receiver_OnListenerError;
Task.WaitAll(receiver.StartListening("GameEventsWithSession", "ASession"));
var client = factory.GetQueueClientByName("GameEventsWithSession", true).Result;
for (var msg = 0; msg < 10; msg++)
{
var packet = new GamePacket {
GameEvent = new GameEvent(), EventId = 100
};
var content = Encoding.Default.GetBytes(DatacontractSerializerHelper.Serialize(packet));
var message = new Message
{
CorrelationId = _correlation,
SessionId = msg % 2 == 1 ? "ASession" : "Different",
Body = content
};
client.SendAsync(message);
}
var sw = new Stopwatch();
sw.Start();
while (sw.ElapsedMilliseconds < 50000 &&
(_errors != 0 || _success != 5))
{
Thread.Sleep(50);
}
sw.Stop();
Assert.AreEqual(0, _errors);
Assert.AreEqual(5, _success);
}
private static void PacketHandler(GamePacketEventArgs args)
{
var Packetc = new GamePacket(args.PacketData);
if (Packetc.Header == Packet.C2S.Cast.Header)
{
var decodedpacket = Packet.C2S.Cast.Decoded(args.PacketData);
LatestCast.Timepass = Environment.TickCount - LatestCast.Tick;
LatestCast.Distance = Math.Sqrt(Math.Pow(decodedpacket.ToX - LatestCast.X, 2) + Math.Pow(decodedpacket.ToY - LatestCast.Y, 2));
LatestCast.Delay = (LatestCast.Distance * 0.01 * Config.Item("delaytime").GetValue <Slider>().Value + Config.Item("delaytimecasts").GetValue <Slider>().Value);
if (Environment.TickCount < LatestCast.Tick + LatestCast.Delay)
{
args.Process = false;
}
if (args.Process == true)
{
LatestCast.Tick = Environment.TickCount;
LatestCast.X = decodedpacket.ToX;
LatestCast.Y = decodedpacket.ToY;
}
}
else if (Packetc.Header == Packet.C2S.Move.Header)
{
//Console.WriteLine("Last movement : " + lastmovement.ToString() + "\n DelayTime : " + (Config.Item("delaytimem").GetValue<Slider>().Value * 25).ToString() + "\n Tick : " + Environment.TickCount.ToString());
var decodedpacket = Packet.C2S.Move.Decoded(args.PacketData);
if (decodedpacket.MoveType != 2)
{
return;
}
if (lastmovement + Config.Item("delaytimem").GetValue <Slider>().Value * 5 > Environment.TickCount)
{
args.Process = false;
Console.WriteLine("delayed");
}
else
{
args.Process = true;
lastmovement = Environment.TickCount;
}
}
}
private void Control_PacketAvailable(GamePacket packet)
{
var msgID = packet.Read <Enums.ControlPacketType>();
Program.Logger.Verbose("--> {0}: MsgID = {1} ({2})", ChannelType.Control, msgID, ((byte)msgID));
switch (msgID)
{
case Enums.ControlPacketType.CloseConnection:
var ccPkt = packet.Read <Packets.Control.CloseConnection>();
// TODO: Cleanly dispose of client
break;
case Enums.ControlPacketType.MatrixAck:
var mAckPkt = packet.Read <Packets.Control.MatrixAck>();
Program.Logger.Verbose("--> {0} Ack for {1} on {2}.", ChannelType.Control, Utils.SimpleFixEndianess(mAckPkt.AckFor), ChannelType.Matrix);
// TODO: Track reliable packets
break;
case Enums.ControlPacketType.ReliableGSSAck:
var gssAckPkt = packet.Read <Packets.Control.ReliableGSSAck>();
Program.Logger.Verbose("--> {0} Ack for {1} on {2}.", ChannelType.Control, Utils.SimpleFixEndianess(gssAckPkt.AckFor), ChannelType.ReliableGss);
// TODO: Track reliable packets
break;
case Enums.ControlPacketType.TimeSyncRequest:
var req = packet.Read <Packets.Control.TimeSyncRequest>();
_ = NetChans[ChannelType.Control].SendClass(new Packets.Control.TimeSyncResponse(req.ClientTime, unchecked (AssignedShard.CurrentTimeLong * 1000)));
break;
case Enums.ControlPacketType.MTUProbe:
var mtuPkt = packet.Read <Packets.Control.MTUProbe>();
// TODO: ???
break;
default:
Program.Logger.Error("---> Unrecognized Control Packet {0} ({1:X2})!!!", msgID, ((byte)msgID));
Program.Logger.Warning("> {0}", BitConverter.ToString(packet.PacketData.ToArray()).Replace("-", " "));
break;
}
}
public virtual void HandlePacket(int code, GamePacket packet)
{
if (packet == null)
{
log.Error("Packet is null!");
return;
}
IPacketHandler handler = null;
if (m_packagesHandlers.ContainsKey(code))
{
handler = m_packagesHandlers[code];
}
else
{
log.ErrorFormat("Receive package's code is not exists! Code: {0}", code);
log.Error(Marshal.ToHexDump(string.Format("Code: {0}", code), packet.Buffer, 0, packet.Length));
return;
}
long timeUsed = Environment.TickCount;
try
{
handler.HandlePacket(m_client, packet);
}
catch (Exception ex)
{
log.ErrorFormat("Error while processing package (handler={0})", handler.GetType().FullName);
log.Error("Handle package error!", ex);
}
timeUsed = Environment.TickCount - timeUsed;
log.InfoFormat("Package process time: {0}ms", timeUsed);
if (timeUsed > 1000)
{
log.WarnFormat("Handle package thread {0} {1} took {2}ms!", System.Threading.Thread.CurrentThread.ManagedThreadId, handler, timeUsed);
}
}
public int HandlePacket(ServerConnector connector, GamePacket packet)
{
int id = packet.ReadInt();
if (GatewayGlobal.BattleServerMgr.Contains(id) ||
GatewayGlobal.ConnectingMgr.Contains(id))
{
return(0);
}
string ip = packet.ReadUTF();
int port = packet.ReadInt();
BattleServerConnector conn = new BattleServerConnector(id);
conn.Connect(ip, port);
return(0);
}
public int HandlePacket(ClientBase client, GamePacket packet)
{
int clientID = packet.ReadInt();
LoginInfo info = new LoginInfo();
info.PlayerID = packet.PlayerID;
GamePlayer player = new GamePlayer(info, client as GameClient);
player.ClientID = clientID;
player.Logined();
GameGlobal.PlayerMgr.Add(player.PlayerID, player);
GameGlobal.CheckMaxClientCount();
return(0);
}
private static void Game_OnGameProcessPacket(GamePacketEventArgs args)
{
if (args.PacketData[0] != 0x34 || new GamePacket(args).ReadInteger(1) != ObjectManager.Player.NetworkId ||
(args.PacketData[5] != 0x11 && args.PacketData[5] != 0x91))
{
return;
}
var networkId = new GamePacket(args).ReadInteger(1);
if (ActiveAttacks.ContainsKey(networkId))
{
ActiveAttacks.Remove(networkId);
}
if (ActiveAttacksTower.ContainsKey(networkId))
{
ActiveAttacksTower.Remove(networkId);
}
}
private void OnRemove()
{
GamePacket packet = new GamePacket(OperationType.DELETE_FLEET, ChosenDeck.GetFleet());
Game1.self.Connection.Send(packet);
GamePacket packetReceived = Game1.self.Connection.GetReceivedPacket();
if (packetReceived.OperationType == OperationType.SUCCESS)
{
Decks.Remove(ChosenDeck);
Clickable.Remove(ChosenDeck);
RefreshRightGrid();
ClearTopGrid();
ShipsInTop.Clear();
ClearBotGrid();
ShipsInBot.Clear();
FillBotShips(ships);
FillBotGrid();
}
}
public void Process(ZeroGPacket packet, NetPeer peer)
{
GamePacket origPacket = PacketGenerator.Decompile(packet);
if (packet.PacketType == "LoadingComplete" && (origPacket.GetType() == typeof(LoadingComplete)))
{
LoadingComplete newPacket = (LoadingComplete)origPacket;
// Console.WriteLine("Player " + newPacket.userName + " has set loading complete status to " + newPacket.isComplete);
LoadingCompleteProcessor.Process(newPacket);
}
else if (packet.PacketType == "ClientInfo" && (origPacket.GetType() == typeof(ClientInfo)))
{
ClientInfo newPacket = (ClientInfo)origPacket;
ClientInfoProcessor.Process(newPacket, peer.Id);
}
else if (packet.PacketType == "PlayerPosition" && (origPacket.GetType() == typeof(PlayerPosition)))
{
PlayerPositionProcessor.Process(packet, peer);
}
}
public static void InvenUseSpendShout_Req(InPacket lea, Client gc)
{
byte Slot = lea.ReadByte();
string Message = lea.ReadString(60);
lea.ReadInt();
lea.ReadByte();
lea.ReadByte();
var chr = gc.Character;
if (Slot >= 0 && Slot < 24 && Message.Length <= 60)
{
gc.Character.Items.Remove((byte)InventoryType.ItemType.Spend3, Slot, 1);
foreach (Character All in MapFactory.AllCharacters)
{
GamePacket.InvenUseSpendShout(All.Client, chr, Message);
}
InventoryPacket.getInvenSpend3(gc);
}
}
public static void Send2Center(GamePacket pkg, ClientBase client)
{
if (CenterServer.Socket.Connected)
{
CenterServer.SendTCP(pkg);
}
else
{
//TODO: 通知客户端无可用中心服务器
if (client != null)
{
ClientMsgPacket p = new ClientMsgPacket();
p.MsgFlag = MsgFlag.NoneCenter;
client.SendTcp(p);
}
}
}
public static ZeroGPacket Generate(string PacketType, GamePacket packet)
{
byte[] byteArray;
if (packet == null || PacketType == null)
{
return(null);
}
var bf = new BinaryFormatter();
using (var ms = new MemoryStream())
{
bf.Serialize(ms, packet);
byteArray = ms.ToArray();
}
ZeroGPacket newPacket = new ZeroGPacket();
newPacket.PacketType = PacketType;
newPacket.InnerData = byteArray;
return(newPacket);
}
public virtual void Send(SocketStateObject state, PacketIdentifier packetId, GamePacket packet)
{
switch (packetId.PacketType)
{
case PacketType.ServerPacket:
case PacketType.ClientPacket:
Send(state, packetId.PacketId, packet.Serialize(new DataStream {
IsLittleEndian = false
}));
return;
case PacketType.ServerContainer:
Send(state, new ServerContainerS00(new[] { new PacketEventArgs(packetId, packet) }));
return;
case PacketType.ClientContainer:
Send(state, new ClientContainerC22(packetId.PacketId, packet));
return;
}
}
public int HandlePacket(ServerConnector connector, GamePacket packet)
{
bool logined = packet.ReadBoolean();
uint clientID = packet.ReadUnsignedInt();
if (logined)
{
//TODO: 记录PlayerID与ClientID的对应关系
//TODO: 转发结果到逻辑服务器
}
else
{
LoginFailedPacket pkg = new LoginFailedPacket();
GatewayGlobal.PlayerClientMgr[clientID].SendTcp(pkg);
}
return(0);
}
public int HandlePacket(ServerConnector connector, GamePacket packet)
{
int clientID = packet.ReadInt();
GatewayClient client = GatewayGlobal.Clients[clientID];
LoginInfo info = new LoginInfo();
info.PlayerID = packet.PlayerID;
GatewayPlayer player = new GatewayPlayer(info, client);
GatewayGlobal.Players.Add(packet.PlayerID, player);
packet.Code2 = (int)BasePacketCode.None_Code;
player.Client.LogicServer.SendTCP(packet);
return(0);
}
private static void Main(string[] args)
{
CustomEvents.Game.OnGameLoad += eventArgs => Game.PrintChat("<font color='#15C3AC'>ProFlash:</font> <font color='#FFFFFF'>by h3h3 loaded.</font>");
Game.OnGameSendPacket += p =>
{
if (Packet.C2S.Cast.Header != p.PacketData[0])
{
return;
}
var packet = new GamePacket(p.PacketData);
var summoner = SummonerByte.Contains(packet.ReadByte(5));
var slot = (SpellSlot)packet.ReadByte();
var flash = ObjectManager.Player.SummonerSpellbook.Spells.SingleOrDefault(s => s.Name == "summonerflash");
if (flash != null)
{
var flashSlot = flash.Slot;
var flashPacket = Packet.C2S.Cast.Decoded(p.PacketData);
if (summoner && slot == flashSlot && flashPacket.SourceNetworkId == ObjectManager.Player.NetworkId)
{
var to = new Vector2(flashPacket.ToX, flashPacket.ToY);
if (ObjectManager.Player.ServerPosition.To2D().Distance(to) < 390)
{
p.Process = false;
var maxRange = ObjectManager.Player.ServerPosition.To2D().Extend(to, 400);
flashPacket.FromX = maxRange.X;
flashPacket.FromY = maxRange.Y;
flashPacket.ToX = maxRange.X;
flashPacket.ToY = maxRange.Y;
Game.PrintChat("- ProFlash -");
Packet.C2S.Cast.Encoded(flashPacket).Send(p.Channel, p.ProtocolFlag);
}
}
}
};
}
public static void OnGameProcessPacket(GamePacketEventArgs args)
{
return;
if (Config.Item("comboWreset").GetValue <bool>() && args.PacketData[0] == 0x65 && MasterYi.W.IsReady() && LXOrbwalker.CurrentMode == LXOrbwalker.Mode.Combo)
{
// LogPacket(args);
GamePacket gp = new GamePacket(args.PacketData);
gp.Position = 1;
Packet.S2C.Damage.Struct dmg = Packet.S2C.Damage.Decoded(args.PacketData);
int targetID = gp.ReadInteger();
int dType = (int)gp.ReadByte();
int Unknown = gp.ReadShort();
float DamageAmount = gp.ReadFloat();
int TargetNetworkIdCopy = gp.ReadInteger();
int SourceNetworkId = gp.ReadInteger();
float dmga =
(float)
MasterYi.player.GetAutoAttackDamage(
ObjectManager.GetUnitByNetworkId <Obj_AI_Base>(targetID));
if (dmga - 10 > DamageAmount || dmga + 10 < DamageAmount)
{
return;
}
if (MasterYi.player.NetworkId != dmg.SourceNetworkId && MasterYi.player.NetworkId == targetID)
{
return;
}
Obj_AI_Base targ = ObjectManager.GetUnitByNetworkId <Obj_AI_Base>(dmg.TargetNetworkId);
if ((int)dmg.Type == 12 || (int)dmg.Type == 4 || (int)dmg.Type == 3)
{
if (MasterYi.W.IsReady() && LXOrbwalker.InAutoAttackRange(targ))
{
MasterYi.W.Cast(targ.Position);
// LXOrbwalker.ResetAutoAttackTimer();
}
}
// Console.WriteLine("dtyoe: " + dType);
}
}
public void send()
{
packet = new GamePacket(request_id);
//Add the damage dealt
packet.addShort16((short)damage);
//Add the number of particles
packet.addShort16((short)numParticles);
for (int i = 0; i < numParticles; i++)
{
//Add all of the positions
packet.addFloat32(particlesPositions[i].x);
packet.addFloat32(particlesPositions[i].y);
packet.addFloat32(particlesPositions[i].z);
//Add all of the angles
packet.addFloat32(particleAngles[i].x);
packet.addFloat32(particleAngles[i].y);
packet.addFloat32(particleAngles[i].z);
}
}
void Awake()
{
self = SteamUser.GetSteamID();
Callback <P2PSessionRequest_t> .Create((cb) =>
{
if (others.ContainsKey(cb.m_steamIDRemote.m_SteamID))
{
SteamNetworking.AcceptP2PSessionWithUser(cb.m_steamIDRemote);
}
});
temp1024 = GamePacket.CreatePacket(1024);
temp768 = GamePacket.CreatePacket(768);
temp512 = GamePacket.CreatePacket(512);
temp256 = GamePacket.CreatePacket(256);
SteamCallbackReceiver.Init();
SteamCallbackReceiver.ChatUpdateEvent += OnLobbyChatUpdate;
SteamCallbackReceiver.LobbyEnterEvent += OnLobbyEnter;
}
private void Game_OnGameUpdate(EventArgs args)
{
if (!IsActive() || !Menu.AutoLatern.GetMenuItem("SAwarenessAutoLaternKey").GetValue <KeyBind>().Active)
{
return;
}
foreach (GameObject gObject in ObjectManager.Get <GameObject>())
{
if (gObject.Name.Contains("ThreshLantern") && gObject.IsAlly &&
gObject.Position.Distance(ObjectManager.Player.ServerPosition) < 400 &&
!ObjectManager.Player.ChampionName.Contains("Thresh"))
{
GamePacket gPacket =
Packet.C2S.InteractObject.Encoded(
new Packet.C2S.InteractObject.Struct(ObjectManager.Player.NetworkId,
gObject.NetworkId));
gPacket.Send();
}
}
}
private void XO_Exit()
{
if (XO_PlayerNumber == 1)
{
XO_Player1Button.Text = "O - [Empty]";
XO_Player1Button.Enabled = true;
XO_PlayerNumber = 0;
GamePacket gamePacket = new GamePacket("P1Q");
Send(gamePacket);
}
else if (XO_PlayerNumber == 2)
{
XO_Player2Button.Text = "X - [Empty]";
XO_Player2Button.Enabled = true;
XO_PlayerNumber = 0;
GamePacket gamePacket = new GamePacket("P2Q");
Send(gamePacket);
}
}
public static GamePacket Encoded(Struct packetStruct)
{
var gamePacket = new GamePacket(Header);
gamePacket.WriteInteger(packetStruct.SourceNetworkId);
gamePacket.WriteByte(packetStruct.SourceNetworkIdP1);
gamePacket.WriteByte(packetStruct.SourceNetworkIdP2);
gamePacket.WriteByte(packetStruct.SourceNetworkIdP3);
gamePacket.WriteByte(packetStruct.SourceNetworkIdP4);
gamePacket.WriteByte(packetStruct.Unknown);
gamePacket.WriteInteger(packetStruct.SkinId); //SKIN ID
foreach (byte b in packetStruct.Unknown2)
{
gamePacket.WriteByte(b);
}
foreach (byte b in packetStruct.Unknown3)
{
gamePacket.WriteByte(b);
}
return(gamePacket);
}
private void OnGamePacketReceived(GamePacket obj)
{
Debug.Log($"Game Command: {obj.GameCommand} Received");
switch (obj.GameCommand)
{
case GameCommand.SEND_HIT:
_runtimeManager.CheckEnemysHit(obj);
break;
case GameCommand.ATTACK_RECEIVE_HIT_RESULT:
_runtimeManager.HandleReceivedHit(obj);
break;
case GameCommand.PLAYER_READY_TO_PLAY:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static void OnGameProcessPacket(GamePacketEventArgs args)
{
try
{
if (Talon.orbwalker.ActiveMode.ToString() == "Combo" || Config.Item("harHard").GetValue <KeyBind>().Active)
{
if (args.PacketData[0] == 101 && Talon.Q.IsReady())
{
Packet.S2C.Damage.Struct dmg = Packet.S2C.Damage.Decoded(args.PacketData);
// LogPacket(args);
GamePacket gp = new GamePacket(args.PacketData);
gp.Position = 1;
int targetID = gp.ReadInteger();
int dType = (int)gp.ReadByte();
int Unknown = gp.ReadShort();
float DamageAmount = gp.ReadFloat();
int TargetNetworkIdCopy = gp.ReadInteger();
int SourceNetworkId = gp.ReadInteger();
if (Talon.Player.NetworkId != dmg.SourceNetworkId)
{
return;
}
Obj_AI_Hero targ = ObjectManager.GetUnitByNetworkId <Obj_AI_Hero>(targetID);
if (targ != null)
{
Talon.sumItems.cast(SummonerItems.ItemIds.Ghostblade);
Talon.Q.Cast();
useQ = true;
Orbwalking.ResetAutoAttackTimer();
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
private void GamePacketReceived(GamePacket arg1, NetPeer peer)
{
switch (arg1.GameCommand)
{
case GameCommand.SEND_HIT:
_roomsController.CheckPlayerHit(arg1);
_roomsController.SetPlayerTurn(_roomsController.Rooms.Find(x => x.RoomId == arg1.RoomId));
break;
case GameCommand.ATTACK_RECEIVE_HIT_RESULT:
_roomsController.SendHitResultToPlayers(arg1);
break;
case GameCommand.PLAYER_READY_TO_PLAY:
Log.Information("PlayerReadyToPlay");
_roomsController.SetPlayerReadyGameState(arg1);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
void Send(byte[] data, PacketType command, CSteamID sender, CSteamID receiver, EP2PSend sendType)
{
GamePacket toSend = GamePacket.CreatePacket(data.Length + HeaderLength);
//prepare packet to send data by setting seek and lenght to 0
toSend.ResetSeekLength();
toSend.Write((byte)command);
toSend.Write((ulong)sender);
toSend.WriteByteData(data, 0, data.Length);
if (MyID != receiver)
{
SteamNetworking.SendP2PPacket(receiver, toSend.Data, (uint)toSend.CurrentLength, sendType);
}
else
{
InvokeCommand((int)command, data, (uint)data.Length, sender);
}
toSend.DisposePacket();
}
/// <summary>
/// 消息分发
/// </summary>
/// <param name="packet"></param>
private void OnPacketDistributeEvt(GamePacket packet)
{
//校验crc
//headcrc和datacrc都需要校验 TODO
//这里对datacrc校验一下
byte[] data = packet.data;
mCrc.Crc(data);
uint dataCrc = (uint)mCrc.Value;
if (packet.header.dataCrc32 == dataCrc)
{
ByteBuffer buffer = new ByteBuffer();
buffer.WriteBytes(packet.data);
KeyValuePair <int, ByteBuffer> _event = new KeyValuePair <int, ByteBuffer>(packet.header.header, buffer);
//facade.SendMessageCommand(NotiConst.DISPATCH_MESSAGE, _event);
}
else
{
Debug.LogError("发送方，接收方 的数据不一致");
//抛弃还是重新请求？TODO
}
}
public RequestHighScore()
{
packet = new GamePacket(request_id = Constants.CMSG_HIGH_SCORE);
}
public RequestLogin()
{
packet = new GamePacket(request_id = Constants.CMSG_AUTH);
}
public RequestUpdateCurTut()
{
packet = new GamePacket(request_id = Constants.CMSG_TUTORIAL_UPDATE_CUR_TUT);
}
public RequestRegister()
{
packet = new GamePacket(request_id = Constants.CMSG_REGISTER);
}
public static bool Check(GamePacket p)
{
return !Enabled || CanCast(p);
}
public RequestShopAction()
{
packet = new GamePacket(request_id = Constants.CMSG_SHOP_ACTION);
}
public RequestTutorial()
{
packet = new GamePacket(request_id = Constants.CMSG_TUTORIAL_DATA);
}
public RequestSpeciesList()
{
packet = new GamePacket(request_id = Constants.CMSG_SPECIES_LIST);
}
public RequestPrediction()
{
packet = new GamePacket(request_id = Constants.CMSG_PREDICTION);
}
public RequestErrorLog()
{
packet = new GamePacket(request_id = Constants.CMSG_ERROR_LOG);
}
public RequestReady()
{
packet = new GamePacket(request_id = Constants.CMSG_READY);
}
public RequestBadgeList()
{
packet = new GamePacket(request_id = Constants.CMSG_BADGE_LIST);
}
public RequestSpeciesAction()
{
packet = new GamePacket(request_id = Constants.CMSG_SPECIES_ACTION);
}
public RequestWorldMenuAction()
{
packet = new GamePacket(request_id = Constants.CMSG_WORLD_MENU_ACTION);
}
/// <summary>
/// Detects the spells that have missile and are casted from fow.
/// </summary>
public static void GameOnOnGameProcessPacket(GamePacketEventArgs args)
{
//Gets received when a projectile is created.
if (args.PacketData[0] == 0x3B)
{
var packet = new GamePacket(args.PacketData);
packet.SetHeader(new PacketHeader(packet));
packet.Read<float>(); //Missile network ID
var missilePosition = new Vector3(packet.Read<float>(), packet.Read<float>(), packet.Read<float>());
var unitPosition = new Vector3(packet.Read<float>(), packet.Read<float>(), packet.Read<float>());
packet.Position = packet.Data.Length - 119;
var missileSpeed = packet.Read<float>();
packet.Position = 65;
var endPos = new Vector3(packet.Read<float>(), packet.Read<float>(), packet.Read<float>());
packet.Position = 112;
var id = packet.Read<byte>();
packet.Position = packet.Data.Length - 83;
var unit = ObjectManager.GetUnitByNetworkId<AIHeroClient>(packet.Read<uint>());
if ((!unit.IsValid || unit.Team == ObjectManager.Player.Team) && !Config.TestOnAllies)
{
return;
}
var spellData = SpellDatabase.GetBySpeed(unit.ChampionName, (int)missileSpeed, id);
if (spellData == null)
{
return;
}
if (spellData.SpellName != "Laser")
{
return;
}
var castTime = Utils.TickCount - Game.Ping / 2 - spellData.Delay -
(int)
(1000 * missilePosition.SwitchYZ().To2D().Distance(unitPosition.SwitchYZ()) /
spellData.MissileSpeed);
//Trigger the skillshot detection callbacks.
TriggerOnDetectSkillshot(
DetectionType.RecvPacket, spellData, castTime, unitPosition.SwitchYZ().To2D(),
endPos.SwitchYZ().To2D(), unit);
}
}
public RequestChallenge()
{
packet = new GamePacket(request_id = Constants.CMSG_TUTORIAL_CHALLENGE);
}
public static void GameOnOnGameProcessPacket(GamePacketEventArgs args)
{
if (args.PacketData[0] == 0x3B)
{
var packet = new GamePacket(args.PacketData) { Position = 1 };
packet.Read<float>(); //Missile network ID
var missilePosition = new Vector3(packet.Read<float>(), packet.Read<float>(), packet.Read<float>());
var unitPosition = new Vector3(packet.Read<float>(), packet.Read<float>(), packet.Read<float>());
packet.Position = packet.Data.Length - 119;
var missileSpeed = packet.Read<float>();
packet.Position = 65;
var endPos = new Vector3(packet.Read<float>(), packet.Read<float>(), packet.Read<float>());
packet.Position = 112;
var id = packet.Read<byte>();
packet.Position = packet.Data.Length - 83;
var unit = ObjectManager.GetUnitByNetworkId<AIHeroClient>(packet.Read<uint>());
if ((!unit.IsValid || unit.Team == ObjectManager.Player.Team))
{
return;
}
var spellData = SpellDatabase.GetBySpeed(unit.ChampionName, (int) missileSpeed, id);
if (spellData == null)
{
return;
}
if (spellData.SpellName != "Laser")
{
return;
}
var castTime = Environment.TickCount - Game.Ping / 2 - spellData.Delay -
(int)
(1000 * Geometry.SwitchYZ(missilePosition).To2D().Distance(Geometry.SwitchYZ(unitPosition)) /
spellData.MissileSpeed);
TriggerOnDetectSkillshot(
DetectionType.RecvPacket, spellData, castTime, unitPosition.SwitchYZ().To2D(),
endPos.SwitchYZ().To2D(), unit);
}
}
protected virtual void Dispose(bool disposing)
{
if (!isDisposed)
{
isDisposed = true;
this.memReader.Dispose();
this.mStream.Dispose();
Packet = null;
userData = null;
tmpbuf = null;
}
}
public RequestChart()
{
packet = new GamePacket(request_id = Constants.CMSG_CHART);
}
public RequestHeartbeat()
{
packet = new GamePacket(request_id = Constants.CMSG_HEARTBEAT);
}
public RequestGetPlayers()
{
packet = new GamePacket(request_id = Constants.CMSG_GET_PLAYERS);
}
public RequestExitGame()
{
packet = new GamePacket(request_id = Constants.CMSG_SAVE_EXIT_GAME);
}
public RequestAvatarList()
{
packet = new GamePacket(request_id = Constants.CMSG_AVATAR_LIST);
}
public RequestTutorialRemoveSpecies()
{
packet = new GamePacket(request_id = Constants.CMSG_TUTORIAL_REMOVE_SPECIES);
}
public void EnqueuePacket(IPEndPoint endPoint, Int32 timeStamp, GameMessage message, byte[] data)
{
lock (_packets)
{
GamePacket packet = new GamePacket();
packet.EndPoint = endPoint;
packet.TimeStamp = timeStamp;
packet.Message = message;
packet.Data = data;
_packets.Add(packet);
}
_waitEvent.Set();
}
public RequestChallengeShopSpecies()
{
packet = new GamePacket(request_id = Constants.CMSG_TUTORIAL_CHALLENGE_SPECIES);
}
public RequestShop()
{
packet = new GamePacket(request_id = Constants.CMSG_SHOP);
}
public RequestWorldList()
{
packet = new GamePacket(request_id = Constants.CMSG_WORLD_LIST);
}
