private void Form1_Load(object sender, EventArgs e)
{
//Trigger the method PrintIncomingMessage when a packet of type 'Message' is received
//We expect the incoming object to be a string which we state explicitly by using <string>
NetworkComms.AppendGlobalIncomingPacketHandler <string>("InitClient", this.InitClient);
//Trigger the method PrintIncomingMessage when a packet of type 'Message' is received
//We expect the incoming object to be a string which we state explicitly by using <string>
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Message", this.PrintIncomingMessage);
//Start listening for incoming connections
Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(System.Net.IPAddress.Any, serverPortStatic));
//Print out the IPs and ports we are now listening on
richTextBox1.AppendText("Server listening for TCP connection on:");
richTextBox1.AppendText("\n");
foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
{
richTextBox1.AppendText(String.Format("{0}:{1}", localEndPoint.Address, localEndPoint.Port));
richTextBox1.AppendText("\n");
}
//Let the user close the server
richTextBox1.AppendText("\nPress ShutDown to close server.");
richTextBox1.AppendText("\n");
//ClientForm a = new ClientForm("as", "asd");
//We have used NetworkComms so we should ensure that we correctly call shutdown
}
public void Connect(IPAddress address)
{
NetworkComms.RemoveGlobalConnectionCloseHandler(HandleConnectionClosed);
NetworkComms.Shutdown();
connectionInfo = new ConnectionInfo(address.ToString(), port);
if (!packetsAppended)
{
NetworkComms.AppendGlobalIncomingPacketHandler <Custom>("Custom", ReceiveCustomPacket);
NetworkComms.AppendGlobalIncomingPacketHandler <int>(PacketName.ReSessionVerificationResult.ToString(), SessionVerificationResultReceived);
NetworkComms.AppendGlobalIncomingPacketHandler <string>(PacketName.ReSessionId.ToString(), SessionIdReceived);
NetworkComms.AppendGlobalIncomingPacketHandler <int>(PacketName.ReLoginResult.ToString(), ReceiveLoginResult);
NetworkComms.AppendGlobalIncomingPacketHandler <ModuleList>(PacketName.ReModuleList.ToString(), ModuleList);
NetworkComms.AppendGlobalIncomingPacketHandler <AppFileData>(PacketName.ReAppFile.ToString(), AppFile);
NetworkComms.AppendGlobalIncomingPacketHandler <GroupList>(PacketName.ReUserGroupList.ToString(), GroupListReceived);
NetworkComms.AppendGlobalIncomingPacketHandler <int>(PacketName.ReUnauthorized.ToString(), UnAuthorizedReceived);
packetsAppended = true;
}
NetworkComms.AppendGlobalConnectionCloseHandler(HandleConnectionClosed);
NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(DPSManager.GetDataSerializer <ProtobufSerializer>(),
NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options);
}
// client
public ChatForm(Connection newTCPConn)
{
NetworkComms.AppendGlobalIncomingPacketHandler <messageHolder>("Message", addMessage);
NetworkComms.AppendGlobalIncomingPacketHandler <clientInfo>("ClientInfo", c_addClient);
clientList = new ArrayList();
this.newTCPConn = newTCPConn;
InitializeComponent();
isHost = false;
cinfo = new clientInfo("Anonymous");
try
{
newTCPConn.SendObject("ClientInfo", cinfo);
}
catch (Exception e)
{
MessageBox.Show("ERR: " + e.Message);
return;
}
String msg = "Connection successful.";
ChatLog.Items.Add(msg);
Users.Items.Add(cinfo.name);
Rank.Items.Add("G");
}
public void Connect()
{
//Trigger the method PrintIncomingMessage when a packet of type 'Network' is received
NetworkComms.AppendGlobalIncomingPacketHandler <Network>("Network", PrintIncomingMessage);
NetworkComms.AppendGlobalConnectionEstablishHandler(OnConnectionEstablished);
NetworkComms.AppendGlobalConnectionCloseHandler(OnConnectionClosed);
Thread.Sleep(net.SLEEP);
//Start listening for incoming connections
Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(System.Net.IPAddress.Any, 2222));
//Print out the IPs and ports we are now listening on
Console.WriteLine("Server listening for TCP connection on:");
foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
{
Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port);
}
Console.WriteLine("\ntype quit' to close server.");
while (Console.ReadLine() != "quit")
{
;
}
//We have used NetworkComms so we should ensure that we correctly call shutdown
NetworkComms.Shutdown();
}
/// <summary>
///
/// </summary>
/// <param name="Port"></param>
/// <param name="response"></param>
private static void SynchronousStart(int Port, out string response)
{
try
{
//Append a packet handler that will get executed when the server receives a "RequestCustomObject" packetType.
//Note: The expected incoming object type here is irrelevant because the client is not providing an object
//If the client does not provide an object when sending the incoming object is set to GetDefault(Type).
NetworkComms.AppendGlobalIncomingPacketHandler <int>("RequestCustomObject", (packetHeader, connection, input) =>
{
//For this short example we just reply with a new CustomObject
//CustomObject myCustomObject = new CustomObject("TESTE",1010);
string myCustomObject = Guid.NewGuid().ToString().Split('-').First();
PrintIncomingMessage(packetHeader, connection, myCustomObject);
//When this is received by the client it will complete the synchronous request
connection.SendObject("CustomObjectReply", myCustomObject);
PrintOutputMessage(packetHeader, connection, myCustomObject);
});
Listening(Port);
response = "Server em escuta nos endereços:";
foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
{
response += Environment.NewLine + String.Format("{0}:{1}", localEndPoint.Address, localEndPoint.Port);
}
}
catch (Exception err)
{
response = err.ToString();
}
}
static void Main(string[] args)
{
//Trigger the method PrintIncomingMessage when a packet of type 'Message' is received
//We expect the incoming object to be a string which we state explicitly by using <string>
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Message", PrintIncomingMessage);
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Login", LoginMessage);
//Start listening for incoming connections
Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(System.Net.IPAddress.Parse("127.0.0.1"), 12345));
//Print out the IPs and ports we are now listening on
Console.WriteLine("Server listening for TCP connection on:");
foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
{
Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port);
}
//Let the user close the server
Console.WriteLine("\nPress any key to close server.");
Console.ReadKey(true);
//We have used NetworkComms so we should ensure that we correctly call shutdown
NetworkComms.Shutdown();
}
private void InitConnection()
{
string serverAddress;
DataSerializer dataSerializer = DPSManager.GetDataSerializer <ProtobufSerializer>();
List <DataProcessor> dataProcessors = new List <DataProcessor>();
Dictionary <string, string> dataProcessorOptions = new Dictionary <string, string>();
dataProcessors.Add(DPSManager.GetDataProcessor <SharpZipLibCompressor.SharpZipLibGzipCompressor>());
NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(dataSerializer, dataProcessors, dataProcessorOptions);
NetworkComms.DefaultSendReceiveOptions.IncludePacketConstructionTime = true;
NetworkComms.DefaultSendReceiveOptions.ReceiveHandlePriority = QueueItemPriority.AboveNormal;
if (IsMainThread)
{
NetworkComms.AppendGlobalIncomingPacketHandler <VRCommand>("Command", HandleIncomingCommand);
}
SystemConfigs.TryGetValue("ServerIPPort", out serverAddress); // get IP:Port
IPEndPoint ip = IPTools.ParseEndPointFromString(serverAddress);
targetServerConnectionInfo = new ConnectionInfo(ip, ApplicationLayerProtocolStatus.Enabled);
}
private void OnConnectionEstablished(object sender, EventArgs e)
{
//LogTextBox.Text += "Connection Established" + Environment.NewLine;
LogTextBox.AppendText("Connection Established" + Environment.NewLine);
//ControlButton is kinda glitchy
ControlButton.Enabled = true;
ConnectButton.Enabled = false;
viewerWidth();
//pRdpViewer.RequestControl(RDPCOMAPILib.CTRL_LEVEL.CTRL_LEVEL_VIEW);
NetworkComms.AppendGlobalIncomingPacketHandler <string>("CtrlLvl", HandleIncomingCtrlLvlPacket);
GetCtrlLvl();
//pRdpViewer.RequestControl(RDPCOMAPILib.CTRL_LEVEL.CTRL_LEVEL_VIEW);
//Thread.Sleep(10000);
//pRdpViewer.Size = new Size(1280, 720);
//Form2 newMDIChild = new Form2();
// Set the Parent Form of the Child window.
//newMDIChild.MdiParent = this;
// Display the new form.
//newMDIChild.Show();
}
// private static bool Emulator;
public static void Start()
{
if (_started)
{
return;
}
_started = true;
NetworkComms.EnableLogging(new LiteLogger(LiteLogger.LogMode.ConsoleOnly));
NetworkComms.IgnoreUnknownPacketTypes = true;
var serializer = DPSManager.GetDataSerializer <NetworkCommsDotNet.DPSBase.ProtobufSerializer>();
NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(serializer,
NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options);
NetworkComms.AppendGlobalIncomingPacketHandler <ServerInfo>(ServerInfo.GetHeader(), ServerInfoReceived);
PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast);
PeerDiscovery.OnPeerDiscovered += OnPeerDiscovered;
Connection.StartListening(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 0));
PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast);
}
private void connectButton_Click(object sender, EventArgs e)
{
if (isValidIPAddress())
{
try
{
String serverInfo = ipAddressTextBox.Text;
//Parse the necessary information out of the provided string
serverIP = serverInfo.Split(':').First();
serverPort = int.Parse(serverInfo.Split(':').Last());
// Handle error connection request
NetworkComms.AppendGlobalIncomingPacketHandler <string>("connectionInfo", HandleConnectionInfo);
NetworkComms.AppendGlobalIncomingPacketHandler <string>("success", HandleSuccessConnection);
NetworkComms.AppendGlobalIncomingPacketHandler <string>("error", HandleErrorConnection);
//Send the message in a single line
NetworkComms.SendObject("RequestConnectionInfo", serverIP, serverPort, "");
connected = true;
connectButton.Enabled = false;
}
catch
{
MessageBox.Show("Could not connect to requested IP and port");
}
}
else
{
MessageBox.Show("Invalid IP and port entered");
}
}
public CreateGameService(GlobalRegister gamecontext)
{
_gr = gamecontext;
NetworkComms.AppendGlobalIncomingPacketHandler <MapRequests>(RequestNames.GetMapInfos, (header, connection, incomingObject) =>
{
ProcessMapRequests(connection, incomingObject);
});
NetworkComms.AppendGlobalIncomingPacketHandler <GameSettings>(RequestNames.StartGame, (
(header, connection, incomingObject) =>
{
var user = _gr.User.GetUserByConnection(connection);
CreateGameWithSettings(user, incomingObject);
}));
NetworkComms.AppendGlobalIncomingPacketHandler <JoinGame>(RequestNames.JoinGame, (header, connection, incomingObject) =>
{
var user = _gr.User.GetUserByConnection(connection);
JoinOpenGame(user, incomingObject);
});
NetworkComms.AppendGlobalIncomingPacketHandler <GameNotifications>(RequestNames.GameNotification, (header, connection, incomingObject) =>
{
var user = _gr.User.GetUserByConnection(connection);
ProcessGameNotifications(incomingObject, connection);
});
NetworkComms.AppendGlobalIncomingPacketHandler <GameCommands>(RequestNames.GameCommand,
(header, connection, incomingObject) =>
{
var user = _gr.User.GetUserByConnection(connection);
var session = _gr.GameSessions.GetSessionByUserId(user);
incomingObject.SenderId = user.Id;
session.Commands.Push(incomingObject);
});
}
public void Run()
{
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Message", PrintIncomingMessage);
NetworkComms.AppendGlobalIncomingPacketHandler <Protocol>("Protocol", HandleIncomingProtocol);
NetworkComms.AppendGlobalIncomingPacketHandler <HandShake>("HandShake", HandleIncomingHandShake);
NetworkComms.AppendGlobalConnectionCloseHandler(HandleConnectionClosed);
this.Serializer = DPSManager.GetDataSerializer <ProtobufSerializer>();
NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(Serializer, NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options);
Connection.StartListening(ConnectionType.TCP, new IPEndPoint(IPAddress.Any, 0));
Console.WriteLine("Server listening for TCP connection on:");
foreach (IPEndPoint l in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
{
Console.WriteLine("{0}:{1}", l.Address, l.Port);
}
lastServerIPEndPoint = (IPEndPoint)Connection.ExistingLocalListenEndPoints(ConnectionType.TCP).Last();
while (true)
{
if (Clients.Count() == 2)
{
game = new SPoker(Clients.Last(), Clients.First());
game.Start();
}
Thread.Sleep(200);
}
//NetworkComms.Shutdown();
}
private static void AppendClientListener(ClientListenEvents listenerEvent)
{
NetworkComms.AppendGlobalIncomingPacketHandler <PlayerInfo>("PlayerInfo",
(packetHeader, connection, incomingString) =>
{
listenerEvent.onRecPlayerInfo?.Invoke(packetHeader, connection, incomingString);
}
);
NetworkComms.AppendGlobalIncomingPacketHandler <GeneratePlayerVehicle>("GeneratePlayerVehicle",
(packetHeader, connection, incomingString) =>
{
listenerEvent.onRecGeneratePlayerVehicle?.Invoke(packetHeader, connection, incomingString);
}
);
NetworkComms.AppendGlobalIncomingPacketHandler <SyncVehicle>("SyncVehicle",
(packetHeader, connection, incomingString) =>
{
listenerEvent.onRecSyncVehicle?.Invoke(packetHeader, connection, incomingString);
}
);
NetworkComms.AppendGlobalIncomingPacketHandler <DestroyPlayerVehicle>("DestroyPlayerVehicle",
(packetHeader, connection, incomingString) =>
{
listenerEvent.onRecDestoryPlayerVehicle?.Invoke(packetHeader, connection, incomingString);
}
);
}
private static void RunServer()
{
//ILogger logger = new LiteLogger(LiteLogger.LogMode.LogFileOnly, "DebugTests_" + NetworkComms.NetworkIdentifier + ".txt");
//NetworkComms.EnableLogging(logger);
//Slightly improves performance when we have many simultaneous incoming connections.
NetworkComms.ConnectionListenModeUseSync = true;
//Trigger the method PrintIncomingMessage when a packet of type 'Message' is received
//We expect the incoming object to be a string which we state explicitly by using <string>
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Message", PrintIncomingMessage);
NetworkComms.AppendGlobalConnectionEstablishHandler(OnConnectionEstablished);
NetworkComms.AppendGlobalConnectionCloseHandler(OnConnectionClosed);
Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(System.Net.IPAddress.Any, 4000));
//Print out the IPs and ports we are now listening on
Console.WriteLine("Server listening for TCP connection on:");
foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
{
Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port);
}
//Let the user close the server
Console.WriteLine("\nPress any key to close server.");
Console.ReadKey(true);
//We have used NetworkComms so we should ensure that we correctly call shutdown
NetworkComms.Shutdown();
}
/// <summary>
/// Try to connect to the server/host
/// </summary>
/// <param name="connectionInfo">The IP and port to try to connect to</param>
public static void ConnectToServer(ConnectionInfo connectionInfo)
{
Connection connection;
//Try to connect to the server using TCP
try
{
connection = TCPConnection.GetConnection(connectionInfo);
}
//Catch any connection error and send an error message
catch
{
MDI_Container.staticMdi_Container.mdi_Join.Invoke(MDI_Forms.MDI_Join.DJoinResult, new object[] { false });
return;
}
//Add a event handler to handle a shutdown of the connection
connection.AppendShutdownHandler(new NetworkComms.ConnectionEstablishShutdownDelegate((c) => MDI_Container.staticMdi_Container.BeginInvoke(MDI_Container.staticMdi_Container.DLostConnection)));
//Register incoming packet handler for setting up RPC from the server
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Initialize-Connection", InitializeServerRPC);
//Set the RPC server to use the newly established connection with the server
RemoteProcedureCalls.Server.serverConnection = connection;
//Register a instance of the clients interface and make it available to the server via RPC
RemoteProcedureCalls.Server.RegisterInstanceForPublicRemoteCall <ClientInterfaceClass, IClientInterface>(new ClientInterfaceClass(), "Client");
//Send a command to the server to tell it to connect to the clients RPC
connection.SendObject <string>("Initialize-Connection", "");
}
public static bool StartClient(string Hostname, int Port, string Password)
{
try
{
logger.Info("Trying to connect to Server");
_Password = Password;
isServer = false;
IPAddress ipAddress = null;
try
{
ipAddress = IPAddress.Parse(Hostname);
}
catch (FormatException)
{
// Improperly formed IP address.
// Try resolving as a domain.
ipAddress = Dns.GetHostEntry(Hostname).AddressList[0];
}
ConnectionInfo serverInfo = new ConnectionInfo(ipAddress.ToString(), Port);
NetworkComms.AppendGlobalConnectionEstablishHandler(HandleNewConnection, false);
NetworkComms.AppendGlobalIncomingPacketHandler <iRTVOMessage>("iRTVOMessage", HandleIncomingMessage);
NetworkComms.AppendGlobalIncomingPacketHandler <object>("iRTVOAuthenticate", HandleAuthenticateRequest);
NetworkComms.AppendGlobalConnectionCloseHandler(HandleConnectionClosed);
TCPConnection.GetConnection(serverInfo, true);
}
catch (Exception ex)
{
logger.Error("Failed to connect to Server: {0}", ex.Message);
return(false);
}
return(true);
}
static void Main(string[] args)
{
//Trigger the method PrintIncomingMessage when a packet of type 'Message' is received
//We expect the incoming object to be a string which we state explicitly by using <string>
NetworkComms.AppendGlobalIncomingPacketHandler <string>("ConnectionRequest", ConnectNewUser);
NetworkComms.AppendGlobalIncomingPacketHandler <string[]>("OpenServer", OpenNewChatServer);
NetworkComms.AppendGlobalIncomingPacketHandler <string>("connectMe", ConnectToChatServer);
NetworkComms.AppendGlobalIncomingPacketHandler <string[]>("newMessage", AddMessageChatServer);
// Close connection and open connection array for new connection
NetworkComms.AppendGlobalConnectionCloseHandler(closeConnection);
//Start listening for incoming connections
Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(System.Net.IPAddress.Any, 0));
//Print out the IPs and ports we are now listening on
Console.WriteLine("Server listening for TCP connection on:");
foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
{
Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port);
}
//Let the user close the server
Console.WriteLine("\nPress any key to close server.");
Console.ReadKey(true);
//We have used NetworkComms so we should ensure that we correctly call shutdown
NetworkComms.Shutdown();
}
/// <summary>
/// Create <see cref="AccountManager"/>.
/// </summary>
/// <param name="accountRepository"><see cref="IAccountRepository"/> implementation.</param>
/// <param name="groupRepository"><see cref="IGroupRepository"/> implementation.</param>
public AccountManager(IAccountRepository accountRepository, IGroupRepository groupRepository)
{
this.authorizedAccounts = new Dictionary <ShortGuid, long>();
this.groupRepository = groupRepository;
this.accountRepository = accountRepository;
NetworkComms.AppendGlobalIncomingPacketHandler <LoginRequest>(PacketName.RequestLogin.ToString(), LoginRequest);
NetworkComms.AppendGlobalIncomingPacketHandler <int>(PacketName.RequestAccountList.ToString(), RequestAccountList);
NetworkComms.AppendGlobalIncomingPacketHandler <RegisterRequest>(PacketName.RequestRegisterAccount.ToString(), RegisterRequest);
NetworkComms.AppendGlobalIncomingPacketHandler <long>(PacketName.RequestUserGroupList.ToString(), RequestUserGroupList);
NetworkComms.AppendGlobalIncomingPacketHandler <PasswordChangeRequest>(PacketName.RequestUpdatePassword.ToString(), ReceivePasswordChangeRequest);
NetworkComms.AppendGlobalIncomingPacketHandler <GroupRequest>(PacketName.RequestDeleteGroupFromUser.ToString(), ReceiveGroupRemoveFromUserRequest);
NetworkComms.AppendGlobalIncomingPacketHandler <Account>(PacketName.RequestUpdateAccountInformation.ToString(), ReceiveUserInformationUpdateRequest);
NetworkComms.AppendGlobalIncomingPacketHandler <int>(PacketName.RequestGroupList.ToString(), ReceiveRequestGroupList);
NetworkComms.AppendGlobalIncomingPacketHandler <GroupRequest>(PacketName.RequestAddGroupToUser.ToString(), ReceiveRequestAddGroupToUser);
NetworkComms.AppendGlobalIncomingPacketHandler <long>(PacketName.RequestDeleteAccount.ToString(), ReceiveRequestDeleteAccount);
NetworkComms.AppendGlobalIncomingPacketHandler <long>(PacketName.RequestDeleteGroup.ToString(), ReceiveDeleteGroup);
NetworkComms.AppendGlobalIncomingPacketHandler <Group>(PacketName.RequestAddGroup.ToString(), ReceiveAddGroup);
NetworkComms.AppendGlobalIncomingPacketHandler <long>(PacketName.RequestAppGroupList.ToString(), ReceiveRequestAppGroupList);
NetworkComms.AppendGlobalIncomingPacketHandler <string>(PacketName.RequestSessionVerification.ToString(), ReceiveSessionVerification);
NetworkComms.AppendGlobalIncomingPacketHandler <GroupRequest>(PacketName.PostAddGroupToApp.ToString(), ReceivePostAddGroupToApp);
NetworkComms.AppendGlobalIncomingPacketHandler <GroupRequest>(PacketName.PostRemoveGroupFromApp.ToString(), ReceivePostRemoveGroupFromApp);
// Check if administrator group exists (a requirement)
if (!groupRepository.Exists(0))
{
// Administrator group should have id = 0
groupRepository.AddGroup(0, "administrator", "Default administrator group");
}
}
static void Main(string[] args)
{
NetworkComms.AppendGlobalIncomingPacketHandler <PlayerObject>("Message", PrintIncomingMessage);
Console.WriteLine("Please enter the server IP and port in the format 192.168.0.1:10000 and press return:");
string serverInfo = Console.ReadLine();
serv.serverIp = serverInfo.Split(':').First();
serv.serverPort = int.Parse(serverInfo.Split(':').Last());
while (end != true)
{
if (once == false)
{
PlayerObject message = new PlayerObject(5, tmp, "Connected");
NetworkComms.SendObject("Message", serv.serverIp, serv.serverPort, message);
once = true;
}
if (Equals(Console.ReadLine(), "PLAY") == true)
{
PlayerObject message = new PlayerObject(20, tmp, "Play from player" + PlayerId);
Console.WriteLine("The card played is : " + tmp[0].ToString());
NetworkComms.SendObject("Message", serv.serverIp, serv.serverPort, message);
}
}
NetworkComms.Shutdown();
}
public Form1()
{
InitializeComponent();
NetworkComms.AppendGlobalIncomingPacketHandler <int>("RequestLoginData", (packetHeader, connection, input) =>
{
Credentials cred = new Credentials(textBox1.Text, textBox2.Text);
connection.SendObject("LoginData", cred);
});
NetworkComms.AppendGlobalIncomingPacketHandler <int>("DisconnectMessage", (packetHeader, connection, input) =>
{
MessageBox.Show("Your connection has been dropped by the server!");
});
NetworkComms.AppendGlobalIncomingPacketHandler <int>("ConnectionMessage", (packetHeader, connection, input) =>
{
MessageBox.Show("You have connected sucesfully!");
});
NetworkComms.AppendGlobalIncomingPacketHandler <int>("LoginApproved", (packetHeader, connection, input) =>
{
test();
Invoke(new Action(() => Close()));
});
NetworkComms.AppendGlobalIncomingPacketHandler <String>("Message", IncMessage);
NetworkComms.AppendGlobalIncomingPacketHandler <String>("UsersCount", UsersCount);
}
private static void InitNetworkComms()
{
DataSerializer dataSerializer = DPSManager.GetDataSerializer <ProtobufSerializer>();
List <DataProcessor> dataProcessors = new List <DataProcessor>();
Dictionary <string, string> dataProcessorOptions = new Dictionary <string, string>();
dataProcessors.Add(DPSManager.GetDataProcessor <SharpZipLibCompressor.SharpZipLibGzipCompressor>());
NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(dataSerializer, dataProcessors, dataProcessorOptions);
NetworkComms.DefaultSendReceiveOptions.IncludePacketConstructionTime = true;
NetworkComms.DefaultSendReceiveOptions.ReceiveHandlePriority = QueueItemPriority.AboveNormal;
NetworkComms.AppendGlobalIncomingPacketHandler <VRCommandServer>("Command", HandleGlobalIncomingCommand);
NetworkComms.AppendGlobalConnectionEstablishHandler(HandleGlobalConnectionEstablishEvent);
NetworkComms.AppendGlobalConnectionCloseHandler(HandleGlobalConnectionCloseEvent);
IPEndPoint ip = IPTools.ParseEndPointFromString(Utility.GetCoreConfig("ServerIPPort"));
_targetServerConnectionInfo = new ConnectionInfo(ip, ApplicationLayerProtocolStatus.Enabled);
_timerPing = new System.Timers.Timer();
_timerPing.Elapsed += new ElapsedEventHandler(OnTimerPingEvent);
_timerPing.Interval = 3000;
_timerPing.Enabled = true;
}
private Client()
{
NetworkComms.DisableLogging();
NetworkComms.IgnoreUnknownPacketTypes = true;
var serializer = DPSManager.GetDataSerializer <ProtobufSerializer>();
NetworkComms.DefaultSendReceiveOptions.DataProcessors.Add(
DPSManager.GetDataProcessor <RijndaelPSKEncrypter>());
NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(serializer,
NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options);
RijndaelPSKEncrypter.AddPasswordToOptions(NetworkComms.DefaultSendReceiveOptions.Options, Utility.PSK);
NetworkComms.AppendGlobalIncomingPacketHandler <Ping>(Ping.Header, PingHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <ClassInfo>(ClassInfo.Header, ClassInfoHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <InstructorLogin>(InstructorLogin.Header, InstructorLoginHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <ClientInfo>(ClientInfo.Header, ClientInfoHandler);
PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast);
PeerDiscovery.OnPeerDiscovered += OnPeerDiscovered;
//NetworkComms.AppendGlobalIncomingPacketHandler<byte[]>("PartialFileData", IncomingPartialFileData);
//NetworkComms.AppendGlobalIncomingPacketHandler<SendInfo>("PartialFileDataInfo",
// IncomingPartialFileDataInfo);
//NetworkComms.AppendGlobalConnectionCloseHandler(OnConnectionClose);
PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast);
}
public void NetworkCommsConfiguration(int port)
{
#region First Initialisation
//On first initialisation we need to configure NetworkComms.Net to handle our incoming packet types
//We only need to add the packet handlers once. If we call NetworkComms.Shutdown() at some future point these are not removed.
if (FirstInitialisation)
{
FirstInitialisation = false;
//Configure NetworkComms.Net to handle any incoming packet of type 'ChatMessage'
//e.g. If we receive a packet of type 'ChatMessage' execute the method 'HandleIncomingChatMessage'
NetworkComms.AppendGlobalIncomingPacketHandler <DataReceiveModel>("ServerMessage", HandleIncomingChatMessage);
}
#endregion
#region Set serializer
//Set the default send receive options to use the specified serializer. Keep the DataProcessors and Options from the previous defaults
NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(Serializer, NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options);
#endregion
#region Listen
//Start listening for new incoming TCP connections
//Can replace IPAddress.Any with IPAddress.Parse("A string of specify IP address but must exsist in command ipconfig in cmd")
Connection.StartListening(ConnectionType.TCP, new IPEndPoint(IPAddress.Any, port));
#endregion
}
/// <summary>
/// Starts the server at the designated IP address and port. Also sets up all the required handlers
/// to recieve packets. Call "EndServer" once the server has completed its job.
/// </summary>
/// <param name="address">IP address on which to listen.</param>
/// <param name="port">Port on which to listen.</param>
public static void CreateServer(IPAddress address, int port)
{
//Trigger the method PrintIncomingMessage when a packet of type 'Message' (defined in the Client
//is received. We expect the incoming object to be a string which we state explicitly by using
//<string>.
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Message", PrintIncomingMessage);
NetworkComms.AppendGlobalIncomingPacketHandler <string>("Hello", NewIncomingConnection);
NetworkComms.AppendGlobalIncomingPacketHandler <StockRecord>("InsertStockRecord", InsertStock);
NetworkComms.AppendGlobalIncomingPacketHandler <int>("DeleteStockRecord", DeleteStock);
NetworkComms.AppendGlobalIncomingPacketHandler <int>("SelectStockRecord", SelectStock);
NetworkComms.AppendGlobalIncomingPacketHandler <StockRecord>("UpdateStockRecord", UpdateStock);
NetworkComms.AppendGlobalIncomingPacketHandler <StockRecord>("DecrementStockRecord", DecrementStock);
NetworkComms.AppendGlobalIncomingPacketHandler <List <ItemSaleRecord> >("InsertReceiptRecord", InsertReceipt);
NetworkComms.AppendGlobalIncomingPacketHandler <int>("GetAllReceipt", GetAllReceipt);
NetworkComms.AppendGlobalIncomingPacketHandler <int>("GetFullReceipt", GetFullReceipt);
NetworkComms.AppendGlobalIncomingPacketHandler <int>("DeleteReceiptRecord", DeleteReceipt);
NetworkComms.AppendGlobalIncomingPacketHandler <List <int> >("PredictSales", PredictSales);
NetworkComms.AppendGlobalIncomingPacketHandler <List <int> >("PredictProfit", PredictProfit);
//Start listening for incoming connections
Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(address, port));
//Print out the IPs and ports we are now listening on
Console.WriteLine("Server listening for TCP connection on:");
foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
{
Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port);
}
}
private void Form1_Load(object sender, EventArgs e)
{
Connection.StartListening(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 10000));
NetworkComms.AppendGlobalIncomingPacketHandler <string>("RegisterServerAddress", (packetHeader, connection, incomingString) =>
{
try
{
if (ServerEndPoint == null)
{
var serverEndPoint = (IPEndPoint)connection.ConnectionInfo.RemoteEndPoint;
var clientEndPoint = (IPEndPoint)connection.ConnectionInfo.LocalEndPoint;
//此端口tcp用
ServerEndPoint = new IPEndPoint(serverEndPoint.Address, 10012);
button1.Enabled = true;
button1.Text = $"TCP:{ServerEndPoint}";
textBox1.Text += $"{DateTime.Now}>> server {ServerEndPoint} request connect.\r\n>";
textBox1.Text += $"{DateTime.Now}>> {clientEndPoint.Address} to {ServerEndPoint.Address} port:10001.\r\n>";
//connection.SendObject<long>("SendClientAddress", clientip);
UDPConnection.SendObject("RegisterClientAddress", clientEndPoint.Address.Address, new IPEndPoint(ServerEndPoint.Address, 10001));
}
}
catch (Exception ex)
{
textBox1.Text += $"client error:{ex.Message}";
}
});
}
private void AppendHandlers()
{
NetworkComms.AppendGlobalIncomingPacketHandler <InitRoutineData>("ServerStartRoutine", HandleStartRoutine);
NetworkComms.AppendGlobalIncomingPacketHandler <InitRoutineData>("ServerSetPlayingTeam", HandleSetPlayingTeam);
NetworkComms.AppendGlobalIncomingPacketHandler <JudgeData>("ServerSetJudgeInfo", HandleSetJudgeInfo);
NetworkComms.AppendGlobalIncomingPacketHandler <string>("ServerCancelRoutine", HandleCancelRoutine);
}
static void Main(string[] args)
{
NetworkComms.AppendGlobalIncomingPacketHandler <String>("Welcome", welcome);
String ipAddress = "127.0.0.1";
IPAddress address = IPAddress.Parse(ipAddress);
IPEndPoint endpoint = new IPEndPoint(address, 5245);
Connection.StartListening(ConnectionType.TCP, endpoint);
Console.WriteLine("Server listening for TCP connection on:");
foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
{
Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port);
System.Console.WriteLine("lol3");
}
Console.WriteLine("\nPress any key to close server.");
Console.ReadKey(true);
NetworkComms.Shutdown();
}
public void initClient(string ipAddress, short port)
{
_port = port;
_ipAddress = ipAddress;
NetworkComms.AppendGlobalIncomingPacketHandler <string>(Macro.OBJECT_TYPE_MESSAGE, received);
sendToServer(Macro.CLIENT_CONNECT_QUERY);
}
/// <summary>
/// 初始化
/// </summary>
public static void Init()
{
if (isInited == true)
{
return;
}
//Add an incoming packet handler using default SendReceiveOptions.
// Multiple handlers for the same packet type will be executed in the order they are added.
//注册接收到消息的处理器 //PacketType用于标志哪种类型的消息，客户端和服务器端协议商定，标志消息类型，可以自定义
//事件是在多线程中回调的，不能实现确定回调的线程
NetworkComms.AppendGlobalIncomingPacketHandler <string>(PacketType, PacketHandlerAction);
//客户端建立连接事件
//事件是在多线程中回调的，不能实现确定回调的线程
NetworkComms.AppendGlobalConnectionEstablishHandler(ConnectionEstablishDelegate);
//关闭连接事件
//事件是在多线程中回调的，不能实现确定回调的线程
NetworkComms.AppendGlobalConnectionCloseHandler(ConnectionShutdownDelegate);
//未处理的信息包处理
//事件是在多线程中回调的，不能实现确定回调的线程
NetworkComms.AppendGlobalIncomingUnmanagedPacketHandler(UnmanagedPacketHandlerDelgatePointer);
isInited = true;
}
public TwoPlayersBettingLogic(IList <InternalPlayer> players, int smallBlind)
{
this.allPlayers = players;
this.smallBlind = smallBlind;
this.RoundBets = new List <PlayerActionName>();
NetworkComms.AppendGlobalIncomingPacketHandler <PlayerAction>("ReplyTurnContext", ReplyTurnContext);
}
