spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include <string> 
#include "SFML\Network.hpp" 

class CNetzwerk 
{ 
public: 
CNetzwerk(); // Konstruktor 
~CNetzwerk(); // Destruktor 
sf::IpAddress getPublicIP(); // liefert die globale IP 
sf::IpAddress getLocalIP(); // liefert die lokale IP 
sf::IpAddress getLastIP(); // liefert die IP des Absenders des letzten angekommenen Paketes 
std::string receive(); // Daten empfangen 
void send(std::string _data, int _Empfänger); // Daten verschicken 
void blocking(bool _Block); // Blocking ein- oder ausschalten 
unsigned short getPort(); // liefert den Port 

private: 
sf::IpAddress publicIP; // globale IP-Adresse des Servers 
sf::IpAddress localIP; // lokale IP-Adresse des Servers 
sf::UdpSocket *m_psocket; // Zeiger auf Socket-Instanz 
sf::IpAddress IP_01; // IP-Adresse von Spieler 1 
sf::IpAddress IP_02; // IP-Adresse von Spieler 2 
sf::IpAddress IP_sender; // IP-Adresse des letzten eingegangenen Packetes 

unsigned short m_Port; // Port von Server 

};

C-/C++-Quelltext

#include <Windows.h> 
#include <iostream> 
#include "CNetzwerk.hpp" 

// Konstruktor 
CNetzwerk::CNetzwerk() 
{ 
m_psocket = new sf::UdpSocket; // Neue UdpSocket-Instanz 

m_Port = GetPrivateProfileIntA ("network", "port", 0, "Config/network.ini"); 

if (m_psocket->bind(m_Port) != sf::Socket::Done) 
{ 
std::cout << "[FEHLER] Socket anbinden!" << std::endl; 
} 

m_psocket->setBlocking(true); // Blocking standardmäßig an 

localIP = getLocalIP(); 

IP_01 = "127.0.0.1"; 
} 

// Destruktor 
CNetzwerk::~CNetzwerk() 
{ 
if (m_psocket != nullptr) 
{ 
delete m_psocket; 
m_psocket = nullptr; 
} 
} 

// senden von Daten 
void CNetzwerk::send(std::string _data, int _Empfänger) 
{ 
if (_Empfänger == 0 && localIP != "") 
{ 
if (m_psocket->send(_data.c_str(), 100, localIP, m_Port) != sf::Socket::Done) 
{ 
std::cout << "[FEHLER] Uebertragung von UDP-Paket an: " << localIP << std::endl; // Fehler... 
} 
else 
{ 
} 
} 
else if (_Empfänger == 1 && IP_01 != "") 
{ 
if (m_psocket->send(_data.c_str(), 100, IP_01, m_Port) != sf::Socket::Done) 
{ 
std::cout << "[FEHLER] Uebertragung von UDP-Paket an: " << IP_01 << std::endl; // Fehler... 
} 
else 
{ 
} 
} 
else if (_Empfänger == 2 && IP_02 != "") 
{ 
if (m_psocket->send(_data.c_str(), 100, IP_02, m_Port) != sf::Socket::Done) 
{ 
std::cout << "[FEHLER] Uebertragung von UDP-Paket an: " << IP_02 << std::endl; // Fehler... 
} 
} 

} 

// empfangen von Daten 
std::string CNetzwerk::receive() 
{ 
char data[100] = ""; 

std::size_t received; 

if (m_psocket->receive(data, 100, received, IP_sender, m_Port) != sf::Socket::Done) 
{ 
std::cout << "[FEHLER] Empfangen von UDP-Paket von: " << IP_sender << std::endl; // Fehler... 
} 

std::string sData = data; 

return sData; 
} 

// liefert Port 
unsigned short CNetzwerk::getPort() 
{ 
return m_Port; 
} 

// Blocking ein- oder ausschalten 
void CNetzwerk::blocking(bool _Block) 
{ 
if (_Block == true) 
{ 
m_psocket->setBlocking(true); // Blocking einschalten = true 
std::cout << "Blocking eingeschalten!" << std::endl; 
} 
else if (_Block == false) 
{ 
m_psocket->setBlocking(false); // Blocking ausschalten = false 
std::cout << "Blocking ausgeschalten!" << std::endl; 
} 
else 
{ 
std::cout << "[FEHLER] Blocking konnte nicht ein- oder ausgeschalten werden!" << std::endl; 
} 
} 

// globale IP 
sf::IpAddress CNetzwerk::getPublicIP() 
{ 
publicIP = sf::IpAddress::getPublicAddress(); 
return publicIP; 
} 

// lokale IP 
sf::IpAddress CNetzwerk::getLocalIP() 
{ 
localIP = sf::IpAddress::getLocalAddress(); 
return localIP; 
}

C-/C++-Quelltext

#include <SFML/Network/IpAddress.hpp> 
#include <iostream> 

int main() 
{ 
    std::cout << sf::IpAddress::getPublicAddress() << std::endl; 
    std::cin.get(); 
    return 0; 
}