DSMemorizer: src/dsmemorizer.cpp Source File

00001 
00002 /* Copyright 2009 Diego Barrios Romero
00003  *
00004  * This file is part of DSMemorizer.
00005  *
00006  * DSMemorizer is free software: you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation, either version 3 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * DSMemorizer distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with DSMemorizer.  If not, see <http://www.gnu.org/licenses/>.
00018  */
00019 
00020 #include <nds.h>
00021 #include <stdio.h>
00022 #include <malloc.h>
00023 #include <fat.h>
00024 #include <unistd.h>   // filesystem functions
00025 #include <maxmod9.h>
00026 #include <string>
00027 #include <vector>
00028 
00029 #include "definitions.h"
00030 #include "types.h"
00031 #include "card.h"
00032 #include "xmlparser.h"
00033 #include "graphics.h"
00034 #include "soundhandler.h"
00035 #include "screenshandler.h"
00036 #include "subscreenhandler.h"
00037 #include "mainscreenhandler.h"
00038 #include "dsmemorizer.h"
00039 
00040 using namespace Types;
00041 
00042 void DSMemorizer::Init ()
00043 {
00044   romaji_conversion = false;
00045   sound_handler_.Init();
00046   sound_handler_.PlayEffect(SoundHandler::THEME);
00047   screens_handler_.Init();
00048   main_screen_handler_.Init (MainScreenMode::SPLASH_SCREEN,
00049                              GameMode::SPLASH_SCREEN, &screens_handler_);
00050   sub_screen_handler_.Init (SubScreenMode::MAIN_MENU, GameMode::MAIN_MENU,
00051                             &screens_handler_);
00052 
00053   // Vertical scroll
00054   int sy = 0;
00055 
00056   int height = 256;
00057   int keys = 0;
00058   touchPosition touch;
00059 
00060   // Loop
00061   while(true)
00062   {
00063       int selected_button = 0;
00064       scanKeys();
00065 
00066       touchRead(&touch);
00067 
00068       keys = keysHeld();
00069 
00070       if (touch.px > TP_MAIN_MENU_BUTTON1_X1 &&
00071           touch.px < TP_MAIN_MENU_BUTTON1_X2 &&
00072           touch.py > TP_MAIN_MENU_BUTTON1_Y1 &&
00073           touch.py < TP_MAIN_MENU_BUTTON1_Y2)
00074         selected_button = 1;
00075       if (touch.px > TP_MAIN_MENU_BUTTON2_X1 &&
00076           touch.px < TP_MAIN_MENU_BUTTON2_X2 &&
00077           touch.py > TP_MAIN_MENU_BUTTON2_Y1 &&
00078           touch.py < TP_MAIN_MENU_BUTTON2_Y2)
00079         selected_button = 2;
00080       if (touch.px > TP_MAIN_MENU_BUTTON3_X1 &&
00081           touch.px < TP_MAIN_MENU_BUTTON3_X2 &&
00082           touch.py > TP_MAIN_MENU_BUTTON3_Y1 &&
00083           touch.py < TP_MAIN_MENU_BUTTON3_Y2)
00084         selected_button = 3;
00085       if (touch.px > TP_MAIN_MENU_BUTTON4_X1 &&
00086           touch.px < TP_MAIN_MENU_BUTTON4_X2 &&
00087           touch.py > TP_MAIN_MENU_BUTTON4_Y1 &&
00088           touch.py < TP_MAIN_MENU_BUTTON4_Y2)
00089         selected_button = 4;
00090 
00091       if (sy < 0) sy = 0;
00092       if (sy >= height - 192) sy = height - 1 - 192;
00093 
00094       if (selected_button)
00095       {
00096         sound_handler_.PlayEffect(SoundHandler::ACTION);
00097         sound_handler_.StopEffect(SoundHandler::THEME);
00098         sound_handler_.UnloadEffect(SoundHandler::THEME);
00099         switch(selected_button)
00100         {
00101           case 1: KanjiMode ();
00102           break;
00103           case 2: KanjiQuizMode ();
00104           break;
00105           case 3: VocabularyMode ();
00106           break;
00107           case 4: VocabularyQuizMode ();
00108           break;
00109         }
00110         sound_handler_.PlayEffect(SoundHandler::THEME);
00111         sub_screen_handler_.Fill(0);
00112         main_screen_handler_.SwitchMode (MainScreenMode::SPLASH_SCREEN,
00113                                          GameMode::MAIN_MENU);
00114         sub_screen_handler_.SwitchMode (SubScreenMode::MAIN_MENU,
00115                                         GameMode::MAIN_MENU);
00116       }
00117       swiWaitForVBlank();
00118    }
00119 
00120 }
00121 
00122 void DSMemorizer::KanjiMode ()
00123 {
00124   xmlparser_.Init("/db/kanjis.xml");
00125 
00126   main_screen_handler_.SwitchMode (MainScreenMode::KANJI, GameMode::KANJI);
00127   sub_screen_handler_.SwitchMode (SubScreenMode::CARDS, GameMode::KANJI);
00128 
00129   int sy = 0;
00130   // Shown card
00131   int card = 1;
00132   // Previously shown card
00133   int previous_card = 0;
00134 
00135   int height = 256;
00136   int keys = 0;
00137   touchPosition touch;
00138   unsigned grade_min, grade_max, strokes_min, strokes_max;
00139   // By default: all the kanjis
00140   grade_min = MIN_GRADE, grade_max = MAX_GRADE;
00141   strokes_min = MIN_STROKES, strokes_max = MAX_STROKES;
00142 
00143   // Loop
00144   bool done = false;
00145   while(!(keys & KEY_B) && !done)
00146   {
00147       scanKeys();
00148 
00149       touchRead(&touch);
00150 
00151       keys = keysDown();
00152 
00153       if ((keys & KEY_LEFT) || (keys & KEY_RIGHT) || (keys & KEY_A) ||
00154           (keys & KEY_X) || (keys & KEY_Y))
00155         sound_handler_.PlayEffect(SoundHandler::ACTION);
00156 
00157       if (keysHeld() & KEY_UP) sy--;
00158       if (keysHeld() & KEY_DOWN) sy++;
00159       if (keys & KEY_LEFT) card--;
00160       if (keys & KEY_RIGHT) card++;
00161       if (keys & KEY_A)
00162         if (main_screen_handler_.ViewNext())
00163           ++card;
00164       if (keys & KEY_X)
00165         card = rand()%xmlparser_.QueryResultSize(grade_min, grade_max,
00166                                                  strokes_min, strokes_max) + 1;
00167       if (keys & KEY_Y)
00168       {
00169         SetOptions(grade_min, grade_max, strokes_min, strokes_max);
00170         card = 1;
00171         previous_card = 0;
00172         sub_screen_handler_.SwitchMode (SubScreenMode::CARDS, GameMode::KANJI);
00173       }
00174 
00175       if (touch.px > TP_LEFT_BOTTOM_IMAGE_X1 &&
00176           touch.px < TP_LEFT_BOTTOM_IMAGE_X2 &&
00177           touch.py > TP_LEFT_BOTTOM_IMAGE_Y1 &&
00178           touch.py < TP_LEFT_BOTTOM_IMAGE_Y2)
00179         done = true;
00180 
00181       if (touch.px > TP_RIGHT_BOTTOM_IMAGE_X1 &&
00182           touch.px < TP_RIGHT_BOTTOM_IMAGE_X2 &&
00183           touch.py > TP_RIGHT_BOTTOM_IMAGE_Y1 &&
00184           touch.py < TP_RIGHT_BOTTOM_IMAGE_Y2)
00185       {
00186         SetOptions(grade_min, grade_max, strokes_min, strokes_max);
00187         card = 1;
00188         previous_card = 0;
00189         sub_screen_handler_.SwitchMode (SubScreenMode::CARDS, GameMode::KANJI);
00190       }
00191 
00192       if (touch.px > TP_CARD1_X1 && touch.px < TP_CARD1_X2 &&
00193           touch.py > TP_CARD_Y1 && touch.py < TP_CARD_Y2)
00194         card--;
00195       if (touch.px > TP_CARD2_X1 && touch.px < TP_CARD2_X2 &&
00196           touch.py > TP_CARD_Y1 && touch.py < TP_CARD_MIDDLE_Y)
00197         card++;
00198       if (touch.px > TP_CARD2_X1 && touch.px < TP_CARD2_X2 &&
00199         touch.py > TP_CARD_MIDDLE_Y && touch.py < TP_CARD_Y2)
00200         card = rand()%xmlparser_.QueryResultSize(grade_min, grade_max,
00201                                                  strokes_min, strokes_max) + 1;
00202 
00203       if (card < 1) card = 1;
00204       if (card > xmlparser_.QueryResultSize(grade_min, grade_max,
00205                                             strokes_min, strokes_max))
00206         card = xmlparser_.QueryResultSize(grade_min, grade_max,
00207                                           strokes_min, strokes_max);
00208       if(sy < 0) sy = 0;
00209       if(sy >= height - 192) sy = height - 1 - 192;
00210 
00211       Card c;
00212       if (previous_card != card)
00213       {
00214         if (previous_card)
00215           sound_handler_.PlayEffect(SoundHandler::ACTION);
00216         sy = 0;
00217         main_screen_handler_.Scroll(0,sy);
00218         c = xmlparser_.card(card, grade_min, grade_max,
00219                             strokes_min, strokes_max);
00220         sub_screen_handler_.PrintCard(c);
00221         main_screen_handler_.PrintCard(c, romaji_conversion);
00222         previous_card = card;
00223       }
00224       main_screen_handler_.Scroll(0,sy);
00225       swiWaitForVBlank();
00226    }
00227 }
00228 
00229 void DSMemorizer::KanjiQuizMode ()
00230 {
00231   xmlparser_.Init("/db/kanjis.xml");
00232 
00233   main_screen_handler_.SwitchMode (MainScreenMode::VERTICAL_TEXTBOXES_VISIBLE,
00234                                    GameMode::KANJI_QUIZ, 3);
00235   sub_screen_handler_.SwitchMode (SubScreenMode::KANJI_CHOOSE,
00236                                   GameMode::KANJI_QUIZ);
00237   main_screen_handler_.Captions("Translation", "on reading", "kun reading");
00238 
00239 
00240   // player score
00241   int score = 0;
00242   // Player answers
00243   int answers = 0;
00244   // Selected kanji number [1-4]
00245   int selected_kanji = 0;
00246   // Vertical scroll
00247   int sy = 0;
00248 
00249   int height = 256;
00250   int keys = 0;
00251   touchPosition touch;
00252 
00253   unsigned grade_min, grade_max, strokes_min, strokes_max;
00254   // By default: all the kanjis
00255   grade_min = MIN_GRADE, grade_max = MAX_GRADE;
00256   strokes_min = MIN_STROKES, strokes_max = MAX_STROKES;
00257 
00258   int card = rand()%xmlparser_.QueryResultSize(grade_min, grade_max,
00259                                                strokes_min, strokes_max) + 1;
00260   int selected_card [4];
00261   // Correct kanji position [1-4]
00262   int correct = randomize_positions (card,
00263                   xmlparser_.QueryResultSize(grade_min, grade_max,
00264                                           strokes_min, strokes_max),
00265                   selected_card[0], selected_card[1],
00266                   selected_card[2], selected_card[3]);
00267   Card c;
00268   c = xmlparser_.card (card, grade_min, grade_max,
00269                        strokes_min, strokes_max);
00270   main_screen_handler_.PrintCard(c, romaji_conversion);
00271 
00272   sub_screen_handler_.PrintScreen(
00273           xmlparser_.card(selected_card[0], grade_min, grade_max,
00274                           strokes_min, strokes_max).symbol(),
00275           xmlparser_.card(selected_card[1], grade_min, grade_max,
00276                           strokes_min, strokes_max).symbol(),
00277           xmlparser_.card(selected_card[2], grade_min, grade_max,
00278                           strokes_min, strokes_max).symbol(),
00279           xmlparser_.card(selected_card[3], grade_min, grade_max,
00280                           strokes_min, strokes_max).symbol(),
00281           score, answers);
00282 
00283   // Loop
00284   bool done = false;
00285   while(!(keys & KEY_B) && !done)
00286   {
00287       scanKeys();
00288 
00289       touchRead(&touch);
00290 
00291       keys = keysDown();
00292 
00293       if ((keys & KEY_A) || (keys & KEY_Y) || (keys & KEY_X))
00294         sound_handler_.PlayEffect(SoundHandler::ACTION);
00295 
00296       if (keysHeld() & KEY_UP) sy--;
00297       if (keysHeld() & KEY_DOWN) sy++;
00298       if (keys & KEY_Y)
00299       {
00300         SetOptions(grade_min, grade_max, strokes_min, strokes_max);
00301         sub_screen_handler_.SwitchMode (SubScreenMode::KANJI_CHOOSE,
00302                                         GameMode::KANJI_QUIZ);
00303         card = rand()%xmlparser_.QueryResultSize(grade_min, grade_max,
00304                                                strokes_min, strokes_max) + 1;
00305         // Correct kanji position [1-4]
00306         correct = randomize_positions (card,
00307                      xmlparser_.QueryResultSize(grade_min, grade_max,
00308                                                 strokes_min, strokes_max),
00309                      selected_card[0], selected_card[1],
00310                      selected_card[2], selected_card[3]);
00311 
00312         c = xmlparser_.card (card, grade_min, grade_max,
00313                              strokes_min, strokes_max);
00314         main_screen_handler_.PrintCard(c, romaji_conversion);
00315 
00316         sub_screen_handler_.PrintScreen(
00317                 xmlparser_.card(selected_card[0], grade_min, grade_max,
00318                                 strokes_min, strokes_max).symbol(),
00319                 xmlparser_.card(selected_card[1], grade_min, grade_max,
00320                                 strokes_min, strokes_max).symbol(),
00321                 xmlparser_.card(selected_card[2], grade_min, grade_max,
00322                                 strokes_min, strokes_max).symbol(),
00323                 xmlparser_.card(selected_card[3], grade_min, grade_max,
00324                                 strokes_min, strokes_max).symbol(),
00325                 score, answers);
00326       }
00327 
00328       if (touch.px > TP_LEFT_BOTTOM_IMAGE_X1 &&
00329           touch.px < TP_LEFT_BOTTOM_IMAGE_X2 &&
00330           touch.py > TP_LEFT_BOTTOM_IMAGE_Y1 &&
00331           touch.py < TP_LEFT_BOTTOM_IMAGE_Y2)
00332         done = true;
00333 
00334       if (touch.px > TP_RIGHT_BOTTOM_IMAGE_X1 &&
00335           touch.px < TP_RIGHT_BOTTOM_IMAGE_X2 &&
00336           touch.py > TP_RIGHT_BOTTOM_IMAGE_Y1 &&
00337           touch.py < TP_RIGHT_BOTTOM_IMAGE_Y2)
00338       {
00339         SetOptions(grade_min, grade_max, strokes_min, strokes_max);
00340         sub_screen_handler_.SwitchMode (SubScreenMode::KANJI_CHOOSE,
00341                                         GameMode::KANJI_QUIZ);
00342         card = rand()%xmlparser_.QueryResultSize(grade_min, grade_max,
00343                                                  strokes_min, strokes_max) + 1;
00344         // Correct kanji position [1-4]
00345         correct = randomize_positions (card,
00346                                        xmlparser_.QueryResultSize(grade_min,
00347                                           grade_max, strokes_min, strokes_max),
00348                                        selected_card[0], selected_card[1],
00349                                        selected_card[2], selected_card[3]);
00350         Card c;
00351         c = xmlparser_.card(card, grade_min, grade_max,
00352                             strokes_min, strokes_max);
00353         main_screen_handler_.PrintCard(c, romaji_conversion);
00354 
00355         sub_screen_handler_.PrintScreen(
00356           xmlparser_.card(selected_card[0], grade_min, grade_max,
00357                           strokes_min, strokes_max).symbol(),
00358           xmlparser_.card(selected_card[1], grade_min, grade_max,
00359                           strokes_min, strokes_max).symbol(),
00360           xmlparser_.card(selected_card[2], grade_min, grade_max,
00361                           strokes_min, strokes_max).symbol(),
00362           xmlparser_.card(selected_card[3], grade_min, grade_max,
00363                           strokes_min, strokes_max).symbol(),
00364           score, answers);
00365       }
00366 
00367       if (touch.px > KC_BOX1_X &&
00368           touch.px < (KC_BOX1_X + (KC_NORMAL_SIZE * 3 >> 1)) &&
00369           touch.py > KC_BOX1_Y &&
00370           touch.py < (KC_BOX1_Y + (KC_NORMAL_SIZE * 3 >> 1)))
00371         selected_kanji = 1;
00372       if (touch.px > KC_BOX2_X &&
00373           touch.px < (KC_BOX2_X + (KC_NORMAL_SIZE * 3 >> 1)) &&
00374           touch.py > KC_BOX2_Y &&
00375           touch.py < (KC_BOX2_Y + (KC_NORMAL_SIZE * 3 >> 1)))
00376         selected_kanji = 2;
00377       if (touch.px > KC_BOX3_X &&
00378           touch.px < (KC_BOX3_X + (KC_NORMAL_SIZE * 3 >> 1)) &&
00379           touch.py > KC_BOX3_Y &&
00380           touch.py < (KC_BOX3_Y + (KC_NORMAL_SIZE * 3 >> 1)))
00381         selected_kanji = 3;
00382       if (touch.px > KC_BOX4_X &&
00383           touch.px < (KC_BOX4_X + (KC_NORMAL_SIZE * 3 >> 1)) &&
00384           touch.py > KC_BOX4_Y &&
00385           touch.py < (KC_BOX4_Y + (KC_NORMAL_SIZE * 3 >> 1)))
00386         selected_kanji = 4;
00387 
00388       if (sy < 0) sy = 0;
00389       if (sy >= height - 192) sy = height - 1 - 192;
00390 
00391       if (selected_kanji)
00392       {
00393         sound_handler_.PlayEffect(SoundHandler::ACTION);
00394         ++answers;
00395         if (selected_kanji == correct)
00396         {
00397           ++score;
00398           sub_screen_handler_.PrintBoards (score, answers);
00399           sub_screen_handler_.PrintTick (selected_kanji);
00400         }
00401         else
00402         {
00403           sub_screen_handler_.PrintTick (correct);
00404           sub_screen_handler_.PrintCross (selected_kanji);
00405         }
00406 
00407         do
00408         {
00409           scanKeys();
00410         }while(!keysDown());
00411 
00412         sy = 0;
00413         main_screen_handler_.Scroll(0,sy);
00414 
00415         card = rand()%xmlparser_.QueryResultSize(grade_min, grade_max,
00416                                                  strokes_min, strokes_max) + 1;
00417         correct = randomize_positions (card,
00418                                        xmlparser_.QueryResultSize(grade_min, grade_max,
00419                                                strokes_min, strokes_max),
00420                                        selected_card[0], selected_card[1],
00421                                        selected_card[2], selected_card[3]);
00422         c = xmlparser_.card(card, grade_min, grade_max, strokes_min, strokes_max);
00423         main_screen_handler_.PrintCard(c, romaji_conversion);
00424 
00425         sub_screen_handler_.PrintScreen(
00426           xmlparser_.card(selected_card[0], grade_min, grade_max,
00427                           strokes_min, strokes_max).symbol(),
00428           xmlparser_.card(selected_card[1], grade_min, grade_max,
00429                           strokes_min, strokes_max).symbol(),
00430           xmlparser_.card(selected_card[2], grade_min, grade_max,
00431                           strokes_min, strokes_max).symbol(),
00432           xmlparser_.card(selected_card[3], grade_min, grade_max,
00433                           strokes_min, strokes_max).symbol(),
00434           score, answers);
00435 
00436         selected_kanji = 0;
00437       }
00438       main_screen_handler_.Scroll(0,sy);
00439       swiWaitForVBlank();
00440    }
00441 }
00442 
00443 
00444 void DSMemorizer::VocabularyMode ()
00445 {
00446   xmlparser_.Init("/db/vocabulary.xml");
00447 
00448   main_screen_handler_.SwitchMode (MainScreenMode::VERTICAL_TEXTBOXES,
00449                                    GameMode::VOCABULARY, 3);
00450   sub_screen_handler_.SwitchMode (SubScreenMode::CARDS, GameMode::VOCABULARY);
00451   main_screen_handler_.Captions("Kanji", "Reading", "Translation");
00452 
00453   int sy = 0;
00454   // Shown card
00455   int card = 1;
00456   // Previously shown card
00457   int previous_card = 0;
00458 
00459   int height = 256;
00460   int keys = 0;
00461   touchPosition touch;
00462   // Loop
00463   bool done = false;
00464   while(!(keys & KEY_B) && !done)
00465   {
00466       scanKeys();
00467 
00468       touchRead(&touch);
00469 
00470      keys = keysDown();
00471 
00472       if ((keys & KEY_LEFT) || (keys & KEY_RIGHT) || (keys & KEY_A) ||
00473           (keys & KEY_X) || (keys & KEY_Y))
00474         sound_handler_.PlayEffect(SoundHandler::ACTION);
00475 
00476       if (keysHeld() & KEY_UP) sy--;
00477       if (keysHeld() & KEY_DOWN) sy++;
00478       if (keys & KEY_LEFT) card--;
00479       if (keys & KEY_RIGHT) card++;
00480       if (keys & KEY_A)
00481         if (main_screen_handler_.ViewNext())
00482           ++card;
00483       if (keys & KEY_X)
00484         card = rand()%xmlparser_.package_records() + 1;
00485       if (keys & KEY_Y)
00486       {
00487         SetOptions();
00488         sub_screen_handler_.SwitchMode (SubScreenMode::CARDS,
00489                                         GameMode::VOCABULARY);
00490       }
00491 
00492       if (touch.px > TP_LEFT_BOTTOM_IMAGE_X1 &&
00493           touch.px < TP_LEFT_BOTTOM_IMAGE_X2 &&
00494           touch.py > TP_LEFT_BOTTOM_IMAGE_Y1 &&
00495           touch.py < TP_LEFT_BOTTOM_IMAGE_Y2)
00496         done = true;
00497 
00498       if (touch.px > TP_RIGHT_BOTTOM_IMAGE_X1 &&
00499           touch.px < TP_RIGHT_BOTTOM_IMAGE_X2 &&
00500           touch.py > TP_RIGHT_BOTTOM_IMAGE_Y1 &&
00501           touch.py < TP_RIGHT_BOTTOM_IMAGE_Y2)
00502       {
00503         SetOptions();
00504         sub_screen_handler_.SwitchMode (SubScreenMode::CARDS,
00505                                         GameMode::VOCABULARY);
00506       }
00507 
00508       if (touch.px > TP_CARD1_X1 && touch.px < TP_CARD1_X2 &&
00509           touch.py > TP_CARD_Y1 && touch.py < TP_CARD_Y2)
00510         card--;
00511       if (touch.px > TP_CARD2_X1 && touch.px < TP_CARD2_X2 &&
00512           touch.py > TP_CARD_Y1 && touch.py < TP_CARD_MIDDLE_Y)
00513         card++;
00514       if (touch.px > TP_CARD2_X1 && touch.px < TP_CARD2_X2 &&
00515           touch.py > TP_CARD_MIDDLE_Y && touch.py < TP_CARD_Y2)
00516         card = rand()%xmlparser_.package_records() + 1;
00517 
00518       if (card < 1) card = 1;
00519       if (card > xmlparser_.package_records())
00520         card = xmlparser_.package_records();
00521       if(sy < 0) sy = 0;
00522       if(sy >= height - 192) sy = height - 1 - 192;
00523 
00524       if (previous_card != card)
00525       {
00526         if (previous_card)
00527           sound_handler_.PlayEffect(SoundHandler::ACTION);
00528         sy = 0;
00529         Card c;
00530         c = xmlparser_.card(card);
00531         sub_screen_handler_.PrintCard(c);
00532         main_screen_handler_.Scroll (0, sy);
00533         main_screen_handler_.PrintCard(c, romaji_conversion);
00534         previous_card = card;
00535       }
00536       main_screen_handler_.Scroll (0,sy);
00537       swiWaitForVBlank();
00538    }
00539 }
00540 
00541 void DSMemorizer::VocabularyQuizMode ()
00542 {
00543   xmlparser_.Init("/db/vocabulary.xml");
00544 
00545   main_screen_handler_.SwitchMode (MainScreenMode::VERTICAL_TEXTBOXES_VISIBLE,
00546                                    GameMode::VOCABULARY_QUIZ, 2);
00547   sub_screen_handler_.SwitchMode (SubScreenMode::VERTICAL_TEXTBOXES_CHOOSE,
00548                                   GameMode::VOCABULARY_QUIZ);
00549   main_screen_handler_.Captions("Translation", "Reading", "");
00550 
00551   // player score
00552   int score = 0;
00553   // Player answers
00554   int answers = 0;
00555   // Selected kanji number [1-4]
00556   int selected_kanji = 0;
00557   // Vertical scroll
00558   int sy = 0;
00559 
00560   int height = 256;
00561   int keys = 0;
00562   touchPosition touch;
00563 
00564 
00565   int card_number = rand()%xmlparser_.package_records() + 1;
00566   int selected_card [4];
00567   // Correct kanji position [1-4]
00568   int correct = randomize_positions (card_number,
00569                                      xmlparser_.package_records(),
00570                                      selected_card[0], selected_card[1],
00571                                      selected_card[2], selected_card[3]);
00572   Card c;
00573   c = xmlparser_.card(card_number);
00574   main_screen_handler_.PrintCard(c, romaji_conversion);
00575 
00576   sub_screen_handler_.PrintScreen(xmlparser_.card(selected_card[0]).symbol(),
00577                                   xmlparser_.card(selected_card[1]).symbol(),
00578                                   xmlparser_.card(selected_card[2]).symbol(),
00579                                   xmlparser_.card(selected_card[3]).symbol(),
00580                                   score, answers);
00581 
00582   // Loop
00583   bool done = false;
00584   while(!(keys & KEY_B) && !done)
00585   {
00586       scanKeys();
00587 
00588       touchRead(&touch);
00589 
00590       keys = keysDown();
00591 
00592       if ((keys & KEY_LEFT) || (keys & KEY_RIGHT) || (keys & KEY_A) ||
00593           (keys & KEY_X) || (keys & KEY_Y))
00594         sound_handler_.PlayEffect(SoundHandler::ACTION);
00595 
00596       if (keysHeld() & KEY_UP) sy--;
00597       if (keysHeld() & KEY_DOWN) sy++;
00598       if (keys & KEY_Y)
00599       {
00600         SetOptions();
00601         sub_screen_handler_.SwitchMode (SubScreenMode::VERTICAL_TEXTBOXES_CHOOSE,
00602                                         GameMode::VOCABULARY_QUIZ);
00603         sub_screen_handler_.PrintScreen(
00604           xmlparser_.card(selected_card[0]).symbol(),
00605           xmlparser_.card(selected_card[1]).symbol(),
00606           xmlparser_.card(selected_card[2]).symbol(),
00607           xmlparser_.card(selected_card[3]).symbol(),
00608           score, answers);
00609       }
00610 
00611       if (touch.px > TP_LEFT_BOTTOM_IMAGE_X1 &&
00612           touch.px < TP_LEFT_BOTTOM_IMAGE_X2 &&
00613           touch.py > TP_LEFT_BOTTOM_IMAGE_Y1 &&
00614           touch.py < TP_LEFT_BOTTOM_IMAGE_Y2)
00615         done = true;
00616 
00617       if (touch.px > TP_RIGHT_BOTTOM_IMAGE_X1 &&
00618           touch.px < TP_RIGHT_BOTTOM_IMAGE_X2 &&
00619           touch.py > TP_RIGHT_BOTTOM_IMAGE_Y1 &&
00620           touch.py < TP_RIGHT_BOTTOM_IMAGE_Y2)
00621       {
00622         SetOptions();
00623         sub_screen_handler_.SwitchMode (SubScreenMode::VERTICAL_TEXTBOXES_CHOOSE,
00624                                         GameMode::VOCABULARY_QUIZ);
00625         sub_screen_handler_.PrintScreen(
00626           xmlparser_.card(selected_card[0]).symbol(),
00627           xmlparser_.card(selected_card[1]).symbol(),
00628           xmlparser_.card(selected_card[2]).symbol(),
00629           xmlparser_.card(selected_card[3]).symbol(),
00630           score, answers);
00631       }
00632 
00633       if (touch.px > VTBC_BOX1_X &&
00634           touch.px < (SCREEN_WIDTH - VTBC_BOX1_X) &&
00635           touch.py > VTBC_BOX1_Y &&
00636           touch.py < (VTBC_BOX1_Y + (VTBC_NORMAL_SIZE * 3 >> 1)))
00637         selected_kanji = 1;
00638       if (touch.px > VTBC_BOX2_X &&
00639           touch.px < (SCREEN_WIDTH - VTBC_BOX2_X) &&
00640           touch.py > VTBC_BOX2_Y &&
00641           touch.py < (VTBC_BOX2_Y + (VTBC_NORMAL_SIZE * 3 >> 1)))
00642         selected_kanji = 2;
00643       if (touch.px > VTBC_BOX3_X &&
00644           touch.px < (SCREEN_WIDTH - VTBC_BOX3_X) &&
00645           touch.py > VTBC_BOX3_Y &&
00646           touch.py < (VTBC_BOX3_Y + (VTBC_NORMAL_SIZE * 3 >> 1)))
00647         selected_kanji = 3;
00648       if (touch.px > VTBC_BOX4_X &&
00649           touch.px < (SCREEN_WIDTH - VTBC_BOX4_X) &&
00650           touch.py > VTBC_BOX4_Y &&
00651           touch.py < (VTBC_BOX4_Y + (VTBC_NORMAL_SIZE * 3 >> 1)))
00652         selected_kanji = 4;
00653 
00654       if (sy < 0) sy = 0;
00655       if (sy >= height - 192) sy = height - 1 - 192;
00656 
00657       if (selected_kanji)
00658       {
00659         sound_handler_.PlayEffect(SoundHandler::ACTION);
00660         ++answers;
00661         if (selected_kanji == correct)
00662         {
00663           ++score;
00664           sub_screen_handler_.PrintBoards (score, answers);
00665           sub_screen_handler_.PrintTick (selected_kanji);
00666         }
00667         else
00668         {
00669           sub_screen_handler_.PrintTick (correct);
00670           sub_screen_handler_.PrintCross (selected_kanji);
00671         }
00672 
00673         do
00674         {
00675           scanKeys();
00676         }while(!keysDown());
00677 
00678         sy = 0;
00679         main_screen_handler_.Scroll(0,sy);
00680 
00681         card_number = rand()%xmlparser_.package_records() + 1;
00682         correct = randomize_positions (card_number,
00683                                        xmlparser_.package_records(),
00684                                        selected_card[0], selected_card[1],
00685                                        selected_card[2], selected_card[3]);
00686         c = xmlparser_.card(card_number);
00687         main_screen_handler_.PrintCard(c, romaji_conversion);
00688 
00689         sub_screen_handler_.PrintScreen(
00690           xmlparser_.card(selected_card[0]).symbol(),
00691           xmlparser_.card(selected_card[1]).symbol(),
00692           xmlparser_.card(selected_card[2]).symbol(),
00693           xmlparser_.card(selected_card[3]).symbol(),
00694           score, answers);
00695 
00696         selected_kanji = 0;
00697       }
00698       main_screen_handler_.Scroll(0,sy);
00699       swiWaitForVBlank();
00700    }
00701 }
00702 
00703 void DSMemorizer::SetOptions (unsigned& grade_min, unsigned& grade_max,
00704                               unsigned& strokes_min, unsigned& strokes_max)
00705 {
00706   sub_screen_handler_.SwitchMode (SubScreenMode::OPTIONS_GRADE_STROKES_ROMAJI,
00707                                   GameMode::NONE);
00708   Graphics::SetColors();
00709   unsigned prev_grade_min, prev_grade_max, prev_strokes_min, prev_strokes_max;
00710   prev_grade_min = prev_grade_max = prev_strokes_min = prev_strokes_max = 0;
00711   bool prev_romaji_conversion = false;
00712 
00713   int keys = 0;
00714   touchPosition touch;
00715 
00716   // Loop
00717   bool done = false;
00718   while(!(keys & KEY_B) && !done)
00719   {
00720     scanKeys();
00721 
00722     touchRead(&touch);
00723 
00724     keys = keysDown();
00725 
00726     if (touch.px > TP_RIGHT_BOTTOM_IMAGE_X1 &&
00727         touch.px < TP_RIGHT_BOTTOM_IMAGE_X2 &&
00728         touch.py > TP_RIGHT_BOTTOM_IMAGE_Y1 &&
00729         touch.py < TP_RIGHT_BOTTOM_IMAGE_Y2)
00730       done = true;
00731 
00732     if (touch.px > TP_OGSR_MINUS1_X1 && touch.px < TP_OGSR_MINUS1_X2 &&
00733         touch.py > TP_OGSR_GRADE_Y1 && touch.py < TP_OGSR_GRADE_Y2)
00734       --grade_min;
00735     if (touch.px > TP_OGSR_PLUS1_X1 && touch.px < TP_OGSR_PLUS1_X2 &&
00736         touch.py > TP_OGSR_GRADE_Y1 && touch.py < TP_OGSR_GRADE_Y2)
00737       ++grade_min;
00738     if (touch.px > TP_OGSR_MINUS2_X1 && touch.px < TP_OGSR_MINUS2_X2 &&
00739         touch.py > TP_OGSR_GRADE_Y1 && touch.py < TP_OGSR_GRADE_Y2)
00740       --grade_max;
00741     if (touch.px > TP_OGSR_PLUS2_X1 && touch.px < TP_OGSR_PLUS2_X2 &&
00742         touch.py > TP_OGSR_GRADE_Y1 && touch.py < TP_OGSR_GRADE_Y2)
00743       ++grade_max;
00744 
00745     if (touch.px > TP_OGSR_MINUS1_X1 && touch.px < TP_OGSR_MINUS1_X2 &&
00746         touch.py > TP_OGSR_STROKES_Y1 && touch.py < TP_OGSR_STROKES_Y2)
00747       --strokes_min;
00748     if (touch.px > TP_OGSR_PLUS1_X1 && touch.px < TP_OGSR_PLUS1_X2 &&
00749         touch.py > TP_OGSR_STROKES_Y1 && touch.py < TP_OGSR_STROKES_Y2)
00750       ++strokes_min;
00751     if (touch.px > TP_OGSR_MINUS2_X1 && touch.px < TP_OGSR_MINUS2_X2 &&
00752         touch.py > TP_OGSR_STROKES_Y1 && touch.py < TP_OGSR_STROKES_Y2)
00753       --strokes_max;
00754     if (touch.px > TP_OGSR_PLUS2_X1 && touch.px < TP_OGSR_PLUS2_X2 &&
00755         touch.py > TP_OGSR_STROKES_Y1 && touch.py < TP_OGSR_STROKES_Y2)
00756       ++strokes_max;
00757     if (touch.px > TP_OGSR_ROMAJI_CHECKBOX_X1 &&
00758         touch.px < TP_OGSR_ROMAJI_CHECKBOX_X2 &&
00759         touch.py > TP_OGSR_ROMAJI_CHECKBOX_Y1 &&
00760         touch.py < TP_OGSR_ROMAJI_CHECKBOX_Y2)
00761       romaji_conversion = !romaji_conversion;
00762 
00763     if (grade_min < MIN_GRADE) grade_min = MIN_GRADE;
00764     if (grade_min > MAX_GRADE) grade_min = MAX_GRADE;
00765     if (grade_max > MAX_GRADE) grade_max = MAX_GRADE;
00766     if (grade_max < MIN_GRADE) grade_max = MIN_GRADE;
00767     if (strokes_min < MIN_STROKES) strokes_min = MIN_STROKES;
00768     if (strokes_min > MAX_STROKES) strokes_min = MAX_STROKES;
00769     if (strokes_max > MAX_STROKES) strokes_max = MAX_STROKES;
00770     if (strokes_max < MIN_STROKES) strokes_max = MIN_STROKES;
00771 
00772     if (prev_grade_min != grade_min || prev_grade_max != grade_max ||
00773         prev_strokes_min != strokes_min || prev_strokes_max != strokes_max ||
00774         prev_romaji_conversion != romaji_conversion)
00775     {
00776       sound_handler_.PlayEffect(SoundHandler::ACTION);
00777       sub_screen_handler_.PrintOptions(grade_min, grade_max,
00778                                        strokes_min, strokes_max,
00779                                        romaji_conversion);
00780 
00781       prev_grade_min = grade_min, prev_grade_max = grade_max;
00782       prev_strokes_min = strokes_min, prev_strokes_max = strokes_max;
00783       prev_romaji_conversion = romaji_conversion;
00784       swiWaitForVBlank();
00785       swiWaitForVBlank();
00786     }
00787     swiWaitForVBlank();
00788   }
00789   sound_handler_.PlayEffect(SoundHandler::ACTION);
00790 }
00791 
00792 void DSMemorizer::SetOptions ()
00793 {
00794   sub_screen_handler_.SwitchMode (SubScreenMode::OPTIONS_ROMAJI,
00795                                   GameMode::NONE);
00796   Graphics::SetColors();
00797   bool prev_romaji_conversion = false;
00798 
00799   int keys = 0;
00800   touchPosition touch;
00801 
00802   // Loop
00803   bool done = false;
00804   while(!(keys & KEY_B) && !done)
00805   {
00806     scanKeys();
00807 
00808     touchRead(&touch);
00809 
00810     keys = keysDown();
00811 
00812     if (touch.px > TP_RIGHT_BOTTOM_IMAGE_X1 &&
00813         touch.px < TP_RIGHT_BOTTOM_IMAGE_X2 &&
00814         touch.py > TP_RIGHT_BOTTOM_IMAGE_Y1 &&
00815         touch.py < TP_RIGHT_BOTTOM_IMAGE_Y2)
00816       done = true;
00817 
00818     if (touch.px > TP_OR_ROMAJI_CHECKBOX_X1 &&
00819         touch.px < TP_OR_ROMAJI_CHECKBOX_X2 &&
00820         touch.py > TP_OR_ROMAJI_CHECKBOX_Y1 &&
00821         touch.py < TP_OR_ROMAJI_CHECKBOX_Y2)
00822       romaji_conversion = !romaji_conversion;
00823 
00824     if (prev_romaji_conversion != romaji_conversion)
00825     {
00826       sound_handler_.PlayEffect(SoundHandler::ACTION);
00827       sub_screen_handler_.PrintOptions(romaji_conversion);
00828 
00829       prev_romaji_conversion = romaji_conversion;
00830       swiWaitForVBlank();
00831       swiWaitForVBlank();
00832     }
00833     swiWaitForVBlank();
00834   }
00835   sound_handler_.PlayEffect(SoundHandler::ACTION);
00836 }
00837