void mpGame::moveDown()
{
if(gameblock.y < TILE_H-3) {
if(Tiles[gameblock.x][gameblock.y+3] != 0) {
if(gameblock.y <= 1) {
// GAME OVER
over = true;
}
else
merge_block();
nextBlock();
}
else
gameblock.y++;
}
else {
merge_block();
nextBlock();
}
}
/*
memmap_free_t* coalesce_block(memmap_free_t* mmap)
A top-level function for coalescing blocks (with checks).
Uses `merge_block` internally.
*/
memmap_free_t* coalesce_block(memmap_free_t* mmap) {
memmap_t* mmap_alloc = (memmap_t*)mmap;
memmap_t* mmap_left = get_prev_block(mmap_alloc);
memmap_t* mmap_right = get_next_block(mmap_alloc);
if(!is_first_in_memory(mmap_alloc) && !get_allocated(mmap_left)) {
#ifdef DEBUG_MEMORY
printf("(Left) Merging %d and %d, ", get_block_size(mmap_left),
get_block_size(mmap_alloc));
#endif
mmap = merge_block((memmap_free_t*)mmap_left, mmap);
#ifdef DEBUG_MEMORY
printf("final size: %d\n", get_block_size((memmap_t*)mmap));
#endif
}
if(!is_last_in_memory(mmap_alloc) && !get_allocated(mmap_right)) {
#ifdef DEBUG_MEMORY
printf("(Right) Merging %d and %d, ", get_block_size(mmap_alloc),
get_block_size(mmap_right));
#endif
mmap = merge_block(mmap, (memmap_free_t*)mmap_right);
#ifdef DEBUG_MEMORY
printf("final size: %d\n", get_block_size((memmap_t*)mmap));
#endif
}
return mmap;
}
void free(void *ptr){
sum_frees++;
num_allocated--;
block_t current;
if (valid_address(ptr)){
current = get_block(ptr);
current->free = 1;
if(current->prev && current->prev->free){
//merge with prev block if works
current = merge_block(current->prev);
}
if (current->next){
//merge with next
merge_block(current);
} else {
if (current->prev){
current->prev->next = NULL;
} else {
//no more blocks
base = NULL;
}
brk(current);
}
} else {
perror("invalid ptr at free");
}
}
void free(void *ptr) {
if (unlikely(!ptr)) {
return;
}
pthread_mutex_lock(&list_lock);
metadata_t* block_ptr = get_block(ptr);
merge_block(block_ptr);
if (unlikely(block_ptr->free != 0 || block_ptr->magic1 != MAGIC_USED || block_ptr->magic1 != block_ptr->magic2)) {
printf(SEGFAULT);
exit(-1);
}
alloc_count--;
if (unlikely(alloc_count == 0)){
brk(base);
base = 0;
} else if (block_ptr->next == NULL){
block_ptr->prev->next = NULL;
brk(block_ptr);
} else {
block_ptr->free = 1;
block_ptr->magic1 = MAGIC_FREE;
block_ptr->magic2 = MAGIC_FREE;
}
pthread_mutex_unlock(&list_lock);
}
void *realloc(void *ptr, size_t size){
if (!ptr) {
return malloc(size);
}
if (valid_address(ptr)) {
size = align_pointer(size);
block_t block = get_block(ptr);
if (size <= block->size && BLOCK_SIZE_MIN <= block->size - size) {
split_block(block, size);
} else {
if (block->next && block->next->free && size <= BLOCK_SIZE + block->size + block->next->size) {
//merge möglich
merge_block(block);
if (BLOCK_SIZE_MIN <= block->size - size) {
split_block(block, size);
}
} else {
//real malloc
void *newptr = malloc(size);
if (!newptr) {
perror("error at realloc");
return NULL;
}
block_t newblock = get_block(newptr);
copy_block(block, newblock);
free(block);
return newptr;
}
}
return ptr;
}
return 0;
}
// 블럭 상태 및 스테이지 업뎃
void Tetris::Update()
{
int key = KeyInput();
switch( stage )
{
case INIT :
press_any_key( key );
break;
case READY :
level_select( key );
break;
case RUNNING :
m_block->Move( key );
// 블럭이 바닥이나 다른 블럭에 닿았다면 합침
if( m_block->GetBlockState() == 2 )
merge_block( m_block->GetBlockX(), m_block->GetBlockY() );
// 꽉 찬 라인이 있는지 확인
m_full_line_num = check_full_line();
if( m_full_line_num != 0 )
full_line_Set();
if( stage_data[m_level].clear_line == m_line )
{
++m_level;
if( m_level >= MAX_STAGE )
{
stage = SUCCESS;
}
m_line = 0;
}
// 게임 오버~
if( GameOver() )
stage = FAILED;
break;
case SUCCESS:
case FAILED:
if( key == 'y' || key == 'Y' )
{
stage = READY;
Init();
}
if( key == 'n' || key == 'N' )
stage = RESULT;
break;
case RESULT:
m_bIsGameOver = true;
break;
}
}
static void move_block(mpGame *g) {
if(g->gblock.y < TILE_H-3) {
if(g->Tiles[g->gblock.x][g->gblock.y+3] != 0) {
if(g->gblock.y <= 1) {
scr = ID_GAMEOVER;
game_over(g);
}
else
merge_block(g);
init_gblock(&g->gblock);
}
else
g->gblock.y++;
}
else {
merge_block(g);
init_gblock(&g->gblock);
}
}
void free(void* ptr)
{
if(!ptr)
return;
block_t* block = (block_t*)(ptr)-1;
block->reserved = 0;
block = merge_block(block);
unsigned char kval = block->kval;
block_t* succ = free_list[kval];
if(succ){
block->succ = succ;
succ->pred = block;
}
free_list[kval] = block;
}
void compact_free_list()
{
// std::cout << "compact free list: before = " << free_list_.size();
std::size_t biggest = 0;
for( iterator it( begin()); it != end(); ++it)
{
while( merge_block( it))
;
biggest = std::max( biggest, it->size);
}
// std::cout << " after = " << free_list_.size() << " items\n";
// std::cout << "biggest block = " << biggest / 1024 / 1024 << " Mb\n";
}
block_t* merge_block(block_t* block)
{
block_t* buddy = find_buddy(block);
if(buddy){
remove_from_free_list(buddy);
remove_from_free_list(block);
if(block > buddy){
++(buddy->kval);
block = buddy;
}else{
++(block->kval);
}
return merge_block(block);
}else{
return block;
}
}
