path: root/src/netlem.c

#include <signal.h>

#include "SDL/SDL.h"
#include "SDL/SDL_net.h"
#include "SDL/SDL_thread.h"

#include "data_localgame.h"

#include "netgame.h"
#include "utils.h"

#include "game.h"
//#include "events.h"
#include "loader.h"
#include "timing.h"
#include "netlem_state_machine.h"

// Application version number
#include "netlem.h"

// Thread arguments structures
struct _networkReadProc_args {
	client_t *client;
	Uint32 *tick;
	int *drift_ms;
};

struct _loadLevelProc_args { 
	serverParams_t *serverParams;
	gameIni_t *gIni;
	gameRess_t *gRess;
	Uint8 *loadProgress;
};

// Material for thread synchronization and collaboration
SDL_sem *semGameStart;
SDL_sem *semLoadLevel;

// Thread entry points
int networkReadProc(void *a);
int loadLevelProc(void *a);

// Client-specific functions
void signals(int signum);
int init(gameConfig_t *conf, gameGraphics_t *graph);
void loadGameConfig(gameConfig_t *conf);
void processLocalEvents();
int updateGraphics();


int main(int argc, char **argv) {

	int drift_ms=0, endMainLoop, result;
	Uint32 tick=0, timeBefore_ms;
	Uint8 loadProgress=0;

	client_t client;
	serverParams_t serverParams;
	gameConfig_t conf;
	gameIni_t gIni;
	gameRess_t gRess;
	gameGraphics_t graph;

	char logMsg[128];
	struct _networkReadProc_args args;
	struct _loadLevelProc_args args2;

	IPaddress ip;

	if(argc!=2) {
		fprintf(stderr, "Usage: %s <nom ou ip du serveur>\n", argv[0]);
		return 1;
	}

	// Log system initialization
	openLog(NULL);

	// Starting log message
	sprintf(logMsg, "NetLemmings version %i.%i", NetLemmings_VERSION_MAJOR, NetLemmings_VERSION_MINOR);
	logs(LOG_INFO, logMsg);

	// Server name resolution and connection
	if(SDLNet_ResolveHost(&ip,argv[1],9999)==-1) {
		logs2(LOG_ERROR, "main(), SDLNet_ResolveHost()", SDLNet_GetError());
		return 2;
	}

	client.sockClient=SDLNet_TCP_Open(&ip);
	if(!client.sockClient) {
		logs2(LOG_ERROR,"main(), SDLNet_TCP_Open()", SDLNet_GetError());
		return 3;
	}

	// Config file loading
	loadGameConfig(&conf);

	// Libraries initialization
	result=init(&conf, &graph);
	if(result!=0) {
		logs(LOG_ERROR,"main(), init()");
		return 3;
	}

	// Synchronization tools intialization
	semGameStart=SDL_CreateSemaphore(0);
	semLoadLevel=SDL_CreateSemaphore(0);

	// Network reader thread to process remote events and time sync
	args.client=&client;
	args.tick=&tick;
	args.drift_ms=&drift_ms;
	SDL_Thread *networkReadThread = SDL_CreateThread(networkReadProc, &args);
	if(!networkReadThread) {
		logs2(LOG_ERROR,"main(), SDL_CreateThread()", SDL_GetError());
		return 4;
	}

	// Worker thread for loading levels asynchronously (the thread begin with a SDL_Wait(semLevelLoadingStart))	
	args2.serverParams=&serverParams;
	args2.gIni=&gIni;
	args2.gRess=&gRess;
	args2.loadProgress=&loadProgress;
	SDL_Thread *loadLevelThread = SDL_CreateThread(loadLevelProc, &args2);
	if(!loadLevelThread) {
		logs2(LOG_ERROR,"main(), SDL_CreateThread()", SDL_GetError());
		return 4; //FIXME : autre num
	}

	//TODO : faire les menus et ne pas forcer ça ici
	if ( changeStateAndNotify(eMultiLoading, client.sockClient) == eNull ) {
		return 6;
	}

	// Main game loop
	endMainLoop=0;
	while(!endMainLoop) {
		timeBefore_ms = SDL_GetTicks();

		// Process local player keyboard and mouse events
		// (note: remote events are processed by network read thread)
		processLocalEvents();

		switch(getState()) {
			case eMultiLoading:
				if(loadProgress==100) {
					changeStateAndNotify(eMultiWaitLoading,client.sockClient);
				}
			break;
			case eMultiWaitLoading:
				result=SDL_SemTryWait(semGameStart);
				switch (result) {
					case -1:
						logs2(LOG_ERROR, "main(), SDL_SemTryWaitTimeout()", SDL_GetError());
						return 7;
						break;
					case 0:
//FIXME : check return value
						changeState(eMultiGame);
						break;
					default:
						break;
				}
				break;
			case eSingleGame:
			case eMultiGame:
				// Make game evolve from the current state to the next time chunk (ie. frame, or tick)
				play(tick++);
				break;
			default:
				endMainLoop=1;
			break;
		}

		// Display that new game state to the local user
		updateGraphics();

		// Delay that we have to wait for the next frame (depends on execution time and network time drift)
		waitForNextTick(timeBefore_ms, drift_ms);
	}

	// Close communcation with the server, stop threads, close logs and go out
	SDLNet_TCP_Close(client.sockClient);
	SDL_WaitThread(networkReadThread, &result);
	sprintf(logMsg, "TimeSync thread terminated with code %i", result);
	logs(LOG_DEBUG, logMsg);

	closeLog();
	return 0;
}

void signals(int signum) {
	static int force=0;
	char buf[128];
	sprintf(buf, "Caught signal %i", signum);
	logs(LOG_WARN, buf);

	if(!force) {
		changeState(eEnd);
		force=1;
		logs(LOG_WARN, "Trying to stop smoothly...");
	} else {
		logs(LOG_WARN, "Emergency stop");
		exit(1);
	}
}

int init(gameConfig_t *conf, gameGraphics_t *graph) {
	int result;


	// SDL subsystems initialization
	result = SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO );
	if ( result != 0 ) {
		logs2(LOG_ERROR, "init(), SDL_Init()", SDL_GetError());
		return 1;
	}
	atexit(SDL_Quit);
	signal(2,signals);

	// Screen setup
	graph->screen = SDL_SetVideoMode(conf->screen.w, conf->screen.h, SCREEN_BPP, SDL_HWSURFACE | SDL_DOUBLEBUF );
	if( graph->screen == NULL ) {
		logs2(LOG_ERROR, "init(), SDL_SetVideoMode()", SDL_GetError());
		return 2;
	}

	// SDL main window caption
	SDL_WM_SetCaption(WIN_CAPTION, NULL);

	// We dont want to see the standard mouse cursor in our main window
	SDL_ShowCursor(0);

	// Memory allocation and initialization for all display layers
	graph->terrain = SDL_CreateRGBSurface(SDL_HWSURFACE, LEVEL_WIDTH, LEVEL_HEIGHT, SCREEN_BPP,0,0,0,0);
	if( graph->terrain == NULL ) {
		logs2(LOG_ERROR, "init(), SDL_CreateRGBSurface()", SDL_GetError());
		return 3;
	}

	graph->stencil = SDL_CreateRGBSurface(SDL_SWSURFACE, LEVEL_WIDTH, LEVEL_HEIGHT, SCREEN_BPP,0,0,0,0);
	if( graph->stencil == NULL ) {
		logs2(LOG_ERROR, "init(), SDL_CreateRGBSurface()", SDL_GetError());
		return 3;
	}

	return 0;
}

void loadGameConfig(gameConfig_t *conf) {
	conf->screen.w=640;
	conf->screen.h=480;
	conf->screen.x=0;
	conf->screen.y=0;
	//TODO : charger vraiment le fichier de conf ^^
}

int networkReadProc(void *a) {
	int result;
	event_t e;
	char logMsg[128];
	
	struct _networkReadProc_args *args = (struct _networkReadProc_args *)a;

	while( getState() != eEnd ) {
	//	logs(LOG_DEBUG, "Waiting event");
		result=receiveEvent(args->client,&e);
		if (result != 0) {
			logs(LOG_WARN, "networkReadProc(), receiveEvents() error");
			changeState(eEnd);
			continue; //TODO : je doute que ça skipe vriament la syncrho du temps :s
		}
	//	logs(LOG_DEBUG, "Got event");

		*(args->drift_ms)=( *(args->tick) - e.serverTick );
		sprintf(logMsg, "serverTick==%i, tick==%i, drift_ms==%i\n", e.serverTick, *(args->tick), *(args->drift_ms));
		logs(LOG_DEBUG, logMsg);


		result=SDL_SemPost(semGameStart);
		if (result!=0) {
			logs2(LOG_ERROR, "main(), SDL_SemPost()", SDL_GetError());
			return 1;
		}


		switch(e.type) {
			case eLemAction:
				//TODO
			break;
			case eTimeSync: // Rien à faire dans ce cas, la synchro du temps se fait quelque soti le tyep d'évènement
			break;
			default:
				logs(LOG_ERROR, "serveClient(), Unknown event type");
		}
	}
	// logs(LOG_DEBUG, "networkReadProc() : end");

	return 0;
}

int startLoadLevel() {
	int result;

	logs(LOG_INFO, "Start game loading");
	result=SDL_SemPost(semLoadLevel);

	return result;
}

int loadLevelProc(void *a) {
	int result,i;
	//char logMsg[128];
	
	struct _loadLevelProc_args *args = (struct _loadLevelProc_args *)a;
	
	logs(LOG_WARN, "loadLevelProc(), beginnng");
	while( getState() != eEnd ) {
		result=SDL_SemWait(semLoadLevel);
		if (result!=0) {
			logs2(LOG_ERROR, "main(), SDL_SemTryWaitTimeout()", SDL_GetError());

		}

		logs(LOG_WARN, "loadLevelProc(), start load level");





		*(args->loadProgress)=100;
		logs(LOG_WARN, "loadLevelProc(), end load level");
		
	}
	logs(LOG_WARN, "loadLevelProc(), end thread");

	return 0;
}

void processLocalEvents() {
	/*TODO : intégration des variables manipulées dans des structs qui vont bien
while( SDL_PollEvent( &event ) ) {
		switch (event.type) {
			case SDL_KEYBOARDEVENT:
				switch(event.key.keysym.sym){
					case SDLK_HOME : decalFps = 0; break;
					case SDLK_END : decalFps = FPS-11; break;
					case SDLK_PAGEUP : if(decalFps>0){decalFps -=1;}break;
					case SDLK_PAGEDOWN : if(decalFps<(FPS-1)){decalFps +=1;}break;
					case SDLK_w : paint_stencil = (paint_stencil==0)? 1 : 0 ; break;
					case SDLK_ESCAPE : quit = 1; break;
					default:break;
				}
			break;
			case SDL_MOUSEMOTION:
				mouseX = event.motion.x;
				mouseY = event.motion.y;
			break;
			case SDL_MOUSEBUTTONDOWN:
				err=mouse_action(&gInit, mouseX, mouseY,camera.x,camera.y );
				if(err!=0){return err;} //FIXME : WTF ?
			break;
			case SDL_QUIT:
				end=1;
			break;
		} 
	}

	if(mouseY <= LEVEL_HEIGHT){ 
	if (mouseX > (SCREEN_WIDTH - BOUND_SENSIBILITE)){
		if (camera.x < (LEVEL_WIDTH - SCREEN_WIDTH ) )
		{camera.x += CAM_VITESSE;}
	}
	if (mouseX < BOUND_SENSIBILITE){
		if (camera.x >= CAM_VITESSE )
		{camera.x -= CAM_VITESSE;}
	}
	*/
}

int updateGraphics() {
	//TODO : modifier les calques


	//Mise à jour de l'écran
	
	/*if( SDL_Flip(screen) == -1 ) {
		return 4;
	}*/

	return 0;
}