void update_sprite_prios(int sprite_no, uint8_t x_pos) {
Node *current_node = inverse_prio_sprites + sprite_no;
// Order by x position and if equal then by sprite number
uint16_t val = (x_pos << 8) | sprite_no;
current_node->x_pos = val;
Node *swap_node = current_node;
// Move up priorities
if (swap_node->next != sentinal && val < swap_node->next->x_pos) {
while (swap_node->next != sentinal && val < swap_node->next->x_pos) {
swap_node = swap_node->next;
}
move_after(current_node, swap_node);
}
// Move down priorites
else if (swap_node->prev != sentinal && val > swap_node->prev->x_pos) {
while (swap_node->prev != sentinal && val > swap_node->prev->x_pos) {
swap_node = swap_node->prev;
}
move_after(current_node, swap_node->prev);
}
// Set new head if replaced
if (current_node != swap_node && swap_node == head_ptr) {
head_ptr = current_node;
}
}
static void tst4(unsigned sz, unsigned num_rounds) {
uint_total_order to;
unsigned_vector v;
unsigned_vector inv_v;
to.insert(0);
v.push_back(0);
inv_v.push_back(0);
for (unsigned i = 0; i < sz; i++) {
to.insert_after(i, i+1);
v.push_back(i+1);
inv_v.push_back(i+1);
}
for (unsigned i = 0; i < num_rounds; i++) {
unsigned v1 = rand() % sz;
unsigned v2 = rand() % sz;
if (v1 != v2) {
to.move_after(v1, v2);
move_after(v, inv_v, v1, v2);
}
for (unsigned k = 0; k < sz - 1; k++) {
SASSERT(inv_v[v[k]] == k);
SASSERT(to.lt(v[k], v[k+1]));
}
if (i % 1000 == 0) {
std::cout << "*";
std::cout.flush();
}
}
std::cout << std::endl;
}
void modify_branch_so_that_state_access_is_indexed(Branch* branch, int index)
{
Term* stateInput = find_state_input(branch);
if (stateInput == NULL)
return;
// If the state output is connected directly to state input, then do nothing.
Term* stateOutput = find_state_output(branch);
if (stateOutput->input(0) == stateInput)
return;
Term* unpackList = apply(branch, FUNCS.unpack_state_from_list, TermList(stateInput));
unpackList->setIntProp("index", index);
move_after_inputs(unpackList);
for (int i=0; i < stateInput->users.length(); i++) {
Term* term = stateInput->users[i];
if (term == unpackList)
continue;
remap_pointers_quick(term, stateInput, unpackList);
}
Term* stateResult = stateOutput->input(0);
ca_assert(stateResult != NULL);
Term* packList = apply(branch, FUNCS.pack_state_to_list,
TermList(stateInput, stateResult));
packList->setIntProp("index", index);
packList->setBoolProp("final", true);
set_input(stateOutput, 0, packList);
move_after(packList, stateResult);
}
void for_loop_fix_state_input(Branch* contents)
{
// This function will look at the state access inside for-loop contents.
// If there's state, the default building functions will have created
// terms that look like this:
//
// input() :state -> unpack_state -> pack_state -> output() :state
//
// We want each loop iteration to have its own state container. So we'll
// insert pack/unpack_state_list_n terms so that each iteration accesses
// state from a list. The result will look like:
//
// input() :state -> unpack_state_list_n(index) -> unpack_state -> pack_state
// -> pack_state_list_n(index) -> output() :state
// First insert the unpack_state_list_n call
Term* stateInput = find_state_input(contents);
// Nothing to do if there's no state input
if (stateInput == NULL)
return;
// Nothing to do if unpack_state_list_n term already exists
if (find_user_with_function(stateInput, FUNCS.unpack_state_list_n) != NULL)
return;
Term* unpackState = find_user_with_function(stateInput, FUNCS.unpack_state);
ca_assert(unpackState != NULL);
Term* index = for_loop_find_index(contents);
Term* unpackStateList = apply(contents, FUNCS.unpack_state_list_n,
TermList(stateInput, index));
transfer_users(stateInput, unpackStateList);
move_before(unpackStateList, unpackState);
set_input(unpackState, 0, unpackStateList);
// Now insert the pack_state_list_n call
Term* stateResult = find_open_state_result(contents, contents->length());
Term* packStateList = apply(contents, FUNCS.pack_state_list_n,
TermList(stateInput, stateResult, index));
packStateList->setBoolProp("final", true);
move_after(packStateList, stateResult);
// Make sure the state output uses this result
Term* stateOutput = append_state_output(contents);
set_input(stateOutput, 0, packStateList);
}
