public static void AppendFileListToPacket(Client client, TcpPacket packet)
{
string[] files = System.IO.Directory.GetFiles(GetTempFolder(client));
packet.AppendParameter(files.Length.ToString());
for (int i = 0; i < files.Length; i++) {
packet.AppendParameter(System.IO.Path.GetFileNameWithoutExtension(files[i]));
}
}
public static IPv4Packet CreateIpV4Packet(IPAddress sourceIpAddress, IPAddress destinationIpAddress,
TcpPacket payloadPacket)
{
var result = new IPv4Packet(sourceIpAddress, destinationIpAddress) { PayloadPacket = payloadPacket };
payloadPacket.UpdateTCPChecksum();
result.UpdateIPChecksum();
result.UpdateCalculatedValues();
return result;
}
internal bool BufferTCPPacket(TcpPacket pTCPPacket, bool pInbound)
{
if (pTCPPacket.Syn && pTCPPacket.Ack)
{
mInboundSequence = (uint)(pTCPPacket.SequenceNumber + 1);
return true;
}
if (pTCPPacket.PayloadData.Length == 0) return true;
if (_mapleVersion == 0)
{
if (pTCPPacket.PayloadData.Length < 13) return false;
byte[] tcpData = pTCPPacket.PayloadData;
MaplePacket pr = new MaplePacket(tcpData);
pr.ReadShort();
_mapleVersion = pr.ReadUShort();
var pos = pr.Position;
{
var shrt = pr.ReadShort();
if (shrt < 0 || shrt > 0x0020)
{
return false;
}
}
pr.Reset(pos);
_maplePatchLocation = pr.ReadString();
byte[] localIV = pr.ReadBytes(4);
byte[] remoteIV = pr.ReadBytes(4);
_mapleLocale = pr.ReadByte();
if (pr.Length > pr.Position || _mapleLocale > 0x12)
{
return false;
}
pr.Dispose();
pr = null;
mOutboundStream = new PacketStream(localIV, _mapleLocale, _mapleVersion, !pInbound);
mInboundStream = new PacketStream(remoteIV, _mapleLocale, (ushort)(0xFFFF - _mapleVersion), pInbound);
mInboundSequence += (uint)tcpData.Length;
}
if (!pInbound) ProcessTCPPacket(pTCPPacket, ref mOutboundSequence, mOutboundBuffer, mOutboundStream, pInbound);
else ProcessTCPPacket(pTCPPacket, ref mInboundSequence, mInboundBuffer, mInboundStream, pInbound);
return true;
}
public static void AppendActiveTeam(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("activeteam");
Player player = client.Player;
for (int i = 0; i < Constants.MAX_ACTIVETEAM; i++) {
if (client.Player.Team[i].Loaded == true) {
packet.AppendParameters(player.Team[i].Name, player.Team[i].Species.ToString(), player.Team[i].Form.ToString(), ((int)player.Team[i].Shiny).ToString(), ((int)player.Team[i].Sex).ToString(),
player.Team[i].HP.ToString(), player.Team[i].MaxHP.ToString(),
Server.Math.CalculatePercent(player.Team[i].Exp, Exp.ExpManager.Exp[player.Team[i].Level - 1]).ToString(),
player.Team[i].Level.ToString(), ((int)player.Team[i].StatusAilment).ToString(), player.Team[i].HeldItemSlot.ToString());
} else {
packet.AppendParameter("notloaded");
}
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static TcpPacket FromBytes(byte[] data)
{
TcpPacket packet = new TcpPacket();
packet.PacketType = (TcpPacketType)Enum.ToObject(typeof(TcpPacketType), data[0]);
if (data.Length > 1)
{
int position = 1;
while (position < data.Length)
{
int length = BitConverter.ToInt32(data, position);
position += 4;
byte[] d = new byte[length];
Array.Copy(data, position, d, 0, length);
position += length;
packet.Append(d);
}
}
return packet;
}
public override object[] Attack(string[] DDoSWork)
{
object[] obj = new object[2];
string sDestinationAddress = DDoSWork[0];
ushort tcpSourcePort = ushort.Parse(GetOpenPort());
ushort tcpDestinationPort = 53;
TcpPacket tcpPacket = new TcpPacket(tcpSourcePort, tcpDestinationPort);
IPAddress ipSourceAddress = System.Net.IPAddress.Parse(GetRandomIP());
IPAddress ipDestinationAddress = System.Net.IPAddress.Parse(sDestinationAddress);
IPv4Packet ipPacket = new IPv4Packet(ipSourceAddress, ipDestinationAddress);
string sourceHwAddress = "90-90-90-90-90-90";
var ethernetSourceHwAddress = System.Net.NetworkInformation.PhysicalAddress.Parse(sourceHwAddress);
string destionationHwAddress = "80-80-80-80-80-80";
var ethernetDestinationHwAdress = System.Net.NetworkInformation.PhysicalAddress.Parse(destionationHwAddress);
var ethernetPacket = new EthernetPacket(ethernetSourceHwAddress, ethernetDestinationHwAdress, EthernetPacketType.None);
ipPacket.PayloadPacket = tcpPacket;
ethernetPacket.PayloadPacket = ipPacket;
byte[] bPacket = new byte[75];
var devices = CaptureDeviceList.Instance;
int i = 0;
var device = null;
return(obj);
}
public void RESPONSE_LEAVE_ROOM_OTHER_PLAYER(TcpPacket packet)
{
SERVERtoCLIENT_LeaveRoomOtherPlayerPacketData recvData = new SERVERtoCLIENT_LeaveRoomOtherPlayerPacketData();
recvData.Deserialize(packet);
if (GameFramework.Instance.MyPlayer.State == PLAYER_STATE.LOBBY)
{
LobbyManager.Instance.CreateLobbyPlayer(recvData.playerID);
RoomButton roomButton = RoomManager.Instance.GetRoomButton(recvData.roomKey);
if (roomButton != null)
{
roomButton.DecreaseRoomJoinCount();
}
}
else if (GameFramework.Instance.MyPlayer.State == PLAYER_STATE.IN_ROOM)
{
RoomManager.Instance.EnteredRoom.LeaveOtherPlayer(recvData.playerID);
}
}
public Certificate(IpPacket ipPacket, TcpPacket tcpPacket)
{
TimeToLive = 0;
ServerIP = ipPacket.SourceAddress.ToString();
UserIP = ipPacket.DestinationAddress.ToString();
ServerPort = tcpPacket.SourcePort.ToString();
UserPort = tcpPacket.DestinationPort.ToString();
Push_Flag = tcpPacket.Psh;
TotalPayLoadLength = tcpPacket.PayloadData.Length;
TotalPayLoad = null;
Country = new List <string>();
StateOrProvince = new List <string>();
Locality = new List <string>();
Organization = new List <string>();
CommonName = new List <string>();
PacketPayLoads = new List <byte[]>();
PacketPayLoads.Add(tcpPacket.PayloadData);
}
/// <summary>
/// Manages the DataReceived event of the output socket
/// </summary>
/// <param name="p">Received data</param>
private void socketTCPOut_DataReceived(TcpPacket p)
{
if (!outputSocketReceptionEnabled)
{
return;
}
lastReceivedPacket = p;
string stringReceived = p.DataString.Trim();
//Console("Rcv: " + "[" + p.SenderIP.ToString() + "] " + stringReceived);
try
{
OnDataReceived(p);
}
//catch (Exception ex)
//{
// //Console("Exception wile managing ConnectionManager.DataReceived event: [" + ex.ToString() + "]");
//}
catch { }
}
public void BuildEthernetPacket()
{
var tcpPacket = TcpPacket.RandomPacket();
var ipPacket = IPPacket.RandomPacket(IPVersion.IPv4);
var ethernetPacket = EthernetPacket.RandomPacket();
// put these all together into a single packet
ipPacket.PayloadPacket = tcpPacket;
ethernetPacket.PayloadPacket = ipPacket;
Console.WriteLine("random packet: {0}", ethernetPacket);
// and get a byte array that represents the single packet
var bytes = ethernetPacket.Bytes;
// and re-parse that packet
var newPacket = Packet.ParsePacket(LinkLayers.Ethernet,
bytes);
Console.WriteLine("re-parsed random packet: {0}", newPacket);
}
private NetworkEventArgs ExtractNetworkInformation(RawCapture packet)
{
EthernetPacket ethernetPacket = PacketDotNet.Packet.ParsePacket(LinkLayers.Ethernet, packet.Data) as EthernetPacket;
IpPacket ipPacket = ethernetPacket.Extract(typeof(IpPacket)) as IpPacket;
TcpPacket tcpPacket = ethernetPacket.Extract(typeof(TcpPacket)) as TcpPacket;
int sourcePort = 0;
int destPort = 0;
if (tcpPacket != null)
{
sourcePort = tcpPacket.SourcePort;
destPort = tcpPacket.DestinationPort;
}
string rawMessageText = System.Text.Encoding.UTF8.GetString(ethernetPacket.Bytes);
string cleanMessageText = Regex.Replace(rawMessageText, @"[^a-zA-Z0-9`!@#$%^&*()_+|\-=\\{}\[\]:"";'<>?,./]", "");
return(new NetworkEventArgs(ipPacket.DestinationAddress.ToString(), destPort, ipPacket.SourceAddress.ToString(), sourcePort, cleanMessageText, DateTime.Now, id));
}
public byte[] Generate(byte[] rawBytes)
{
int udpStreamId;
if (!int.TryParse(streamIdTextBox.Text, out udpStreamId))
{
throw new Exception($"Failed to parse TCP stream ID. Must be an integer, was: '{streamIdTextBox.Text}'");
}
PhysicalAddress emptyAddress = PhysicalAddress.Parse("000000000000");
PacketDotNet.EthernetPacket etherPacket = new EthernetPacket(emptyAddress, emptyAddress, EthernetType.IPv4);
bool flip = udpStreamId < 0;
udpStreamId = Math.Abs(udpStreamId);
Random r = new Random(udpStreamId);
IPAddress sourceIp = new IPAddress(r.Next());
IPAddress destIp = new IPAddress(r.Next());
if (flip)
{
IPAddress tempAddress = sourceIp;
sourceIp = destIp;
destIp = tempAddress;
}
IPv4Packet ipPacket = new IPv4Packet(sourceIp, destIp)
{
Protocol = ProtocolType.Udp
};
TcpPacket tcpPacket = new TcpPacket(1, 1)
{
PayloadData = rawBytes
};
ipPacket.PayloadPacket = tcpPacket;
etherPacket.PayloadPacket = ipPacket;
return(etherPacket.Bytes);
}
public Packet GetNextPacket(RawCapture raw)
{
RawCapture rawCapture;
Packet result = null;
rawCapture = raw;
if (rawCapture != null)
{
Packet p = Packet.ParsePacket(rawCapture.LinkLayerType, rawCapture.Data);
result = p;
try
{
TcpPacket tcp = p.Extract <TcpPacket>();
if (tcp != null && tcp.PayloadData.Length > 0)
{
ExtractUpperPacket(tcp);
}
else
{
// UNDONE: For GOOSE and SV or null TCP
EthernetPacket ether = p.Extract <EthernetPacket>();
ExtractEthernetPacket(ether);
}
}
catch (Exception ex)
{
#if DEBUG
Console.WriteLine("No. {0}: {1}\nTPKT buffer count: {2}.", currentPacketIndex, ex.Message, tpktBuff.Reassembled.Count);
Console.WriteLine(ex.StackTrace);
#endif
}
}
if (packets.Count > 0)
{
result = packets.Pop();
}
return(result);
}
private static void device1_OnPacketArrival(object sender, CaptureEventArgs e)
{
try
{
Kavprot.Packets.Packet packet = Kavprot.Packets.Packet.ParsePacket(e.Packet);
if (packet is Kavprot.Packets.EthernetPacket)
{
var ip = Kavprot.Packets.IpPacket.GetEncapsulated(packet);
if (ip.Protocol == Kavprot.Packets.IPProtocolType.TCP)
{
TcpPacket tcp = TcpPacket.GetEncapsulated(packet);
if (tcp != null)
{
if (!tcp.IsValidChecksum(TransportPacket.TransportChecksumOption.None))
{
Alert.Attack("Intrusion Detected : Invalid TCP Checksum", "an intrusion was detected using TCP from " + ip.SourceAddress.ToString() + " @port " + tcp.SourcePort.ToString(), ToolTipIcon.Warning, true);
}
}
}
else if (ip.Protocol == Kavprot.Packets.IPProtocolType.UDP)
{
UdpPacket udp = UdpPacket.GetEncapsulated(packet);
if (udp != null)
{
if (!udp.IsValidChecksum(TransportPacket.TransportChecksumOption.None))
{
Alert.Attack("Intrusion Detected : Invalid UDP Checksum", "an intrusion was detected using UDP from " + ip.SourceAddress.ToString() + " @port " + udp.SourcePort.ToString(), ToolTipIcon.Warning, true);
}
}
}
}
}
catch
{
}
finally
{
}
}
/// <summary>
/// 尝试发送FIN+ACK标志结束某一组互联网上的连接。
/// </summary>
/// <param name="srcAddress">连接的起点，应为小端地址。</param>
/// <param name="srcPort">连接起点的端口。</param>
/// <param name="dstAddress">连接的终点，应为大端地址。</param>
/// <param name="dstPort">连接终点的端口。</param>
/// <returns>成功发送包返回true，失败返回false。</returns>
public bool KillConnection(IPAddress srcAddress, ushort srcPort, IPAddress dstAddress, ushort dstPort)
{
EthernetPacket ether;
// 寻找指定目标
lock (_tcpLinks) {
if (_tcpLinks.All(item => !(item.SrcAddress.Equals(srcAddress) && item.SrcPort == srcPort) ||
!(item.DstAddress.Equals(dstAddress) && item.DstPort == dstPort)))
{
return(false);
}
ether = new EthernetPacket(_tcpLinks.Find(item => item.SrcAddress.Equals(srcAddress) && item.SrcPort == srcPort &&
item.DstAddress.Equals(dstAddress) && item.DstPort == dstPort)
.LastPacket.BytesHighPerformance);
}
// 解析包数据
var ipv4 = (IPv4Packet)ether.PayloadPacket;
var tcp = (TcpPacket)ipv4.PayloadPacket;
// 设置数据包内容
var payload = new TcpPacket(tcp.SourcePort, tcp.DestinationPort)
{
Fin = true,
Ack = true,
SequenceNumber = (uint)(tcp.SequenceNumber + (tcp.PayloadPacket?.TotalPacketLength ?? 0)),
AcknowledgmentNumber = tcp.AcknowledgmentNumber,
WindowSize = tcp.WindowSize
};
payload.UpdateCalculatedValues();
ipv4.PayloadPacket = payload;
payload.ParentPacket = ipv4;
payload.UpdateTCPChecksum();
_device.SendPacket(ether);
return(true);
}
/// <summary>
/// Create a tcp
/// </summary>
/// <param name="tcp">
/// A <see cref="TcpPacket"/>
/// </param>
public TcpConnection(TcpPacket tcp)
{
ConnectionState = ConnectionStates.Open;
closeTimer = new System.Timers.Timer();
closeTimer.Interval = Timeout.TotalMilliseconds;
closeTimer.Elapsed += HandleCloseTimerElapsed;
Flows = new List <TcpFlow>();
var ip = tcp.ParentPacket as IPPacket;
var flowA = new TcpFlow(ip.SourceAddress, tcp.SourcePort);
Flows.Add(flowA);
var flowB = new TcpFlow(ip.DestinationAddress, tcp.DestinationPort);
Flows.Add(flowB);
// start the close timer
closeTimer.Enabled = true;
}
private void handleServerInfo(TcpPacket packet)
{
int infoSetsNumber = 0,
infoOffset = 32;
// Calculating how many server information sets do we received from server.
infoSetsNumber = ragnarokPacket.getServerInfoSetsNumber(packet.PayloadData.Length);
byte[] payloadData = packet.PayloadData;
try
{
for (int i = 0, dataOffset = 0; i < infoSetsNumber; i++)
{
int port, playerCount;
byte[] byteServerName = new byte[20];
string IP, strServerName;
IP = payloadData[0 + i * infoOffset + dataOffset].ToString() + "." + payloadData[1 + i * infoOffset + dataOffset].ToString() + "." +
payloadData[2 + i * infoOffset + dataOffset].ToString() + "." + payloadData[3 + i * infoOffset + dataOffset].ToString();
port = (payloadData[5 + i * infoOffset + dataOffset] << 8) + payloadData[4 + i * infoOffset + dataOffset];
playerCount = (payloadData[27 + i * infoOffset + dataOffset] << 8) + payloadData[26 + i * infoOffset + dataOffset];
Array.Copy(payloadData, 6 + i * infoOffset + dataOffset, byteServerName, 0, 20);
strServerName = System.Text.Encoding.GetEncoding("big5").GetString(byteServerName, 0, 20).Replace("\0", string.Empty);
mainform.Invoke(mainform.updateDataGridView_Var, strServerName, IP, port.ToString(), playerCount.ToString());
dataOffset += 4;
/* free byteServerName.*/
byteServerName = null;
}
onListen = false;
}
catch (Exception e)
{
Console.WriteLine("Error in handle server info:" + e);
}
}
void send_packet()
{
var tcpPacket = new TcpPacket(UInt16.Parse(SRC_port_textBox.Text), UInt16.Parse(DST_port_textBox.Text));
var ipSourceAddress = IPAddress.Parse(SRC_IP_textBox.Text); // "127.0.0.1"
var ipDestinationAddress = IPAddress.Parse(DST_IP_textBox.Text); //"127.0.0.1"
var ipPacket = new IPv4Packet(ipSourceAddress, ipDestinationAddress);
tcpPacket.PayloadData = Encoding.Default.GetBytes(Data_textBox.Text); // "I like dogs"
var sourceHwAddress = "90-90-90-90-90-90";
var ethernetSourceHwAddress = System.Net.NetworkInformation.PhysicalAddress.Parse(sourceHwAddress);
var destinationHwAddress = "80-80-80-80-80-80";
var ethernetDestinationHwAddress = System.Net.NetworkInformation.PhysicalAddress.Parse(destinationHwAddress);
EthernetPacket ethernetPacket = new EthernetPacket(ethernetSourceHwAddress,
ethernetDestinationHwAddress,
EthernetType.None);
ipPacket.PayloadPacket = tcpPacket;
ethernetPacket.PayloadPacket = ipPacket;
captureDevice.SendPacket(ethernetPacket);
}
public void TestGetEncapsulated()
{
var ethernetPacket = BuildTCPPacket();
// store the logging value
var oldThreshold = LoggingConfiguration.GlobalLoggingLevel;
// disable logging to improve performance
LoggingConfiguration.GlobalLoggingLevel = log4net.Core.Level.Off;
var startTime = DateTime.Now;
var endTime = startTime.Add(new TimeSpan(0, 0, 15));
int testRuns = 0;
while (DateTime.Now < endTime)
{
// Disable CS0618 (use of obsolete method), because we are testing the now obsolete
// methods for performance
#pragma warning disable 0618
var tcpPacket = TcpPacket.GetEncapsulated(ethernetPacket);
#pragma warning restore 0618
Assert.IsNotNull(tcpPacket);
Assert.AreEqual(tcpPacket.SourcePort, tcpSourcePort);
Assert.AreEqual(tcpPacket.DestinationPort, tcpDestinationPort);
testRuns++;
}
// update the actual end of the loop
endTime = DateTime.Now;
// restore logging
LoggingConfiguration.GlobalLoggingLevel = oldThreshold;
var rate = new Rate(startTime, endTime, testRuns, "Test runs");
Console.WriteLine(rate.ToString());
}
public void RESPONSE_GAME_PLAYER_MOVE(TcpPacket packet)
{
if (packet.header.extra == (int)EXTRA.SUCCESS)
{
SERVERtoHOST_GamePlayerMovePacketData recvData = new SERVERtoHOST_GamePlayerMovePacketData();
recvData.Deserialize(packet);
CLIENTtoSERVER_GamePlayerMovePacketData sendData = new CLIENTtoSERVER_GamePlayerMovePacketData();
sendData.playerKey = recvData.playerKey;
sendData.gameKey = GameManager.Instance.GameKey;
sendData.posX = recvData.posX;
sendData.posY = recvData.posY;
sendData.posZ = recvData.posZ;
sendData.angularX = recvData.angularX;
sendData.angularY = recvData.angularY;
sendData.angularZ = recvData.angularZ;
NetworkManager.Instance.SendCommand((int)PROTOCOL.GAME_PLAYER_MOVE, (int)EXTRA.HOST_TO_SERVER, sendData);
}
}
void ParsePacket(IPv4Packet ipPacket)
{
TcpPacket tcpPacket = (TcpPacket)ipPacket.PayloadPacket;
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append(String.Format("{0}:{1}", ipPacket.SourceAddress, tcpPacket.SourcePort));
sb.Append(" --> ");
sb.Append(String.Format("{0}:{1}", ipPacket.DestinationAddress, tcpPacket.DestinationPort));
sb.AppendLine(String.Format(" Len = {0}", tcpPacket.PayloadData.Length));
//sb.Append(" Data = ");
//foreach (byte b in tcpPacket.PayloadData)
//{
// sb.Append(String.Format("{0} ", b.ToString()));
//}
//sb.AppendLine(ByteArrayToHex(tcpPacket.PayloadData));
sb.Append(FormatPacketData(tcpPacket.PayloadData));
Log(sb.ToString());
}
/// <summary>
/// 获取Flag标志位
/// </summary>
/// <param name="tcp"></param>
/// <returns></returns>
public static string TcpFlagType(TcpPacket tcp)
{
StringBuilder sbr = new StringBuilder();
if (tcp.Ack)
{
sbr.Append("ACK ");
}
if (tcp.Urg)
{
sbr.Append("URG ");
}
if (tcp.Psh)
{
sbr.Append("PSH ");
}
if (tcp.Rst)
{
sbr.Append("RST ");
}
if (tcp.Syn)
{
sbr.Append("SYN ");
}
if (tcp.Fin)
{
sbr.Append("FIN ");
}
if (tcp.ECN)
{
sbr.Append("ECN ");
}
if (tcp.CWR)
{
sbr.Append("CWR ");
}
return(sbr.ToString());
}
private void ProcessTCPPacket(TcpPacket pTCPPacket, ref uint pSequence, Dictionary <uint, byte[]> pBuffer, PacketStream pStream, bool pInbound)
{
if (pTCPPacket.SequenceNumber > pSequence)
{
byte[] data;
while ((data = pBuffer.GetOrDefault(pSequence, null)) != null)
{
pBuffer.Remove(pSequence);
pStream.Append(data);
pSequence += (uint)data.Length;
}
if (pTCPPacket.SequenceNumber > pSequence)
{
pBuffer[(uint)pTCPPacket.SequenceNumber] = pTCPPacket.PayloadData;
}
}
if (pTCPPacket.SequenceNumber < pSequence)
{
int difference = (int)(pSequence - pTCPPacket.SequenceNumber);
if (difference > 0)
{
byte[] data = pTCPPacket.PayloadData;
if (data.Length > difference)
{
pStream.Append(data, difference, data.Length - difference);
pSequence += (uint)(data.Length - difference);
}
}
}
else if (pTCPPacket.SequenceNumber == pSequence)
{
byte[] data = pTCPPacket.PayloadData;
pStream.Append(data);
pSequence += (uint)data.Length;
}
CheckForPackets(pStream, pInbound);
}
public void RESPONSE_JOIN_ROOM_OTHER_PLAYER(TcpPacket packet)
{
if (packet.header.extra == (int)EXTRA.SUCCESS)
{
SERVERtoCLIENT_JoinRoomOtherPlayerPacketData recvData = new SERVERtoCLIENT_JoinRoomOtherPlayerPacketData();
recvData.Deserialize(packet);
if (GameFramework.Instance.MyPlayer.State == PLAYER_STATE.LOBBY)
{
//내가 Lobby에 있을때 다른사람이 Room으로 들어갔으므로 오른쪽 유저 리스트에 해당 유저를 지워야 함
LobbyManager.Instance.RemoveLobbyPlayer(recvData.playerID);
//해당 방에 사람이 들어갔으므로 방 참여자수 1 증가
RoomButton roomButton = RoomManager.Instance.GetRoomButton(recvData.roomKey);
if (roomButton != null)
{
roomButton.IncreaseRoomJoinCount();
}
}
else if (GameFramework.Instance.MyPlayer.State == PLAYER_STATE.IN_ROOM)
{
//내가 Room에 있을때 다른사람이 Room에서 들어왔으므로 방에 해당 유저를 추가해야 함
string chatMessage = "[Server] : " + recvData.playerID + "님이 방에 입장하였습니다.";
RoomGUI.Instance.ShowChatMessage(chatMessage, Color.red);
Player player = new OtherPlayer();
player.Initialize();
player.PlayerID = recvData.playerID;
RoomPlayer roomPlayer = RoomManager.Instance.CreateRoomPlayer(player);
roomPlayer.readyState = false;
roomPlayer.isLeader = false;
RoomManager.Instance.EnteredRoom.PushRoomPlayer(roomPlayer);
RoomGUI.Instance.UpdateRoomPlayerUIElement(RoomManager.Instance.EnteredRoom);
}
}
}
public void RESPONSE_JOIN_ROOM(TcpPacket packet)
{
if (packet.header.extra == (int)EXTRA.SUCCESS)
{
SERVERtoCLIENT_JoinRoomPacketData recvData = new SERVERtoCLIENT_JoinRoomPacketData();
recvData.Deserialize(packet);
LobbySceneGUI.Instance.ChangeLobbyToRoom();
RoomPlayer[] roomPlayers = new RoomPlayer[recvData.joinedPlayerCount];
for (int i = 0; i < recvData.joinedPlayerCount; i++)
{
Player player;
if (recvData.joinedPlayers[i] != GameFramework.Instance.MyPlayer.PlayerID)
{
player = new OtherPlayer();
player.Initialize();
player.PlayerID = recvData.joinedPlayers[i];
}
else
{
player = GameFramework.Instance.MyPlayer;
}
RoomPlayer roomPlayer = RoomManager.Instance.CreateRoomPlayer(player);
roomPlayer.readyState = recvData.joinedPlayerReadyState[i];
roomPlayer.isLeader = recvData.isLeaders[i];
roomPlayers[i] = roomPlayer;
}
Room room = RoomManager.Instance.CreateRoom(recvData.roomName, recvData.roomKey, recvData.joinedPlayerCount);
room.PushRoomPlayer(roomPlayers);
room.Enter();
RoomGUI.Instance.Initialize(room);
}
}
public void DataHandle()
{
while (true)
{
if (receiveMsgs.Count != 0)
{
//패킷을 Dequeue 한다 패킷 : 메시지 타입 + 메시지 내용
lock (receiveLock)
{
tcpPacket = receiveMsgs.Dequeue();
}
//타입과 내용을 분리한다
byte Id = tcpPacket.msg[0];
msg = new byte[tcpPacket.msg.Length - 1];
Array.Copy(tcpPacket.msg, 1, msg, 0, msg.Length);
HeaderData headerData = new HeaderData();
//Dictionary에 등록된 델리게이트형 메소드에서 msg를 반환받는다.
if (m_notifier.TryGetValue(Id, out recvNotifier))
{
ServerPacketId packetId = recvNotifier(msg);
//send 할 id를 반환받음
if (packetId != ServerPacketId.None)
{
tcpPacket = new TcpPacket(msg, tcpPacket.client);
sendMsgs.Enqueue(tcpPacket);
}
}
else
{
Console.WriteLine("DataHandler::TryGetValue 에러 " + Id);
headerData.Id = (byte)ServerPacketId.None;
}
}
}
}
// check if packet might contain traces of POST data (packet to process)
public static bool HasPOST(TcpPacket packet)
{
if (packet.PayloadData != null)
{
var data = encoding.GetString(packet.PayloadData);
// check for possible full GET/POST requests
if (data.Length > 3 && (data.Substring(0, 4) == "POST" || data.Substring(0, 3) == "GET"))
{
return(false);
}
// get rid of possible left-over headers
if (data.Contains("\r\n\r\n"))
{
var parts = Regex.Split(data, "\r\n\r\n");
if (parts.Length > 1)
{
data = parts[1];
}
}
// check for "key=value" pairs
var split = data.Split('&');
if (split.Length > 0)
{
var keys = split[0].Split('=');
if (keys.Length > 0)
{
return(true);
}
}
}
return(false);
}
public void HandleAsyncReceiveData(IAsyncResult asyncResult)
{
AsyncData asyncData = (AsyncData)asyncResult.AsyncState;
Socket clientSock = asyncData.clientSock;
try
{
asyncData.msgSize = (short)clientSock.EndReceive(asyncResult);
}
catch
{
Console.WriteLine("클라이언트가 접속을 종료했습니다.");
LoginUser.Remove(clientSock);
clientSock.Close();
return;
}
if (asyncData.msgSize > 0)
{
Array.Resize(ref asyncData.msg, asyncData.msgSize);
TcpPacket paket = new TcpPacket(asyncData.msg, clientSock);
lock (receiveLock)
{
try
{
msgs.Enqueue(paket);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
asyncData = new AsyncData(clientSock);
clientSock.BeginReceive(asyncData.msg, 0, UnityServer.packetLength, SocketFlags.None, asyncReceiveLengthCallBack, (Object)asyncData);
}
public void RESPONSE_ENTER_LOBBY(TcpPacket packet)
{
if (packet.header.extra == (int)EXTRA.SUCCESS)
{
SERVERtoCLIENT_EnterLobbyPacketData recvData = new SERVERtoCLIENT_EnterLobbyPacketData();
recvData.Deserialize(packet);
for (int i = 0; i < recvData.roomCount; i++)
{
RoomButton roomButton = RoomManager.Instance.CreateRoomButton(recvData.roomKeys[i], recvData.roomNames[i], recvData.isStart[i], recvData.joinedRoomPlayerCount[i]);
LobbyManager.Instance.AttachRoomButton(roomButton);
}
for (int i = 0; i < recvData.playerCount; i++)
{
LobbyManager.Instance.CreateLobbyPlayer(recvData.playerIds[i]);
}
}
else if (packet.header.extra == (int)EXTRA.FAIL)
{
Debug.Log("FAIL RESPONSE_LOBBY_INFO");
}
}
public void SendMenuTo(Client client)
{
TcpPacket packet = new TcpPacket("custommenu");
packet.AppendParameters(MenuName, Closeable.ToString());
packet.AppendParameters(Width.ToString(), Height.ToString());
packet.AppendParameters(mPictures.Count.ToString(), mLabels.Count.ToString(), mTextBoxs.Count.ToString());
for (int i = 0; i < mPictures.Count; i++)
{
packet.AppendParameters(mPictures[i].ImagePath, mPictures[i].X.ToString(), mPictures[i].Y.ToString());
}
for (int i = 0; i < mLabels.Count; i++)
{
packet.AppendParameters(mLabels[i].X.ToString(), mLabels[i].Y.ToString(), mLabels[i].Width.ToString(), mLabels[i].Height.ToString(),
mLabels[i].Text, mLabels[i].Font, mLabels[i].FontSize.ToString(), mLabels[i].Color.ToArgb().ToString());
}
for (int i = 0; i < mTextBoxs.Count; i++)
{
packet.AppendParameters(mTextBoxs[i].X.ToString(), mTextBoxs[i].Y.ToString(), mTextBoxs[i].Width.ToString(), mTextBoxs[i].Text);
}
packet.FinalizePacket();
Messenger.SendDataTo(client, packet);
}
public Packet Resolve()
{
using (MemoryStream ms = new MemoryStream(this._datagram))
{
BinaryReader rdr = new BinaryReader(ms, Packet.ENCODING);
TcpPacket packet = new TcpPacket();
packet.Version = rdr.ReadInt16();
/*packet.Type = */ rdr.ReadByte();//skip packet.Type
packet.Command = rdr.ReadUInt64();
switch (packet.CMD)
{
case TcpPacket.CMD_REQUEST_FILE_TRANSPORT:
packet.Extend = ResolveRequestFileTransportExtend(rdr, _securityKey);
break;
default:
break;
}
return(packet);
}
}
private void TCP(TcpPacket tcp)
{
if (TCPNode == null)
{
TCPNode = new TreeNode();
}
TCPNode.Nodes.Clear();
TCPNode.Text = string.Format("Transmission Control Protocol, Src Port: {0}, Dst Port: {1}, Seq: {2}, Ack: {3}",
tcp.SourcePort, tcp.DestinationPort, tcp.SequenceNumber, tcp.Ack);
TCPNode.Nodes.Add(string.Format("Source Port: {0}", tcp.SourcePort));
TCPNode.Nodes.Add(string.Format("Destination Port: {0}", tcp.DestinationPort));
TCPNode.Nodes.Add(string.Format("Sequence number: {0}", tcp.SequenceNumber));
TCPNode.Nodes.Add(string.Format("Acknowledgement number: {0}", tcp.SequenceNumber));
TCPNode.Nodes.Add(string.Format("Header Length: {0} bytes", tcp.Header.Length));
TCPNode.Nodes.Add(string.Format("Flags: {0}", tcp.AllFlags.ToString("X")));
TCPNode.Nodes.Add(string.Format("Window size value: {0}", tcp.WindowSize));
TCPNode.Nodes.Add(string.Format("Checksum: {0}", tcp.Checksum));
TCPNode.Nodes.Add(string.Format("Urgent pointer: {0}", tcp.UrgentPointer));
//TCPNode.Nodes.Add(string.Format(""));
//TCPNode.Nodes.Add(string.Format(""));
tree.Nodes.Add(TCPNode);
appNext(tcp.PayloadData, tcp.SourcePort, tcp.DestinationPort);
}
public void AddPacketToMapBut(Client client, IMap map, TcpPacket packet, int sourceX, int sourceY, int range)
{
if (map != null)
{
if (!cachingEnabled)
{
foreach (Client i in map.GetClients())
{
if (client == null || i.TcpID != client.TcpID)
{
if (range == -1 || IsInRange(range, sourceX, sourceY, i.Player.X, i.Player.Y))
{
AddPacket(i, packet);
}
}
}
}
else
{
hitListCache.AddCacheItem(new object[] { PacketHitListTargets.RangedMapBut, client, map, packet, sourceX, sourceY, range });
}
}
}
public void HandleTcpPacket(IPv4Datagram datagram)
{
TcpPacket packet = datagram.HandleTcpPacket();
ListViewItem item = new ListViewItem(count.ToString());
item.SubItems.Add(datagram.SourceName);
item.SubItems.Add(packet.SourcePort.ToString() + " " + consts.GetTcpPorts(packet.SourcePort));
item.SubItems.Add(datagram.DestinationName);
item.SubItems.Add(packet.DestinationPort.ToString() + " " + consts.GetTcpPorts(packet.DestinationPort));
item.SubItems.Add(datagram.Identification.ToString());
item.SubItems.Add(packet.Sequence.ToString());
lstwTcp.Items.Add(item);
packets.Add(GetHashString(), datagram); //Bu iki IP cifti ile ilgili tum Datagramlar
count++;
lblCount.Text = count.ToString();
this.Update();
}
public override void Deserialize(TcpPacket packet)
{
this.roomCount = packet.stream.ReadInt();
this.roomKeys = new string[this.roomCount];
this.roomNames = new string[this.roomCount];
this.isStart = new bool[this.roomCount];
this.joinedRoomPlayerCount = new int[this.roomCount];
for (int i = 0; i < this.roomCount; i++)
{
this.roomKeys[i] = packet.stream.ReadString();
}
for (int i = 0; i < this.roomCount; i++)
{
this.roomNames[i] = packet.stream.ReadString();
}
for (int i = 0; i < this.roomCount; i++)
{
this.joinedRoomPlayerCount[i] = packet.stream.ReadInt();
}
for (int i = 0; i < this.roomCount; i++)
{
this.isStart[i] = packet.stream.ReadBool();
}
this.playerCount = packet.stream.ReadInt();
this.playerIds = new string[this.playerCount];
for (int i = 0; i < this.playerCount; i++)
{
this.playerIds[i] = packet.stream.ReadString();
}
}
public static void AppendMapNpcs(Client client, PacketHitList hitlist, IMap map, bool temp)
{
TcpPacket packet = new TcpPacket("mapnpcdata");
packet.AppendParameter(map.MapID);
packet.AppendParameter(temp.ToIntString());
for (int i = 0; i < Constants.MAX_MAP_NPCS; i++) {
if ((int)map.ActiveNpc[i].Direction > 3) map.ActiveNpc[i].Direction = Enums.Direction.Right;
packet.AppendParameters(map.ActiveNpc[i].Num.ToString(), map.ActiveNpc[i].Sprite.ToString(), map.ActiveNpc[i].Form.ToString(), ((int)map.ActiveNpc[i].Shiny).ToString(), ((int)map.ActiveNpc[i].Sex).ToString(),
map.ActiveNpc[i].X.ToString(), map.ActiveNpc[i].Y.ToString(), ((int)map.ActiveNpc[i].Direction).ToString(), ((int)map.ActiveNpc[i].StatusAilment).ToString());
if (map.ActiveNpc[i].Num > 0 && NpcManager.Npcs[map.ActiveNpc[i].Num].Behavior != Enums.NpcBehavior.Friendly && NpcManager.Npcs[map.ActiveNpc[i].Num].Behavior != Enums.NpcBehavior.Shopkeeper && NpcManager.Npcs[map.ActiveNpc[i].Num].Behavior != Enums.NpcBehavior.Scripted) {
packet.AppendParameters("1");
} else {
packet.AppendParameters("0");
}
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static TcpPacket CreateTournamentRulesPacket(Tournament tournament)
{
TcpPacket packet = new TcpPacket("tournamentrules");
packet.AppendParameters(
tournament.Rules.SleepClause.ToIntString(),
tournament.Rules.AccuracyClause.ToIntString(),
tournament.Rules.SpeciesClause.ToIntString(),
tournament.Rules.FreezeClause.ToIntString(),
tournament.Rules.OHKOClause.ToIntString(),
tournament.Rules.SelfKOClause.ToIntString());
return packet;
}
public static void AppendMapItems(Client client, PacketHitList hitlist, IMap map, bool temp)
{
TcpPacket packet = new TcpPacket("mapitemdata");
packet.AppendParameter(map.MapID);
packet.AppendParameter(temp.ToIntString());
for (int i = 0; i < Constants.MAX_MAP_ITEMS; i++) {//server will lie to the client and send all hidden items as blank
if (!map.ActiveItem[i].Hidden) {
packet.AppendParameters(map.ActiveItem[i].Num.ToString(), map.ActiveItem[i].Value.ToString(), map.ActiveItem[i].Sticky.ToIntString(), map.ActiveItem[i].X.ToString(), map.ActiveItem[i].Y.ToString());
} else {
packet.AppendParameters("0", "0", "0", "0", "0");
}
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static void AppendAllNpcs(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("allnpcsdata");
for (int i = 1; i <= Npcs.NpcManager.Npcs.MaxNpcs; i++) {
packet.AppendParameters(i.ToString(),
Npcs.NpcManager.Npcs[i].Name.Trim());
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public void SendMenuTo(Client client)
{
TcpPacket packet = new TcpPacket("custommenu");
packet.AppendParameters(MenuName, Closeable.ToString());
packet.AppendParameters(Width.ToString(), Height.ToString());
packet.AppendParameters(mPictures.Count.ToString(), mLabels.Count.ToString(), mTextBoxs.Count.ToString());
for (int i = 0; i < mPictures.Count; i++) {
packet.AppendParameters(mPictures[i].ImagePath, mPictures[i].X.ToString(), mPictures[i].Y.ToString());
}
for (int i = 0; i < mLabels.Count; i++) {
packet.AppendParameters(mLabels[i].X.ToString(), mLabels[i].Y.ToString(), mLabels[i].Width.ToString(), mLabels[i].Height.ToString(),
mLabels[i].Text, mLabels[i].Font, mLabels[i].FontSize.ToString(), mLabels[i].Color.ToArgb().ToString());
}
for (int i = 0; i < mTextBoxs.Count; i++) {
packet.AppendParameters(mTextBoxs[i].X.ToString(), mTextBoxs[i].Y.ToString(), mTextBoxs[i].Width.ToString(), mTextBoxs[i].Text);
}
packet.FinalizePacket();
Messenger.SendDataTo(client, packet);
}
public static void AppendAllItems(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("allitemsdata");
for (int i = 0; i < Items.ItemManager.Items.MaxItems; i++) {
if (Items.ItemManager.Items[i].Name.Trim() != "") {
packet.AppendParameters(i.ToString(),
Items.ItemManager.Items[i].Name.Trim(),
Items.ItemManager.Items[i].Desc.Trim(),
Items.ItemManager.Items[i].Pic.ToString(),
((int)Items.ItemManager.Items[i].Type).ToString(),
Items.ItemManager.Items[i].Data1.ToString(),
Items.ItemManager.Items[i].Data2.ToString(),
Items.ItemManager.Items[i].Data3.ToString(),
Items.ItemManager.Items[i].Price.ToString(),
Items.ItemManager.Items[i].StackCap.ToString(),
Items.ItemManager.Items[i].Bound.ToIntString(),
Items.ItemManager.Items[i].Loseable.ToIntString(),
Items.ItemManager.Items[i].Rarity.ToString(),
Items.ItemManager.Items[i].ReqData1.ToString(),
Items.ItemManager.Items[i].ReqData2.ToString(),
Items.ItemManager.Items[i].ReqData3.ToString(),
Items.ItemManager.Items[i].ReqData4.ToString(),
Items.ItemManager.Items[i].ReqData5.ToString(),
Items.ItemManager.Items[i].ScriptedReq.ToString(),
Items.ItemManager.Items[i].AddHP.ToString(),
Items.ItemManager.Items[i].AddPP.ToString(),
Items.ItemManager.Items[i].AddAttack.ToString(),
Items.ItemManager.Items[i].AddDefense.ToString(),
Items.ItemManager.Items[i].AddSpAtk.ToString(),
Items.ItemManager.Items[i].AddSpDef.ToString(),
Items.ItemManager.Items[i].AddSpeed.ToString(),
Items.ItemManager.Items[i].AddEXP.ToString(),
Items.ItemManager.Items[i].AttackSpeed.ToString(),
Items.ItemManager.Items[i].RecruitBonus.ToString());
} else {
packet.AppendParameters(i.ToString(), 0.ToString());
}
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static void AppendAvailableExpKitModules(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("kitmodules");
packet.AppendParameter(client.Player.AvailableExpKitModules.Count);
for (int i = 0; i < client.Player.AvailableExpKitModules.Count; i++) {
packet.AppendParameter((int)client.Player.AvailableExpKitModules[i].Type);
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static void AppendAllStoryNames(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("allstoriesdata");
for (int i = 0; i <= Stories.StoryManager.Stories.MaxStories; i++) {
if (!string.IsNullOrEmpty(Stories.StoryManager.Stories[i].Name)) {
packet.AppendParameters(Stories.StoryManager.Stories[i].Name);
} else {
packet.AppendParameters("");
}
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static void AppendAllSpells(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("allspellsdata");
for (int i = 1; i <= Moves.MoveManager.Moves.MaxMoves; i++) {
packet.AppendParameters(
i.ToString(),
Moves.MoveManager.Moves[i].Name.Trim(),
((int)Moves.MoveManager.Moves[i].RangeType).ToString(),
Moves.MoveManager.Moves[i].Range.ToString(),
((int)Moves.MoveManager.Moves[i].TargetType).ToString(),
Moves.MoveManager.Moves[i].HitTime.ToString(),
Moves.MoveManager.Moves[i].HitFreeze.ToIntString());
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static TcpPacket CreateTournamentSpectateListingPacket()
{
TcpPacket packet = new TcpPacket();
int validTournyCount = 0;
for (int i = 0; i < TournamentManager.Tournaments.Count; i++) {
Tournament tourny = TournamentManager.Tournaments[i];
if (tourny.TournamentStarted == false) {
validTournyCount++;
packet.AppendParameter(tourny.Name);
packet.AppendParameter(tourny.ID);
for (int n = 0; n < tourny.RegisteredMembers.Count; n++) {
if (tourny.RegisteredMembers[n].Admin) {
packet.AppendParameter(tourny.RegisteredMembers[n].Client.Player.Name);
break;
}
}
}
}
packet.PrependParameters("tournamentspectatelisting", validTournyCount.ToString());
return packet;
}
/// <summary>
/// Sends a command to the connected server.
/// The return value of this function does not signify command success, only if the command was sent.
/// </summary>
/// <param name="command">The command type to send.</param>
/// <param name="args">The arguments to send.</param>
/// <returns>True if the command was sent; otherwise, false.</returns>
protected bool SendCommand( byte command, params object[] args )
{
try
{
using ( TcpPacket packet = new TcpPacket() )
{
packet.Write( command );
foreach ( object arg in args )
{
if ( arg is byte[] )
packet.Write( ( byte[] )arg );
else if ( arg is string )
packet.Write( ( string )arg, Encoding.ASCII );
else
packet.Write( arg.GetType(), arg );
}
Socket.Send( packet );
}
return true;
}
catch
{
return false;
}
}
public static void AppendAllPokemon(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("allpokemon");
packet.AppendParameter(Constants.TOTAL_POKEMON);
for (int i = 1; i <= Constants.TOTAL_POKEMON; i++) {
packet.AppendParameters(Pokedex.Pokedex.GetPokemon(i).Name,
Pokedex.Pokedex.GetPokemon(i).Forms.Count.ToString());
//foreach (Pokedex.PokemonForm form in Pokedex.Pokedex.GetPokemon(i).Forms) {
// packet.AppendParameter(form.Sprite[0, 0]);
//}
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
/// <summary>
/// Attempts to receive a tcp packet from the socket.
/// </summary>
/// <returns>The packet.</returns>
public TcpPacket ReceivePacket()
{
TcpPacket pack = new TcpPacket();
uint size = NetHelpers.EndianSwap( this.Reader.ReadUInt32() );
byte[] payload = Reader.ReadBytes( ( int )size );
pack.SetPayload( payload );
return pack;
}
public static void AppendInventory(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("playerinv");
packet.AppendParameter(client.Player.MaxInv);
for (int i = 1; i <= client.Player.MaxInv; i++) {
packet.AppendParameters(client.Player.Inventory[i].Num.ToString(),
client.Player.Inventory[i].Amount.ToString(),
client.Player.Inventory[i].Sticky.ToIntString());
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static void AppendJobList(Client client, PacketHitList hitlist)
{
//
TcpPacket packet = new TcpPacket("joblist");
Player player = client.Player;
packet.AppendParameter(player.JobList.JobList.Count.ToString());
for (int i = 0; i < player.JobList.JobList.Count; i++) {
WonderMailJob job = player.JobList.JobList[i];
packet.AppendParameters(job.Mission.Title, job.Mission.Summary, job.Mission.GoalName);
packet.AppendParameters(WonderMailManager.Missions.MissionPools[(int)job.Mission.Difficulty - 1].MissionClients[job.Mission.MissionClientIndex].Species,
WonderMailManager.Missions.MissionPools[(int)job.Mission.Difficulty - 1].MissionClients[job.Mission.MissionClientIndex].Form,
(int)job.Mission.MissionType, job.Mission.Data1, job.Mission.Data2, (int)job.Mission.Difficulty,
WonderMailManager.Missions.MissionPools[(int)job.Mission.Difficulty - 1].Rewards[job.Mission.RewardIndex].ItemNum,
WonderMailManager.Missions.MissionPools[(int)job.Mission.Difficulty - 1].Rewards[job.Mission.RewardIndex].Amount, job.Mission.Mugshot);
//MapGeneralInfo mapInfo = MapManager.RetrieveMapGeneralInfo(player.JobList.JobList[i].Mission.Goal);
packet.AppendParameters((int)player.JobList.JobList[i].Accepted);
if (player.JobList.JobList[i].SendsRemaining > 0) {
packet.AppendParameters(1);
} else {
packet.AppendParameters(0);
}
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static void AppendWornEquipment(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("playerhelditem");
for (int i = 0; i < Constants.MAX_ACTIVETEAM; i++) {
if (client.Player.Team[i].Loaded == true) {
packet.AppendParameter(client.Player.Team[i].HeldItemSlot);
} else {
packet.AppendParameter("0");
}
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static void AppendMapData(Client client, PacketHitList hitlist, IMap map, Enums.MapID mapType)
{
TcpPacket packet = new TcpPacket("mapdata");
int x, y;
if (map.MaxX == 0)
map.MaxX = 19;
if (map.MaxY == 0)
map.MaxY = 14;
packet.AppendParameter((int)mapType);
packet.AppendParameters(map.MapID,
map.Name.Trim(),
map.Revision.ToString(),
((int)map.Moral).ToString(),
map.Up.ToString(),
map.Down.ToString(),
map.Left.ToString(),
map.Right.ToString(),
map.Music,
map.Indoors.ToIntString(),
((int)map.Weather).ToString(),
map.MaxX.ToString(),
map.MaxY.ToString(),
map.Darkness.ToString(),
map.HungerEnabled.ToIntString(),
map.RecruitEnabled.ToIntString(),
map.ExpEnabled.ToIntString(),
map.TimeLimit.ToString(),
map.MinNpcs.ToString(),
map.MaxNpcs.ToString(),
map.NpcSpawnTime.ToString(),
map.Cacheable.ToIntString());
if (map.MapType == Enums.MapType.Instanced) {
string mapBase = MapManager.GenerateMapID(((InstancedMap)map).MapBase);
packet.AppendParameter(mapBase);
} else {
packet.AppendParameter("");
}
for (y = 0; y <= map.MaxY; y++) {
for (x = 0; x <= map.MaxX; x++) {
packet.AppendParameters(map.Tile[x, y].Ground.ToString(),
map.Tile[x, y].GroundAnim.ToString(),
map.Tile[x, y].Mask.ToString(),
map.Tile[x, y].Anim.ToString(),
map.Tile[x, y].Mask2.ToString(),
map.Tile[x, y].M2Anim.ToString(),
map.Tile[x, y].Fringe.ToString(),
map.Tile[x, y].FAnim.ToString(),
map.Tile[x, y].Fringe2.ToString(),
map.Tile[x, y].F2Anim.ToString(),
((int)map.Tile[x, y].Type).ToString(),
map.Tile[x, y].Data1.ToString(),
map.Tile[x, y].Data2.ToString(),
map.Tile[x, y].Data3.ToString(),
map.Tile[x, y].String1,
map.Tile[x, y].String2,
map.Tile[x, y].String3,
map.Tile[x, y].RDungeonMapValue.ToString(),
map.Tile[x, y].GroundSet.ToString(),
map.Tile[x, y].GroundAnimSet.ToString(),
map.Tile[x, y].MaskSet.ToString(),
map.Tile[x, y].AnimSet.ToString(),
map.Tile[x, y].Mask2Set.ToString(),
map.Tile[x, y].M2AnimSet.ToString(),
map.Tile[x, y].FringeSet.ToString(),
map.Tile[x, y].FAnimSet.ToString(),
map.Tile[x, y].Fringe2Set.ToString(),
map.Tile[x, y].F2AnimSet.ToString());
}
}
packet.AppendParameter(map.Npc.Count);
for (x = 0; x < map.Npc.Count; x++) {
packet.AppendParameters(map.Npc[x].NpcNum,
map.Npc[x].SpawnX,
map.Npc[x].SpawnY,
map.Npc[x].MinLevel,
map.Npc[x].MaxLevel,
map.Npc[x].AppearanceRate,
(int)map.Npc[x].StartStatus,
map.Npc[x].StartStatusCounter,
map.Npc[x].StartStatusChance);
}
packet.AppendParameter(map.TempChange.ToIntString());
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static void AppendAllRDungeons(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("allrdungeons");
packet.AppendParameter(RDungeons.RDungeonManager.RDungeons.Count);
for (int i = 0; i < RDungeons.RDungeonManager.RDungeons.Count; i++) {
packet.AppendParameters(RDungeons.RDungeonManager.RDungeons[i].DungeonName.Trim());
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
private static void AppendNpcMoveInternal(IMap map, Combat.ICharacter target, PacketHitList hitlist, TcpPacket packet, IMap borderingMap, Enums.MapID borderingMapID, Client targetClient)
{
if (targetClient.Player.GetActiveRecruit() != target) {
if (AI.MovementProcessor.WillCharacterSeeCharacter(targetClient.Player.Map, targetClient.Player.GetActiveRecruit(), map, MapManager.GetOppositeMapID(borderingMapID), target)) {
if (!targetClient.Player.IsSeenCharacterSeen(target)) {
targetClient.Player.OutdateCharacter(target, Enums.OutdateType.Location);
targetClient.Player.AddActivationIfCharacterNotSeen(hitlist, target);
} else {
hitlist.AddPacket(targetClient, packet);
}
} else {
if (targetClient.Player.IsSeenCharacterSeen(target)) {
hitlist.AddPacket(targetClient, packet);
//unsee character
} else {
targetClient.Player.OutdateCharacter(target, Enums.OutdateType.Location);
}
}
}
}
public static TcpPacket CreateNpcSpawn(MapNpc mapNpc)
{
TcpPacket packet = new TcpPacket("spawnnpc");
packet.AppendParameters(mapNpc.MapID, mapNpc.MapSlot.ToString(), mapNpc.Num.ToString(), mapNpc.Sprite.ToString(),
mapNpc.Form.ToString(), ((int)mapNpc.Shiny).ToString(), ((int)mapNpc.Sex).ToString(),
mapNpc.X.ToString(), mapNpc.Y.ToString(), ((int)mapNpc.Direction).ToString(), ((int)mapNpc.StatusAilment).ToString());
if (mapNpc.Num > 0) {
Npc npc = NpcManager.Npcs[mapNpc.Num];
if (npc.Behavior != Enums.NpcBehavior.Friendly && npc.Behavior != Enums.NpcBehavior.Shopkeeper && npc.Behavior != Enums.NpcBehavior.Scripted) {
packet.AppendParameters("1");
} else {
packet.AppendParameters("0");
}
}
packet.FinalizePacket();
return packet;
}
public static void AppendAllShops(Client client, PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("allshopsdata");
for (int i = 1; i <= Shops.ShopManager.Shops.MaxShops; i++) {
packet.AppendParameters(i.ToString(),
Shops.ShopManager.Shops[i].Name.Trim());
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
/// <summary>
/// Sends the specified packet on the socket.
/// </summary>
/// <param name="packet">The packet.</param>
public void Send( TcpPacket packet )
{
this.Send( packet.GetData() );
}
public static TcpPacket CreatePlayerAllRecruitsPacket(Client client)
{
TcpPacket packet = new TcpPacket();
int recruitCount = 0;
int[] team = new int[4] { -1, -1, -1, -1 };
using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
foreach (AssemblyRecruitData assemblyRecruit in PlayerDataManager.LoadPlayerAssemblyRecruits(dbConnection.Database, client.Player.CharID)) {
recruitCount++;
if (client.Player.IsInTeam(assemblyRecruit.RecruitIndex) == false) {
int size = 1;
//int mugshot = -1;
int species = assemblyRecruit.Species;
//int sprite = 0;
//if (species > -1 && species <= Constants.TOTAL_POKEMON) {
// Pokedex.PokemonForm pokemon = Pokedex.Pokedex.GetPokemonForm(species, assemblyRecruit.Form);
// mugshot = pokemon.Mugshot[assemblyRecruit.Shiny, assemblyRecruit.Sex];
// sprite = pokemon.Sprite[assemblyRecruit.Shiny, assemblyRecruit.Sex];
//}
packet.AppendParameters(assemblyRecruit.RecruitIndex, species, (int)assemblyRecruit.Sex, assemblyRecruit.Form, (int)assemblyRecruit.Shiny, assemblyRecruit.Level);
packet.AppendParameter(assemblyRecruit.Name);
} else {
int teamSlot = client.Player.FindTeamSlot(assemblyRecruit.RecruitIndex);
team[teamSlot] = assemblyRecruit.RecruitIndex;
//int mugshot = Pokedex.Pokedex.GetPokemonForm(client.Player.Team[teamSlot].Species, client.Player.Team[teamSlot].Form).Mugshot[assemblyRecruit.Shiny, assemblyRecruit.Sex];
if (teamSlot > -1 && teamSlot < 4) {
packet.AppendParameters(assemblyRecruit.RecruitIndex.ToString(), client.Player.Team[teamSlot].Sprite.ToString(), ((int)client.Player.Team[teamSlot].Sex).ToString(),
client.Player.Team[teamSlot].Form.ToString(), ((int)client.Player.Team[teamSlot].Shiny).ToString(), client.Player.Team[teamSlot].Level.ToString(), client.Player.Team[teamSlot].Name);
}
}
}
}
packet.PrependParameters("allrecruits", recruitCount.ToString(), team[0].ToString(), team[1].ToString(), team[2].ToString(), team[3].ToString());
return packet;
}
public void AppendFriendsList(PacketHitList hitlist)
{
TcpPacket packet = new TcpPacket("friendslist");
packet.AppendParameter(Friends.Count);
for (int i = 0; i < Friends.Count; i++) {
Client clientIsOn = ClientManager.FindClient(Friends[i]);
int ison;
if (clientIsOn != null) {
ison = 1;
} else {
ison = 0;
}
packet.AppendParameters(Friends[i], ison.ToString());
}
packet.FinalizePacket();
hitlist.AddPacket(client, packet);
}
public static TcpPacket CreateTilePacket(int x, int y, IMap map)
{
TcpPacket packet = new TcpPacket("tiledata");
packet.AppendParameters(
x.ToString(),
y.ToString(),
map.Tile[x, y].Ground.ToString(),
map.Tile[x, y].GroundAnim.ToString(),
map.Tile[x, y].Mask.ToString(),
map.Tile[x, y].Anim.ToString(),
map.Tile[x, y].Mask2.ToString(),
map.Tile[x, y].M2Anim.ToString(),
map.Tile[x, y].Fringe.ToString(),
map.Tile[x, y].FAnim.ToString(),
map.Tile[x, y].Fringe2.ToString(),
map.Tile[x, y].F2Anim.ToString(),
((int)map.Tile[x, y].Type).ToString(),
map.Tile[x, y].Data1.ToString(),
map.Tile[x, y].Data2.ToString(),
map.Tile[x, y].Data3.ToString(),
map.Tile[x, y].String1,
map.Tile[x, y].String2,
map.Tile[x, y].String3,
map.Tile[x, y].RDungeonMapValue.ToString(),
map.Tile[x, y].GroundSet.ToString(),
map.Tile[x, y].GroundAnimSet.ToString(),
map.Tile[x, y].MaskSet.ToString(),
map.Tile[x, y].AnimSet.ToString(),
map.Tile[x, y].Mask2Set.ToString(),
map.Tile[x, y].M2AnimSet.ToString(),
map.Tile[x, y].FringeSet.ToString(),
map.Tile[x, y].FAnimSet.ToString(),
map.Tile[x, y].Fringe2Set.ToString(),
map.Tile[x, y].F2AnimSet.ToString()
);
return packet;
}
