Example #1
0
/* Looks up a string, s, in a trie, t, and returns the number of occ. */
int   trie_lookup(trie t, string s)
{
  if(t == NULL)
    return 0;				/* Didn't find it */
  
  if(s[0] == '\0')			/* At the end */
    return (t->next[char2index(s[0])])->number;
  else
    return (trie_lookup(t->next[char2index(s[0])], s+1));
}
Example #2
0
/* Insert a string, s, in a trie, t, and return the updated trie */
trie  trie_insert(trie t, string s)
{
  if(t == NULL)
    t = trie_init();
  
  if(s[0] == '\0')			/* We've found the end */
    t->number++;
  else
    t->next[char2index(s[0])] = trie_insert(t->next[char2index(s[0])], s+1);

  return t;
}
Example #3
0
void engine_player_hit (Engine* engine) {
	Player* player = engine->player;
	Context* context = (Context*) engine->context;
	vertex* v;
	char* game_over = "GAME OVER";
	int tmp = *engine->shield;
	int i = 0;
	tmp -= 10;

	if (tmp <= 0) {
		tmp = 0;
		engine_create_explosion(
			*player->x + player->v_buf->v->bitmap->w / 2
			, *player->y + player->v_buf->v->bitmap->h / 2
			, engine
		);
		player->v_buf->v = NULL;

		for (; i < strlen(game_over); i++) {
			v = vertex_create(
				(engine->max_w / 2 - (strlen(game_over) / 2) * GLYPH_SIZE)
					+ (i * GLYPH_SIZE)
				, SCREEN_TOP + engine->max_h / 2 - GLYPH_SIZE / 2
				, context->glyphs->map[char2index(game_over[i])]
			);
			
			context->video[1] = vertex_buffer_push(context->video[1], v);
		}
	}

	*engine->shield = tmp;
}
Example #4
0
void engine_draw_score (Context* context) {
	static int prev_score = -1;
	char score[MAX_SCORE_DIGITS+1];
	int i, k;
	
	if (prev_score == context->profile->score) {
		return;
	}
	
	snprintf(
		score
		, (MAX_SCORE_DIGITS + 1) * sizeof(char)
		, "%d"
		, context->profile->score
	);
	
	for (i = 0; i < strlen(score); i++) {
		k = MAX_SCORE_DIGITS - strlen(score) + i;
		context->engine->score_bufs[k]->v->bitmap =
			context->glyphs->map[char2index(score[i])];
	}
	
	prev_score = context->profile->score;
}
qint64 U2AssemblyBasesFrequenciesInfo::getCharFrequency(char c) {
    int index = char2index(c);
    return index >= 0 ? baseFrequencies[index] : 0;
}
void U2AssemblyBasesFrequenciesInfo::addToCharFrequency(char c) {
    int index = char2index(c);
    if(index >= 0) {
        ++baseFrequencies[index];
    }
}
Example #7
0
Engine* engine_init_level (Context* context) {
	Engine* engine = (Engine*) malloc(sizeof(Engine));
	engine->context = context;
	engine->tiles = load_tiles(context);
	int h, w, i;
	
	h = context->video[0]->head->v->bitmap->h;
	w = context->video[0]->head->v->bitmap->w;
	
	engine->partition_len =
		ceil((((double) w) / BOX_SIZE))
		* ceil((((double) h) / BOX_SIZE));
	engine->partitions =
		(Node**) malloc(engine->partition_len * sizeof(Node*));
	memset(engine->partitions, 0, engine->partition_len * sizeof(Node*));

	engine->flash_anims = linked_list_init();
	
	for (i = 0; i < engine->partition_len; i++) {
		engine->partitions[i] = linked_list_init();
	}
	
	engine->max_h = h;
	engine->max_w = w;
	
	// Clear any and all vertexes left on the screen (including the background)
	clear_buffers(context);
	
	engine->loading_bufs = engine_create_loading(context, h, w);
	
	engine_init_bg(engine, h, w);
	engine_inc_loading(engine);

	engine->explosion = engine_load_explosion(context, engine);
	engine->explosions = linked_list_init();
	engine->explo_field = 0;

	engine->tbl_count = 0;
	engine->player_tbl = (Player**) malloc(TBL_MAX * sizeof(Player*));
	
	engine->player = engine_load_player(
		context
		, engine
		, "ship"
		, w / 2
		, h - SCREEN_TOP
	);
	engine_inc_loading(engine);
	
	engine->shot_bufs = engine_init_shots(context, engine, h);
	engine->shot_field = 0ULL;
	
	engine->enemy_sprites = engine_load_enemies(context, engine);
	engine->shield_bufs = engine_init_shield(context, engine);
	
	engine->score_bufs = engine_init_score(context, h);
	engine->enemies = (Player**) malloc(MAX_ENEMIES * sizeof(Player*));
	memset(engine->enemies, 0, MAX_ENEMIES * sizeof(Player*));
	engine->enemy_field = 0;
	
	context->game_state = TYRIAN_GAME_LEVEL;
	engine_clear_loading(context, engine);
	
#if DEBUG
	vertex* v;
	fps = (vertex_buffer**) malloc(6 * sizeof(vertex_buffer*));
	char str[7] = "FPS 00";
	for (i = 0; i < 6; i++) {
		v = vertex_create(
			w - GLYPH_SIZE * (6 - i)
			, SCREEN_TOP
			, context->glyphs->map[char2index(str[i])]
		);
		context->video[1] = vertex_buffer_push(context->video[1], v);
		fps[i] = context->video[1]->prev;
	}
#endif
	
	return engine;
}