Esempio n. 1
0
ENetServer::~ENetServer()
{
    // stop the server if we haven't already
    stop();
    // TODO: prevent this from being called multiple times
    enet_deinitialize();
}
Esempio n. 2
0
int module_stop (Q5Module* self)
{
  EcListCursor cursor;
  
  self->done = TRUE;
  
  eclist_cursor (self->threads, &cursor);
  
  while (eclist_cnext (&cursor))
  {
    ecthread_join (cursor.value);
  }
  
  while (eclist_cnext (&cursor))
  {
    ecthread_delete((EcThread*)(&cursor.value));
  }
  
  eclist_delete (&(self->threads));
  
  gse_destroy(&(self->entities));

  enet_host_destroy (self->server);

  enet_deinitialize();
   
  eclogger_fmt (LL_DEBUG, properties.name, "server", "stopped");  

  return TRUE;
}
Esempio n. 3
0
		CNetManager::~CNetManager(void)
		{
			if(host)
				enet_host_destroy(host);

			enet_deinitialize();
		}
Esempio n. 4
0
int main(int argc, char *argv[] )
{
	FeriteScript *script = NULL;
	char *error_message = NULL;
	
	SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
	SDL_EnableUNICODE(1);
	
	enet_initialize();
	
	Mix_Init(0);
	
	int audio_rate = 22050;
	Uint16 audio_format = AUDIO_S16; /* 16-bit stereo */
	int audio_channels = 2;
	int audio_buffers = 4096;
	Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers);
	
	srand(time(NULL));
	
	if( ferite_init(0, NULL) )
	{
		ferite_set_script_argv(argc, argv);
		script = ferite_script_compile("Game.fe");
		if( ferite_has_compile_error(script) )
		{
			error_message = ferite_get_error_log(script);
			fprintf(stderr, "[ferite: compile]\n%s", error_message);
		}
		else
		{
			ferite_array_init(script);
			ferite_string_init(script);
			ferite_number_init(script);
			game_engine_init(script);
			
			ferite_script_execute(script);
			if( ferite_has_runtime_error(script) )
			{
				error_message = ferite_get_error_log(script);
				fprintf(stderr, "[ferite: execution]\n%s", error_message);
			}
		}
		if( error_message )
		{
			ffree(error_message);
		}
		ferite_script_delete(script);
		ferite_deinit();
	}
	
	enet_deinitialize();
	
	Mix_CloseAudio();
	Mix_Quit();
	
	SDL_Quit();
	
	return 0;
}
Esempio n. 5
0
		void Manager::deinitialize()
		{
			if (_server != nullptr)
				enet_peer_disconnect(_server, 0);

			enet_host_destroy(_host);
			enet_deinitialize();
		}
Esempio n. 6
0
void Network::DeInit()
{
    AutoLock<Mutex> lock(m_mutex);

    if(m_host)
        enet_host_destroy((ENetHost*)m_host);
    enet_deinitialize();
}
Esempio n. 7
0
VALUE renet_main_deinitialize(VALUE self)
{
    if (rb_cv_get(mENet, "@@initialized") == Qtrue)
    {
        enet_deinitialize();
    }
    rb_cv_set(mENet, "@@initialized", Qfalse);
    return Qtrue;
}
Esempio n. 8
0
void 
shmup_game_close(shmup_game *g) 
{
	enet_host_destroy(g->host);
	enet_deinitialize();
	bpool_destroy(g->bpool);
	free(g);

}
Esempio n. 9
0
void NetworkDeinitialize()
{
    enet_deinitialize();

    AllocatorDestroy(gs_NetworkAllocator);
    gs_NetworkAllocator = nullptr;

    LogInfo("Deinitialized ENet");
}
Esempio n. 10
0
void Network::finalize(Client & client)
{
	if(m_server)
		enet_peer_disconnect_now(m_server, 0);
	if(m_client)
		enet_host_destroy(m_client);
	enet_socket_destroy(m_socket);
	enet_deinitialize();
}
Esempio n. 11
0
int module_start (Q5Module* self)
{
  int i;  
  uint32_t gameEngineSrvNo;
  ENetAddress address;

  if (enet_initialize () != 0)
  {
    eclogger_msg (LL_ERROR, properties.name, "server", "could not initialize enet");
    return FALSE;
  }
  
  enet_address_set_host (&address, self->host);
  address.port = self->port;
  
  self->server = enet_host_create (&address, 32, 2, 0, 0);      
  if (!self->server)
  {
    enet_deinitialize();

    eclogger_msg (LL_ERROR, properties.name, "server", "can't start enet server");
    return FALSE;
  }

  eclogger_fmt (LL_DEBUG, properties.name, "server", "listen '%s' on port '%u'", self->host, self->port);

  self->threads = eclist_new ();
  
  self->done = FALSE;
  
  for (i = 0; i < 1; i++)
  {
    EcThread thread = ecthread_new ();
    
    eclist_append(self->threads, thread);
    
    ecthread_start(thread, module_thread_run, self);
  }

  gameEngineSrvNo = q5core_getModuleId (self->core, "GAME_E");
  
  if (gameEngineSrvNo == 0)
  {
    eclogger_fmt (LL_WARN, properties.name, "server", "no game engine available");
  }
  
  self->entities = gse_create (self->server, gameEngineSrvNo, "Lobo's geiler server");
  
  gse_addRealm (self->entities, "the shire");
  
  ecmessages_add (self->instance->msgid, Q5_DATA_GET, module_callback_get, self);

  return TRUE;
}
Esempio n. 12
0
DebuggerServer::~DebuggerServer(void)
{
	if (m_server) {
		ENetHost* const server = (ENetHost*)m_server;	
		enet_peer_reset_queues (&server->peers[0]);

		delete (ENetEvent*) m_event;
		delete (ENetAddress*) m_address;
		enet_host_destroy((ENetHost*) m_server);
		enet_deinitialize();
	}
}
Esempio n. 13
0
NNetwork::~NNetwork()
{
    if (Client)
    {
        enet_host_destroy(Client);
    }
    if (Server)
    {
        enet_host_destroy(Server);
    }
    enet_deinitialize();
}
Esempio n. 14
0
Connection::~Connection(){
	if(!client){
		int i;
		for(i=0;i<=sizeof(conn->peers);i++)
			enet_peer_disconnect(&conn->peers[i],0);
		enet_host_service (conn, & event, 3000);
	}else{
		enet_peer_disconnect(peer,0);
		enet_host_service (conn, & event, 3000);
	}
	enet_host_destroy(conn);
	enet_deinitialize();
}
Esempio n. 15
0
Network::~Network()
{
    ENetEvent event;
    enet_peer_disconnect(server, 0);
    while (enet_host_service (client, &event, 3000) > 0) {
        if(event.type == ENET_EVENT_TYPE_RECEIVE)
            enet_packet_destroy (event.packet);
        else if(event.type == ENET_EVENT_TYPE_DISCONNECT)
            break;
    }
    enet_host_destroy(client);
    enet_deinitialize();
}
Esempio n. 16
0
void finalize()
{
    if (!client)
        return; // Wasn't initialized at all

    if (connections) {
        logger->error("Tried to shutdown the network subsystem while there "
                "are network connections left!");
    }

    clearNetworkHandlers();
    enet_deinitialize();
}
    void ClientTransmissionManager::Unload()
    {
        if(!this->mIsUnloaded)
        {
            this->mIsUnloaded=true;

			//enet
			if(this->mClient!=NULL)
			{
				enet_host_destroy(this->mClient);
			}
            enet_deinitialize();
        }
    }
Esempio n. 18
0
void Shutdown() {
    if (g_room_member) {
        if (g_room_member->IsConnected())
            g_room_member->Leave();
        g_room_member.reset();
    }
    if (g_room) {
        if (g_room->GetState() == Room::State::Open)
            g_room->Destroy();
        g_room.reset();
    }
    enet_deinitialize();
    NGLOG_DEBUG(Network, "shutdown OK");
}
Esempio n. 19
0
    NetManager::~NetManager()
    {
        if(mIsServer)
        {
            for(size_t i = 0; i < mClients.size(); i++)
                enet_peer_disconnect(mClients[i], 0);
        }
        else if(mServerPeer != NULL)
        {
            enet_peer_disconnect(mServerPeer, 0);
        }

        enet_host_destroy(mHost);

        enet_deinitialize();
    }
Esempio n. 20
0
void CHostENet::End()
{
    if (m_Status == INIT_AND_CONNECTED)
        DisconnectAll();

    enet_host_destroy(m_Host);
    enet_deinitialize();
    m_Status = NO_INIT;

    std::vector<CPeerENet*>::iterator it = m_PeerList.begin();
    while (it != m_PeerList.end()) {
        delete (*it);
        ++it;
    }
    m_PeerList.clear();
}
Esempio n. 21
0
void network_deinit()
{
  g_debug("Stopping server");
  tetris_plugin_action(PLUGIN_SHUTDOWN, -1, NULL, NULL);

  /* Disconnect each clients */
  g_slist_foreach(network->clients, (GFunc) enet_peer_disconnect_now, 0);

  /* ENet's documentation doesn't say anything about how to properly
    delete an ENetPeer, and using free on them results in a segfault,
    so we just don't do anything */
  g_slist_free(network->clients);
  enet_host_destroy(network->server);
  enet_deinitialize();
  g_free(network);
}
Esempio n. 22
0
GameLabyrinth::~GameLabyrinth()
{
    if (host != NULL)
    {
        for EACH(ClientVector, clients, client)
        {
            (*client)->disconenct();
            delete *client;
        }
        clients.clear();
        if (server.peer != NULL)
        {
            clientDisconnectFromServer();
        }

        enet_host_destroy(host);
        enet_deinitialize();
        log_msg("net", "Network deinitialized");
    }
Esempio n. 23
0
int main(int argc, char** argv)
{

	/** 1. ENET INITIALIZATION **/
	if(enet_initialize() != 0)
	{
		std::cerr << "Error ocurred while initializing enet.";
		return EXIT_FAILURE;
	}

	QApplication app(argc, argv);
	std::cout << "qapp ok\n";
	MainWindow window;
	std::cout << "window ok\n";

	client *c = new client();
	c->init(argv[1], argv[2]);

	std::cout << "cliente creado\n";
	window.setclient(c);
	std::cout << "window setclient ok\n";

	std::cout << "cliente seteado\n";
	boost::thread t(boost::bind(&client::run, c));

	window.setQApp(&app);
	window.show();
	app.exec();

	t.join();

	delete c;
	enet_deinitialize();

	return 0;
}
void NetworkLayerENet::cleanup()
{
    gamehost_shutdown();
    client_shutdown();
    enet_deinitialize();
}
Esempio n. 25
0
static void on_unload(ErlNifEnv* env, void* priv_data) {
  enet_deinitialize();
}
Esempio n. 26
0
NetworkManager::~NetworkManager()
{
    enet_deinitialize();
}
Esempio n. 27
0
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;
}
Esempio n. 28
0
 void shutdown() {
     enet_deinitialize();
 }
Esempio n. 29
0
int main(int argc, char **argv)
{
    // Initialize Allegro
    if (!al_init())
    {
        fprintf(stderr, "Fatal Error: Allegro initialization failed!\n");
        return -1;
    }

    // Initialize the Allegro Image addon, used to load sprites and maps
    if (!al_init_image_addon())
    {
        fprintf(stderr, "Fatal Error: Allegro Image Addon initialization failed!\n");
        return -1;
    }

    // Initialize primitives for drawing
    if (!al_init_primitives_addon())
    {
        fprintf(stderr, "Fatal Error: Could not initialize primitives module!");
        throw -1;
    }

    // Initialize keyboard modules
    if (!al_install_keyboard())
    {
        fprintf(stderr, "Fatal Error: Could not initialize keyboard module!");
        throw -1;
    }

    // Initialize mouse
    if (!al_install_mouse())
    {
        fprintf(stderr, "Fatal Error: Could not initialize mouse module!");
        throw -1;
    }

    // Initialize networking system
    if (enet_initialize())
    {
        fprintf(stderr, "Fatal Error: Could not initialize enet!");
        throw -1;
    }

    // Create a display
    ALLEGRO_DISPLAY *display;
    al_set_new_display_option(ALLEGRO_VSYNC, 2, ALLEGRO_REQUIRE);
    al_set_new_display_flags(ALLEGRO_OPENGL | ALLEGRO_RESIZABLE);
    display = al_create_display(1280, 720);
    if(!display)
    {
        // FIXME: Make the error argument mean anything?
        fprintf(stderr, "Fatal Error: Could not create display\n");
        throw -1;
    }

    //load font
    //gg2 font as placeholder for now i guess
    al_init_font_addon();
    al_init_ttf_addon();
    ALLEGRO_FONT *font = al_load_font("Vanguard Main Font.ttf", 12, ALLEGRO_TTF_MONOCHROME);
    if (!font)
    {
      fprintf(stderr, "Could not load 'gg2bold.ttf'.\n");
      throw -1;
    }

//    MainMenu *mainmenu = new MainMenu(display);
    bool isserver;
    if (argc >= 2)
    {
        // If there are any arguments
        isserver = false;
    }
    else
    {
        isserver = true;
    }
//    double lasttimeupdated = al_get_time();
//    bool run = true;
//    while (run)
//    {
//        if (al_get_time() - lasttimeupdated >= MENU_TIMESTEP)
//        {
//            run = mainmenu->run(display, &gametype);
//            lasttimeupdated = al_get_time();
//        }
//    }
//    delete mainmenu;

    Engine engine(isserver);
    Renderer renderer;
    InputCatcher inputcatcher(display);
    Gamestate renderingstate(&engine);

    std::unique_ptr<Networker> networker;
    if (isserver)
    {
        networker = std::unique_ptr<Networker>(new ServerNetworker());
    }
    else
    {
        networker = std::unique_ptr<Networker>(new ClientNetworker());
    }

    engine.loadmap("lijiang");
    // FIXME: Hack to make sure the oldstate is properly initialized
    engine.update(&(networker->sendbuffer), 0);

    EntityPtr myself(0);
    if (isserver)
    {
        myself = engine.currentstate->addplayer();
        engine.currentstate->get<Player>(myself)->spawntimer.active = true;
    }
    else
    {
        ClientNetworker *n = reinterpret_cast<ClientNetworker*>(networker.get());
        while (not n->isconnected())
        {
            n->receive(engine.currentstate.get());
        }
        myself = engine.currentstate->playerlist[engine.currentstate->playerlist.size()-1];
    }

    InputContainer held_keys;
    double mouse_x;
    double mouse_y;

    double enginetime = al_get_time();
    double networkertime = al_get_time();
    while (true)
    {
        try
        {
            while (al_get_time() - enginetime >= ENGINE_TIMESTEP)
            {
                networker->receive(engine.currentstate.get());
                inputcatcher.run(display, &held_keys, &mouse_x, &mouse_y);
                if (not isserver)
                {
                    Character *c = engine.currentstate->get<Player>(myself)->getcharacter(engine.currentstate.get());
                    if (c != 0)
                    {
                        ClientNetworker *n = reinterpret_cast<ClientNetworker*>(networker.get());
                        n->sendinput(held_keys, mouse_x/renderer.zoom+renderer.cam_x, mouse_y/renderer.zoom+renderer.cam_y);
                    }
                }
                engine.setinput(myself, held_keys, mouse_x/renderer.zoom+renderer.cam_x, mouse_y/renderer.zoom+renderer.cam_y);
                engine.update(&(networker->sendbuffer), ENGINE_TIMESTEP);
                networker->sendeventdata(engine.currentstate.get());

                enginetime += ENGINE_TIMESTEP;
            }
            if (isserver)
            {
                if (al_get_time() - networkertime >= NETWORKING_TIMESTEP)
                {
                    ServerNetworker *n = reinterpret_cast<ServerNetworker*>(networker.get());
                    n->sendframedata(engine.currentstate.get());

                    networkertime = al_get_time();
                }
            }
            renderingstate.interpolate(engine.oldstate.get(), engine.currentstate.get(), (al_get_time()-enginetime)/ENGINE_TIMESTEP);
            renderer.render(display, &renderingstate, myself, networker.get());
        }
        catch (int e)
        {
            if (e != 0)
            {
                fprintf(stderr, "\nError during regular loop.");
                fprintf(stderr, "\nExiting..");
            }
            al_destroy_display(display);
            return 0;
        }
    }
    al_shutdown_font_addon();
    al_shutdown_ttf_addon();
    al_destroy_display(display);
    enet_deinitialize();
    return 0;
}
Esempio n. 30
0
void lanarts_net_quit() {
	enet_deinitialize();
}