private void SendConnected(int cId, IPEndPoint iPEnd)
{
ConnectionPacket packet = new ConnectionPacket();
packet.payload.clientId = cId;
SendToClient(packet, iPEnd);
}
public void OnPreReceiveData(SocketClient socketClient, byte[] Buffer)
{
BasePacket basePacket = (BasePacket)PacketDeserializer.Deserialize(Buffer, PacketHeaderSize.HeaderSize);
if (basePacket.packetType == PacketType.ConnectionStat)
{
ConnectionPacket connectionpacket = (ConnectionPacket)basePacket;
if (socketServer.clientsManager.SocketClients.ContainsKey(connectionpacket.ClientId))
{
socketClient.SendPacket(new ConnectionPacket(false, 0, false, true));
socketClient.Dispose();
IGConsole.Instance.println("Same Client Already Connected");
}
else
{
socketServer.clientsManager.UpdatePreClient(connectionpacket.ClientId, connectionpacket.IsBot, socketClient);
if (connectionpacket.IsBot)
{
clientsManagerObj.clientsManager.AddClient(new HardwareClient(connectionpacket.ClientId, socketClient));
}
else
{
clientsManagerObj.clientsManager.AddClient(new ConsoleClient(connectionpacket.ClientId, socketClient, clientsManagerObj.clientsManager.Clients));
}
socketClient.SendPacket(new ConnectionPacket(true, 0, false));
IGConsole.Instance.println("Client Connected ID(" + connectionpacket.ClientId + ") ISBOT(" + connectionpacket.IsBot + ")");
}
}
else
{
IGConsole.Instance.println("Client Reset has Problem");
}
}
public void Handle(ConnectionPacket packet, PacketSession peerSession)
{
if (packet.Connected)
{
// 로그인한 유저 객체 만들고 각 객체 상황 전달한다.
var playerObject = _context.NewGameObject(ObjectType.Player);
peerSession.Send(playerObject.ToLoginPacket());
foreach (var each in _context.GameObjects.Select(e => e.ToSpawnPacket()))
{
peerSession.Send(each);
}
foreach (var each in _context.GameObjects.Select(e => e.ToMovePacket()))
{
peerSession.Send(each);
}
// 다른 유저들에게 해당 유저가 접속했다는 사실을 알려준다.
_context.BroadcastPacket(playerObject.ToSpawnPacket(), peerSession);
_context.AddPlayer(playerObject, peerSession);
}
else
{
var logoutObject = _context.RemovePlayer(peerSession);
// 다른 유저들에게 유저가 나갔다는 사실을 알려준다.
if (logoutObject != null)
{
_context.BroadcastPacket(logoutObject.ToDespawnPacket(), peerSession);
}
}
}
private void ConnectThread()
{
try
{
IPAddress serverIP = IPAddress.Parse(User.IP);
Client.Connect(serverIP, User.Port);
ConnectionPacket request = new ConnectionPacket("ConnectionRequest", User.Username);
Send(request);
Packet response = Recieve();
HandlePacket(response);
}
catch (ArgumentNullException e)
{
Console.WriteLine("ArgumentNullException: {0}", e);
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
MessageBox.Show("No host listening on port-IP combination", "Alert", MessageBoxButton.OK);
}
catch (ThreadAbortException e)
{
Debug.WriteLine(e);
}
}
private void PacketReceiver_OnDataInvoke(ulong Id, BasePacket basePacket)
{
if (basePacket.packetType == PacketType.ConnectionStat)
{
ConnectionPacket cp = (ConnectionPacket)basePacket;
if (cp.IsConnecting == true)
{
PrintStatusLabel("Connected");
SceneManager.LoadScene("MainScene", LoadSceneMode.Single);
}
else
{
if (cp.HasError == true)
{
socketClient.ErrorStop();
PrintStatusLabel("Already Connected");
}
else
{
socketClient.Stop();
SceneManager.LoadScene("ConnectScene", LoadSceneMode.Single);
}
}
}
OnDataInvoke?.Invoke(basePacket);
}
public static Packet ConvertToPacket(this byte[] buffer, SocketReceivedResult socketReceiveResult)
{
Packet receivedPacket = null;
var eventType = buffer.GetSocketEventType();
switch (eventType)
{
case PacketTypeEnum.Connection:
receivedPacket = new ConnectionPacket();
break;
case PacketTypeEnum.Ping:
receivedPacket = new PingPacket();
break;
case PacketTypeEnum.Disconnect:
receivedPacket = new DisconnectPacket();
break;
case PacketTypeEnum.Movement:
receivedPacket = new MovementPacket();
break;
default:
Log.Error("Unknown packet type, cannot handle them");
break;
}
receivedPacket.Deserialize(buffer);
receivedPacket.SetHeader(eventType, socketReceiveResult.RemoteEndPoint);
return(receivedPacket);
}
public override void OnConnected()
{
ConnectionPacket conPacket = new ConnectionPacket("D_Connection");
conPacket.player_id = -1;
SendPacketToServer(conPacket);
}
public void Abort()
{
if (Client.Connected)
{
ConnectionPacket disconnecter = new ConnectionPacket("Disconnect", User.Username);
Send(disconnecter);
Client.Close();
}
if (connectionThread != null)
{
connectionThread.Abort();
}
}
public void ReceiveData(BasePacket basePacket)
{
if (basePacket.packetType == PacketType.ConnectionStat)
{
ConnectionPacket cp = (ConnectionPacket)basePacket;
if (cp.IsConnecting == false)
{
clientSender.Dispose();
}
}
ManualReceiveData(basePacket);
}
private void AddDefaultPacketReceives()
{
Packet_Register.Instance.clientPacketReceivedRegister.Add("D_Connection", packetObj => {
ConnectionPacket connectionPacket = (ConnectionPacket)packetObj[0];
player_id = connectionPacket.player_id;
isConnectedToServer = true;
OnConnectPacket ocp = new OnConnectPacket("D_OnConnect");
SendPacketToServer(ocp);
return(false);
});
}
public void ReceivingConnection(Stream stream, IPEndPoint iPEnd)
{
if (!NetworkManager.Instance.isServer && state != ConnectionState.Connected)
{
ConnectionPacket packet = new ConnectionPacket();
packet.Deserialize(stream);
if (packet.payload.clientId == NetworkManager.Instance.clientId)
{
state = ConnectionState.Connected;
if (whenConnected != null)
{
whenConnected(true);
whenConnected = null;
}
}
}
}
public ClientConnection AddConnection(ConnectionPacket connectionPacket)
{
_clientIdentifierCounter += 1;
var newClient = new ClientConnection()
{
Id = _clientIdentifierCounter,
EndPoint = connectionPacket.Header.Sender,
Nickname = connectionPacket.Nickname,
LastPingTimeStamp = DateTime.UtcNow.Ticks
};
_connections.TryAdd(_clientIdentifierCounter, newClient);
Log.Info($"{connectionPacket.Nickname} has been connected");
return(newClient);
}
public void QueryUserOnConnect(Packet packet)
{
MessageBoxResult result = MessageBox.Show($"User {packet.Username} wishes to connect, Accept?", "Alert", MessageBoxButton.YesNo);
if (result == MessageBoxResult.Yes)
{
ConnectionPacket response = new ConnectionPacket("ConnectionAccept", User.Username);
Send(response);
Listening = false;
Action <Packet> action = (Action <Packet>)Actions["ConnectionAccept"];
Application.Current.Dispatcher.Invoke(() => { action(packet); });
}
else if (result == MessageBoxResult.No)
{
ConnectionPacket response = new ConnectionPacket("ConnectionDeny", User.Username);
Send(response);
Client.Close();
}
}
private void AddDefaultPacketReceives()
{
Packet_Register.Instance.serverPacketReceivedRegister.Add("D_Connection", packetObj =>
{
ConnectionPacket connectionPacket = (ConnectionPacket)packetObj[0];
NetConnection senderConnection = (NetConnection)packetObj[2];
//Register Player
int newID = GetNextPlayerID();
playersConnection.Add(senderConnection, newID);
players.Add(newID, senderConnection);
connectionPacket.player_id = newID;
SendPacketToExistingConnection(connectionPacket, senderConnection, -1);
return(false);
});
Packet_Register.Instance.serverPacketReceivedRegister.Add("D_OnConnect", packetObj =>
{
OnConnectPacket instantiate = (OnConnectPacket)packetObj[0];
int playerId = (int)packetObj[1];
NetConnection conn = (NetConnection)packetObj[2];
foreach (PacketWithId <InstantiationPacket> ip in registers)
{
SendPacketToExistingConnection(ip.packet, conn, ip.playerId);
}
if (funcOnNewConnection != null)
{
funcOnNewConnection.Invoke(packetObj);
}
return(false);
});
Packet_Register.Instance.serverPacketReceivedRegister.Add("D_Instantiate", packetObj =>
{
InstantiationPacket instantiate = (InstantiationPacket)packetObj[0];
int playerId = (int)packetObj[1];
instantiate.item_net_id = GetNextItemID();
registers.Add(new PacketWithId <InstantiationPacket>(instantiate, playerId));
SendPacketToAll(instantiate, playerId);
return(false);
});
Packet_Register.Instance.serverPacketReceivedRegister.Add("D_Delete", packetObj =>
{
DeletePacket instantiate = (DeletePacket)packetObj[0];
int playerId = (int)packetObj[1];
NetConnection conn = (NetConnection)packetObj[2];
int idToRemove = -1;
for (int i = 0; i < registers.Count; i++)
{
//Found packet we need to delete
if (registers[i].packet.item_net_id == instantiate.item_net_id)
{
idToRemove = i;
break;
}
}
registers.RemoveAt(idToRemove);
SendPacketToAll(instantiate, playerId);
return(false);
});
Packet_Register.Instance.serverPacketReceivedRegister.Add("D_PositionRotation", packetObj =>
{
PositionRotation packet = (PositionRotation)packetObj[0];
int playerId = (int)packetObj[1];
NetConnection conn = (NetConnection)packetObj[2];
SendPacketToAll(packet, playerId);
return(false);
});
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="packet">The packet.</param>
/// <param name="connection">The connection handler.</param>
public PacketEventArgs(ConnectionPacket packet, ConnectionHandler connection)
{
this.EventID = packet.EventID;
this.Connection = connection;
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="packet">The packet.</param>
/// <param name="connection">The connection handler.</param>
public PacketEventArgs(ConnectionPacket packet, ConnectionHandler connection)
{
this.EventID = packet.EventID;
this.Connection = connection;
}
public string GetPacketMembers(BasePacket basePacket)
{
StringBuilder PacketMembers = new StringBuilder("(");
switch (basePacket.packetType)
{
case PacketType.ConnectionStat:
ConnectionPacket cp = basePacket as ConnectionPacket;
PacketMembers.Append("IsConnecting: ");
PacketMembers.Append(cp.IsConnecting);
PacketMembers.Append(", IsBot: ");
PacketMembers.Append(cp.IsBot);
PacketMembers.Append(", HasError: ");
PacketMembers.Append(cp.HasError);
break;
case PacketType.CamFrame:
CamPacket cap = basePacket as CamPacket;
PacketMembers.Append("CamFrame: ");
PacketMembers.Append(cap.CamFrame);
break;
case PacketType.CamConfig:
CamConfigPacket cacc = basePacket as CamConfigPacket;
PacketMembers.Append("camaraConfigType: ");
PacketMembers.Append(cacc.camaraConfigType.ToString());
PacketMembers.Append(", enable: ");
PacketMembers.Append(cacc.enable);
break;
case PacketType.CamResolutionReq:
CamResolutionReqPacket crqr = basePacket as CamResolutionReqPacket;
PacketMembers.Append("Resolution: ");
PacketMembers.Append(crqr.Resolution);
break;
case PacketType.CamResolution:
CamResolutionPacket crr = basePacket as CamResolutionPacket;
PacketMembers.Append("Resolution: ");
PacketMembers.Append(crr.Resolution);
break;
case PacketType.CamReceived:
CamPacketRecived cpr = basePacket as CamPacketRecived;
break;
case PacketType.CarStatus:
CarStatusPacket csp = basePacket as CarStatusPacket;
PacketMembers.Append("cardevice: ");
PacketMembers.Append(csp.cardevice);
PacketMembers.Append(", position: ");
PacketMembers.Append(csp.position);
PacketMembers.Append(", rotation: ");
PacketMembers.Append(csp.rotation);
break;
case PacketType.CarStatusReceived:
CarStatusRecivedPacket csrp = basePacket as CarStatusRecivedPacket;
break;
case PacketType.CarGPSSpotStatus:
CarGPSSpotStatusPacket cgpsssp = basePacket as CarGPSSpotStatusPacket;
PacketMembers.Append("GPSMover: ");
PacketMembers.Append(cgpsssp.GPSMover);
PacketMembers.Append(", GPSPosition: ");
PacketMembers.Append(cgpsssp.GPSPosition);
PacketMembers.Append(", GPSSpotManagerChangeType: ");
PacketMembers.Append(cgpsssp.GPSSpotManagerChangeType);
PacketMembers.Append(", Index: ");
PacketMembers.Append(cgpsssp.Index);
break;
case PacketType.CarStatusChangeReq:
CarStatusChangeReqPacket cscrp = basePacket as CarStatusChangeReqPacket;
PacketMembers.Append("ReqCarDevice: ");
PacketMembers.Append(cscrp.ReqCarDevice);
break;
case PacketType.CarGPSSpotStatusChangeReq:
CarGPSSpotStatusChangeReqPacket cgpssscrp = basePacket as CarGPSSpotStatusChangeReqPacket;
PacketMembers.Append("GPSMover: ");
PacketMembers.Append(cgpssscrp.GPSMover);
PacketMembers.Append(", GPSPosition: ");
PacketMembers.Append(cgpssscrp.GPSPosition);
PacketMembers.Append(", GPSSpotManagerChangeType: ");
PacketMembers.Append(cgpssscrp.GPSSpotManagerChangeType);
PacketMembers.Append(", Index: ");
PacketMembers.Append(cgpssscrp.Index);
break;
case PacketType.UpdateDataReq:
DataUpdatePacket dup = basePacket as DataUpdatePacket;
PacketMembers.Append("modeType: ");
PacketMembers.Append(dup.modeType);
break;
case PacketType.UpdateDataChanged:
DataUpdatedPacket dudp = basePacket as DataUpdatedPacket;
PacketMembers.Append("modeType: ");
PacketMembers.Append(dudp.modeType);
break;
case PacketType.UpdateConsoleModeReq:
ConsoleUpdatePacket cup = basePacket as ConsoleUpdatePacket;
PacketMembers.Append("consoleMode: ");
PacketMembers.Append(cup.consoleMode);
PacketMembers.Append("TargetBot: ");
PacketMembers.Append(cup.TargetBot);
break;
case PacketType.UpdateConsoleModeChanged:
ConsoleUpdatedPacket cudp = basePacket as ConsoleUpdatedPacket;
PacketMembers.Append("consoleMode: ");
PacketMembers.Append(cudp.consoleMode);
break;
case PacketType.UniversalCommand:
UniversalCommandPacket ucp = basePacket as UniversalCommandPacket;
PacketMembers.Append("key: ");
PacketMembers.Append(ucp.key);
PacketMembers.Append("keyType: ");
PacketMembers.Append(ucp.keyType);
break;
case PacketType.ClientsInfoReq:
ClientinfoReqPacket cirp = basePacket as ClientinfoReqPacket;
break;
case PacketType.ClientsInfo:
ClientinfoPacket cip = basePacket as ClientinfoPacket;
PacketMembers.Append("ClientsInfo: ");
PacketMembers.Append(cip.ClientsInfo);
break;
default:
break;
}
PacketMembers.Append(')');
return(PacketMembers.ToString());
}
public static Packet Handle(Connection conn, byte[] packet)
{
ushort packetType;
try
{
var obj = GenericSerializer.GetObject<InitBlocksData>(packet);
packetType = obj.Type;
}
catch (Exception e)
{
packetType = BitConverter.ToUInt16(packet, 2);
}
var cm = ConnectionManager.Instance;
var pm = ProcessingManager.Instance;
switch (packetType)
{
case 0:
var ciPacket = new ClientInfoPacket(packet);
conn.RemoteClientID = ciPacket.ClientID;
string ip = conn.socket.RemoteEndPoint.ToString().Split(':')[0];
ushort port = ciPacket.ListenPort;
cm.Broadcast(new ConnectionPacket(ciPacket.ClientID, ip, port));
return ciPacket;
case 1:
MessagePacket mPacket = new MessagePacket(packet);
if (OnMessageReceived != null)
OnMessageReceived(mPacket.Message);
break;
case 2:
ConnectionPacket cPacket = new ConnectionPacket(packet);
OnMessageReceived(string.Format("packet received: {0}:{1}", cPacket.IP, cPacket.Port));
if (cm.GetConnection(cPacket.ClientID) == null && cm.ClientID != cPacket.ClientID)
{
//OnMessageReceived(string.Format("trying to connect: {0}:{1}", cPacket.IP, cPacket.Port));
cm.Connect(cPacket.IP, cPacket.Port);
}
break;
case 3:
ProcessingBlockNotifyPacket pbnp = new ProcessingBlockNotifyPacket(packet);
pm.SetProcessingState(pbnp.BlockId, pbnp.State);
OnMessageReceived(string.Format("Block {0} | {1}.", pbnp.BlockId, pbnp.State.ToString()));
//MessageBox.Show(string.Format("Block {0} | {1}.", pbnp.BlockId, pbnp.State.ToString()));
break;
case 4:
HashFoundPacket hfPacket = new HashFoundPacket(packet);
OnMessageReceived("Password found " + hfPacket.Password);
OnHashFoundEvent(hfPacket.Password);
pm.Initialized = false;
break;
case 5:
InitBlocksPacket ibp = new InitBlocksPacket(packet);
if (pm.Initialized)
return ibp;
OnMessageReceived("Initializing blocks...");
pm.Setup(ibp.MD5Hash, ibp.Range);
OnMessageReceived("Blocks Initialized.");
break;
case 6:
BlockProcessPacket bpp = new BlockProcessPacket(packet);
break;
}
return null;
}
