コード例 #1
0
ファイル: calcsig.c プロジェクト: jasminegrosso/zeno
real sig2_gsp(gsprof *tgsp, gsprof *mgsp, real beta_a, real *sig2, real r)
{
    int n = tgsp->npoint - 1;
    real r0, rn, gamma, m0, c0;

    r0 = tgsp->radius[0];
    rn = tgsp->radius[n];
    if (r < r0) {
        gamma = 2 * beta_a + mgsp->alpha + tgsp->alpha + 2;
        m0 = mass_gsp(mgsp, r0);
        if (gamma != 0.0) {
            c0 = sig2[0] + m0 / (gamma * r0);
            return (- (m0 / r0) * rpow(r / r0, 2 + mgsp->alpha) / gamma +
                    c0 * rpow(r0 / r, 2 * beta_a + tgsp->alpha));
        } else {
            c0 = sig2[0] + rlog(r0) * m0 / r0;
            return (- rlog(r) * m0 / rpow(r0, 3 + mgsp->alpha) /
                    rpow(r, 2 * beta_a + tgsp->alpha) +
                    c0 * rpow(r0 / r, 2 * beta_a + tgsp->alpha));
        }
    } else if (r > rn) {
        if (tgsp->density[n] > 0) {
            gamma = 2 * beta_a + mgsp->beta + tgsp->beta + 2;
            return (- mgsp->mtot / ((2*beta_a + tgsp->beta - 1) * r) +
                    (mgsp->mtot - mass_gsp(mgsp, r)) / (gamma * r));
        } else
            return (0.0);
    } else
        return (seval(r, tgsp->radius, sig2, sig2 + n + 1, n + 1));
}
コード例 #2
0
ファイル: RemoteConnection.c プロジェクト: pixelmager/rocket
void RemoteConnection_close()
{
	if (RemoteConnection_connected())
	{
		rlog(R_INFO, "closing client socket %d\n", s_socket);
		closesocket(s_socket);
		s_socket = INVALID_SOCKET;
	}

	rlog(R_INFO, "closing socket %d\n", s_serverSocket);

	closesocket(s_serverSocket);
	s_serverSocket = INVALID_SOCKET;
}
コード例 #3
0
ファイル: polysnap.c プロジェクト: jasminegrosso/zeno
void polymodel1(void)
{
  bodyptr p;
  real r, x, v;

  for (p = btab; p < NthBody(btab, nbody); p = NextBody(p)) {
    Mass(p) = 1.0 / nbody;
    r = xrandom(0.0, 2.0);
    pickshell(Pos(p), 3, r);
    x = SQRT2 * rcos(PI * (2.0 - xrandom(0.0, 1.0)) / 4.0);
    v = (xrandom(-1.0, 1.0) < 0.0 ? -1.0 : 1.0) *
      (1 - x*x) * rsqrt(rlog(2 / r));
    MULVS(Vel(p), Pos(p), v/r);
    Phi(p) = 0.5 * rlog(r / 2.0) - 0.5;
  }
  bodyfields[4] = NULL;				// don't output Aux data
}
コード例 #4
0
ファイル: RemoteConnection.c プロジェクト: pixelmager/rocket
bool RemoteConnection_createListner()
{
	struct sockaddr_in sin;
	int yes = 1;

#if defined(_WIN32)
	 WSADATA wsaData;
	if (WSAStartup(MAKEWORD(2,0),&wsaData) != 0)
		return false;
#endif

	s_serverSocket = socket(AF_INET, SOCK_STREAM, 0);

	if (s_serverSocket == INVALID_SOCKET)
		return false;

	memset(&sin, 0, sizeof sin);

	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = INADDR_ANY;
	sin.sin_port = htons(1338);

	if (setsockopt(s_serverSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(int)) == -1)
	{
		perror("setsockopt");
		return false;
	}

	if (-1 == bind(s_serverSocket, (struct sockaddr *)&sin, sizeof(sin)))
	{
		perror("bind");
		rlog(R_ERROR, "Unable to bind server socket\n");
		return false;
	}

	while (listen(s_serverSocket, SOMAXCONN) == -1)
		;

	rlog(R_INFO, "Created listner\n");

	return true;
}
コード例 #5
0
ファイル: game.c プロジェクト: wernsey/rengine
int init(const char *appTitle, int flags) {
	flags |= SDL_WINDOW_SHOWN;

	rlog("Creating Window.");

	win = SDL_CreateWindow(appTitle, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screenWidth, screenHeight, flags);
	if(!win) {
		rerror("SDL_CreateWindow: %s", SDL_GetError());
		return 0;
	}

	ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
	if(!ren) {
		rerror("SDL_CreateRenderer: %s", SDL_GetError());
		return 0;
	}

    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, filter);

	rlog("Window Created.");

    if(SDL_ShowCursor(show_cursor) < 0) {
        rerror("SDL_ShowCursor: %s", SDL_GetError());
    }

	bmp = bm_create(virt_width, virt_height);

	tex = SDL_CreateTexture(ren, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, bmp->w, bmp->h);
	if(!tex) {
		rerror("SDL_CreateTexture: %s", SDL_GetError());
		return 0;
	}
	rlog("Texture Created.");

	reset_keys();

	return 1;
}
コード例 #6
0
ファイル: RemoteConnection.c プロジェクト: pixelmager/rocket
void RemoteConnection_disconnect()
{
#if defined(_WIN32)
	closesocket(s_socket);
#else
	close(s_socket);
#endif
	s_socket = INVALID_SOCKET;

	rlog(R_INFO, "disconnect!\n");

	s_paused = true;

	memset(s_nameLookup.ids, -1, sizeof(int) * s_nameLookup.count);
	s_nameLookup.count = 0;
}
コード例 #7
0
ファイル: game.c プロジェクト: wernsey/rengine
int handleSpecialKeys(SDL_Scancode key) {
	if(key == SDL_SCANCODE_ESCAPE && (keys[SDL_SCANCODE_LSHIFT] || keys[SDL_SCANCODE_RSHIFT])) {
		quit = 1;
		return 1;
	} else if (key == SDL_SCANCODE_F11) {
		if(!(SDL_GetWindowFlags(win) & SDL_WINDOW_FULLSCREEN_DESKTOP)) {
			if(SDL_SetWindowFullscreen(win, SDL_WINDOW_FULLSCREEN_DESKTOP) < 0)
				rerror("Unable to set window to fullscreen: %s", SDL_GetError());
		} else if(SDL_SetWindowFullscreen(win, 0) < 0) {
			rerror("Unable to set window to windowed: %s", SDL_GetError());
		}
		return 1;
	} else if(key == SDL_SCANCODE_F12) {
        char filename[256];
        snprintf(filename, sizeof filename, "%s/save.png", initial_dir);
		bm_save(bmp, filename);
		rlog("Screenshot saved as %s", filename);
		return 1;
	}
	return 0;
}
コード例 #8
0
ファイル: RemoteConnection.c プロジェクト: pixelmager/rocket
void RemoteConnection_updateListner(int currentRow)
{
	struct timeval timeout;
	struct sockaddr_in client;
	SOCKET clientSocket = INVALID_SOCKET;
	fd_set fds;

	FD_ZERO(&fds);
	FD_SET(s_serverSocket, &fds);

	timeout.tv_sec = 0;
	timeout.tv_usec = 0;
	
	if (RemoteConnection_connected())
		return;

	// look for new clients
	
	if (select(s_serverSocket + 1, &fds, NULL, NULL, &timeout) > 0)
	{
		clientSocket = clientConnect(s_serverSocket, &client);

		if (INVALID_SOCKET != clientSocket)
		{
			snprintf(s_connectionName, sizeof(s_connectionName), "Connected to %s", inet_ntoa(client.sin_addr));
			rlog(R_INFO, "%s\n", s_connectionName); 
			s_socket = clientSocket; 
			s_clientIndex = 0;
			RemoteConnection_sendPauseCommand(true);
			RemoteConnection_sendSetRowCommand(currentRow);
		}
		else 
		{
			//
		}
	}
}
コード例 #9
0
ファイル: gspdisk.c プロジェクト: jasminegrosso/zeno
real ratanh(real x)
{
  return (0.5 * rlog((1.0 + x) / (1.0 - x)));
}
コード例 #10
0
ファイル: samrdumps.c プロジェクト: BackupTheBerlios/samqfs
void *
samr_restore(void* jobid)
{
	node_t		*destp;
	node_t		*pathp;
	node_t		*oldpathp;
	node_t		*copyp;
	int		rval;
	argbuf_t	*arg;
	char		mountpt[BUFFSIZ];
	dumpspec_t	*dsp;
	char		msgbuf[MAX_MSGBUF_SIZE] = {0};
	char		catmsg[MAX_MSGBUF_SIZE] = {0};
	int		fd;
	sqm_lst_t		*filelst = NULL;
	char		*ptr;
	size_t		end;

	arg = samr_get_args((char *)jobid);

	if (arg == NULL) {

		pthread_mutex_lock(&search_mutex);
		search_active = 0;  /* Indicate search/restore is done */
		pthread_mutex_unlock(&search_mutex);

		end_this_activity((char *)jobid);
		return (NULL);
	}
	Trace(TR_MISC, "restoring from %s %s",
	    arg->r.fsname, arg->r.dumpname);

	/*
	 * cleanup handler ends activity and frees arg but
	 * jobid was malloced in the function that called
	 * pthread_create and must be freed here.
	 */
	free(jobid);

	pthread_cleanup_push(&restorecleanup, arg);

	dsp = arg->r.dsp;

	rval = getfsmountpt(arg->r.fsname, mountpt, sizeof (mountpt));

	if (rval == 0) {
		/* Pick up pointers to starts of these lists */
		destp = arg->r.dest->head;
		copyp = arg->r.copies->head;
	} else {
		Trace(TR_MISC, "Restore init failed %s", samerrmsg);
		goto done;
	}

	/* Open log file */
	if ((fd = open64(RESTORELOG, O_WRONLY|O_APPEND|O_CREAT, 0644)) != -1) {
		dsp->logfil = fdopen(fd, "a"); /* Open logfile for append */
	}
	if (dsp->logfil == NULL) {
		/* must return or a crash will follow on rlog */
		rval = samrerr(SE_NOTAFILE, RESTORELOG);
		goto done;
	}

	/* Log the fact that we are starting a restore */
	strlcpy(catmsg, GetCustMsg(SE_START_RESTORE), sizeof (catmsg));
	snprintf(msgbuf, sizeof (msgbuf), catmsg, destp->data, samerrmsg);
	rlog(dsp->logfil, catmsg, destp->data, samerrmsg);

	/* strip off any trailing slashes on the destinations */
	for (pathp = destp; pathp != NULL; pathp = pathp->next) {
		ptr = (char *)pathp->data;

		if (ptr == NULL) {
			continue;
		}

		end = strlen(ptr) - 1;
		while ((ptr[end] == '/') || (ptr[end] == '.')) {
			ptr[end] = '\0';
		}
	}

	/*
	 * if we're restoring the whole filesystem, don't restore the
	 * root node, just call into the restore_children func.
	 */
	if (strcmp((char *)(arg->r.filepaths->head->data), ".") == 0) {
		restore_children(".", copyp->data,
		    destp->data, mountpt, dsp, arg->r.replace, FALSE);
		goto done;
	}


	/* get the details for the requested files */
	rval = collect_file_details_restore(dsp->fsname, dsp->snapname,
	    "", arg->r.filepaths, 0, &filelst);

	if (rval != 0) {
		/* we could probably do a better error */
		strlcpy(catmsg, GetCustMsg(SE_RESTORE_FAILED), sizeof (catmsg));
		snprintf(msgbuf, sizeof (msgbuf), catmsg, samerrmsg);
		strlcat(msgbuf, " ", sizeof (msgbuf));
		strlcat(msgbuf, destp->data, sizeof (msgbuf));
		rlog(dsp->logfil, msgbuf, NULL, NULL);
		PostEvent(DUMP_CLASS, DUMP_INTERRUPTED_SUBCLASS,
		    SE_RESTORE_FAILED, LOG_ERR, msgbuf, NOTIFY_AS_FAULT);
		Trace(TR_MISC, "Restore init failed %s", samerrmsg);
		goto done;
	}

	/* Push a cleanup handler for the filelst */
	pthread_cleanup_push(&free_file_details_lst, filelst);

	for (pathp = filelst->head, oldpathp = arg->r.filepaths->head;
	    (pathp != NULL) && (oldpathp != NULL);
	    pathp = pathp->next, oldpathp = oldpathp->next) {

		filedetails_t	*details = (filedetails_t *)pathp->data;

		/*
		 * Restore this file/directory/link/whatever.
		 * If it's a directory, also restore children
		 */
		rval = restore_node(
		    details, copyp->data, destp->data, mountpt,
		    dsp, arg->r.replace);
		if (rval) {
			/*
			 * file already exists isn't fatal reset rval for
			 * later
			 */
			if (samerrno == SE_FILE_ALREADY_EXISTS) {
				rval = 0;
			}

			strlcpy(catmsg, GetCustMsg(SE_RESTORE_FAILED),
			    sizeof (catmsg));
			snprintf(msgbuf, sizeof (msgbuf), catmsg, samerrmsg);
			rlog(dsp->logfil, msgbuf, NULL, NULL);
			PostEvent(DUMP_CLASS, DUMP_INTERRUPTED_SUBCLASS,
			    SE_RESTORE_FAILED, LOG_ERR,
			    msgbuf, NOTIFY_AS_FAULT);
		}

		/* Restore any children */
		if ((rval == 0) && (S_ISDIR(details->prot))) {
			restore_children((char *)oldpathp->data, copyp->data,
			    destp->data, mountpt, dsp, arg->r.replace,
			    FALSE);
		}

		strlcpy(catmsg, GetCustMsg(SE_FINISH_RESTORE), sizeof (catmsg));
		snprintf(msgbuf, sizeof (msgbuf), catmsg, " ", samerrmsg);
		strlcat(msgbuf, destp->data, sizeof (msgbuf));
		rlog(dsp->logfil, msgbuf, NULL, NULL);

		destp = destp->next;
		copyp = copyp->next;
	}

	/* pop file list free handler */
	pthread_cleanup_pop(1);

done:
	/* pop the cleanup handler */
	pthread_cleanup_pop(1);

	return (NULL);
}
コード例 #11
0
ファイル: samrdumps.c プロジェクト: BackupTheBerlios/samqfs
/* Restore child nodes. Recursive. */
static int
restore_children(char *dir_name, int *copy, char *dest, char *mountpt,
	dumpspec_t *dsp, replace_t replace, boolean_t count_only)
{
	int		st;
	char		childdest[MAXPATHLEN + 1];
	char		msgbuf[MAX_MSGBUF_SIZE] = {0};
	char		catmsg[MAX_MSGBUF_SIZE] = {0};
	sqm_lst_t		*lstp = NULL;
	sqm_lst_t		*dirlist = NULL;
	uint32_t	morefiles = 0;
	restrict_t	filter;
	filedetails_t	*details;
	char		*ptr;
	char		startFrom[MAXPATHLEN + 1];
	node_t		*node;
	char		*lastFile = NULL;
	char		*startp;
	char		*destp;

	dirlist = lst_create();
	if (dirlist == NULL) {
		return (-1);
	}

	memset(&filter, 0, sizeof (restrict_t));

/* TODO:  Add testcancel points and cleanup function */

	startFrom[0] = '\0';

	/*
	 * get file info from the database in chunks so as not to
	 * overwhelm ourselves if we're restoring a huge directory
	 */
	do {
		lstp = lst_create();
		if (lstp == NULL) {
			goto done;
		}
		st = list_snapshot_files(dsp->fsname, dsp->snapname,
		    dir_name, startFrom, filter, 0, 2048, FALSE,
		    &morefiles, lstp);

		if (st != 0) {
			/* list_snapshot_files doesn't set samerrmsg */
			snprintf(msgbuf, sizeof (msgbuf),
			    GetCustMsg(SE_RESTORE_FAILED), "");
			snprintf(catmsg, sizeof (catmsg), "%d %s ",
			    st, strerror(st));
			strlcat(msgbuf, catmsg, sizeof (msgbuf));
			strlcat(msgbuf, dir_name, sizeof (msgbuf));
			rlog(dsp->logfil, msgbuf, NULL, NULL);
			PostEvent(DUMP_CLASS, DUMP_INTERRUPTED_SUBCLASS,
			    SE_RESTORE_FAILED, LOG_ERR,
			    msgbuf, NOTIFY_AS_FAULT);
			goto done;
		}

		/*
		 * Create new destination path - add filename with
		 * strlcat to avoid possible problems with % in
		 * the pathname.
		 */
		strlcpy(childdest, dest, MAXPATHLEN + 1);
		strlcat(childdest, "/", MAXPATHLEN + 1);
		destp = childdest + strlen(childdest);

		for (node = lstp->head; node != NULL; node = node->next) {
			details = node->data;

			if (details == NULL) {
				continue;
			}

			/*
			 * save the path name in case we need it to get
			 * more files
			 */
			lastFile = details->file_name;

			*destp = '\0';
			strlcat(childdest, details->file_name, MAXPATHLEN + 1);

			/* if we're only counting, don't call restore_node */

			/* Restore the child node */
			if (!count_only) {
				st = restore_node(details, copy, childdest,
				    mountpt, dsp, replace);
				if (st != 0) {
					strlcpy(catmsg,
					    GetCustMsg(SE_RESTORE_FAILED),
					    sizeof (catmsg));
					snprintf(msgbuf, sizeof (msgbuf),
					    catmsg, samerrmsg);
					rlog(dsp->logfil, msgbuf, NULL, NULL);
					PostEvent(DUMP_CLASS,
					    DUMP_INTERRUPTED_SUBCLASS,
					    SE_RESTORE_FAILED, LOG_ERR,
					    msgbuf, NOTIFY_AS_FAULT);
					/* file already exists isn't fatal */
					if (samerrno ==
					    SE_FILE_ALREADY_EXISTS) {
						st = 0;
					}
				}
			}

			if (S_ISDIR(details->prot)) {
				lst_append(dirlist, details->file_name);
				/* ensure not doubly deleted */
				details->file_name = NULL;
			}
		}

		if (count_only) {
			restore_max += lstp->length;
		}

		if (lastFile) {
			strlcpy(startFrom, lastFile, sizeof (startFrom));
		}
		lst_free_deep_typed(lstp, FREEFUNCCAST(free_file_details));
		lstp = NULL;
	} while (morefiles > 0);

	/* restore any directories we found along the way */

	strlcpy(startFrom, dir_name, sizeof (startFrom));
	strlcat(startFrom, "/", sizeof (startFrom));
	startp = startFrom + strlen(startFrom);

	for (node = dirlist->head; node != NULL; node = node->next) {
		ptr = (char *)node->data;
		*startp = '\0';

		/* Create new source path */
		strlcat(startp, ptr, sizeof (startFrom));

		/* Create new destination path */
		snprintf(childdest, MAXPATHLEN + 1, "%s/%s", dest, ptr);

		/* this will log individual errors for failure */
		(void) restore_children(startFrom, copy, childdest, mountpt,
		    dsp, replace, count_only);
	}

done:
	if (lstp != NULL) {
		lst_free_deep_typed(lstp, FREEFUNCCAST(free_file_details));
	}
	if (dirlist != NULL) {
		lst_free_deep(dirlist);
	}

	return (st);
}
コード例 #12
0
ファイル: game.c プロジェクト: wernsey/rengine
int main(int argc, char *argv[]) {
	int opt;

	int fullscreen = 0, resizable = 0, borderless = 0;

	const char *appTitle = DEFAULT_APP_TITLE;

	const char *game_dir = NULL;
	const char *pak_filename = "game.pak";

	const char *rlog_filename = "rengine.log";

	const char *startstate;

	struct game_state *gs = NULL;

	int demo = 0;

	SDL_version compiled, linked;

	log_init(rlog_filename);
	json_error = rerror;

	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_AUDIO) < 0) {
		rerror("SDL_Init: %s", SDL_GetError());
		return 1;
	}
	atexit(SDL_Quit);

	while((opt = getopt(argc, argv, "p:g:l:d?")) != -1) {
		switch(opt) {
			case 'p': {
				pak_filename = optarg;
			} break;
			case 'g' : {
				game_dir = optarg;
				pak_filename = NULL;
			} break;
			case 'l': {
				rlog_filename = optarg;
			} break;
			case 'd': {
				demo = 1;
			} break;
			case '?' : {
				usage(argv[0]);
				return 1;
			}
		}
	}

	if(!getcwd(initial_dir, sizeof initial_dir)) {
		rerror("error in getcwd(): %s", strerror(errno));
		return 1;
	}
	rlog("Running engine from %s", initial_dir);

	if(!gdb_new()) {
		rerror("Unable to create Game Database");
		return 1;
	}
	re_initialize();
	states_initialize();
	if(!snd_init()) {
		rerror("Terminating because of audio problem.");
		return 1;
	}

	/* Don't quite know how to use this in Windows yet.
	*/
	SDL_LogSetAllPriority(SDL_LOG_PRIORITY_WARN);
	SDL_Log("Testing Log capability.");
    
	SDL_VERSION(&compiled);
	SDL_GetVersion(&linked);
	rlog("SDL version %d.%d.%d (compile)", compiled.major, compiled.minor, compiled.patch);
	rlog("SDL version %d.%d.%d (link)", linked.major, linked.minor, linked.patch);

	if(!demo) {
		if(pak_filename) {
			rlog("Loading game PAK file: %s", pak_filename);
			if(!rs_read_pak(pak_filename)) {
				rerror("Unable to open PAK file '%s'; Playing demo mode.", pak_filename);
				goto start_demo;
			}
		} else {
			rlog("Not using a PAK file. Using '%s' instead.", game_dir);
			if(chdir(game_dir)) {
				rerror("Unable to change to '%s': %s", game_dir, strerror(errno));
				return 1;
			}
		}

		game_ini = re_get_ini(GAME_INI);
		if(game_ini) {
			appTitle = ini_get(game_ini, "init", "appTitle", "Rengine");

			screenWidth = atoi(ini_get(game_ini, "screen", "width", PARAM(SCREEN_WIDTH)));
			screenHeight = atoi(ini_get(game_ini, "screen", "height", PARAM(SCREEN_HEIGHT)));
			resizable = atoi(ini_get(game_ini, "screen", "resizable", "0")) ? SDL_WINDOW_RESIZABLE : 0;
			borderless = atoi(ini_get(game_ini, "screen", "borderless", "0")) ? SDL_WINDOW_BORDERLESS : 0;
			fullscreen = atoi(ini_get(game_ini, "screen", "fullscreen", "0")) ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0;
			fps = atoi(ini_get(game_ini, "screen", "fps", PARAM(DEFAULT_FPS)));
			if(fps <= 0)
				fps = DEFAULT_FPS;

			filter = !my_stricmp(ini_get(game_ini, "screen", "filter", "nearest"), "linear")? "1": "0";

			virt_width = atoi(ini_get(game_ini, "virtual", "width", PARAM(VIRT_WIDTH)));
			virt_height = atoi(ini_get(game_ini, "virtual", "height", PARAM(VIRT_HEIGHT)));

            show_cursor = atoi(ini_get(game_ini, "mouse", "show-cursor", PARAM(1)))? 1 : 0;

			startstate = ini_get(game_ini, "init", "startstate", NULL);
			if(startstate) {
                gs = get_state(startstate);
				if(!gs) {
					rerror("Unable to get initial state: %s", startstate);
					return 1;
				}
			} else {
				rerror("No initial state in %s", GAME_INI);
				return 1;
			}
		} else {
			rerror("Unable to load %s", GAME_INI);
			return 1;
		}
	} else {
start_demo:
		rlog("Starting demo mode");
		gs = get_demo_state("demo");
	}

	rlog("Initialising...");

	if(!init(appTitle, fullscreen | borderless | resizable)) {
		return 1;
	}
	
	if(!bmf_init()){	
        rlog("Quiting; Unable to start FreeType font library");
        return 1;
	}

    assert(gs);
	rlog("Entering initial state...");
    if(!change_state(gs)) {
        rlog("Quiting, because of earlier problems with the initial state");
        return 1;
    }
	
    frameStart = SDL_GetTicks();

	rlog("Event loop starting...");

	while(!quit) {
		gs = current_state();
		if(!gs) {
			break;
		}

		if(gs->update)
			gs->update(gs, bmp);

		advanceFrame();
	}

	rlog("Event loop stopped.");

	gs = current_state();
	if(gs && gs->deinit)
		gs->deinit(gs);

	bm_free(bmp);

	SDL_DestroyTexture(tex);
	SDL_DestroyRenderer(ren);
	SDL_DestroyWindow(win);

	SDL_Quit();

	ini_free(game_ini);

	re_clean_up();

	bmf_deinit();
	
	gdb_save("dump.db"); /* For testing the game database functionality. Remove later. */

	gdb_close();
	snd_deinit();
	rlog("Engine shut down.");

	return 0;
}
コード例 #13
0
ファイル: game.c プロジェクト: wernsey/rengine
/* advanceFrame() is kept separate so that it
 * can be exposed to the scripting system later
 */
void advanceFrame() {
	SDL_Event event;
	Uint32 end;
	int new_btns, cursor;

    frame_counter++;

	render();

	end = SDL_GetTicks();
	assert(end > frameStart);

	if(end - frameStart < 1000/fps)
		SDL_Delay(1000/fps - (end - frameStart));

	frameStart = SDL_GetTicks();

    cursor = SDL_ShowCursor(-1);
    if(cursor < 0) {
        rerror("SDL_ShowCursor: %s", SDL_GetError());
        cursor = 0;
    }

    if(cursor > 0) {
        int mx, my;
        new_btns = SDL_GetMouseState(&mx, &my);

        /* clicked = buttons that were down in the previous frame and aren't down anymore */
        mouse_clck = mouse_btns & ~new_btns;
        mouse_btns = new_btns;

        mouse_x = screen_to_virt_x(mx);
        mouse_y = screen_to_virt_y(my);
    } else {
        /* Ignore the mouse if the cursor is gone */
        new_btns = 0;
        mouse_clck = 0;
        mouse_btns = 0;
        mouse_x = -1;
        mouse_y = -1;
    }
	
	last_key = SDL_SCANCODE_UNKNOWN;

	while(SDL_PollEvent(&event)) {
		if(event.type == SDL_QUIT) {
			quit = 1;
		} else if(event.type == SDL_KEYDOWN) {
			/* FIXME: Descision whether to stick with scancodes or keycodes? */
			int index = event.key.keysym.scancode;

			/* Special Keys: F11, F12 and Esc */
			if(!handleSpecialKeys(event.key.keysym.scancode)) {
				/* Not a special key: */
				assert(index < SDL_NUM_SCANCODES);
				keys[index] = 1;
                last_key = index;
			}

		} else if(event.type == SDL_KEYUP) {
			int index = event.key.keysym.scancode;
			assert(index < SDL_NUM_SCANCODES);
			keys[index] = 0;
		/*} else if(event.type == SDL_MOUSEBUTTONDOWN) {
		} else if(event.type == SDL_MOUSEMOTION) {
            mouse_x = screen_to_virt_x(event.motion.x);
            mouse_y = screen_to_virt_y(event.motion.y);*/
		} else if(event.type == SDL_WINDOWEVENT) {
			switch(event.window.event) {
			case SDL_WINDOWEVENT_RESIZED:
				screenWidth = event.window.data1;
				screenHeight = event.window.data2;
				rlog("Window resized to %dx%d", screenWidth, screenHeight);
				break;
			default: break;
			}
		}
	}
}
コード例 #14
0
ファイル: Editor.c プロジェクト: pixelmager/rocket
static int processCommands()
{
	int strLen, newRow, serverIndex;
	unsigned char cmd = 0;
	int ret = 0;
	TrackViewInfo* viewInfo = getTrackViewInfo();

	if (RemoteConnection_recv((char*)&cmd, 1, 0)) 
	{
		switch (cmd) 
		{
			case GET_TRACK:
			{
				char trackName[4096];

				reset_tracks = true;	

				memset(trackName, 0, sizeof(trackName));

				RemoteConnection_recv((char *)&strLen, sizeof(int), 0);
				strLen = ntohl(strLen);

				if (!RemoteConnection_connected())
					return 0;

				if (!RemoteConnection_recv(trackName, strLen, 0))
					return 0;

				rlog(R_INFO, "Got trackname %s (%d) from demo\n", trackName, strLen);

				// find track
				
				serverIndex = TrackData_createGetTrack(&s_editorData.trackData, trackName);
				// if it's the first one we get, select it too
				if (serverIndex == 0)
					setActiveTrack(0);

				// setup remap and send the keyframes to the demo
				RemoteConnection_mapTrackName(trackName);
				RemoteConnection_sendKeyFrames(trackName, s_editorData.trackData.syncData.tracks[serverIndex]);
				TrackData_linkTrack(serverIndex, trackName, &s_editorData.trackData);

				s_editorData.trackData.tracks[serverIndex].active = true;

				ret = 1;

				break;
			}

			case SET_ROW:
			{
				//int i = 0;
				ret = RemoteConnection_recv((char*)&newRow, sizeof(int), 0);

				if (ret)
				{
					viewInfo->rowPos = htonl(newRow);
					viewInfo->selectStartRow = viewInfo->selectStopRow = viewInfo->rowPos;
					rlog(R_INFO, "row from demo %d\n", s_editorData.trackViewInfo.rowPos);
				}

				ret = 1;

				break;
			}
		}
	}

	return ret;
}
コード例 #15
0
static unsigned int remnode_send(remnode_item *remnode,
                                 pwr_sClass_RemTrans *remtrans,
                                 char *buf,
                                 int buf_size)
{
  unsigned int          sts, i;
  unsigned int          size_of_telegram, datasize;
  unsigned int          number_of_DLE = 0;
  unsigned int          delta_pos = 0;
  unsigned int          pos_counter = 0;
  unsigned int          follow_on = FALSE;
  unsigned int          A_telegram = FALSE;
  unsigned char         ch, cpu_number, CPU;
  unsigned char         BCC = DLE ^ ETX;
  unsigned char         datasize_low_byte, datasize_high_byte;
  unsigned char         received_char = '\0';
  unsigned char         response_buffer[RESP_MESSAGE_SIZE];
  unsigned char         *restore_buf_ptr = (unsigned char *)buf;
  static unsigned char  sstx[2] = {STX, '\0'};
  static unsigned char  sdle[2] = {DLE, '\0'};
  static unsigned char  snak[2] = {NAK, '\0'};
  fd_set read_fd;
  struct timeval tv;


  /* Define complete telegrams for sending */

  struct{
    unsigned char telegram_header[HEADER_SIZE];
    unsigned char telegram[MAX_SIZE_DATA_BLOCK*2 + NUMBER_OF_STOP_CHAR];
  }sendbuffer;

  struct{
    unsigned char telegram_header[FOLLOW_ON_HEADER_SIZE];
    unsigned char telegram[MAX_SIZE_DATA_BLOCK*2 + NUMBER_OF_STOP_CHAR];
  }follow_on_sendbuffer;


  do     /* Send 128 byte telegrams until message is finished */
  {
    if ( !follow_on )
    {
      A_telegram = TRUE;
/*************************************************************************/
/**    Send A-telegram.                                                 **/
/*************************************************************************/
/**    Check if follow on telegrams are needed.                         **/
/*************************************************************************/
      if ( buf_size - pos_counter > MAX_SIZE_DATA_BLOCK )
      {
        delta_pos = MAX_SIZE_DATA_BLOCK;
        follow_on = TRUE;
      }
      else
      {
        delta_pos = buf_size - pos_counter;
      }

/*************************************************************************/
/**    Calculate the size of the A-telegram.                            **/
/*************************************************************************/
      /* Count DLE characters */
      for ( i=0 ; i<delta_pos ; i++ )
      {
         if ( *buf++ == DLE )
            number_of_DLE += 1;
      }
      size_of_telegram = HEADER_SIZE+
                         delta_pos+number_of_DLE+NUMBER_OF_STOP_CHAR;

/*************************************************************************/
/**    Fill in the telegram header and calculate BCC.                   **/
/*************************************************************************/
      /* Size have to be expressed in number of 16 bits words. */
      /* If odd number of bytes add one. */

      datasize = buf_size/2 + buf_size%2;
      datasize_low_byte = (unsigned char)(BYTE_MASK & datasize);
      datasize = datasize >> 8;
      datasize_high_byte = (unsigned char)(BYTE_MASK & datasize);
      cpu_number = (unsigned char)remtrans->Address[2];
      CPU = '\xFF';
      CPU = CPU_NR_MASK & cpu_number;

      sendbuffer.telegram_header[0] = '\0';
      sendbuffer.telegram_header[1] = '\0';
      sendbuffer.telegram_header[2] = 'A';
      sendbuffer.telegram_header[3] = 'D';
      sendbuffer.telegram_header[4] = (unsigned char)remtrans->Address[0];
      sendbuffer.telegram_header[5] = (unsigned char)remtrans->Address[1];
      sendbuffer.telegram_header[6] = datasize_high_byte;
      sendbuffer.telegram_header[7] = datasize_low_byte;
      sendbuffer.telegram_header[8] = '\xFF';
      sendbuffer.telegram_header[9] = CPU;

      /* Calculate checksum for the header */
      for ( i=0 ; i<HEADER_SIZE ; i++ )
      {
        BCC ^= sendbuffer.telegram_header[i];
      }
/*************************************************************************/
/**   Fill up A-telegram with contents of message and calculate BCC     **/
/*************************************************************************/
      buf = (char *)restore_buf_ptr;
      for ( i=0 ; i<(delta_pos+number_of_DLE) ; i++ )
      {
        ch = sendbuffer.telegram[i] = *buf++;
        BCC ^= ch;
        if ( ch == DLE )
        {
          sendbuffer.telegram[++i] = DLE;
          BCC ^= ch;
        }
      }
      if ( delta_pos%2 )
      {
        /* Ensure that a even number of bytes is treated */
        sendbuffer.telegram[i++] = '\0';
        size_of_telegram += 1;
      }
      sendbuffer.telegram[i++] = DLE;
      sendbuffer.telegram[i++] = ETX;
      sendbuffer.telegram[i]   = BCC;

      pos_counter = delta_pos;
    }
    else  /* follow on telegram */
    {

/*************************************************************************/
/**    Send follow on telegram.                                         **/
/*************************************************************************/
/**    Check if more follow on telegrams are needed.                    **/
/*************************************************************************/
      if ( buf_size - pos_counter > MAX_SIZE_DATA_BLOCK )
      {
        delta_pos = MAX_SIZE_DATA_BLOCK;
        follow_on = TRUE;
      }
      else
      {
        delta_pos = buf_size - pos_counter;
        follow_on = FALSE;
      }

/*************************************************************************/
/**    Calculate the size of the follow on telegram.                    **/
/*************************************************************************/
      /* Count DLE characters */
      restore_buf_ptr = (unsigned char *)buf;
      number_of_DLE = 0;
      for ( i=0 ; i<delta_pos ; i++ )
      {
         if ( *buf++ == DLE )
            number_of_DLE += 1;
      }
      size_of_telegram = FOLLOW_ON_HEADER_SIZE+
                         delta_pos+number_of_DLE+NUMBER_OF_STOP_CHAR;

/*************************************************************************/
/**    Fill in the follow on telegram header and calculate BCC.         **/
/*************************************************************************/
      follow_on_sendbuffer.telegram_header[0] = '\xFF';
      follow_on_sendbuffer.telegram_header[1] = '\0';
      follow_on_sendbuffer.telegram_header[2] = 'A';
      follow_on_sendbuffer.telegram_header[3] = 'D';

      /* Calculate checksum for the header */
      BCC = DLE ^ ETX;
      for ( i=0 ; i<FOLLOW_ON_HEADER_SIZE ; i++ )
      {
        BCC ^= follow_on_sendbuffer.telegram_header[i];
      }

/*************************************************************************/
/* Fill up follow on telegram with contents of message and calculate BCC */
/*************************************************************************/
      buf = (char *)restore_buf_ptr;
      for ( i = 0 ; i < (delta_pos+number_of_DLE) ; i++ )
      {
        ch = follow_on_sendbuffer.telegram[i] = *buf++;
        BCC ^= ch;
        if ( ch == DLE )
        {
          follow_on_sendbuffer.telegram[++i] = DLE;
          BCC ^= ch;
        }
      }
      if ( delta_pos%2 )
      {
        /* Ensure that a even number of bytes is treated */
        follow_on_sendbuffer.telegram[i++] = '\0';
        size_of_telegram += 1;
      }
      follow_on_sendbuffer.telegram[i++] = DLE;
      follow_on_sendbuffer.telegram[i++] = ETX;
      follow_on_sendbuffer.telegram[i]   = BCC;

      pos_counter += delta_pos;

    }

/*************************************************************************/
/**    Execute the send procedure                                       **/
/*************************************************************************/
    /* Send STX and wait for answer */
    sts = write(ser_fd, sstx, 1);
    rlog("snd STX", 0);
    if ( sts > 0) {
      load_timeval(&tv, rn_RK512->CharTimeout);
      FD_ZERO(&read_fd);
      FD_SET(ser_fd, &read_fd);
      select(ser_fd+1, &read_fd, NULL, NULL, &tv);
      sts = read(ser_fd, &received_char, 1);
    }
    if ( sts > 0) { //om det inte var timeout

      if ( received_char == STX ) {
	rlog("snd STX received", 0);
	/* Both nodes is in sending mode. */
	/* Cancel this send operation and wait for next timeout or receive */
	write(ser_fd, snak, 1);
	return(FALSE);
      }
      if ( received_char == DLE ) {
	/* Contact is established. Send telegram */
	rlog("snd DLE received, contact", 0);
	if ( A_telegram ) {
	  sts = write(ser_fd, &sendbuffer, size_of_telegram);
	  rlog("snd message sent", size_of_telegram);
	  A_telegram = FALSE;
	}
	else {
	  sts = write(ser_fd, &follow_on_sendbuffer, size_of_telegram);
	  rlog("snd message sent", size_of_telegram);
	}
	if ( sts > 0 ) {
	  /* wait for break character or timeout */
	  load_timeval(&tv, rn_RK512->CharTimeout);
	  FD_ZERO(&read_fd);
	  FD_SET(ser_fd, &read_fd);
	  select(ser_fd+1, &read_fd, NULL, NULL, &tv);
	  sts = read(ser_fd, &received_char, 1);

          if ( sts > 0 &&(received_char == DLE) ) {

/*************************************************************************/
/**   The sending was a SUCCESS. Take care of the response message      **/
/*************************************************************************/
	    rlog("snd DLE received, success", 0);
	    load_timeval(&tv, rn_RK512->CharTimeout);
	    FD_ZERO(&read_fd);
	    FD_SET(ser_fd, &read_fd);
	    select(ser_fd+1, &read_fd, NULL, NULL, &tv);
	    sts = read(ser_fd, &received_char, 1);

            if ( sts > 0 &&(received_char == STX) ) {
              /* Send DLE acknowledge and wait for response data */
	      sts = write(ser_fd, sdle, 1);
              if ( sts > 0 ) {
                BCC = '\0';
                for (i=0 ;
                     i < RESP_MESSAGE_SIZE && sts > 0;
                     i++ ) {

		  load_timeval(&tv, rn_RK512->CharTimeout);
		  FD_ZERO(&read_fd);
		  FD_SET(ser_fd, &read_fd);
		  select(ser_fd+1, &read_fd, NULL, NULL, &tv);
		  sts = read(ser_fd, &received_char, 1);

                  response_buffer[i] = received_char;
                  BCC ^= received_char;
                }  /* endfor */

                if ( sts > 0 &&
                     (response_buffer[2] == '\0') ) {
                  /* Compare received BCC with calculated */
		  load_timeval(&tv, rn_RK512->CharTimeout);
		  FD_ZERO(&read_fd);
		  FD_SET(ser_fd, &read_fd);
		  select(ser_fd+1, &read_fd, NULL, NULL, &tv);
		  sts = read(ser_fd, &received_char, 1);
                  if ( sts > 0 &&
                       ( BCC == received_char ) ) {
                    /* Response telegram received OK */
		    sts = write(ser_fd, sdle, 1);
                    if ( response_buffer[3] != 0 ) {
                      /* This response contains a error code */
                      errh_CErrLog(REM__SIEMENSERROR,
                                   errh_ErrArgL(response_buffer[3]) );
                    }
                  }
                  else {
                    /* Wrong checksum. */
                    sts = FALSE;
                  }
                }
                else {
                  /* This is not a response message as expected */
		  sts = write(ser_fd, snak, 1);
                  sts = FALSE;
                }
              } /* ENDIF. DLE acknowledge failed */
            }
            else
            {
              /* STX character in response message was expected. */
              /* Ensure that error status is returned */
              sts = FALSE;
            }
          }
          else
          {
            /* DLE ack. after sending telegram was expected. */
            /* Ensure that error status is returned */
	    rlog("snd DLE missing", 0);
            sts = FALSE;
          }
        } /* ENDIF. Contact established but tty_write failed */
      }
      else
      {
        /* Failed in making contact. Wrong response character. */
        /* Ensure that error status is returned */
        sts = FALSE;
      }
    }  /* ENDIF. tty_write or tty_read failed */

/*************************************************************************/
/**  Check final status.                                                **/
/*************************************************************************/
    if ( EVEN(sts))
    {
      /* The send procedure has failed */
      sts = write(ser_fd, snak, 1);
      rlog("snd failed, NAK sent", 0);

      follow_on = FALSE;

      /* Ensure that error status is returned */
      sts = FALSE;
    }

  }while( follow_on );