block_list coff_make(section_list seclist) { block_list blklist; block blk_coff_header; block blk_optional_header; block blk_section_header; block blk_sections; section text_sec, data_sec, bss_sec; int section_header_number; blklist = block_list_create(); blk_coff_header = block_create("COFF header"); blk_optional_header = block_create("optional header"); blk_section_header = block_create("section header"); blk_sections = block_create("sections"); block_list_insert(blklist, NULL, blk_coff_header); block_list_insert(blklist, NULL, blk_optional_header); block_list_insert(blklist, NULL, blk_section_header); block_list_insert(blklist, NULL, blk_sections); section_list_align(seclist, sizeof(long)); text_sec = section_list_search(seclist, ".text"); data_sec = section_list_search(seclist, ".data"); bss_sec = section_list_search(seclist, ".bss"); /* 不要なセクション情報を削除 */ coff_delete_waste_section(seclist); section_header_number = section_list_get_length(seclist); /* COFFヘッダを作成 */ coff_make_coff_header(blk_coff_header, section_list_get_length(seclist)); /* オプションヘッダを作成 */ coff_make_optional_header(blk_optional_header, section_get_memory_size(text_sec), section_get_memory_size(data_sec), section_get_memory_size(bss_sec), section_list_get_entry_point(seclist), section_get_virtual_addr(text_sec), section_get_virtual_addr(data_sec)); /* セクションヘッダを作成 */ coff_make_section_header(blk_section_header, seclist, sizeof(struct coff_header) + sizeof(struct coff_optional_header) + sizeof(struct coff_section_header) * section_header_number); /* セクションの本体を作成 */ coff_make_sections(blk_sections, seclist); block_list_align(blklist, sizeof(long)); return blklist; }
void create_arena(void) { int x; arena_id = hashstring("arena"); arena = getplanebyid(arena_id); if (arena != NULL) return; score(); /* ist wichtig, damit alle Parteien einen score haben, wenn sie durchs Tor wollen. */ guardian_faction(arena, 999); if (arena) arena_center = findregion(plane_center_x(arena), plane_center_y(arena)); if (!arena_center) { newarena = 1; arena = create_new_plane(arena_id, "Arena", -10000, -10000, 0, BLOCKSIZE - 1, PFL_LOWSTEALING | PFL_NORECRUITS | PFL_NOALLIANCES); block_create(arena->minx, arena->miny, T_OCEAN); arena_center = findregion(plane_center_x(arena), plane_center_y(arena)); for (x = 0; x != BLOCKSIZE; ++x) { int y; for (y = 0; y != BLOCKSIZE; ++y) { region *r = findregion(arena->minx + x, arena->miny + y); freset(r, RF_ENCOUNTER); r->planep = arena; switch (distance(r, arena_center)) { case 4: terraform(r, T_FIREWALL); break; case 0: terraform(r, T_GLACIER); break; case 1: terraform(r, T_SWAMP); break; case 2: terraform(r, T_MOUNTAIN); break; } } } } make_temple(arena_center); #ifdef CENTRAL_VOLCANO init_volcano(); #else if (arena_center->terrain != T_DESERT) terraform(arena_center, T_DESERT); #endif rsetmoney(arena_center, 0); rsetpeasants(arena_center, 0); tower_init(); }
/* * Stores held ztr huffman_codes as ZTR chunks. * Returns 0 for success * -1 for failure */ int ztr_store_hcodes(ztr_t *ztr) { int i; ztr_chunk_t *chunks; int nchunks; if (ztr->nhcodes == 0) return 0; /* Extend chunks array */ nchunks = ztr->nchunks + ztr->nhcodes; chunks = (ztr_chunk_t *)realloc(ztr->chunk, nchunks * sizeof(*chunks)); if (!chunks) return -1; ztr->chunk = chunks; /* Encode */ for (i = 0; i < ztr->nhcodes; i++) { block_t *blk = block_create(NULL, 2); int j = ztr->nchunks; unsigned char bytes[2]; ztr->chunk[j].type = ZTR_TYPE_HUFF; ztr->chunk[j].mdata = 0; ztr->chunk[j].mdlength = 0; ztr->chunk[j].ztr_owns = 1; bytes[0] = 0; bytes[1] = ztr->hcodes[i].codes->code_set; store_bytes(blk, bytes, 2); /* FIXME: Now already cached in ztr_hcode_t */ if (0 == store_codes(blk, ztr->hcodes[i].codes, 1)) { /* Last byte is always merged with first of stream */ if (blk->bit == 0) { unsigned char zero = 0; store_bytes(blk, &zero, 1); } ztr->chunk[j].data = (char *)blk->data; ztr->chunk[j].dlength = blk->byte + (blk->bit != 0); block_destroy(blk, 1); ztr->nchunks++; } } return ztr->nchunks == nchunks ? 0 : -1; }
struct node *alloc_scope(struct compiler *compiler, struct block **block_var, enum block_type type) { struct block *block = block_create(compiler, type); struct node *result = compiler_alloc(compiler, sizeof(struct node)); block->parent = compiler->current_block; block->owner = compiler->current_block ? compiler->current_block->owner : 0; result->left = (void *)block; result->type = N_SCOPE; compiler->current_block = block; *block_var = block; return result; }
int map_block_add(map* p_map, float fill_percent, float dispertion_average) { int i,j; int block_nb=0; if(fill_percent <= 0) return 0; //Reduce algo complexity else if (fill_percent >1)fill_percent=1; //roof //Count the actual number of blocks to put (equal at the fill percent of empty and unprotected tiles) //Get all possibly blocks for (i=0;i<p_map->height;i++) { for (j=0;j<p_map->width[i];j++) { if ((p_map->pp_tile[i][j].type == EMPTY) && (!p_map->pp_tile[i][j].is_protected)) { block_nb++; } } } //Apply percentage block_nb = block_nb * fill_percent; int initial_block_nb = block_nb; //Randomly put blocks on the map while(block_nb > 0) { i = rand() % (p_map->height); j = rand() % (p_map->width[i]); if ((p_map->pp_tile[i][j].type == EMPTY) && (!p_map->pp_tile[i][j].is_protected)) { p_map->pp_tile[i][j].type = BLOCK; p_map->pp_tile[i][j].p_block = block_create(); p_map->pp_tile[i][j].p_block->x = j * TILE_SIZE; p_map->pp_tile[i][j].p_block->y = i * TILE_SIZE; p_map->pp_tile[i][j].is_walkable= false; block_nb--; } } return initial_block_nb; }
int state_save(memfile_t *file) { stateheader_t header; block_t *block; int i; //clear the state info memset(&header,0,sizeof(stateheader_t)); //set the ident/version of the state header header.ident = ident; header.version = version; //calculate total data size for(i=0;blockinfo[i].type;i++) { blockinfo[i].size = 0; blockinfo[i].func(STATE_SIZE,(u8*)&blockinfo[i].size); if(blockinfo[i].size) { header.usize += blockinfo[i].size + 8; } } //write the state header writevar(header.ident,4); writevar(header.version,2); writevar(header.flags,2); writevar(header.usize,4); writevar(header.csize,4); writevar(header.crc32,4); //write each block for(i=0;blockinfo[i].type;i++) { if(blockinfo[i].size == 0) continue; printf("saving block '%4s' (%d bytes)\n",&blockinfo[i].type,blockinfo[i].size); block = block_create(blockinfo[i].type,blockinfo[i].size); blockinfo[i].func(STATE_SAVE,block->data); block_save(file,block); block_destroy(block); } return(0); }
Access *access_avi_create(char *access_path) { return_val_if_fail(access_path, NULL); int fd = -1; char file_path[64] = {0}; if(avi_parse_path(access_path, file_path, 64) != 0) { msg_dbg("Fun(%s) error parse the access_path(%s) failed!\n", __func__, access_path); return NULL; } Access *thiz = (Access *)FTK_ZALLOC(sizeof(Access) + sizeof(PrivInfo)); return_val_if_fail(thiz != NULL, NULL); /*open the file */ fd = open(file_path, O_RDONLY); if(fd <= 0) { msg_dbg("error:open the file failed! file path(%s)\n", file_path); return NULL; } thiz->seek = NULL; thiz->read = NULL; thiz->block = access_avi_block; thiz->control = NULL; thiz->destroy = access_avi_destroy; DECL_PRIV(thiz, priv); priv->file_path = FTK_STRDUP(file_path); priv->block = block_create(MAX_H264_PACKET_LEN); access_init_ffmpeg(thiz, file_path); return thiz; }
// Create a heapAllocator of *size* bytes // Initialised with one block pointing to the whole memory heapAllocator* heap_create( int heap_size ) { // We add space for the first block header, so we do get the correct total size // ie. this means that heap_create (size), followed by heap_Allocate( size ) should work void* data = malloc( sizeof( heapAllocator ) + sizeof( block ) + heap_size ); memset( data, 0, sizeof( heapAllocator ) + sizeof( block ) + heap_size ); heapAllocator* allocator = (heapAllocator*)data; data = (uint8_t*)data + sizeof( heapAllocator ); allocator->total_size = heap_size; allocator->total_free = heap_size; allocator->total_allocated = 0; allocator->bitpool_count = 0; // Should not be possible to fail creating the first block header allocator->free = NULL; allocator->first = block_create( allocator, data, heap_size ); vAssert( allocator->first ); vAssert( allocator->free == allocator->first ); vAssert( allocator->free == allocator->first ); vAssert( nextFree( allocator->free ) == NULL ); return allocator; }
void blocks_initialize(ALLEGRO_DISPLAY* display) { unsigned short blocks_in_row = 0; unsigned short row = 1; unsigned short count = 1; while (row <= BLOCKS_ROWS) { block_create((blocks_in_row * BLOCK_W), (unsigned short) ((SCREEN_H/2) - (row * BLOCK_H))); ++blocks_in_row; ++count; if (blocks_in_row * BLOCK_W > SCREEN_W) { ++row; blocks_in_row = 0; } } struct listNode* current = first; while (current != NULL) { current->bitmap = al_create_bitmap(BLOCK_W, BLOCK_H); al_set_target_bitmap(current->bitmap); al_clear_to_color(al_map_rgb(234,225,100)); current = current->next; } al_set_target_bitmap(al_get_backbuffer(display)); /* Change drawing target to screen buffer */ al_flip_display(); /* Print buffer to screen */ }
/* * Searches through the cached huffman_codeset_t tables looking for a stored * huffman code of type 'code_set'. * NB: only code_sets >= CODE_USER will be stored here. * * Returns codes on success, * NULL on failure */ ztr_hcode_t *ztr_find_hcode(ztr_t *ztr, int code_set) { int i; if (code_set < CODE_USER) return NULL; /* computed on-the-fly or use a hard-coded set */ /* Check through chunks for undecoded HUFF chunks */ if (!ztr->hcodes_checked) { for (i = 0; i < ztr->nchunks; i++) { if (ztr->chunk[i].type == ZTR_TYPE_HUFF) { block_t *blk; huffman_codeset_t *cs; uncompress_chunk(ztr, &ztr->chunk[i]); blk = block_create((unsigned char *)(ztr->chunk[i].data+2), ztr->chunk[i].dlength-2); cs = restore_codes(blk, NULL); if (!cs) { block_destroy(blk, 1); return NULL; } cs->code_set = (unsigned char)(ztr->chunk[i].data[1]); ztr_add_hcode(ztr, cs, 1); block_destroy(blk, 1); } } ztr->hcodes_checked = 1; } /* Check cached copies */ for (i = 0; i < ztr->nhcodes; i++) { if (ztr->hcodes[i].codes->code_set == code_set) return &ztr->hcodes[i]; } return NULL; }
void pge_init() { // Allocate for(int z = 0; z < GRID_DEPTH; z++) { for(int y = 0; y < GRID_HEIGHT; y++) { for(int x = 0; x < GRID_WIDTH; x++) { s_block_array[vec2i(Vec3(x, y, z))] = block_create(Vec3(x * BLOCK_SIZE, y * BLOCK_SIZE, z * BLOCK_SIZE), GSize(BLOCK_SIZE, BLOCK_SIZE), COLOR_INVISIBLE); } } } for(int i = 0; i < MAX_CLOUDS; i++) { s_cloud_array[i] = cloud_create(Vec3(0, 0, SKY_HEIGHT), GSize(BLOCK_SIZE, BLOCK_SIZE), Vec3(GRID_WIDTH * BLOCK_SIZE, GRID_HEIGHT * BLOCK_SIZE, SKY_HEIGHT)); } // Set up world generate_world(); // Set up engine pge_isometric_set_projection_offset(PBL_IF_ROUND_ELSE(GPoint(90, 110), GPoint(72, 80))); pge_isometric_set_enabled(true); pge_set_framerate(FRAME_RATE_IDLE); pge_begin(GColorBlack, logic, render, click); s_main_window = pge_get_window(); s_status_layer = text_layer_create(grect_inset( layer_get_bounds((window_get_root_layer(s_main_window))), PBL_IF_ROUND_ELSE(GEdgeInsets(30, 0, 130, 0), GEdgeInsets(0, 0, 150, 0)))); text_layer_set_background_color(s_status_layer, GColorBlack); text_layer_set_text_color(s_status_layer, GColorWhite); text_layer_set_text_alignment(s_status_layer, PBL_IF_ROUND_ELSE(GTextAlignmentCenter, GTextAlignmentLeft)); layer_add_child(window_get_root_layer(s_main_window), text_layer_get_layer(s_status_layer)); update_status_text(); #ifdef BENCHMARK APP_LOG(APP_LOG_LEVEL_INFO, "Heap free: %dB after creating %d blocks (Size: %dB)", (int)heap_bytes_free(), (GRID_WIDTH * GRID_HEIGHT * GRID_DEPTH), get_world_size()); #endif }
// Allocates *size* bytes from the given heapAllocator *heap* // Will crash if out of memory // NEEDS TO BE THREADSAFE void* heap_allocate_aligned( heapAllocator* heap, size_t toAllocate, size_t alignment, const char* source ) { (void)source; vmutex_lock( &allocator_mutex ); #ifdef MEM_DEBUG_VERBOSE printf( "HeapAllocator request for " dPTRf " bytes, " dPTRf " byte aligned.\n", toAllocate, alignment ); #endif bitpool* bit_pool = heap_findBitpool( heap, toAllocate ); if ( bit_pool ) { void* data = bitpool_allocate( bit_pool, toAllocate ); if ( data ) { vmutex_unlock( &allocator_mutex ); return data; } } size_t size_original = toAllocate; toAllocate += alignment; // Make sure we have enough space to align block* b = heap_findEmptyBlock( heap, toAllocate ); if ( !b ) { heap_dumpBlocks( heap ); printError( "HeapAllocator out of memory on request for " dPTRf " bytes. Total size: " dPTRf " bytes, Used size: " dPTRf " bytes\n", toAllocate, heap->total_size, heap->total_allocated ); vAssert( 0 ); } vAssert( b->free ); assertBlockInvariants( b ); removeFromFreeList( heap, b ); b->free = false; assertBlockInvariants( b ); if ( b->size > ( toAllocate + sizeof( block ) + sizeof( block* ) * 2) ) { void* new_ptr = ((uint8_t*)b->data) + toAllocate; block* remaining = block_create( heap, new_ptr, b->size - toAllocate ); block_insertAfter( b, remaining ); b->size = toAllocate; heap->total_allocated += sizeof( block ); heap->total_free -= sizeof( block ); validateBlockNext(b); validateBlockNext(remaining); } assertBlockInvariants( b ); // Move the data pointer on enough to force alignment uintptr_t offset = alignment - (((uintptr_t)b->data - 1) % alignment + 1); b->data = ((uint8_t*)b->data) + offset; b->size -= offset; // Now move the block on and copy the header, so that it's contiguous with the block block* new_block_position = (block*)(((uint8_t*)b) + offset); // Force alignment for this so we can memcpy (on Android, even memcpy requires alignments when dealing with structs) block block_temp; memcpy( &block_temp, b, sizeof( block )); ////////////////////////////////////////////////////// vAssert( b->prevFree == NULL ); vAssert( b->nextFree == NULL ); b = new_block_position; memcpy( b, &block_temp, sizeof( block )); // Fix up pointers to this block, for the new location if ( b->prev ) { b->prev->next = b; b->prev->size += offset; // Increment previous block size by what we've moved the block } else heap->first = b; if ( b->next ) b->next->prev = b; assertBlockInvariants( b ); ////////////////////////////////////////////////////// validateBlockNext(b); heap->total_allocated += toAllocate; heap->total_free -= toAllocate; ++heap->allocations; // Ensure we have met our requirements uintptr_t align_offset = ((uintptr_t)b->data) % alignment; vAssert( align_offset == 0 ); // Correctly Aligned vAssert( b->size >= size_original ); // Large enough #ifdef MEM_DEBUG_VERBOSE printf("Allocator returned address: " xPTRf ".\n", (uintptr_t)b->data ); #endif #ifdef MEM_STACK_TRACE block_recordAlloc( b, mem_stack_string ); #endif // MEM_STACK_TRACE assertBlockInvariants( b ); #ifdef TRACK_ALLOCATIONS if (source) strncpy( b->source, source, MemSourceLength); else b->source[0] = '\0'; #endif //validateFreeList( heap ); vmutex_unlock( &allocator_mutex ); return b->data; }
int main(int argc, char *argv[]) { lapis_init(); engine_t *engine = lapis_get_engine(); set_ticks_per_second(30); game_state_t *state = game_state_create(0); state->num_render_levels = RL_NUM; engine_switch_state(engine, state); /* initialize video */ lsdl_set_video_mode(engine->sdl_driver, WIDTH, HEIGHT, 0, 1); SDL_EnableKeyRepeat(500, 50); SDL_WM_SetCaption( "Open DM v. 0.1", NULL ); glMatrixMode( GL_PROJECTION ); glLoadIdentity( ); gluPerspective(FIELD_OF_VISION, 1, 0.1, 100); // glEnable(GL_TEXTURE_2D); glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_DEPTH_TEST); // glDisable(GL_LIGHTING); // glEnable(GL_LIGHTING); glViewport(0, 0, WIDTH, HEIGHT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0,0,0, 0, 0, -10, 0, 1.0, 0); /* test */ /* load graphics */ // lapis_lua_t *lua = lua_scripting_init(); // if( lua_scripting_run_file(lua, "main.lua") != 0 ) // return 0; /* end test */ /* create objects */ game_object_t * global_object = game_object_create("global", NULL); game_state_append_object(state, global_object); game_object_set_recv_callback_c_func(global_object, global_message_handler); game_state_append_bcast_recvr(state, global_object, "sdl-event"); block_t *block = block_create(1, 1); game_state_append_object(state, block->go); camera_t *camera = camera_create(0, 0, 0); game_state_append_object(state, camera->go); lapis_mainloop(); /* this will be cleaned up by the OS */ //game_state_destroy(state); //lapis_deinit(); return 0; }
int main (int argc, char **argv) { int result = handle_options(argc, argv); struct device *dev; int i; if (result != 0) exit(result); if (argc - optind != 1) { printf ("Necesita un argumento que es el nombre del" " sistema de ficheross\n\n"); while (optind < argc) printf ("'%s' ", argv[optind++]); printf ("\n"); usage(-2); } dev = block_create(argv[optind], num_blocks, block_size); if (dev == NULL) { printf("Error creando el sistema de ficheros %s (%s)\n", argv[optind], strerror(errno)); exit(-1); } if (block_close(dev) == -1) { printf("Error cerrando el sistema de ficheros %s 1\n", argv[optind]); exit(-1); } dev = block_open(argv[optind]); if (dev == NULL) { printf("Error abriendo el sistema de ficheros %s 2\n", argv[optind]); exit(-1); } for (i = 0; i < num_blocks; i++) { int buffer[block_size/4]; int j; for (j = 0; j < block_size/4; j++) buffer[j] = i; result = block_write(dev, buffer, i); if (result == -1) printf("Error escribiendo bloque %d, (Error %s)\n", i, strerror(errno)); } if (block_close(dev) == -1) { printf("Error cerrando el sistema de ficheros %s 2\n", argv[optind]); exit(-1); } dev = block_open(argv[optind]); if (dev == NULL) { printf("Error abriendo el sistema de ficheros %s 3\n", argv[optind]); exit(-1); } for (i = 0; i < num_blocks; i++) { int buffer[block_size/4]; int j; result = block_read(dev, buffer, i); if (result == -1) printf("Error leyendo bloque %d, (Error %s)\n", i, strerror(errno)); for (j = 0; j < block_size/4; j++) if (buffer[j] != i) { printf("Contenido blque %d erroreo\n", i); break; } } if (block_close(dev) == -1) { printf("Error cerrando el sistema de ficheros %s 4\n", argv[optind]); exit(-1); } exit (0); }
void g_updateGame() { if (game.state == STATE_IDLE) { //do nothing } else if (game.state == STATE_MENU) { //menuSound = m_move; switch ( m_move() ) { case SND_MENUMOVE: s_playSound(menuMove); break; case SND_MENUSELECT: s_playSound(menuSelect); break; case SND_NONE: default: break; } /* if ( !m_move() ) { //too much output //printf("[g_updateGame]: m_move returned false!\n"); } */ } else if (game.state == STATE_PLAYING) { //game.currentTime = SDL_GetTicks(); //take note of the frame here, see if it is time to move the current tetro //1 notch down if ( dropFrameInterval >= dropIntervalPerRow[game.level] && !game.isSoftDropping ) //time to drop down 1, only if down arrow not already held down { dropFrameInterval = 0; if ( !tetro_move(game.current, DIR_SOUTH) ) //the periodic drop down was blocked { //printf("[g_updateGame]: periodic drop down blocked!\n"); g_onDownBlocked(); } //game.lastDropTime = game.currentTime; } //rotate has priority if ( game.current->tryRotate ) { debug_msg("[g_updateGame]: trying rotate...\n"); if ( tetro_rotate(game.current) ) { debug_msg("[g_updateGame]: rotate success!\n"); s_playSound(rotate); } else debug_msg("[g_updateGame]: rotate failed!\n"); } //for delayed auto shifting if ( game.dasDir != DIR_NONE ) { game.current->nextMoveY = DIR_NONE; if ( game.dasDelaying ) { if ( game.dasFrame >= DAS_DELAY ) { game.dasDelaying = false; game.current->nextMoveX = game.dasDir; game.dasFrame = 0; } } else { if ( game.dasFrame >= DAS_PERIOD ) { game.current->nextMoveX = game.dasDir; game.dasFrame = 0; } } game.dasFrame++; } //printf("game.dasFrame = %d\n", game.dasFrame); if ( game.isSoftDropping ) { if ( game.softDropFrame >= SOFT_DROP_FRAMES ) //time to move down a notch { game.softDropFrame = 0; if ( !tetro_move(game.current, DIR_SOUTH) ) { //printf("[g_updateGame]: periodic drop down blocked!\n"); g_onDownBlocked(); game.softDropFrame = SOFT_DROP_FRAMES; //next block insta drop down game.score += game.softDropDistanceCount; game.softDropDistanceCount = 0; } else game.softDropDistanceCount++; } game.softDropFrame++; } else { //create resultant move direction if ( game.current->nextMoveX == DIR_NONE ) game.current->nextMoveDir = game.current->nextMoveY; else if ( game.current->nextMoveY == DIR_NONE ) game.current->nextMoveDir = game.current->nextMoveX; else if ( game.current->nextMoveY == DIR_NORTH ) { if ( game.current->nextMoveX == DIR_WEST ) game.current->nextMoveDir = DIR_NORTHWEST; else game.current->nextMoveDir = DIR_NORTHEAST; } else //nextMoveY == south { if ( game.current->nextMoveX == DIR_WEST ) game.current->nextMoveDir = DIR_SOUTHWEST; else game.current->nextMoveDir = DIR_SOUTHEAST; } //attempt to move tetro in this direction if ( !tetro_move(game.current, game.current->nextMoveDir) ) { printf("move failed no sound\n"); //printf("[g_updateGame]: tetro_move failed!\n"); if ( game.current->nextMoveDir == DIR_SOUTH || game.current->nextMoveDir == DIR_SOUTHWEST || game.current->nextMoveDir == DIR_SOUTHEAST ) { g_onDownBlocked(); } } else if ( game.current->nextMoveDir == DIR_WEST || game.current->nextMoveDir == DIR_EAST ) //successful move, check to see if i should play a sound { printf("play move because move succeeded west or east\n"); //if ( game.dasFrame == 0 && game.dasDelaying == true ) s_playSound(moveSideways); } } game.current->nextMoveX = DIR_NONE; game.current->nextMoveY = DIR_NONE; game.current->nextMoveDir = DIR_NONE; game.current->tryRotate = false; dropFrameInterval++; } else if (game.state == STATE_LOSS) { //the idea: every frame fill up one of the spaces with a "dead" block. so in 180 frames the whole screen will be filled short i; block * b; if (game.lossFrame == -1) { //do nothing } else { if (game.lossCurrentRow >= SIZE_Y) { g_clear(REASON_LOSS); } else { if (game.lossFrame == 0) SDL_Delay(LOSS_PAUSE); if (game.lossFrame % 3 == 0) { for ( i = 0; i < SIZE_X; i++ ) { b = g_getBlockAtPos(i, game.lossCurrentRow); if (b != NULL) g_removeBlockFromPos(b); b = NULL; b = block_create(TETRO_DEAD, NULL); if ( !block_teleport(b, i, game.lossCurrentRow) ) debug_msg("[g_updateGame]: STATE_LOSS- error teleporting dead block into position!\n"); b = NULL; } game.lossCurrentRow++; } } } game.lossFrame++; } else debug_msg("[g_updateGame]: unknown game.state!\n"); menu.nextMoveDir = DIR_NONE; }