Exemplo n.º 1
0
void bootmgr_setup_touch()
{
    if(!settings.touch_ui)
        return;

    bootmgr_set_touches_count(0);
    switch(bootmgr_phase)
    {
        case BOOTMGR_MAIN:
            bootmgr_add_touch(40,  125, 160, 245, bootmgr_touch_int,    1);
            bootmgr_add_touch(160, 125, 280, 245, bootmgr_touch_sd,     2);
            bootmgr_add_touch(40,  245, 160, 365, bootmgr_touch_ums,    3);
            bootmgr_add_touch(160, 245, 280, 365, bootmgr_touch_tetris, 4);
            break;
        case BOOTMGR_UMS:
            bootmgr_add_touch(80, 370, 240, 410, bootmgr_touch_exit_ums, 1);
            bootmgr_print_fill(80, 370, 160, 40, WHITE, 24);
            bootmgr_printf(-1, 24, BLACK, "Exit");
            break;
        case BOOTMGR_SD_SEL:
        {
            bootmgr_add_touch(0,   430, 78,  480, bootmgr_touch_sd_up,     1);
            bootmgr_add_touch(80,  430, 158, 480, bootmgr_touch_sd_down,   2);
            bootmgr_add_touch(160, 430, 238, 480, bootmgr_touch_sd_select, 3);
            bootmgr_add_touch(240, 430, 320, 480, bootmgr_touch_sd_exit,   4);
            bootmgr_printf(31, 28, BLACK, "Up       Down     Select     Exit");
            bootmgr_print_fill(0,   430, 78, 49, WHITE, 28);
            bootmgr_print_fill(80,  430, 78, 49, WHITE, 29);
            bootmgr_print_fill(160, 430, 78, 49, WHITE, 30);
            bootmgr_print_fill(240, 430, 78, 49, WHITE, 31);
            break;
        }
    }
}
Exemplo n.º 2
0
void tetris_init()
{
    tetris_set_defaults();
    
    pieces = (tetris_piece***)malloc(sizeof(tetris_piece*)*TETRIS_W);
    uint16_t y, z;
    for(y = 0; y < TETRIS_W; ++y)
    {
        pieces[y] = (tetris_piece**)malloc(sizeof(tetris_piece*)*TETRIS_H);
        for(z = 0; z < TETRIS_H; ++z)
            pieces[y][z] = NULL;
    }

    pthread_mutex_init(tetris_draw_mutex, NULL);
    t_tetris = (pthread_t*)malloc(sizeof(pthread_t));
    pthread_create(t_tetris, NULL, tetris_thread, NULL);

    bootmgr_display->bg_img = 0;
    bootmgr_set_lines_count(0);
    bootmgr_set_fills_count(0);
    bootmgr_print_fill(9,                      29,  TETRIS_W*BLOCK_SIZE+1, 1,                     WHITE, TETRIS_BORDER_TOP);
    bootmgr_print_fill(9,                      29,  1,                     TETRIS_H*BLOCK_SIZE+1, WHITE, TETRIS_BORDER_LEFT);
    bootmgr_print_fill(TETRIS_W*BLOCK_SIZE+10, 29,  1,                     TETRIS_H*BLOCK_SIZE+1, WHITE, TETRIS_BORDER_RIGHT);
    bootmgr_print_fill(9,                      470, TETRIS_W*BLOCK_SIZE+1, 1,                     WHITE, TETRIS_BORDER_BOTTOM);

    tetris_print_score();
    tetris_print_batt();
    bootmgr_printf(243, 1, WHITE, "Next");
    bootmgr_printf(243, 2, WHITE, "piece:");
    bootmgr_printf(10+((220 - 21*8)/2), 15, WHITE, "Press \"Home\" to start");
    bootmgr_draw();
}
Exemplo n.º 3
0
void bootmgr_setup_touch(void)
{
    if(!settings.touch_ui)
        return;

    bootmgr_set_touches_count(0);
    switch(bootmgr_phase)
    {
        case BOOTMGR_MAIN:
            bootmgr_add_touch(40,  125, 160, 245, bootmgr_touch_int,    1);
            bootmgr_add_touch(160, 125, 280, 245, bootmgr_touch_sd,     2);
            bootmgr_add_touch(40,  245, 160, 365, bootmgr_touch_ums,    3);
            bootmgr_add_touch(160, 245, 280, 365, bootmgr_touch_misc,   4);
            break;
        case BOOTMGR_UMS:
            bootmgr_add_touch(80, 370, 240, 410, bootmgr_touch_exit_ums, 1);
            bootmgr_print_fill(80, 370, 160, 40, WHITE, 24);
            bootmgr_printf(-1, 24, BLACK, "Exit");
            break;
        case BOOTMGR_SD_SEL:
        {
            bootmgr_add_touch(0,   430, 78,  480, bootmgr_touch_sd_up,     1);
            bootmgr_add_touch(80,  430, 158, 480, bootmgr_touch_sd_down,   2);
            bootmgr_add_touch(160, 430, 238, 480, bootmgr_touch_sd_select, 3);
            bootmgr_add_touch(240, 430, 320, 480, bootmgr_touch_sd_exit,   4);
            bootmgr_printf(31, 28, BLACK, "Up       Down     Select     Exit");
            bootmgr_print_fill(0,   430, 78, 49, WHITE, 28);
            bootmgr_print_fill(80,  430, 78, 49, WHITE, 29);
            bootmgr_print_fill(160, 430, 78, 49, WHITE, 30);
            bootmgr_print_fill(240, 430, 78, 49, WHITE, 31);
            break;
        }
        case BOOTMGR_CHARGER:
        {
            bootmgr_add_touch(80, 370, 240, 410, bootmgr_touch_exit_charger, 1);
            bootmgr_print_fill(80, 370, 160, 40, WHITE, 24);
            bootmgr_printf(-1, 24, BLACK, "Back to main menu");
            break;
        }
        case BOOTMGR_MISC:
        {
            int itr = 0;
            for(; misc_callbacks[itr] != NULL; ++itr)
                bootmgr_add_touch(0, itr*ISO_CHAR_HEIGHT*3, BOOTMGR_DIS_W, (itr+1)*ISO_CHAR_HEIGHT*3, misc_callbacks[itr], itr);

            bootmgr_add_touch(80, 370, 240, 410, bootmgr_touch_exit_misc, itr);
            bootmgr_print_fill(80, 370, 160, 40, WHITE, 24);
            bootmgr_printf(-1, 24, BLACK, "Back to main menu");
            break;
        }
    }
}
Exemplo n.º 4
0
void bootmgr_select(int8_t line)
{
    bootmgr_line *ln = NULL;
    if(selected != -1 && (ln = _bootmgr_get_line(selected)))
       ln->color = WHITE;
    ln = _bootmgr_get_line(line);
    if(ln)
        ln->color = BLACK;

    if(line == -1)
        bootmgr_erase_fill(BOOTMGR_FILL_SELECT);
    else
        bootmgr_print_fill(0, line*ISO_CHAR_HEIGHT, BOOTMGR_DIS_W, ISO_CHAR_HEIGHT, WHITE, BOOTMGR_FILL_SELECT);
    selected = line;
}
Exemplo n.º 5
0
void tetris_draw(uint8_t move)
{
    if(move && current)
    {
        pthread_mutex_lock(tetris_draw_mutex);
        if(!tetris_can_move_piece(TETRIS_DOWN))
        {
            if(!current->moved)
            {
                uint8_t lines = 2;
                if(settings.tetris_max_score < score)
                {
                    ++lines;
                    settings.tetris_max_score = score;
                    bootmgr_save_settings();
                    bootmgr_printf(10+((220 - 15*8)/2), 16, WHITE, "New high score!");
                }
                bootmgr_print_fill(11, 14*ISO_CHAR_HEIGHT, 219, lines*ISO_CHAR_HEIGHT, BLACK, 1);
                bootmgr_printf(10+((220 - 9*8)/2),  14, WHITE, "Game over");
                bootmgr_printf(10+((220 - 23*8)/2), 15, WHITE, "Press \"Home\" to restart");
                bootmgr_draw_fills();
                bootmgr_draw_text();
                fb_update(&fb);
                state = TETRIS_FINISHED;
                pthread_mutex_unlock(tetris_draw_mutex);
                return;
            }

            uint8_t x,y;
            for(x = 0; x < 5; ++x)
                for(y = current->y < 2 ? current->y : 0; y < 5; ++y)
                    if(p_shape[current->type][current->rotation][y][x])
                        pieces[current->x+(x-2)][current->y+(y-2)] = current;

            tetris_check_line();
            tetris_spawn_new();
        }
        else
            tetris_move_piece(TETRIS_DOWN);
        pthread_mutex_unlock(tetris_draw_mutex);
    }

    android_memset16(fb.bits, BLACK, BOOTMGR_DIS_W*BOOTMGR_DIS_H*2);

    tetris_print_batt();
    bootmgr_draw_fills();
    bootmgr_draw_text();


    tetris_piece *itr = current;
    uint8_t i = 0;
    uint16_t *bits;

    uint8_t y, x;
    do
    {
        for(y = 0; y < 5; ++y)
        {
            uint8_t len = 0;
            int8_t st = -1;
            for(x = 0; x < (i ? 4 : 5); ++x)
            {
                if(p_shape[itr->type][itr->rotation][y][x])
                {
                    if(st == -1)
                        st = x;
                    ++len;
                }
            }
            if(st == -1)
                continue;

            bits = fb.bits;
            bits += BOOTMGR_DIS_W*(30+((itr->y-(2-y))*BLOCK_SIZE)) + 10 + (itr->x-(2-st))*BLOCK_SIZE;
            for(x = 0; x < BLOCK_SIZE; ++x)
            {
                android_memset16(bits, tetris_get_color_for_type(itr->type), len*BLOCK_SIZE*2);
                bits += BOOTMGR_DIS_W;
            }
        }
        itr = preview;
        ++i;
    } while(i < 2);

    for(x = 0; x < TETRIS_W; ++x)
    {
        for(y = 0; y < TETRIS_H; ++y)
        {
            if(!pieces[x][y])
                continue;

            bits = fb.bits;
            bits += BOOTMGR_DIS_W*(30+(y*BLOCK_SIZE)) + 10 + x*BLOCK_SIZE;

            for(i = 0; i < BLOCK_SIZE; ++i)
            {
                android_memset16(bits, tetris_get_color_for_type(pieces[x][y]->type), BLOCK_SIZE*2);
                bits += BOOTMGR_DIS_W;
            }
        }
    }

    fb_update(&fb);
}
Exemplo n.º 6
0
void tetris_key(int key)
{
    switch(key)
    {
        case KEY_VOLUMEDOWN:
        {
            if(state & TETRIS_PAUSED)
            {
                bootmgr_erase_text(14);
                bootmgr_erase_text(15);
                bootmgr_erase_fill(1);
                state &= ~(TETRIS_PAUSED);
                state |= TETRIS_STARTED;
            }
            else if(state & TETRIS_STARTED)
            {
                bootmgr_print_fill(11, 14*ISO_CHAR_HEIGHT, 219, 32, BLACK, 1);
                bootmgr_printf(10+((220 - 6*8)/2),  14, WHITE, "Paused");
                bootmgr_printf(10+((220 - 25*8)/2), 15, WHITE, "Press \"VolDown\" to resume");
                bootmgr_draw_fills();
                bootmgr_draw_text();
                fb_update(&fb);
                state &= ~(TETRIS_STARTED);
                state |= TETRIS_PAUSED;
            }
            break;
        }
        case KEY_VOLUMEUP:
            tetris_exit();
            bootmgr_set_time_thread(1);
            break;
        case KEY_HOME:
        {
            if(!(state & TETRIS_STARTED))
            {
                if(state & TETRIS_FINISHED)
                {
                    tetris_clear(0);
                    tetris_set_defaults();
                    bootmgr_erase_text(14);
                    bootmgr_erase_fill(1);
                    tetris_print_score();
                }
                bootmgr_erase_text(15);
                state = (TETRIS_STARTED | TETRIS_SPAWN_NEW);
            }
            else
            {
                pthread_mutex_lock(tetris_draw_mutex);
                tetris_move_piece(TETRIS_DOWN_FAST);
                tetris_draw(0);
                pthread_mutex_unlock(tetris_draw_mutex);
            }
            break;
        }
        case KEY_BACK:
        {
            if(state & TETRIS_STARTED)
            {
                pthread_mutex_lock(tetris_draw_mutex);
                tetris_rotate_piece();
                tetris_draw(0);
                pthread_mutex_unlock(tetris_draw_mutex);
            }
            break;
        }
        case KEY_MENU:
        case KEY_SEARCH:
        {
            if(state & TETRIS_STARTED)
            {
                pthread_mutex_lock(tetris_draw_mutex);
                if(tetris_can_move_piece(key == KEY_MENU ? TETRIS_LEFT : TETRIS_RIGHT))
                    tetris_move_piece(key == KEY_MENU ? TETRIS_LEFT : TETRIS_RIGHT);
                tetris_draw(0);
                pthread_mutex_unlock(tetris_draw_mutex);
            }
            break;
        }
    }
}