Error NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer,int p_buffer_size){
ERR_FAIL_COND_V(incoming_packets.size()==0,ERR_UNAVAILABLE);
Map<StringName,ENetPeer*>::Element *E=NULL;
if (target_peer!=StringName()) {
peer_map.find(target_peer);
if (!E) {
ERR_EXPLAIN("Invalid Target Peer: "+String(target_peer));
ERR_FAIL_V(ERR_INVALID_PARAMETER);
}
}
int packet_flags=0;
switch(transfer_mode) {
case TRANSFER_MODE_UNRELIABLE: {
packet_flags=ENET_PACKET_FLAG_UNSEQUENCED;
} break;
case TRANSFER_MODE_RELIABLE: {
packet_flags=ENET_PACKET_FLAG_RELIABLE;
} break;
case TRANSFER_MODE_ORDERED: {
packet_flags=ENET_PACKET_FLAG_RELIABLE;
} break;
}
/* Create a reliable packet of size 7 containing "packet\0" */
ENetPacket * packet = enet_packet_create (p_buffer,p_buffer_size,packet_flags);
if (target_peer==StringName()) {
enet_host_broadcast(host,send_channel,packet);
} else {
enet_peer_send (E->get(), send_channel, packet);
}
enet_host_flush(host);
return OK;
}
// Function for the keyboard thread.
void *
KeyboardThreadFunction(void *Data)
{
int i;
char Input[81] = "hello", *s;
ENetPacket *packet;
fprintf(stderr, "Ctrl-C to exit.\n");
while (1)
{
fprintf(stderr, PROMPT);
if (NULL == fgets(Input, sizeof(Input), stdin))
continue;
if (!IsServer && peer == NULL)
{
fprintf(stderr, "Not connected to server.\n");
continue;
}
// Trim off trailing CR or LF.
for (s = Input; *s; s++)
if (*s == '\n' || *s == '\r')
{
*s = 0;
break;
}
packet = enet_packet_create(Input, strlen(Input) + 1,
ENET_PACKET_FLAG_RELIABLE);
if (IsServer)
enet_host_broadcast(host, 0, packet);
else
{
i = enet_peer_send((ENetPeer *) peer, 0, packet);
if (i)
fprintf(stderr, "Failed.\n");
else
fprintf(stderr, "Succeeded.\n");
}
enet_host_flush(host);
}
}
bool Network::Broadcast(bool reliable, const void* data, int len)
{
AutoLock<Mutex> lock(m_mutex);
if(!m_host)
return false;
if(m_type != SERVER)
{
std::cout << "Broadcast operation valid only if type is server" << std::endl;
return false;
}
if(len == -1)
len = strlen((const char*)data);
ENetPacket* packet = enet_packet_create(data, len, reliable ? ENET_PACKET_FLAG_RELIABLE : 0);
enet_host_broadcast((ENetHost*)m_host, reliable ? 1 : 0, packet);
return true;
}
int main(int argc, char *argv[])
{
ENetAddress address;
ENetHost *server;
ENetEvent event;
int serviceResult;
puts("Starting server");
if (enet_initialize() != 0)
{
puts("Error initialising enet");
exit(EXIT_FAILURE);
}
/* Bind the server to the default localhost. */
/* A specific host address can be specified by */
/* enet_address_set_host (& address, "x.x.x.x"); */
address.host = ENET_HOST_ANY;
/* Bind the server to port 1234. */
address.port = 1234;
server = enet_host_create(&address,
32, /* number of clients */
2, /* number of channels */
0, /* Any incoming bandwith */
0); /* Any outgoing bandwith */
if (server == NULL)
{
puts("Could not create server host");
exit(EXIT_FAILURE);
}
while (true)
{
serviceResult = 1;
/* Keep doing host_service until no events are left */
while (serviceResult > 0)
{
/* Wait up to 1000 milliseconds for an event. */
serviceResult = enet_host_service(server, &event, 1000);
if (serviceResult > 0)
{
switch (event.type)
{
case ENET_EVENT_TYPE_CONNECT:
printf("A new client connected from %x:%u.\n",
event.peer->address.host,
event.peer->address.port);
/* Store any relevant client information here. */
event.peer->data = (void *)"Client information";
break;
case ENET_EVENT_TYPE_RECEIVE:
printf(
"A packet of length %lu containing '%s' was "
"received from %s on channel %u.\n",
event.packet->dataLength,
event.packet->data,
event.peer->data,
event.channelID);
/* Tell all clients about this message */
enet_host_broadcast(server, 0, event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
printf("%s disconnected.\n", event.peer->data);
/* Reset the peer's client information. */
event.peer->data = NULL;
break;
case ENET_EVENT_TYPE_NONE:
break;
}
}
else if (serviceResult > 0)
{
puts("Error with servicing the server");
exit(EXIT_FAILURE);
}
}
}
enet_host_destroy(server);
enet_deinitialize();
return 0;
}
void gs_frames_broadcast (ENetHost* host, ubyte_t ch1, ubyte_t ch2, EcUdc node, int reliable)
{
ENetPacket* packet = gs_frame_createPacket (ch1, ch2, node, reliable);
enet_host_broadcast (host, 0, packet);
}
void
Server::Run()
{
ENetEvent event;
string clave = "hola";
string foo = "";
cout << "Servido a la escucha..." << endl;
while (true)
{
foo = "";
enet_host_service (server, & event, 10000);
switch (event.type)
{
//Si se ha producido un evento de conexion
case ENET_EVENT_TYPE_CONNECT:
cout << "Nuevo cliente conectado. " <<
event.peer->address.host << ":" <<
event.peer->address.port << endl;
break;
//Evento de recibo de mensajes
case ENET_EVENT_TYPE_RECEIVE:
foo.append(reinterpret_cast<const char*>(event.packet->data));
if(foo == clave)
{
ENetPacket *response = enet_packet_create ("pepe", strlen
("pepe") + 1, ENET_PACKET_FLAG_RELIABLE);
enet_host_broadcast (server, 0, response);
}
else
enet_host_broadcast (server, 0, event.packet);
/*cout << "Se ha recibido del cliente: " << event.packet->data << endl;
stringstream ss;
ss << event.packet->data;
ENetPacket *response = enet_packet_create (ss.str(), strlen
(event.packet->data) + 1, ENET_PACKET_FLAG_RELIABLE);
enet_host_broadcast (server, 0, response);
enet_host_broadcast (server, 0, response);
enet_packet_destroy (event.packet);*/
break;
case ENET_EVENT_TYPE_DISCONNECT:
cout << "Se ha desconectado el cliente" << endl;
event.peer -> data = NULL;
break;
case ENET_EVENT_TYPE_NONE:
cout << "Se ha desconectado el cliente" << endl;
break;
}
}
enet_host_destroy(server);
}
Error NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer,int p_buffer_size){
ERR_FAIL_COND_V(!active,ERR_UNCONFIGURED);
ERR_FAIL_COND_V(connection_status!=CONNECTION_CONNECTED,ERR_UNCONFIGURED);
int packet_flags=0;
switch(transfer_mode) {
case TRANSFER_MODE_UNRELIABLE: {
packet_flags=ENET_PACKET_FLAG_UNSEQUENCED;
} break;
case TRANSFER_MODE_UNRELIABLE_ORDERED: {
packet_flags=0;
} break;
case TRANSFER_MODE_RELIABLE: {
packet_flags=ENET_PACKET_FLAG_RELIABLE;
} break;
}
Map<int,ENetPeer*>::Element *E=NULL;
if (target_peer!=0) {
E = peer_map.find(ABS(target_peer));
if (!E) {
ERR_EXPLAIN("Invalid Target Peer: "+itos(target_peer));
ERR_FAIL_V(ERR_INVALID_PARAMETER);
}
}
ENetPacket * packet = enet_packet_create (NULL,p_buffer_size+12,packet_flags);
encode_uint32(unique_id,&packet->data[0]); //source ID
encode_uint32(target_peer,&packet->data[4]); //dest ID
encode_uint32(packet_flags,&packet->data[8]); //dest ID
copymem(&packet->data[12],p_buffer,p_buffer_size);
if (server) {
if (target_peer==0) {
enet_host_broadcast(host,0,packet);
} else if (target_peer<0) {
//send to all but one
//and make copies for sending
int exclude=-target_peer;
for (Map<int,ENetPeer*>::Element *F=peer_map.front();F;F=F->next()) {
if (F->key()==exclude) // exclude packet
continue;
ENetPacket* packet2 = enet_packet_create (packet->data,packet->dataLength,packet_flags);
enet_peer_send(F->get(),0,packet2);
}
enet_packet_destroy(packet); //original packet no longer needed
} else {
enet_peer_send (E->get(), 0, packet);
}
} else {
ERR_FAIL_COND_V(!peer_map.has(1),ERR_BUG);
enet_peer_send (peer_map[1], 0, packet); //send to server for broadcast..
}
enet_host_flush(host);
return OK;
}
void Connection::sendToAll(u8 channelnum, SharedBuffer<u8> data, bool reliable)
{
ENetPacket *packet = enet_packet_create(*data, data.getSize(), reliable ? ENET_PACKET_FLAG_RELIABLE : 0);
enet_host_broadcast(m_enet_host, 0, packet);
}
int main(int argc, char **argv) {
if (enet_initialize() != 0) {
fprintf(stderr, "An error occurred while initializing ENet.\n");
return EXIT_FAILURE;
} else {
fprintf(stdout, "ENet initialized correctly.\n");
}
atexit(enet_deinitialize);
ENetAddress address;
ENetHost *server;
int eventStatus;
/* Bind the server to the default localhost. */
/* A specific host address can be specified by */
/* enet_address_set_host(&address, "x.x.x.x"); */
address.host = ENET_HOST_ANY;
address.port = SERVER_PORT;
server = enet_host_create(&address, MAX_CONN, 2, 0, 0);
if (server == NULL) {
fprintf(stderr, "An error occured while try to create an ENet server host.\n");
exit(EXIT_FAILURE);
} else {
fprintf(stdout, "ENet server created successfully.\n");
}
eventStatus = 1;
ENetEvent event;
while (1) {
eventStatus = enet_host_service(server, &event, 50000);
// If we had some event that interested us
if (eventStatus > 0) {
switch(event.type) {
case ENET_EVENT_TYPE_CONNECT:
printf("(Server) We got a new connection from %x\n",
event.peer->address.host);
break;
case ENET_EVENT_TYPE_RECEIVE:
printf("(Server) Message from client : %s\n", event.packet->data);
// Lets broadcast this message to all
enet_host_broadcast(server, 0, event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
printf("%s disconnected.\n", event.peer->data);
// Reset client's information
event.peer->data = NULL;
break;
case ENET_EVENT_TYPE_NONE:
printf("No event.\n");
break;
}
}
}
enet_host_destroy(server);
return 0;
}
void ListenServerNetMode::syncOutgoingPackets(ObjectManager* objectManager)
{
/**
* WARNING: Make sure to always send spawn packets first, and then data packets. Otherwise players may get object
* data that belongs to or points to an object that hasn`t been created yet.
*/
/** Step 1 - handle spawning objects that already exist on active players machines to connected players. */
// So, if there are any new players connected...
if(m_connectedPlayers.size() > 0)
{
// ...go through all replicated objects...
for(Object* object : objectManager->xiGetReplicatedObjects())
{
// ...if the object exists and has already been spawned on active players machines...
if(object && object->riGetRepLayout()->isSpawned)
{
// ...create a spawn packet and send it to all connected players.
if(ENetPacket* packet = createSpawnPacket(object))
{
for(SPlayer* player : m_connectedPlayers)
{
enet_peer_send(player->peer, NETWORK_CHANNEL_ID_DATA, packet);
}
}
}
}
}
/** Step 2 - handle spawning objects that hasn`t been spawned to anyone yet. */
// So, for every object that hasn`t been spawned on any player machine yet...
for(Object* object : objectManager->xiGetNewReplicatedObjects())
{
// Create a spawn packet and send it to all players.
if(ENetPacket* packet = createSpawnPacket(object))
{
enet_host_broadcast(m_host, NETWORK_CHANNEL_ID_DATA, packet);
}
// Mark the object as spawned
object->riGetRepLayout()->isSpawned = true;
}
// Clear new replicated objects container so we don`t constantly send the same spawn packets.
objectManager->xiClearNewReplicatedObjects();
/** Step 3 - handle sending initial object data to connected players. */
// So, if there are any new players connected
if(m_connectedPlayers.size() > 0)
{
// ...go through all replicated objects...
for(Object* object : objectManager->xiGetReplicatedObjects())
{
// ...if the object exists...
if(object)
{
// ...create a initial data packet and send it to all connected players.
if(ENetPacket* packet = createDataPacket(object, true))
{
for(SPlayer* player : m_connectedPlayers)
{
enet_peer_send(player->peer, NETWORK_CHANNEL_ID_DATA, packet);
}
}
}
}
}
/** Step 4 - handle sending delta object data to active players. */
// So, for every replicated object (both new and old ones)...
for(Object* object : objectManager->xiGetReplicatedObjects())
{
// ...if the object exists...
if(object)
{
// ...create a data packet and send it to active players if any data has to be sent
if(ENetPacket* packet = createDataPacket(object, true))
{
for(SPlayer* player : m_activePlayers)
{
enet_peer_send(player->peer, NETWORK_CHANNEL_ID_DATA, packet);
}
}
}
}
}
void ListenServerNetMode::syncConnectedPlayers(GameInstance* instance, ObjectManager* objectManager)
{
for(int playerId : m_connectedPlayersIds)
{
SPlayer* player = m_players[playerId];
if(player->peer)
{
m_connectedPlayers.push_back(player);
SNetConnectionResponse data;
data.type = NET_PT_CONNECTION_RESPONSE;
data.playerId = player->playerId;
ENetPacket* packet = enet_packet_create(&data, sizeof(SNetConnectionResponse), ENET_PACKET_FLAG_RELIABLE);
enet_peer_send(player->peer, NETWORK_CHANNEL_ID_DATA, packet);
}
{
const int netId = objectManager->m_netIdPool.reserve();
if(playerId == m_localPlayerId)
{
instance->xiSetLocalPlayerId(m_localPlayerId);
instance->xiSetLocalControllerNetId(netId);
}
Object* object = instance->xiSpawnObject(".PlayerController", netId);
if(PlayerController* pc = dynamic_cast<PlayerController*>(object))
{
pc->playerId = playerId;
SNetPlayerConnected data;
data.type = NET_PT_PLAYER_CONNECTED;
data.playerId = player->playerId;
data.controllerId = pc->xiGetNetId();
ENetPacket* packet = enet_packet_create(&data, sizeof(SNetPlayerConnected), ENET_PACKET_FLAG_RELIABLE);
enet_host_broadcast(m_host, NETWORK_CHANNEL_ID_DATA, packet);
instance->xiOnPlayerConnected(pc);
}
}
if(player->peer)
{
for(PlayerController* pc : objectManager->xiGetPlayerControllers())
{
if(pc->playerId != player->playerId)
{
SNetPlayerConnected data;
data.type = NET_PT_PLAYER_CONNECTED;
data.playerId = pc->playerId;
data.controllerId = pc->xiGetNetId();
ENetPacket* packet = enet_packet_create(&data, sizeof(SNetPlayerConnected), ENET_PACKET_FLAG_RELIABLE);
enet_peer_send(player->peer, NETWORK_CHANNEL_ID_DATA, packet);
}
}
}
}
m_connectedPlayersIds.clear();
}
void CNetManager::sendOutPacketUnreliable(SOutPacket& outpacket)
{
ENetPacket* packet = enet_packet_create((char*)outpacket.getData(), outpacket.getSize(), 0);
enet_host_broadcast(host, 0, packet);
}
bool CNetManager::setUpClient(const c8* addressc, const u32 port)
{
mode = ENM_CLIENT;
if(verbose)
std::cout << "irrNetLite: Creating client!" << std::endl;
host = enet_host_create(NULL, 1, netParams.downBandwidth / 8, netParams.upBandwidth / 8);
ENetEvent event;
enet_address_set_host(&address, addressc);
address.port = port;
if(verbose)
std::cout << "irrNetLite: Connecting to "
<< addressc << ":" << port << std::endl;
// Sets up two channels.
peer = enet_host_connect(host, &address, 2);
if(peer == NULL)
{
std::cout << "irrNetLite: Error: Could not resolve server address. Connection failed.\n";
return false;
}
if(!( enet_host_service(host, &event, netParams.connectionTimeout) > 0 &&
event.type == ENET_EVENT_TYPE_CONNECT))
{
enet_peer_reset(peer);
std::cout << "irrNetLite: Error: Connection timed out. Connection failed.\n";
return false;
}
while(enet_host_service(host, &event, netParams.connectionTimeout) > 0)
{
if(event.channelID == 1 && event.type == ENET_EVENT_TYPE_RECEIVE)
{
enet_uint8* buff = event.packet->data;
u8 packiden = 0;
memcpy((char*)&packiden, buff, 1);
if(packiden == 4)
{
memcpy((char*)&playerID, buff+1, 2);
if(playerID == 0)
{
std::cout << "irrNetLite: Error: Null player ID recieved. Server likely full.";
enet_peer_reset(event.peer);
return false;
}
if(verbose)
std::cout << "irrNetLite: Player ID is " << playerID << ".\n";
u8 packid = 3;
ENetPacket* packet = enet_packet_create(&packid, 1, ENET_PACKET_FLAG_RELIABLE);
enet_host_broadcast(host, 1, packet);
return true;
}
}
}
std::cout << "irrNetLite: Error: Failed to recieve Player ID. Connection failed.\n";
return false;
}
void
shmup_game_update(shmup_game *g, double t, double dt)
{
static int tick = 0;
static int mx, my;
int i;
ENetEvent event;
ENetPacket *packet;
bullet *b;
tick++;
while (enet_host_service(g->host, &event, 0) > 0) {
switch (event.type) {
case ENET_EVENT_TYPE_CONNECT:
printf("A new client connected from %x:%u.\n",
event.peer->address.host,
event.peer->address.port);
// sprintf(event.peer->data, "client %x.", event.peer->address.host);
g->player[g->num_players].pos = v2(g->window_width/2, g->window_height/2);
g->player[g->num_players].vel = v2zero;
g->player[g->num_players].acc = v2zero;
g->num_players++;
break;
case ENET_EVENT_TYPE_RECEIVE:
g->player[1].keyflags = (short) *event.packet->data;
// event.packet->dataLength,
// event.packet->data,
// event.peer->data,
// event.channelID);
enet_packet_destroy(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
printf("%s disconected.\n", event.peer->data);
/* Reset the peer's client information. */
event.peer->data = NULL;
break;
case ENET_EVENT_TYPE_NONE:
break;
}
}
glfwGetMousePos(&mx, &my);
g->emitter.x = (double) mx;
g->emitter.y = (double) g->window_height-my;
if (glfwGetMouseButton(GLFW_MOUSE_BUTTON_LEFT))
shmup_game_fire(g, 40, 0, v2zero, v2zero, v2zero);
if (glfwGetMouseButton(GLFW_MOUSE_BUTTON_RIGHT))
shmup_game_fire(g, 40, 1, v2zero, v2zero, v2zero);
if (glfwGetKey('1'))
g->render_type = 1;
if (glfwGetKey('2'))
g->render_type = 2;
g->player->keyflags = KF_NONE;
if (glfwGetKey('A')) g->player->keyflags |= KF_MOV_L;
if (glfwGetKey('D')) g->player->keyflags |= KF_MOV_R;
if (glfwGetKey('W')) g->player->keyflags |= KF_MOV_U;
if (glfwGetKey('S')) g->player->keyflags |= KF_MOV_D;
if (glfwGetKey(GLFW_KEY_SPACE)) g->player->keyflags |= KF_FIR_1;
for (i=0; i < g->num_players; i++) {
player_update(g, &g->player[i], dt);
}
b = g->bpool->bdata;
/*
* be careful with this pointer, as this data may be moved by the
* bpool_resize function! Make sure it points to the right place.
*/
/* do updates */
for (i=0; i < g->bpool->n_active; i++) {
bullet_update(&b[i], dt);
}
/* do collisions */
for (i=0; i < g->bpool->n_active; i++) {
if (!point_vs_aabb(b[i].pos, v2zero, v2(g->window_width, g->window_height)))
bpool_deactivate(g->bpool, i--);
}
if (g->network_type == CLIENT) {
packet = enet_packet_create(&g->player->keyflags, sizeof(short), ENET_PACKET_FLAG_RELIABLE);
enet_peer_send(g->peer, 0, packet);
} else {
packet = enet_packet_create(&g->player->keyflags, sizeof(short), ENET_PACKET_FLAG_RELIABLE);
enet_host_broadcast(g->host, 0, packet);
}
}
/* \brief update enet state internally */
static int _nethckEnetUpdate(void)
{
__NETHCKclient client;
ENetEvent event;
unsigned int packets = 0;
TRACE(2);
/* wait up to 1000 milliseconds for an event */
while (enet_host_service(_NETHCKserver.enet, &event, 1000) > 0) {
switch (event.type) {
case ENET_EVENT_TYPE_CONNECT:
printf("A new client connected from %x:%u.\n",
event.peer->address.host,
event.peer->address.port);
/* fill new client struct */
memset(&client, 0, sizeof(__NETHCKclient));
enet_address_get_host_ip(&event.peer->address, client.host, sizeof(client.host));
event.peer->data = _nethckServerNewClient(&client);
break;
case ENET_EVENT_TYPE_RECEIVE:
/* manage packet by kind */
printf("A packet of length %zu was received on channel %u.\n",
event.packet->dataLength, event.channelID);
printf("ID: %d\n", ((nethckPacket*)event.packet->data)->type);
switch (((nethckPacket*)event.packet->data)->type) {
case NETHCK_PACKET_OBJECT:
_nethckServerManagePacketObject(event.packet->data);
break;
case NETHCK_PACKET_OBJECT_TRANSLATION:
case NETHCK_PACKET_OBJECT_MATERIAL:
case NETHCK_PACKET_OBJECT_TEXTURE:
default:
break;
}
/* echo the packet to clients */
enet_host_broadcast(_NETHCKserver.enet, 0, event.packet);
/* clean up the packet now that we're done using it. */
//enet_packet_destroy(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
printf("%s disconected.\n", ((__NETHCKclient*)event.peer->data)->host);
/* free the client */
_nethckServerFreeClient(event.peer->data);
event.peer->data = NULL;
break;
default:
break;
}
++packets;
}
RET(2, "%u", packets);
return packets;
}
void Manager::broadcast(const sf::Packet &packet)
{
assert(_host);
ENetPacket *netPacket = enet_packet_create(packet.getData(), packet.getDataSize(), 0);
enet_host_broadcast(_host, 0, netPacket);
}
void Host::broadcastMessage(const MessagePtr& message, uint8 channel)
{
message->prepare();
enet_host_broadcast(host, channel, message->getPacket());
}
void NetServer::BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel)
{
enet_host_broadcast (m_pHost, channel, pPacket);
m_activeNetworkTime = GfTimeClock();
}
