Cube  Check-in [9093e4cf6a]

  language: 'objc')

objfw_dep = dependency('objfw')
sdl_dep = dependency('SDL2')
sdlimage_dep = dependency('SDL2_image')
sdlmixer_dep = dependency('SDL2_mixer')
zlib_dep = dependency('zlib')
enet_dep = dependency('libenet')

client_link_args = []
server_link_args = []
extra_deps = []

if host_machine.system() == 'windows'
  client_link_args += ['-lopengl32', '-lglu32', '-lwinmm']
  server_link_args += ['-lwinmm']
elif host_machine.system() == 'darwin'
  extra_deps += dependency('OpenGL', method: 'extraframework')
else
  extra_deps += dependency('gl')
  extra_deps += dependency('glu')
  extra_deps += dependency('x11')
endif


subdir('src')

	conoutf(@"attempting to connect to %@", servername);
	ENetAddress address = { ENET_HOST_ANY, CUBE_SERVER_PORT };
	if (enet_address_set_host(&address, servername.UTF8String) < 0) {
		conoutf(@"could not resolve server %@", servername);
		return;
	}

	clienthost = enet_host_create(NULL, 1, 0, rate, rate);

	if (clienthost) {
		enet_host_connect(clienthost, &address, 0, 1);
		enet_host_flush(clienthost);
		connecting = lastmillis;
		connattempts = 0;
	} else {
		conoutf(@"could not connect to server");
		disconnect(false, false);
	}
}

void
disconnect(bool onlyclean, bool async)
{
	if (clienthost) {
		if (!connecting && !disconnecting) {
			enet_peer_disconnect(clienthost->peers, 0);
			enet_host_flush(clienthost);
			disconnecting = lastmillis;
		}
		if (clienthost->peers->state != ENET_PEER_STATE_DISCONNECTED) {
			if (async)
				return;
			enet_peer_reset(clienthost->peers);

  ],
  dependencies: [
    objfw_dep,
    sdl_dep,
    sdlimage_dep,
    sdlmixer_dep,
    zlib_dep,
    enet_dep,
    extra_deps
  ],

  link_args: client_link_args,

  win_subsystem: 'windows')

executable('server',
  [
    'Client.m',
    'Entity.m',
    'ServerEntity.m',
    'server.m',
    'serverms.m',
    'serverutil.m',
    'tools.m',
  ],
  objc_args: ['-DSTANDALONE'],
  dependencies: [
    objfw_dep,
    sdl_dep,
    enet_dep
  ],

  link_args: server_link_args,

  win_subsystem: 'console')

}

void
disconnect_client(int n, OFString *reason)
{
	[OFStdOut writeFormat: @"disconnecting client (%@) [%@]\n",
			       clients[n].hostname, reason];
	enet_peer_disconnect(clients[n].peer, 0);
	clients[n].type = ST_EMPTY;
	send2(true, -1, SV_CDIS, n);
}

void
resetitems()
{

	    sdesc, dedicated);

	if ((isdedicated = dedicated)) {
		ENetAddress address = { ENET_HOST_ANY, CUBE_SERVER_PORT };
		if (ip.length > 0 &&
		    enet_address_set_host(&address, ip.UTF8String) < 0)
			printf("WARNING: server ip not resolved");
		serverhost = enet_host_create(&address, MAXCLIENTS, 0, 0,
		    uprate);
		if (!serverhost)
			fatal(@"could not create server host\n");
		for (int i = 0; i < MAXCLIENTS; i++)
			serverhost->peers[i].data = (void *)-1;
	}

	resetserverifempty();

	}];
}

static void
servermenu()
{
	if (pingsock == ENET_SOCKET_NULL) {
		pingsock = enet_socket_create(ENET_SOCKET_TYPE_DATAGRAM);
		resolverinit(1, 1000);
	}

	resolverclear();

	for (ServerInfo *si in servers)
		resolverquery(si.name);

		[OFStdOut writeFormat: @"looking up %@...\n", hostname];
		enet_address_set_host(ad, hostname.UTF8String);
		if (ad->host == ENET_HOST_ANY)
			return;
	}
	if (mssock != ENET_SOCKET_NULL)
		enet_socket_destroy(mssock);
	mssock = enet_socket_create(ENET_SOCKET_TYPE_STREAM);
	if (mssock == ENET_SOCKET_NULL) {
		printf("could not open socket\n");
		return;
	}
	if (enet_socket_connect(mssock, ad) < 0) {
		printf("could not connect\n");
		return;

		mid = master;
	masterpath = @(mid);
	masterbase = [OFString stringWithUTF8String: master
					     length: mid - master];
	serverdesc = sdesc;

	if (listen) {


		pongsock = enet_socket_create(ENET_SOCKET_TYPE_DATAGRAM);
		if (pongsock == ENET_SOCKET_NULL) {
			fatal(@"could not create server info socket\n");
			return;
		}
		ENetAddress address = { ENET_HOST_ANY, CUBE_SERVINFO_PORT };
		if (enet_socket_bind(pongsock, &address) != 0) {
			fatal(@"could not create server info socket\n");
			return;
		}
	}
}