// This should probably go in the helper file with the save logic.
// But it's late and I want to get saving/loading working.
static void load_game() {
// We already know that we have valid data (can_load).
lines_cleared = persist_read_int(SCORE_KEY);
level = (lines_cleared / 10) + 1;
if (level > 10) { level = 10; }
update_num_layer(lines_cleared, scoreStr, score_layer);
update_num_layer(level, levelStr, level_layer);
tick_time = max_tick - (tick_interval * level);
persist_read_data(GRID_KEY, grid, sizeof(grid));
persist_read_data(GRID_COL_KEY, grid_col, sizeof(grid_col));
blockType = persist_read_int(BLOCK_TYPE_KEY);
nextBlockType = persist_read_int(NEXT_BLOCK_TYPE_KEY);
blockX = persist_read_int(BLOCK_X_KEY);
blockY = persist_read_int(BLOCK_Y_KEY);
make_block(block, blockType, blockX, blockY);
make_block(nextBlock, nextBlockType, nextBlockX, nextBlockY);
rotation = persist_read_int(ROTATION_KEY);
if (rotation != 0) {
for (int i=0; i<rotation; i++) {
GPoint rPoints[4];
rotate_block(rPoints, block, blockType, i);
for (int j=0; j<4; j++) {
block[j] = rPoints[j];
}
}
}
}
void traversing(astree* root){
for (size_t index = 0; index < root->children.size(); ++index) {
int nodesymbol = root->children[index]->symbol;
switch(nodesymbol){
case TOK_STRUCT:
make_struct_symbol(root->children[index]);
fprintf(fsym, "\n");
break;
case TOK_FUNCTION:
make_func_symbol(root->children[index]);
fprintf(fsym, "\n");
break;
case TOK_PROTOTYPE:
make_proto_symbol(root->children[index]);
fprintf(fsym, "\n");
break;
case TOK_VARDECL:
make_vardecl(root->children[index]);
break;
case TOK_IF:
make_block(root->children[index]->children[1]);
break;
case TOK_IFELSE:
make_block(root->children[index]->children[1]);
make_block(root->children[index]->children[2]);
break;
default:
break;
}
}
}
STATEMENT *make_if(EXPRESSION *c, STATEMENT *s1, STATEMENT *s2, int source_line)
{
if (source_line == 0 && c)
source_line = CAST_TO_AST(c)->source_line;
NODE *node = create_ast_node(STMT_IF, source_line);
tree_add_child(node, c);
tree_add_child(node, make_block(NULL, s1, 0));
tree_add_child(node, make_block(NULL, s2, 0));
return CAST_TO_STATEMENT(node);
}
// Add a cmark_node as child of another. Return pointer to child.
static cmark_node* add_child(cmark_doc_parser *parser, cmark_node* parent,
cmark_node_type block_type, int start_line, int start_column)
{
assert(parent);
// if 'parent' isn't the kind of cmark_node that can accept this child,
// then back up til we hit a cmark_node that can.
while (!can_contain(parent->type, block_type)) {
finalize(parser, parent, start_line);
parent = parent->parent;
}
cmark_node* child = make_block(block_type, start_line, start_column);
child->parent = parent;
if (parent->last_child) {
parent->last_child->next = child;
child->prev = parent->last_child;
} else {
parent->first_child = child;
child->prev = NULL;
}
parent->last_child = child;
return child;
}
static int tolua_make_block(lua_State * L)
{
int x = (int)tolua_tonumber(L, 1, 0);
int y = (int)tolua_tonumber(L, 2, 0);
int r = (int)tolua_tonumber(L, 3, 6);
const char *str = tolua_tostring(L, 4, TOLUA_CAST "ocean");
const struct terrain_type *ter = get_terrain(str);
make_block(x, y, r, ter);
return 0;
}
void make_func_symbol(astree* root){
astree* function = root->children[0]->children[0];
symbol* sym = newsymbol(function);
const string* key;
vector<symbol*> params;
sym->parameters = ¶ms;
key = function->lexinfo;
insert_symbol (*symbol_stack[0], key, sym, function);
astree* paramlist = root->children[1];
for (size_t index = 0;
index < paramlist->children.size(); ++index){
astree* param = paramlist->children[index]->children[0];
sym = newsymbol(param);
key = param->lexinfo;
++sym->blocknr;
params.push_back(sym);
fprintf(fsym, " ");
insert_symbol (*symbol_stack[0], key, sym, param);
}
make_block(root->children[2]);
}
static EXPRESSION *simplify_expression(MODULE *module, FUNCTION *func, BLOCK *block, EXPRESSION *expr, STATEMENT *before)
{
int i;
int source_line = CAST_TO_AST(expr)->source_line;
if (!has_graph(func) && is_short_circuit(expr))
{
TYPE *new_temp_type = CAST_TO_EXPRESSION(tree_get_child(expr, 0))->type;
EXPRESSION *new_temp = make_new_temp(module, func, new_temp_type, source_line);
STATEMENT *new_assign = make_assignment(new_temp, tree_get_child(expr, 0), source_line);
tree_add_before(CAST_TO_NODE(block), CAST_TO_NODE(new_assign), CAST_TO_NODE(before));
STATEMENT *new_assign2 = make_assignment(new_temp, tree_get_child(expr, 1), source_line);
EXPRESSION *new_cond = new_temp;
if (tree_is_type(expr, EXPR_OR))
new_cond = make_unary_expression(EXPR_NOT, new_cond, source_line);
STATEMENT *new_if = make_if(new_cond, make_block(NULL, new_assign2, 0), NULL, 0);
tree_add_before(CAST_TO_NODE(block), CAST_TO_NODE(new_if), CAST_TO_NODE(before));
return new_temp;
}
if (has_graph(func) && is_short_circuit(expr))
{
GRAPH *graph = func->graph;
EXPRESSION *sub0 = tree_get_child(expr, 0);
EXPRESSION *sub1 = tree_get_child(expr, 1);
STATEMENT *new_test = make_test(sub0, source_line);
EDGE_TYPE inner_type = tree_is_type(expr, EXPR_OR) ? EDGE_NO : EDGE_YES;
EDGE_TYPE outer_type = tree_is_type(expr, EXPR_OR) ? EDGE_YES : EDGE_NO;
add_vertex(graph, CAST_TO_NODE(new_test));
HASH *subhash = get_from_hash(graph->forward, before, sizeof(void *));
HASH_ITERATOR iter;
for (hash_iterator(subhash, &iter); hash_iterator_valid(&iter); hash_iterator_next(&iter))
{
EDGE_TYPE type = (EDGE_TYPE) iter.entry->data;
if (outer_type & type)
add_edge(graph, CAST_TO_NODE(new_test), iter.entry->key, type);
if (inner_type & type)
inner_type = type;
}
inject_before(graph, CAST_TO_NODE(new_test), CAST_TO_NODE(before), inner_type);
return sub1;
}
if (is_simple(expr))
return expr;
if (tree_is_type(expr, EXPR_CALL))
{
EXPRESSION *args = CAST_TO_EXPRESSION(tree_get_child(expr, 1));
args = atomise_expression(module, func, block, args, before);
tree_get_child(expr, 1) = args;
return expr;
}
for (i = 0; i < tree_num_children(expr); i++)
{
EXPRESSION *child = tree_get_child(expr, i);
if (!is_atomic(child))
{
TYPE *new_temp_type = CAST_TO_EXPRESSION(child)->type;
EXPRESSION *new_temp = make_new_temp(module, func, new_temp_type, CAST_TO_AST(child)->source_line);
STATEMENT *new_assign = make_assignment(new_temp, child, CAST_TO_AST(child)->source_line);
if (has_graph(func))
{
GRAPH *graph = func->graph;
add_vertex(graph, CAST_TO_NODE(new_assign));
inject_before(graph, CAST_TO_NODE(new_assign), CAST_TO_NODE(before), 0);
}
else
tree_add_before(CAST_TO_NODE(block), CAST_TO_NODE(new_assign), CAST_TO_NODE(before));
tree_get_child(expr, i) = new_temp;
}
}
return expr;
}
// Create a root document node.
static cmark_node* make_document()
{
cmark_node *e = make_block(NODE_DOCUMENT, 1, 1);
return e;
}
bool core::archive::image_cache::serialize_block(storage& _storage, const images_map_t& _images) const
{
assert(!_images.empty());
return serialize_block_impl(_storage, make_block(boost::adaptors::values(_images)));
}
bool core::archive::image_cache::serialize_block(storage& _storage, const image_vector_t& _images) const
{
assert(!_images.empty());
return serialize_block_impl(_storage, make_block(_images));
}
static void drop_block() {
if (blockType == -1) {
// Create a new block.
blockType = nextBlockType;
nextBlockType = rand() % 7;
rotation = 0;
int adjust = 0;
if (blockType == Z || blockType == J) { adjust = -1; }
if (blockType == LINE) { adjust = -2; }
blockX = 5 + adjust;
blockY = 0;
nextBlockX = 0;
nextBlockY = 0;
make_block(block, blockType, blockX, blockY);
make_block(nextBlock, nextBlockType, nextBlockX, nextBlockY);
}
else {
// Handle the current block.
// Drop it, and if it can't drop then f**k it.
// Uh, I mean stick it in place and make a new block.
bool canDrop = true;
for (int i=0; i<4; i++) {
int benthic = block[i].y + 1;
if (benthic > 19) { canDrop = false; }
if (grid[block[i].x][benthic]) { canDrop = false; }
}
if (canDrop) {
for (int i=0; i<4; i++) {
block[i].y += 1;
}
}
else {
for (int i=0; i<4; i++) {
grid[block[i].x][block[i].y] = true;
grid_col[block[i].x][block[i].y] = blockType;
}
layer_mark_dirty(s_bg_layer);
blockType = -1;
// Clear rows if possible.
for (int j=0; j<20; j++) {
bool isRow = true;
for (int i=0; i<10; i++) {
if (!grid[i][j]) { isRow = false; }
}
if (isRow) {
// I hate all these nested loops...
// But yeah, drop the above rows.
lines_cleared += 1;
if (level < 10 && lines_cleared >= (10 * level)) {
level += 1;
tick_time -= tick_interval;
update_num_layer (level, levelStr, level_layer);
}
update_num_layer (lines_cleared, scoreStr, score_layer);
for (int k=j; k>0; k--) {
for (int i=0; i<10; i++) {
grid[i][k] = grid[i][k-1];
grid_col[i][k] = grid_col[i][k-1];
}
}
for (int i=0; i<10; i++) {
grid[i][0] = false;
grid_col[i][0] = 255;
}
}
}
// Check whether you've lost.
for (int i=0; i<4; i++) {
if (block[i].y == 0) {
playing = false;
lost = true;
Layer *window_layer = window_get_root_layer(window);
layer_remove_from_parent(s_bg_layer);
layer_remove_from_parent(s_left_pane_layer);
layer_add_child(window_layer, text_layer_get_layer(title_layer));
text_layer_set_text(title_layer, "You lost!");
text_layer_set_text(score_label_layer, "");
text_layer_set_text(score_layer, "");
text_layer_set_text(level_label_layer, "");
text_layer_set_text(level_layer, "");
// When you lose, wipe the save.
// No need to get fancy; just mark 'has save' false since
// we'll re-create the whole thing when it gets set to true.
persist_write_bool(HAS_SAVE_KEY, false);
// High score?
if (!persist_exists(HIGH_SCORE_KEY) ||
lines_cleared > persist_read_int(HIGH_SCORE_KEY)) {
persist_write_int(HIGH_SCORE_KEY, lines_cleared);
layer_add_child(window_layer, text_layer_get_layer(high_score_layer));
text_layer_set_text(high_score_layer, "New high score!");
}
return;
}
}
}
}
layer_mark_dirty(s_left_pane_layer);
}
void *malloc(unsigned int num_bytes) {
int i = 0;
struct fm_mem_reserved *ptr;
unsigned int space_required;
unsigned int free_left = 0;
struct fm_mem_reserved *item;
// The link list describing memory actually comes from the
// unassigned memory blocks itself!!!
space_required = num_bytes + sizeof(struct fm_mem_reserved);
for (i = 0; i < MEM_ARRAY_SIZE; i++) {
if (fm_top_level_memory[i].active == TRUE) {
item = fm_top_level_memory[i].head;
/*
* WHOLE BLOCK IS FREE. ALLOCATE FIRST CHILD AND ASSIGN TO HEAD
*/
if (item == NULL) {
free_left = fm_top_level_memory[i].memory_end - fm_top_level_memory[i].memory_start;
if (space_required < free_left) {
ptr = make_block(
fm_top_level_memory[i].memory_start,
fm_top_level_memory[i].memory_start + space_required
);
fm_top_level_memory[i].head = ptr;
return (void*) ptr->memory_start;
}
} else {
kprintf("scanning for end of list\n");
/*
* ROOM BEFORE FIRST CHILD OF HEAD
* (first block allocated out from this top level was removed)
*/
if ((item->memory_start - fm_top_level_memory[i].memory_start) > space_required) {
ptr = make_block(
fm_top_level_memory[i].memory_start,
fm_top_level_memory[i].memory_start + space_required
);
ptr->next = item;
fm_top_level_memory[i].head = ptr;
return (void*) ptr->memory_start;
}
/*
* ROOM BETWEEN TWO NODES
* (allocated block from the middle of the list was removed)
*/
while (item->next != NULL) {
if ((item->next->memory_start - item->memory_end) > space_required) {
//gap inside the linked list. hand it out.
ptr = make_block(
item->memory_end,
item->memory_end + space_required
);
ptr->next = item->next;
item->next = ptr;
return (void*) ptr->memory_start;
}
item = item->next;
}
/*
* THE BLOCK ISN'T FULL AND SPACE IS AVAILABLE AT END OF LIST
*/
free_left = fm_top_level_memory[i].memory_end - item->memory_end;
if (space_required < free_left) {
ptr = make_block(
item->memory_end,
item->memory_end + space_required
);
item->next = ptr;
return (void*) ptr->memory_start;
}
}
}
}
kprintf("no block big enough\n");
return E_OUT_OF_MEMORY;
}
