sc_result sc_graph_find_min_path(sc_addr graph, sc_addr beg_vertex, sc_addr end_vertex, sc_addr_list **path)
{
sc_addr curr_vertex, cur_wave;
sc_addr_list *not_checked_vertices = nullptr, *wave_list_head = nullptr, *path_head = nullptr;
sc_iterator3 *wave_it;
sc_iterator5 *it5 = sc_iterator5_f_a_a_a_f_new(graph,
sc_type_arc_pos_const_perm,
sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
sc_graph_keynode_rrel_vertex);
if (sc_helper_check_arc(sc_graph_keynode_graph, graph, sc_type_arc_pos_const_perm) == SC_FALSE)
return SC_RESULT_ERROR_INVALID_PARAMS;
while (sc_iterator5_next(it5) == SC_TRUE)
{
if (SC_ADDR_IS_EQUAL(beg_vertex, it5->results[2]) == SC_FALSE)
{
not_checked_vertices = sc_addr_list_append(not_checked_vertices);
not_checked_vertices->value = it5->results[2];
}
}
cur_wave = sc_memory_node_new(sc_type_node | sc_type_const);
sc_memory_arc_new(sc_type_arc_pos_const_perm, cur_wave, beg_vertex);
wave_list_head = sc_addr_list_append(wave_list_head);
wave_list_head->value = cur_wave;
do {
cur_wave = create_wave(cur_wave, graph, ¬_checked_vertices);
wave_it = sc_iterator3_f_a_a_new(cur_wave,
sc_type_arc_pos_const_perm,
sc_type_node | sc_type_const);
if (sc_iterator3_next(wave_it) == SC_FALSE)
//TODO clear memory
return SC_RESULT_ERROR;
wave_list_head = sc_addr_list_append(wave_list_head);
wave_list_head->value = cur_wave;
} while(sc_helper_check_arc(cur_wave, end_vertex, sc_type_arc_pos_const_perm) == SC_FALSE);
path_head = sc_addr_list_append(path_head);
path_head->value = end_vertex;
curr_vertex = end_vertex;
wave_list_head = sc_addr_list_next(wave_list_head);
do {
curr_vertex = find_adjacent_from_wave(graph, wave_list_head->value, curr_vertex);
path_head = sc_addr_list_append(path_head);
path_head->value = curr_vertex;
} while((wave_list_head = sc_addr_list_next(wave_list_head)) != nullptr);
*path = path_head;
return SC_RESULT_OK;
}
void advance_to_next_level( game_state_t* GS )
{
int i, j, k;
// Reset formations
for( i = 0 ; i < MAX_FORMATIONS ; i++ ) {
GS->formations[i].nr_ranks = 0;
for( j = 0 ; j < MAX_FORMATION_RANKS ; j++ ) {
GS->formations[i].ranks[j].occupied_by = NULL;
for( k = 0 ; k < NR_FILLFROM_RANKS ; k++ ) {
GS->formations[i].ranks[j].fillfrom_index[k] = -1;
}
}
}
//...! record score
//...GS->shots_fired = 0;
//...GS->shots_missed = 0;
//...GS->best_resource = 0;
++GS->current_level;
#if TEST_LEVELS
int L = GS->current_level;
formation_t* f = &(GS->formations[0]);
f->nr_ranks = create_formation( GS, f, TIER_1, L, 0, 1 );
create_formation_enemies( GS, f, TIER_1, L*L );
#elif LEVEL_DESIGN_V2
int L = GS->current_level;
int formation_index = 0;
create_wave( GS, L, &formation_index );
create_wave( GS, L+1, &formation_index );
#else
create_units( GS );
#endif
}
void game_start(void* ptr){
Jogo* jogo = (Jogo*) ptr;
finaliza_jogo(jogo);
jogo-> vidas = 2;
jogo->score = 0;
cria_escudos( jogo);
cria_tanque( jogo);
jogo->invasores = create_wave(50, N_ALIEN);
jogo->buffer = inicializa_buffer(jogo->display, jogo->fonte, LARGURA_INICIAL, ALTURA_INICIAL, jogo->escudo, N_ESCUDOS,
jogo->tanque, jogo->invasores, &jogo->vidas, &jogo->score);
jogo->estado_do_jogo = PLAY;
}
/**
* Initialize the project, doing any necessary opengl initialization.
* @param camera An already-initialized camera.
* @param scene The scene to render.
* @return true on success, false on error.
*/
bool OpenglProject::initialize( Camera* camera, Scene* scene )
{
// copy scene
this->scene = *scene;
// TODO opengl initialization code and precomputation of mesh/heightmap
// Set configuration bitflags
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
// Debug: Render in wireframe mode
// glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
GLfloat light_ambient[] = { 0.5, 0.25, 0.55, 1.0 };
GLfloat light_diffuse[] = { 0.95, 0.4, 0.5, 1.0 };
GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_position[] = { 20.0, 5.0, 15.0, 0.0 };
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(
camera->get_fov_degrees(),
camera->get_aspect_ratio(),
camera->get_near_clip(),
camera->get_far_clip());
glMatrixMode( GL_MODELVIEW );
this->scene.mesh.normals = new Vector3[this->scene.mesh.num_vertices];
generate_normals(this->scene.mesh);
wave_resolution = 128;
create_wave();
return true;
}
/// @brief Находит один из минимальных путей в графе @p graph
/// от вершины @p beg_vertex до вершины @p end_vertex.
///
/// Волновой алгоритм поиска одного из минимальных путей:
/// 1. Добавить все вершины графа (кроме начальной вершины пути) в множество непроверенных вершин.
///
/// 2. Создать начальную волну и добавить в нее начальную вершину пути.
///
/// 3. Начальная волна - новая волна. Новой волной будем называть последнюю созданную волну.
///
/// 4. Сформировать следующую волну для новой волны. В нее попадет та вершина,
/// которая является смежной вершине из новой волны и присутствует во множестве непроверенных вершин.
/// Если вершина попала в формируемую волну, то ее надо исключить из множества непроверенных вершин.
/// Созданную волну установим как следующую для новой волны, и после этого созданную волну будем считать новой волной.
///
/// 5. Если новая волна пуста, то значит между вершинами не существует пути.
/// Завершить алгоритм.
///
/// 6. Если в текущей волне есть конечная вершина, то перейти к пункту 7, иначе к пункту 4.
///
/// 7. Сформировать один из минимальных путей, проходя в обратном порядке по списку волн.
///
/// @param s sc-сессия, при помощи которой будет производиться работа с sc-памятью.
/// @param seg sc-сегмент, в котором происходит работа алгоритма.
/// @param graph неориентированный граф, в котором будет находится минимальный путь.
/// @param beg_vertex начальная вершина пути.
/// @param end_vertex конечная вершина пути.
///
/// @return связка отношения "простая цепь*" или 0, если минимальный путь не найден.
///
sc_addr find_min_path(sc_session* s, sc_segment* seg, sc_addr graph, sc_addr beg_vertex, sc_addr end_vertex)
{
// 1. Добавить все вершины графа (кроме начальной вершины пути) в множество непроверенных вершин.
//
sc_addr not_checked_vertexes = s->create_el(seg, SC_N_CONST); // множество непроверенных вершин
// Итератор по вершинам графа
//
sc_iterator *it = s->create_iterator(
sc_constraint_new(
CONSTR_3_f_a_a,
graph,
SC_A_CONST|SC_POS,
0,
SC_A_CONST|SC_POS,
graph_theory::vertex_
), true);
sc_for_each (it) {
sc_addr vertex = it->value(2);
// Не добавляем вершину начала пути в множество непросмотренных вершин.
//
if (vertex != beg_vertex)
sc_set::include_in(s, it->value(2), not_checked_vertexes);
}
// 2. Создать начальную волну и добавить в нее начальную вершину пути.
// 3. Начальная волна - новая волна.
//
sc_addr new_wave = s->create_el(seg, SC_N_CONST);
sc_set::include_in(s, beg_vertex, new_wave);
// Создаем начало списка волн.
sc_addr waves_list_head = sc_list::create(s, seg, new_wave);
sc_addr waves_list_tail = waves_list_head;
do {
// 4. Сформировать следующую волну для новой волны.
// Установить созданную волну как следующую для новой волны.
// Созданная волна - новая волна.
//
new_wave = create_wave(s, seg, graph, new_wave, not_checked_vertexes);
sc_addr waves_list_curr = sc_list::create(s, seg, new_wave);
sc_list::set_next(s, waves_list_tail, waves_list_curr);
waves_list_tail = waves_list_curr;
// 5. Если новая волна пуста, то значит между вершинами не существует пути.
//
if (sc_set::is_empty(s, new_wave)) {
// Очищаем память и завершаем алгоритм.
//
erase_waves_list(s, waves_list_head);
s->erase_el(not_checked_vertexes);
return 0;
}
// 6. Если в текущей волне есть конечная вершина, то перейти к пункту 7, иначе к пункту 4.
//
} while (!sc_set::is_in(s, end_vertex, new_wave));
// Подчистим память...
//
s->erase_el(not_checked_vertexes);
// 7. Сформировать один из минимальных путей, проходя в обратном порядке по списку волн.
// Сформируем связку отношения "простая цепь*"
//
sc_addr route = s->create_el(seg, SC_N_CONST); // связка отношения "простая цепь*"
sc_addr route_struct = s->create_el(seg, SC_N_CONST); // ориентированный граф структуры маршрута
sc_set::include_in(s, route_struct, graph_theory::directed_graph);
sc_addr route_visit = s->create_el(seg, SC_N_CONST); // бинарное отношение посещения
// Добавим все компоненты в связку отношения "простая цепь*".
//
sc_tup::add(s, route, N1_, route_struct);
sc_tup::add(s, route, N2_, graph);
sc_tup::add(s, route, N3_, route_visit);
sc_set::include_in(s, route, graph_theory::simple_trail);
// Добавим в простую цепь посещение начальной вершины.
//
sc_addr beg_vertex_visit = add_vertex_visit_to_route(s, route, beg_vertex);
// Добавим в простую цепь посещение конечной вершины.
//
sc_addr end_vertex_visit = add_vertex_visit_to_route(s, route, end_vertex);
// Пройдем в обратном направлении по списку волн
// и сформируем структуру маршрута.
//
sc_addr curr_vertex = end_vertex;
// Строим из списка волн маршрут, проходя по этому списку в обратном направлении.
sc_list::reverse_iterator list_it(s, waves_list_tail), list_end;
for (++list_it; list_it != list_end; ++list_it) {
sc_addr curr_wave = *list_it;
sc_addr edge = find_any_edge(s, graph, curr_vertex, curr_wave);
// Получаем предыдущую вершину в пути.
//
sc_addr prev_vertex = get_other_vertex_incidence_edge(s, edge, curr_vertex);
// Добавляем посещение ребра @p edge в путь.
//
add_edge_visit_to_route(s, route, edge, prev_vertex, curr_vertex);
curr_vertex = prev_vertex;
}
// Подчистим память...
//
erase_waves_list(s, waves_list_head);
return route;
}
