tile.cpp

00001 #include "tile.h"
00002 
00003 // constructors
00004 
00005 Tile::Tile(PinName pin1, PinName pin2, PinName pin3){
00006     LCD_ptr = new uLCD_4DGL(pin1, pin2, pin3);
00007     setup = false;
00008     score = 0;
00009     win = false;
00010 }
00011 
00012 // member functions
00013 void Tile::TilePattern3(int square){
00014     int i = 0;
00015     int j = 0;
00016     switch(square){
00017         case 0:
00018             square0();
00019             square1();
00020             square3();
00021             break;
00022         case 1:
00023             square0();
00024             square1();
00025             square2();
00026             square4();
00027             break;
00028         case 2:
00029             square1();
00030             square2();
00031             square5();
00032             break;
00033         case 3:
00034             square0();
00035             square3();
00036             square4();
00037             square6();
00038             break;
00039         case 4:
00040             square1();
00041             square3();
00042             square4();
00043             square5();
00044             square7();
00045             break;
00046         case 5:
00047             square2();
00048             square4();
00049             square5();
00050             square8();
00051             break;
00052         case 6:
00053             square3();
00054             square6();
00055             square7();
00056             break;
00057         case 7:
00058             square4();
00059             square6();
00060             square7();
00061             square8();
00062             break;
00063         case 8:
00064             square5();
00065             square7();
00066             square8();
00067             break;
00068         default:
00069             break;
00070     }    
00071     score++;
00072     for(i = 0; i < 9; i++){
00073         if(squares[i] == true)
00074             j++;
00075     }
00076     if(j == 9){
00077         win = true;
00078     }
00079 }
00080 
00081 void Tile::TilePattern4(int square){
00082     int i = 0;
00083     int j = 0;
00084     switch(square){
00085         case 0:
00086             smallSquare0();
00087             smallSquare1();
00088             smallSquare4();
00089             break;
00090         case 1:
00091             smallSquare0();
00092             smallSquare1();
00093             smallSquare2();
00094             smallSquare5();
00095             break;
00096         case 2:
00097             smallSquare1();
00098             smallSquare2();
00099             smallSquare3();
00100             smallSquare6();
00101             break;
00102         case 3:
00103             smallSquare2();
00104             smallSquare3();
00105             smallSquare7();
00106             break;
00107         case 4:
00108             smallSquare0();
00109             smallSquare4();
00110             smallSquare5();
00111             smallSquare8();
00112             break;
00113         case 5:
00114             smallSquare1();
00115             smallSquare4();
00116             smallSquare5();
00117             smallSquare6();
00118             smallSquare9();
00119             break;
00120         case 6:
00121             smallSquare2();
00122             smallSquare5();
00123             smallSquare6();
00124             smallSquare7();
00125             smallSquare10();
00126             break;
00127         case 7:
00128             smallSquare3();
00129             smallSquare6();
00130             smallSquare7();
00131             smallSquare11();
00132             break;
00133         case 8:
00134             smallSquare4();
00135             smallSquare8();
00136             smallSquare9();
00137             smallSquare12();
00138             break;
00139         case 9:
00140             smallSquare5();
00141             smallSquare8();
00142             smallSquare9();
00143             smallSquare10();
00144             smallSquare13();
00145             break;
00146         case 10:
00147             smallSquare6();
00148             smallSquare9();
00149             smallSquare10();
00150             smallSquare11();
00151             smallSquare14();
00152             break;
00153         case 11:
00154             smallSquare7();
00155             smallSquare10();
00156             smallSquare11();
00157             smallSquare15();
00158             break;
00159         case 12:
00160             smallSquare8();
00161             smallSquare12();
00162             smallSquare13();
00163             break;
00164         case 13:
00165             smallSquare9();
00166             smallSquare12();
00167             smallSquare13();
00168             smallSquare14();
00169             break;
00170         case 14:
00171             smallSquare10();
00172             smallSquare13();
00173             smallSquare14();
00174             smallSquare15();
00175             break;
00176         case 15:
00177             smallSquare11();
00178             smallSquare14();
00179             smallSquare15();
00180             break;
00181         default:
00182             break;
00183     }
00184     score++;
00185     for(i = 0; i < 16; i++){
00186         if(smallSquares[i] == true)
00187             j++;
00188     }
00189     if(j == 16){
00190         win = true;
00191     }
00192 }
00193 
00194 void Tile::TilePatternSetup(){
00195     if(number_of_tiles == true){ // 3x3
00196         square0();
00197         square1();
00198         square2();
00199         square3();
00200         square4();
00201         square5();
00202         square6();
00203         square7();
00204         square8();
00205     }
00206     if(number_of_tiles == false){ // 4x4
00207         smallSquare0();
00208         smallSquare1();
00209         smallSquare2();
00210         smallSquare3();
00211         smallSquare4();
00212         smallSquare5();
00213         smallSquare6();
00214         smallSquare7();
00215         smallSquare8();
00216         smallSquare9();
00217         smallSquare10();
00218         smallSquare11();
00219         smallSquare12();
00220         smallSquare13();
00221         smallSquare14();
00222         smallSquare15();
00223     }
00224     setup = true;
00225 }
00226 
00227 void Tile::setNumberOfTiles(bool size){
00228     number_of_tiles = size;
00229 }
00230 
00231 int Tile::getScore(){
00232     return(score);
00233 }
00234 
00235 void Tile::resetScore(){
00236     score = 0;
00237 }
00238 
00239 void Tile::reset(){
00240     resetScore();
00241     win = false;
00242     setup = false;
00243     TilePatternSetup();
00244 }
00245 
00246 void Tile::pause(){
00247     int i = 0;
00248     if(number_of_tiles == true){    // 3x3
00249         for(i = 0; i < 9; i++)
00250             squares[i] = !squares[i];
00251     }
00252     else{
00253         for(i = 0; i < 16; i++)
00254             smallSquares[i] = !smallSquares[i];
00255     }
00256 }
00257 
00258 void Tile::unpause(){
00259     if(number_of_tiles == true){
00260         square0();
00261         square1();
00262         square2();
00263         square3();
00264         square4();
00265         square5();
00266         square6();
00267         square7();
00268         square8();
00269     }
00270     else{
00271         smallSquare0();
00272         smallSquare1();
00273         smallSquare2();
00274         smallSquare3();
00275         smallSquare4();
00276         smallSquare5();
00277         smallSquare6();
00278         smallSquare7();
00279         smallSquare8();
00280         smallSquare9();
00281         smallSquare10();
00282         smallSquare11();
00283         smallSquare12();
00284         smallSquare13();
00285         smallSquare14();
00286         smallSquare15();
00287     }
00288 }
00289 
00290 bool Tile::drawCursor(int position){
00291     if(number_of_tiles == true)
00292         return(squares[position]);
00293     else
00294         return(smallSquares[position]);
00295 } //return false for red, true for green
00296 
00297 // *************************************** //
00298 //              3x3 SQUARES
00299 // *************************************** //
00300 
00301 // SQUARE 0
00302 void Tile::square0(){
00303     switch(setup){
00304         case false:
00305             LCD_ptr->filled_rectangle(87, 0, 127, 41, TILE_OFF);
00306             squares[0] = false;
00307             break;
00308         case true:
00309             squares[0] = !squares[0];
00310             if(squares[0] == true)
00311                 LCD_ptr->filled_rectangle(87, 0, 127, 41, TILE_ON);
00312             else
00313                 LCD_ptr->filled_rectangle(87, 0, 127, 41, TILE_OFF);
00314             break;
00315     }
00316 }
00317 
00318 // SQUARE 1
00319 void Tile::square1(){
00320     switch(setup){
00321         case false:
00322             LCD_ptr->filled_rectangle(87, 44, 127, 85, TILE_OFF);
00323             squares[1] = false;
00324             break;
00325         case true:
00326             squares[1] = !squares[1];
00327             if(squares[1] == true)
00328                 LCD_ptr->filled_rectangle(87, 44, 127, 85, TILE_ON);
00329             else
00330                 LCD_ptr->filled_rectangle(87, 44, 127, 85, TILE_OFF);
00331             break;
00332     }
00333 }
00334 
00335 //SQUARE 2
00336 void Tile::square2(){
00337     switch(setup){
00338         case false:
00339             LCD_ptr->filled_rectangle(87, 88, 127, 127, TILE_OFF);
00340             squares[2] = false;
00341             break;
00342         case true:
00343             squares[2] = !squares[2];
00344             if(squares[2] == true)
00345                 LCD_ptr->filled_rectangle(87, 88, 127, 127, TILE_ON);
00346             else
00347                 LCD_ptr->filled_rectangle(87, 88, 127, 127, TILE_OFF);
00348             break;
00349     }
00350 }
00351 
00352 // SQUARE 3
00353 void Tile::square3(){
00354     switch(setup){
00355         case false:
00356             LCD_ptr->filled_rectangle(44, 0, 85, 41, TILE_OFF);
00357             squares[3] = false;
00358             break;
00359         case true:
00360             squares[3] = !squares[3];
00361             if(squares[3] == true)
00362                 LCD_ptr->filled_rectangle(44, 0, 85, 41, TILE_ON);
00363             else
00364                 LCD_ptr->filled_rectangle(44, 0, 85, 41, TILE_OFF);
00365             break;
00366     }
00367 }
00368 
00369 // SQUARE 4
00370 void Tile::square4(){
00371     switch(setup){
00372         case false:
00373             LCD_ptr->filled_rectangle(44, 44, 85, 85, TILE_OFF);
00374             squares[4] = false;
00375             break;
00376         case true:
00377             squares[4] = !squares[4];
00378             if(squares[4] == true)
00379                 LCD_ptr->filled_rectangle(44, 44, 85, 85, TILE_ON);
00380             else
00381                 LCD_ptr->filled_rectangle(44, 44, 85, 85, TILE_OFF);
00382             break;
00383     }
00384 }
00385 
00386 // SQUARE 5
00387 void Tile::square5(){
00388     switch(setup){
00389         case false:
00390             LCD_ptr->filled_rectangle(44, 88, 85, 127, TILE_OFF);
00391             squares[5] = false;
00392             break;
00393         case true:
00394             squares[5] = !squares[5];
00395             if(squares[5] == true)
00396                 LCD_ptr->filled_rectangle(44, 88, 85, 127, TILE_ON);
00397             else
00398                 LCD_ptr->filled_rectangle(44, 88, 85, 127, TILE_OFF);
00399             break;
00400     }
00401 }
00402 
00403 // SQUARE 6
00404 void Tile::square6(){
00405     switch(setup){
00406         case false:
00407             LCD_ptr->filled_rectangle(0, 0, 41, 41, TILE_OFF);
00408             squares[6] = false;
00409             break;
00410         case true:
00411             squares[6] = !squares[6];
00412             if(squares[6] == true)
00413                 LCD_ptr->filled_rectangle(0, 0, 41, 41, TILE_ON);
00414             else
00415                 LCD_ptr->filled_rectangle(0, 0, 41, 41, TILE_OFF);
00416             break;
00417     }
00418 }
00419 
00420 // SQUARE 7
00421 void Tile::square7(){
00422     switch(setup){
00423         case false:
00424             LCD_ptr->filled_rectangle(0, 44, 41, 85, TILE_OFF);
00425             squares[7] = false;
00426             break;
00427         case true:
00428             squares[7] = !squares[7];
00429             if(squares[7] == true)
00430                 LCD_ptr->filled_rectangle(0, 44, 41, 85, TILE_ON);
00431             else
00432                 LCD_ptr->filled_rectangle(0, 44, 41, 85, TILE_OFF);
00433             break;
00434     }
00435 }
00436 
00437 // SQUARE 8
00438 void Tile::square8(){
00439     switch(setup){
00440         case false:
00441             LCD_ptr->filled_rectangle(0, 88, 41, 127, TILE_OFF);
00442             squares[8] = false;
00443             break;
00444         case true:
00445             squares[8] = !squares[8];
00446             if(squares[8] == true)
00447                 LCD_ptr->filled_rectangle(0, 88, 41, 127, TILE_ON);
00448             else
00449                 LCD_ptr->filled_rectangle(0, 88, 41, 127, TILE_OFF);
00450             break;
00451     }
00452 }
00453 
00454 
00455 // *************************************** //
00456 //              4x4 SQUARES
00457 // *************************************** //
00458 
00459 // SQUARE 0
00460 void Tile::smallSquare0(){
00461     switch(setup){
00462         case false:
00463             LCD_ptr->filled_rectangle(96, 0, 126, 29, TILE_OFF);
00464             smallSquares[0] = false;
00465             break;
00466         case true:
00467             smallSquares[0] = !smallSquares[0];
00468             if(smallSquares[0] == true)
00469                 LCD_ptr->filled_rectangle(96, 0, 126, 29, TILE_ON);
00470             else
00471                 LCD_ptr->filled_rectangle(96, 0, 126, 29, TILE_OFF);
00472             break;
00473     }
00474 }
00475 
00476 // SQUARE 1
00477 void Tile::smallSquare1(){
00478     switch(setup){
00479         case false:
00480             LCD_ptr->filled_rectangle(96, 32, 126, 61, TILE_OFF);
00481             smallSquares[1] = false;
00482             break;
00483         case true:
00484             smallSquares[1] = !smallSquares[1];
00485             if(smallSquares[1] == true)
00486                 LCD_ptr->filled_rectangle(96, 32, 126, 61, TILE_ON);
00487             else
00488                 LCD_ptr->filled_rectangle(96, 32, 126, 61, TILE_OFF);
00489             break;
00490     }
00491 }
00492 
00493 // SQUARE 2
00494 void Tile::smallSquare2(){
00495     switch(setup){
00496         case false:
00497             LCD_ptr->filled_rectangle(96, 64, 126, 93, TILE_OFF);
00498             smallSquares[2] = false;
00499             break;
00500         case true:
00501             smallSquares[2] = !smallSquares[2];
00502             if(smallSquares[2] == true)
00503                 LCD_ptr->filled_rectangle(96, 64, 126, 93, TILE_ON);
00504             else
00505                 LCD_ptr->filled_rectangle(96, 64, 126, 93, TILE_OFF);
00506             break;
00507     }
00508 }
00509 
00510 // SQUARE 3
00511 void Tile::smallSquare3(){
00512     switch(setup){
00513         case false:
00514             LCD_ptr->filled_rectangle(96, 96, 126, 126, TILE_OFF);
00515             smallSquares[3] = false;
00516             break;
00517         case true:
00518             smallSquares[3] = !smallSquares[3];
00519             if(smallSquares[3] == true)
00520                 LCD_ptr->filled_rectangle(96, 96, 126, 126, TILE_ON);
00521             else
00522                 LCD_ptr->filled_rectangle(96, 96, 126, 126, TILE_OFF);
00523             break;
00524     }
00525 }
00526 
00527 // SQUARE 4
00528 void Tile::smallSquare4(){
00529     switch(setup){
00530         case false:
00531             LCD_ptr->filled_rectangle(64, 0, 93, 29, TILE_OFF);
00532             smallSquares[4] = false;
00533             break;
00534         case true:
00535             smallSquares[4] = !smallSquares[4];
00536             if(smallSquares[4] == true)
00537                 LCD_ptr->filled_rectangle(64, 0, 93, 29, TILE_ON);
00538             else
00539                 LCD_ptr->filled_rectangle(64, 0, 93, 29, TILE_OFF);
00540             break;
00541     }
00542 }
00543 
00544 // SQUARE 5
00545 void Tile::smallSquare5(){
00546     switch(setup){
00547         case false:
00548             LCD_ptr->filled_rectangle(64, 32, 93, 61, TILE_OFF);
00549             smallSquares[5] = false;
00550             break;
00551         case true:
00552             smallSquares[5] = !smallSquares[5];
00553             if(smallSquares[5] == true)
00554                 LCD_ptr->filled_rectangle(64, 32, 93, 61, TILE_ON);
00555             else
00556                 LCD_ptr->filled_rectangle(64, 32, 93, 61, TILE_OFF);
00557             break;
00558     }
00559 }
00560 
00561 // SQUARE 6
00562 void Tile::smallSquare6(){
00563     switch(setup){
00564         case false:
00565             LCD_ptr->filled_rectangle(64, 64, 93, 93, TILE_OFF);
00566             smallSquares[6] = false;
00567             break;
00568         case true:
00569             smallSquares[6] = !smallSquares[6];
00570             if(smallSquares[6] == true)
00571                 LCD_ptr->filled_rectangle(64, 64, 93, 93, TILE_ON);
00572             else
00573                 LCD_ptr->filled_rectangle(64, 64, 93, 93, TILE_OFF);
00574             break;
00575     }
00576 }
00577 
00578 // SQUARE 7
00579 void Tile::smallSquare7(){
00580     switch(setup){
00581         case false:
00582             LCD_ptr->filled_rectangle(64, 96, 93, 126, TILE_OFF);
00583             smallSquares[7] = false;
00584             break;
00585         case true:
00586             smallSquares[7] = !smallSquares[7];
00587             if(smallSquares[7] == true)
00588                 LCD_ptr->filled_rectangle(64, 96, 93, 126, TILE_ON);
00589             else
00590                 LCD_ptr->filled_rectangle(64, 96, 93, 126, TILE_OFF);
00591             break;
00592     }
00593 }
00594 
00595 // SQUARE 8
00596 void Tile::smallSquare8(){
00597     switch(setup){
00598         case false:
00599             LCD_ptr->filled_rectangle(32, 0, 61, 29, TILE_OFF);
00600             smallSquares[8] = false;
00601             break;
00602         case true:
00603             smallSquares[8] = !smallSquares[8];
00604             if(smallSquares[8] == true)
00605                 LCD_ptr->filled_rectangle(32, 0, 61, 29, TILE_ON);
00606             else
00607                 LCD_ptr->filled_rectangle(32, 0, 61, 29, TILE_OFF);
00608             break;
00609     }
00610 }
00611 
00612 // SQUARE 9
00613 void Tile::smallSquare9(){
00614     switch(setup){
00615         case false:
00616             LCD_ptr->filled_rectangle(32, 32, 61, 61, TILE_OFF);
00617             smallSquares[9] = false;
00618             break;
00619         case true:
00620             smallSquares[9] = !smallSquares[9];
00621             if(smallSquares[9] == true)
00622                 LCD_ptr->filled_rectangle(32, 32, 61, 61, TILE_ON);
00623             else
00624                 LCD_ptr->filled_rectangle(32, 32, 61, 61, TILE_OFF);
00625             break;
00626     }
00627 }
00628 
00629 // SQUARE 10
00630 void Tile::smallSquare10(){
00631     switch(setup){
00632         case false:
00633             LCD_ptr->filled_rectangle(32, 64, 61, 93, TILE_OFF);
00634             smallSquares[10] = false;
00635             break;
00636         case true:
00637             smallSquares[10] = !smallSquares[10];
00638             if(smallSquares[10] == true)
00639                 LCD_ptr->filled_rectangle(32, 64, 61, 93, TILE_ON);
00640             else
00641                 LCD_ptr->filled_rectangle(32, 64, 61, 93, TILE_OFF);
00642             break;
00643     }
00644 }
00645 
00646 // SQUARE 11
00647 void Tile::smallSquare11(){
00648     switch(setup){
00649         case false:
00650             LCD_ptr->filled_rectangle(32, 96, 61, 126, TILE_OFF);
00651             smallSquares[11] = false;
00652             break;
00653         case true:
00654             smallSquares[11] = !smallSquares[11];
00655             if(smallSquares[11] == true)
00656                 LCD_ptr->filled_rectangle(32, 96, 61, 126, TILE_ON);
00657             else
00658                 LCD_ptr->filled_rectangle(32, 96, 61, 126, TILE_OFF);
00659             break;
00660     }
00661 }
00662 
00663 // SQUARE 12
00664 void Tile::smallSquare12(){
00665     switch(setup){
00666         case false:
00667             LCD_ptr->filled_rectangle(0, 0, 29, 29, TILE_OFF);
00668             smallSquares[12] = false;
00669             break;
00670         case true:
00671             smallSquares[12] = !smallSquares[12];
00672             if(smallSquares[12] == true)
00673                 LCD_ptr->filled_rectangle(0, 0, 29, 29, TILE_ON);
00674             else
00675                 LCD_ptr->filled_rectangle(0, 0, 29, 29, TILE_OFF);
00676             break;
00677     }
00678 }
00679 
00680 // SQUARE 13
00681 void Tile::smallSquare13(){
00682     switch(setup){
00683         case false:
00684             LCD_ptr->filled_rectangle(0, 32, 29, 61, TILE_OFF);
00685             smallSquares[13] = false;
00686             break;
00687         case true:
00688             smallSquares[13] = !smallSquares[13];
00689             if(smallSquares[13] == true)
00690                 LCD_ptr->filled_rectangle(0, 32, 29, 61, TILE_ON);
00691             else
00692                 LCD_ptr->filled_rectangle(0, 32, 29, 61, TILE_OFF);
00693             break;
00694     }
00695 }
00696 
00697 // SQUARE 14
00698 void Tile::smallSquare14(){
00699     switch(setup){
00700         case false:
00701             LCD_ptr->filled_rectangle(0, 64, 29, 93, TILE_OFF);
00702             smallSquares[14] = false;
00703             break;
00704         case true:
00705             smallSquares[14] = !smallSquares[14];
00706             if(smallSquares[14] == true)
00707                 LCD_ptr->filled_rectangle(0, 64, 29, 93, TILE_ON);
00708             else
00709                 LCD_ptr->filled_rectangle(0, 64, 29, 93, TILE_OFF);
00710             break;
00711     }
00712 }
00713 
00714 // SQUARE 15
00715 void Tile::smallSquare15(){
00716     switch(setup){
00717         case false:
00718             LCD_ptr->filled_rectangle(0, 96, 29, 126, TILE_OFF);
00719             smallSquares[15] = false;
00720             break;
00721         case true:
00722             smallSquares[15] = !smallSquares[15];
00723             if(smallSquares[15] == true)
00724                 LCD_ptr->filled_rectangle(0, 96, 29, 126, TILE_ON);
00725             else
00726                 LCD_ptr->filled_rectangle(0, 96, 29, 126, TILE_OFF);
00727             break;
00728     }
00729 }