Heap CreateHeap(int initial_number_of_elements) {
Heap initial_heap;
initial_heap.size = 0;
initial_heap.number_of_elements = initial_number_of_elements;
int number_of_nodes = initial_number_of_elements/2;
if(initial_number_of_elements % 2) {
number_of_nodes = (initial_number_of_elements/2) + 1;
}
// Obtem até o penultimo elemento.
int i;
for(i = 0; i + 1 < number_of_nodes; i++) {
scanf("%d", &initial_heap.node[i].min);
scanf("%d", &initial_heap.node[i].max);
AssignValues(&initial_heap.node[i]);
initial_heap.size++;
}
// Obtem o último elemento. A obtenção deste é diferente devido à
// possibilidade de haver um número ímpar de elementos.
scanf("%d", &initial_heap.node[i].min);
initial_heap.node[i].max = -1;
if(initial_number_of_elements % 2 == 0) {
scanf("%d", &initial_heap.node[i].max);
AssignValues(&initial_heap.node[i]);
}
initial_heap.size++;
// Torna a entrada inicial em um heap.
initial_heap = HeapifyInterval(initial_heap);
return initial_heap;
}
bool Controller::ChooseUnit(int & number, Vehicle& myUnit)
{
templateIO sArr, sArrGun;
VehicleGun newGun;
std::string filename = "Vehicles.txt";
std::string unitType = filename;
unitType.erase(unitType.find('.'), 4);
if (ReadFile(sArr, filename, unitType, number) == 0 && ReadFile(sArrGun, "VehicleGuns.txt", "VehicleGuns", number) == 0)
{
Vehicle backup = myUnit;
if (AssignValues(sArrGun, unitType, newGun))
{
if (AssignValues(sArr, unitType, myUnit, newGun))
return true;
else
{
myUnit = backup;
return false;
}
}
}
else
{
return false;
}
}
void UpwardsMin(Heap *intervals, int position) {
int father_position = (position - 1) / 2;
Interval node_interval = (*intervals).node[position];
while((position > 0) && ((*intervals).node[father_position].min) > node_interval.min) {
(*intervals).node[position].min = (*intervals).node[father_position].min;
position = father_position;
father_position = (position - 1) / 2;
AssignValues(&(*intervals).node[position]);
}
(*intervals).node[position].min = node_interval.min;
AssignValues(&(*intervals).node[position]);
}
Gura_ModuleEntry()
{
PrepareParamInfoDict();
AssignValues(env);
AssignFunctions(env);
Gura_AssignMethodTo(VTYPE_image, image, opengl);
return true;
}
// Tendo o pai como referência, o mesmo é comparado com seus filhos e trocado
// caso a sua prioridade seja maior que a de um deles.
void DownwardsMin(Heap *intervals, int position) {
//Assume que o filho de menor valor é o da esquerda.
int lowest_son_position = 2*position+1;
bool stop = false;
// Enquanto o vetor ainda estiver sendo percorrido e o pai
// não ser menor que ambos seus filhos...
while((!stop) && (lowest_son_position < (*intervals).size)) {
// Caso os filhos da direita e esquerda existirem e o valor atual do
// filho de menor valor for maior que o do irmão, significa que a
// posição do filho de menor valor é a posição do irmão.
int father_value = (*intervals).node[position].min;
if(BrotherHasLowerValue((*intervals), lowest_son_position)){
lowest_son_position += 1;
// Garante que o valor a ser utilizado é o correto.
AssignValues(&(*intervals).node[lowest_son_position]);
}
// Caso o pai possua prioridade maior que a do filho de menor prioridade,
// troca os valores de ambos entre si. A verificação é feita para ambos
// os extremos do intervalo.
if((father_value > (*intervals).node[lowest_son_position].min)
&& IsNotEmpty((*intervals).node[lowest_son_position].min)) {
SwapValues(&(*intervals).node[position].min,
&(*intervals).node[lowest_son_position].min);
} else if ((father_value > (*intervals).node[lowest_son_position].max)
&& IsNotEmpty((*intervals).node[lowest_son_position].max)) {
SwapValues(&(*intervals).node[position].min,
&(*intervals).node[lowest_son_position].max);
//Caso o pai esteja na posição correta, interrompe o loop.
} else {
stop = true;
}
position = lowest_son_position;
lowest_son_position = (2 * lowest_son_position) + 1;
//Ajusta os valores máximo e mínimo, caso necessário.
AssignValues(&(*intervals).node[position]);
}
AssignValues(&(*intervals).node[position]);
}
// Tendo o pai como referência, o mesmo é comparado com seus filhos e trocado
// caso a sua prioridade seja menor que a de um deles.
void DownwardsMax(Heap *intervals, int position) {
//Assume que o filho de maior valor é o da esquerda.
int highest_son_position = 2*position+1;
bool stop = false;
// Enquanto o vetor ainda estiver sendo percorrido e o pai
// não ser maior que ambos seus filhos...
while((!stop) && (highest_son_position < (*intervals).size)) {
// Caso os filhos da direita e esquerda existirem e o valor do filho de
// maior valor for menor que o do irmão, significa que a posição do filho de
// maior valor é a posição do irmão.
int father_value = (*intervals).node[position].max;
if(BrotherHasHigherValue((*intervals), highest_son_position)) {
highest_son_position += 1;
// Garante que o valor a ser utilizado é o correto.
AssignValues(&(*intervals).node[highest_son_position]);
}
// Caso o pai possua prioridade menor que a do filho de maior prioridade,
// troca os valores de ambos entre si.
if(father_value < (*intervals).node[highest_son_position].max) {
SwapValues(&(*intervals).node[position].max,
&(*intervals).node[highest_son_position].max);
position = highest_son_position;
highest_son_position = (2 * highest_son_position) + 1;
//Ajusta os valores máximo e mínimo, caso necessário.
AssignValues(&(*intervals).node[position]);
//Caso o pai esteja na posição correta, interrompe o loop.
} else {
stop = true;
}
}
AssignValues(&(*intervals).node[position]);
}
bool Controller::ChooseUnit(int & number, Gun* myUnit)
{
templateIO sArr;
std::string filename = "Weapons.txt";
std::string unitType = filename.erase(filename.find('.'), 4);
if (ReadFile(sArr, filename, unitType, number) == 0)
{
Gun backup = *myUnit;
if (AssignValues(sArr, unitType, myUnit))
return true;
else
{
*myUnit = backup;
return false;
}
}
else
{
return false;
}
}
bool Controller::ChooseUnit(int& number, CrewMember& myUnit)
{
templateIO sArr;
std::string filename = "CrewMembers.txt";
std::string unitType = filename;
unitType.erase(unitType.find('.'), 4);
if (ReadFile(sArr, filename, unitType, number) == 0)
{
CrewMember backup = myUnit;
if (AssignValues(sArr, unitType, myUnit))
return true;
else
{
myUnit = backup;
return false;
}
}
else
{
return false;
}
}
Heap InsertNewElement(Heap interval_heap, int priority_new_element) {
int position = (interval_heap.size -1)/2;
if(position < 0) {
position = 0;
}
Interval father_interval = interval_heap.node[position];
// Caso o número de elementos seja par...
if(interval_heap.number_of_elements % 2 == 0) {
// Utiliza mais um nó.
interval_heap.size++;
interval_heap.number_of_elements++;
position = interval_heap.size - 1;
// Se o novo valor estiver fora do intervalo dos pais...
if(ValueIsOutOfInterval(father_interval, priority_new_element)) {
// ...Insere o novo valor e ealiza a devida operação de subida.
if(ValueIsLowerThanMin(father_interval, priority_new_element)) {
interval_heap.node[position].min = priority_new_element;
interval_heap.node[position].max = -1;
UpwardsMin(&interval_heap, position);
} else {
interval_heap.node[position].min = -1;
interval_heap.node[position].max = priority_new_element;
UpwardsMax(&interval_heap, position);
}
} else {
// Caso contrário, só insere o novo valor.
interval_heap.node[position].min = priority_new_element;
interval_heap.node[position].max = -1;
}
// Caso o número de elementos seja ímpar...
} else {
interval_heap.number_of_elements++;
position = interval_heap.size - 1;
// Põe a nova prioridade no campo não preenchido.
if(interval_heap.node[position].min == -1) {
interval_heap.node[position].min = priority_new_element;
} else {
interval_heap.node[position].max = priority_new_element;
}
// Ajusta o máximo e o mínimo do intervalo.
AssignValues(&interval_heap.node[position]);
// Se o novo valor estiver fora do intervalo dos pais...
if(ValueIsOutOfInterval(father_interval, priority_new_element)) {
// ...Realiza a devida operação de subida.
if(ValueIsLowerThanMin(father_interval, priority_new_element)) {
if(position != 0) {
UpwardsMin(&interval_heap, position);
}
} else {
if(position != 0) {
UpwardsMax(&interval_heap, position);
}
}
}
}
return interval_heap;
}