//! Testing rendering speeds.
void test_speeds()
{
irq_init(NULL);
irq_add(II_VBLANK, NULL);
gFont= vwf_default;
int ii;
const char *str= glados[0];
int len= strlen(str);
for(ii=0; ii<countof(gProfs); ii++)
{
gProfs[ii].proc(&gProfs[ii], str);
key_wait_till_hit(KEY_ANY);
}
RegisterRamReset(RESET_GFX);
REG_DISPCNT= DCNT_MODE0 | DCNT_BG2;
tte_init_se_default(2, BG_CBB(0) | BG_SBB(24));
tte_init_con();
pal_bg_bank[14][1]= CLR_ORANGE;
iprintf("%d\n", len);
for(ii=0; ii<countof(gProfs); ii++)
{
tte_set_special(SE_PALBANK(14+(ii&1)));
iprintf("%-17s %6d %d\n", gProfs[ii].str, gProfs[ii].time,
gProfs[ii].time/len);
}
key_wait_till_hit(KEY_START);
}
int main()
{
// Init interrupts and VBlank irq.
irq_init(NULL);
irq_add(II_VBLANK, NULL);
// Video mode 0, enable bg 0.
REG_DISPCNT= DCNT_MODE0 | DCNT_BG0;
// Init 4bpp vwf text on bg 0.
tte_init_chr4c(0, // BG 0
BG_CBB(0)|BG_SBB(31), // Charblock 0; screenblock 31
0xF000, // Screen-entry offset
bytes2word(1,2,0,0), // Color attributes.
CLR_YELLOW, // Yellow text
&verdana9Font, // Verdana 9 font
NULL // Use default chr4 renderer
);
// Initialize use of stdio.
tte_init_con();
// Printf something at 96,72
tte_printf("#{P:96,72}Hello World!");
while(1)
{
VBlankIntrWait();
}
return 0;
}
static int
configure(int type, int value)
{
static struct irq_handle handle = {NULL, irq, IRQ_ADC_TEMP, ADC_INPUT_RANGE_1};
switch(type) {
case SENSORS_HW_INIT:
_value = 0;
return 1;
case SENSORS_ACTIVE:
if (value) irq_add(&handle);
else irq_remove(&handle);
return 1;
}
return 0;
}
int main()
{
// Init interrupts and VBlank irq.
irq_init(NULL);
irq_add(II_VBLANK, mmVBlank);
mmInitDefault( (mm_addr)soundbank_bin, 8 );
CreditDevkitArmandtonc();
MainMenu();
while(1)
{
VBlankIntrWait();
}
return 0;
}
int playPuzzle(int NUR_ROWS, int NUR_COLS, int puzzle[NUR_ROWS][NUR_COLS], int puzzle_index) {
int cursor_r = 0;
int cursor_c = 0;
// Load palette
memcpy16(pal_bg_mem, SharedPal, SharedPalLen / 2);
// Load tiles into CBB 0 (16x16) and 1 (8x8)
// Each charblock is 0x4000, an 8x8 tile is 0x20 bytes,
// so there are 512 8x8 tiles or 128 16x16 tiles in each charblock.
memcpy16(tile_mem[0], tiles16Tiles, tiles16TilesLen / 2);
memcpy16(tile_mem[1], tiles8Tiles, tiles8TilesLen / 2);
// Load the 16x16 puzzle map into screenblocks 28-31
for (int r = 0; r < 32; r++) {
for (int c = 0; c < 32; c++) {
set_tile(28, r, c, OUTSIDE);
}
}
for (int c = 0; c < NUR_COLS; c++) set_tile(28, NUR_ROWS, c, BOTTOM_EDGE);
for (int r = 0; r < NUR_ROWS; r++) set_tile(28, r, NUR_COLS, RIGHT_EDGE);
set_tile(28, NUR_ROWS, NUR_COLS, BOTTOM_RIGHT_CORNER);
for (int r = 0; r < NUR_ROWS; r++) {
for (int c = 0; c < NUR_COLS; c++) {
set_tile(28, r, c, puzzle[r][c]);
}
}
// Load the 16x16 cursor map into screenblocks 24-27
for (int r = 0; r < 32; r++) {
for (int c = 0; c < 32; c++) {
set_tile(24, r, c, TRANSPARENT);
}
}
set_tile(24, cursor_r, cursor_c, CURSOR);
// 8x8 tiles:
// set up BG2 for a 4bpp 32x32t map, using charblock 1 and screenblock 22 (cursor)
REG_BG2CNT = BG_CBB(1) | BG_SBB(22) | BG_4BPP | BG_REG_32x32;
// set up BG3 for a 4bpp 32x32t map, using charblock 1 and screenblock 23 (puzzle squares)
REG_BG3CNT = BG_CBB(1) | BG_SBB(23) | BG_4BPP | BG_REG_32x32;
// 16x16 tiles:
// set up BG0 for a 4bpp 64x64t map, using charblock 0 and screenblocks 24-27 (cursor)
REG_BG0CNT = BG_CBB(0) | BG_SBB(24) | BG_4BPP | BG_REG_64x64;
// set up BG1 for a 4bpp 64x64t map, using charblock 0 and screenblocks 28-31 (puzzle squares)
REG_BG1CNT = BG_CBB(0) | BG_SBB(28) | BG_4BPP | BG_REG_64x64;
if (small_tiles) {
REG_DISPCNT = DCNT_MODE0 | DCNT_BG2 | DCNT_BG3;
}
else {
REG_DISPCNT = DCNT_MODE0 | DCNT_BG0 | DCNT_BG1;
}
int max_horiz_offset_16 = NUR_COLS * 16 - 240;
if (max_horiz_offset_16 < 0) max_horiz_offset_16 = 0;
int max_vert_offset_16 = NUR_ROWS * 16 - 160;
if (max_vert_offset_16 < 0) max_vert_offset_16 = 0;
int max_horiz_offset_8 = NUR_COLS * 8 - 240;
if (max_horiz_offset_8 < 0) max_horiz_offset_8 = 0;
int max_vert_offset_8 = NUR_ROWS * 8 - 160;
if (max_vert_offset_8 < 0) max_vert_offset_8 = 0;
REG_BG0HOFS = REG_BG1HOFS = REG_BG2HOFS = REG_BG3HOFS = 0;
REG_BG0VOFS = REG_BG1VOFS = REG_BG2VOFS = REG_BG3VOFS = 0;
irq_init(NULL);
irq_add(II_VBLANK, NULL);
int key_repeat = 0;
bool clearing = false;
while (1) {
VBlankIntrWait();
key_poll();
set_tile(24, cursor_r, cursor_c, TRANSPARENT); // remove the cursor
if (key_hit(1 << KI_LEFT | 1 << KI_RIGHT | 1 << KI_UP | 1 << KI_DOWN)) {
key_repeat = 0; // reset the key repeat timer
}
#define START_REPEAT 20
#define REPEAT_SPEED 2
if (key_is_down(1 << KI_LEFT | 1 << KI_RIGHT | 1 << KI_UP | 1 << KI_DOWN)) {
if (key_repeat < START_REPEAT) key_repeat++;
else key_repeat = START_REPEAT - REPEAT_SPEED;
}
bool virtual_left = key_hit(1 << KI_LEFT ) || (key_is_down(1 << KI_LEFT ) && key_repeat == START_REPEAT);
bool virtual_right = key_hit(1 << KI_RIGHT) || (key_is_down(1 << KI_RIGHT) && key_repeat == START_REPEAT);
bool virtual_up = key_hit(1 << KI_UP ) || (key_is_down(1 << KI_UP ) && key_repeat == START_REPEAT);
bool virtual_down = key_hit(1 << KI_DOWN ) || (key_is_down(1 << KI_DOWN ) && key_repeat == START_REPEAT);
bool moved_cursor = false;
if (virtual_left && cursor_c > 0 ) {
cursor_c--;
REG_BG0HOFS = REG_BG1HOFS = (cursor_c * max_horiz_offset_16) / (NUR_COLS - 1);
REG_BG2HOFS = REG_BG3HOFS = (cursor_c * max_horiz_offset_8 ) / (NUR_COLS - 1);
moved_cursor = true;
}
if (virtual_right && cursor_c < NUR_COLS - 1) {
cursor_c++;
REG_BG0HOFS = REG_BG1HOFS = (cursor_c * max_horiz_offset_16) / (NUR_COLS - 1);
REG_BG2HOFS = REG_BG3HOFS = (cursor_c * max_horiz_offset_8 ) / (NUR_COLS - 1);
moved_cursor = true;
}
if (virtual_up && cursor_r > 0 ) {
cursor_r--;
REG_BG0VOFS = REG_BG1VOFS = (cursor_r * max_vert_offset_16) / (NUR_ROWS - 1);
REG_BG2VOFS = REG_BG3VOFS = (cursor_r * max_vert_offset_8 ) / (NUR_ROWS - 1);
moved_cursor = true;
}
if (virtual_down && cursor_r < NUR_ROWS - 1) {
cursor_r++;
REG_BG0VOFS = REG_BG1VOFS = (cursor_r * max_vert_offset_16) / (NUR_ROWS - 1);
REG_BG2VOFS = REG_BG3VOFS = (cursor_r * max_vert_offset_8 ) / (NUR_ROWS - 1);
moved_cursor = true;
}
if (key_hit(1 << KI_A)) {
switch (puzzle[cursor_r][cursor_c]) {
case WHITE:
case BLACK:
puzzle[cursor_r][cursor_c] = DOT;
sram_mem[(puzzle_index + 1) * 1024 + cursor_r * NUR_COLS + cursor_c] = DOT;
set_tile(28, cursor_r, cursor_c, DOT);
clearing = false;
break;
case DOT:
puzzle[cursor_r][cursor_c] = WHITE;
sram_mem[(puzzle_index + 1) * 1024 + cursor_r * NUR_COLS + cursor_c] = WHITE;
set_tile(28, cursor_r, cursor_c, WHITE);
clearing = true;
break;
default:
clearing = false;
break;
}
}
else if (key_is_down(1 << KI_A) && moved_cursor) {
switch (puzzle[cursor_r][cursor_c]) {
case WHITE:
case BLACK:
case DOT:
if (clearing) {
puzzle[cursor_r][cursor_c] = WHITE;
sram_mem[(puzzle_index + 1) * 1024 + cursor_r * NUR_COLS + cursor_c] = WHITE;
set_tile(28, cursor_r, cursor_c, WHITE);
}
else {
puzzle[cursor_r][cursor_c] = DOT;
sram_mem[(puzzle_index + 1) * 1024 + cursor_r * NUR_COLS + cursor_c] = DOT;
set_tile(28, cursor_r, cursor_c, DOT);
}
break;
}
}
if (key_hit(1 << KI_B)) {
switch (puzzle[cursor_r][cursor_c]) {
case WHITE:
case DOT:
puzzle[cursor_r][cursor_c] = BLACK;
sram_mem[(puzzle_index + 1) * 1024 + cursor_r * NUR_COLS + cursor_c] = BLACK;
set_tile(28, cursor_r, cursor_c, BLACK);
clearing = false;
break;
case BLACK:
puzzle[cursor_r][cursor_c] = WHITE;
sram_mem[(puzzle_index + 1) * 1024 + cursor_r * NUR_COLS + cursor_c] = WHITE;
set_tile(28, cursor_r, cursor_c, WHITE);
clearing = true;
break;
default:
clearing = false;
break;
}
}
else if (key_is_down(1 << KI_B) && moved_cursor) {
switch (puzzle[cursor_r][cursor_c]) {
case WHITE:
case BLACK:
case DOT:
if (clearing) {
puzzle[cursor_r][cursor_c] = WHITE;
sram_mem[(puzzle_index + 1) * 1024 + cursor_r * NUR_COLS + cursor_c] = WHITE;
set_tile(28, cursor_r, cursor_c, WHITE);
}
else {
puzzle[cursor_r][cursor_c] = BLACK;
sram_mem[(puzzle_index + 1) * 1024 + cursor_r * NUR_COLS + cursor_c] = BLACK;
set_tile(28, cursor_r, cursor_c, BLACK);
}
break;
}
}
if (key_hit(1 << KI_SELECT)) {
small_tiles = !small_tiles;
if (small_tiles) {
REG_DISPCNT = DCNT_MODE0 | DCNT_BG2 | DCNT_BG3;
}
else {
REG_DISPCNT = DCNT_MODE0 | DCNT_BG0 | DCNT_BG1;
}
}
if (key_hit(1 << KI_L)) {
return -1; // move 1 puzzle to the left
}
if (key_hit(1 << KI_R)) {
return 1; // move 1 puzzle to the right
}
set_tile(24, cursor_r, cursor_c, CURSOR); // readd the cursor
}
}
