ELEC2645 (2017/18) / Mbed 2 deprecated ll13jrm

Dependencies:   mbed

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers Snake.cpp Source File

Snake.cpp

00001 #include "Snake.h"
00002 
00003 ///////////////// constructor/destructor /////////////////
00004 
00005 Snake::Snake()
00006 {
00007 
00008 }
00009 
00010 Snake::~Snake()
00011 {
00012 
00013 }
00014 
00015 ///////////////// public methods /////////////////
00016 
00017 void Snake::init(Direction in,Direction cur, int pos_x, int pos_y)
00018 {
00019     
00020     _pos.x = pos_x;
00021     _pos.y = pos_y;
00022     set_snake_direction(in, cur);
00023     
00024 }
00025 
00026 void Snake::update(Direction in, Direction cur) 
00027 {
00028     set_current_direction(in);
00029     cur = get_current_direction();
00030     set_snake_direction(in, cur);
00031     Direction next = get_snake_direction();
00032     set_snake_position(next);
00033     
00034 }
00035 
00036 void Snake::draw(N5110 &lcd)
00037 {
00038     
00039     lcd.setPixel(_pos.x,_pos.y,true);
00040     
00041 }
00042 
00043 void Snake::set_snake_direction(Direction input, Direction current)
00044 {
00045       
00046     switch(current) {
00047        
00048         case CENTRE:
00049         
00050                 set_centre(input, current);
00051                 
00052                 break;
00053                 
00054         case N:
00055         
00056                 set_north(input, current);
00057                  
00058                 break;
00059                 
00060         case E:
00061         
00062                 set_east(input, current);
00063                 
00064                 break;
00065                 
00066         case S:
00067             
00068                 set_south(input, current);
00069                 
00070                 break;
00071                 
00072         case W:
00073         
00074                 set_west(input, current);
00075                 
00076                 break;
00077                 
00078         default:
00079                 
00080                 
00081                 //set_centre(input, current);
00082                 //error("Invalid state (current)");
00083                 
00084                 break;
00085 
00086             }
00087             
00088                                 
00089 }
00090 
00091 Direction Snake::get_snake_direction()
00092 {
00093     
00094     Direction d = _next;
00095     
00096     return d;
00097     
00098 }
00099 
00100 void Snake::set_centre(Direction input, Direction current)
00101 {
00102       switch(input) {
00103                 
00104                 case CENTRE:
00105                 
00106                 // cannnot be CENTRE
00107                 
00108                 _next = current;
00109                 
00110                 break;
00111                 
00112                 case N:
00113                 
00114                 _next = input;
00115                 
00116                 break;
00117                 
00118                 case E:
00119                 
00120                 _next = input;
00121                 
00122                 break;
00123                 
00124                 case S:
00125                 
00126                 _next = input;
00127                 
00128                 break;
00129                 
00130                 case W:
00131                 
00132                 _next = input;
00133                 
00134                 break;
00135                 
00136                 default:
00137                 
00138                 _next = current;
00139                 
00140                 break;
00141                 
00142                 }
00143                 
00144 }  
00145 void Snake::set_north(Direction input, Direction current)
00146 {
00147     switch(input) {
00148             
00149                 case CENTRE:
00150                 
00151                 _next = N;
00152                 
00153                 break;
00154                 
00155                 case N:
00156                 
00157                 _next = N;
00158                 
00159                 break;
00160                 
00161                 case E:
00162                 
00163                 _next = E;
00164                 
00165                 break;
00166                 
00167                 case S:
00168                 
00169                 // cannot be S
00170                 
00171                 _next = N;
00172                 
00173                 break;
00174                 
00175                 case W:
00176                 
00177                 _next = W;
00178                 
00179                 break;
00180                 
00181                 default:
00182                 
00183                 _next = current;
00184                                 
00185                 break;
00186                 
00187                 }
00188 }
00189 void Snake::set_east(Direction input, Direction current)
00190 {
00191     
00192     switch(input) {
00193             
00194                 case CENTRE:
00195                 
00196                 _next = E;
00197                 
00198                 break;
00199                 
00200                 case N:
00201                 
00202                 _next = N;
00203                 
00204                 break;
00205                 
00206                 case E:
00207                 
00208                 _next = E;
00209                 
00210                 break;
00211                 
00212                 case S:
00213                 
00214                 _next = S;
00215                 
00216                 break;
00217                 
00218                 case W:
00219                 
00220                 // cannot be W
00221                 
00222                 _next = E;
00223                 
00224                 break;
00225                 
00226                 default:
00227                 
00228                 _next = current;
00229                 
00230                 break;
00231                 
00232                 }
00233             
00234     
00235 }
00236 void Snake::set_south(Direction input, Direction current)
00237 {
00238     switch(input) {
00239             
00240                 case CENTRE:
00241                 
00242                 _next = S;
00243                 
00244                 break;
00245                 
00246                 case N:
00247                 
00248                 // cannot be N
00249                 
00250                 _next = S;
00251                 
00252                 break;
00253                 
00254                 case E:
00255                 
00256                 _next = E;
00257                 
00258                 break;
00259                 
00260                 case S:
00261                 
00262                 _next = S;
00263                 
00264                 break;
00265                 
00266                 case W:
00267                 
00268                 _next = W;
00269                 
00270                 break;
00271                 
00272                 default:
00273                 
00274                 _next = current;
00275                                 
00276                 break;
00277                 
00278                 }
00279                 
00280             
00281 }
00282 void Snake::set_west(Direction input, Direction current)
00283 {
00284     switch(input) {
00285             
00286                 case CENTRE:
00287                 
00288                 _next = W;
00289                 
00290                 break;
00291                 
00292                 case N:
00293                 
00294                 _next = N;
00295                 
00296                 break;
00297                 
00298                 case E:
00299                 
00300                 // cannot be E
00301                 
00302                 _next = W;
00303                 
00304                 break;
00305                 
00306                 case S:
00307                 
00308                 _next = S;
00309                 
00310                 break;
00311                 
00312                 case W:
00313                 
00314                 _next = W;
00315                 
00316                 break;
00317                 
00318                 default:
00319                 
00320                 _next = current;
00321                 
00322                 break;
00323                 
00324                 }
00325                 
00326 }
00327 
00328 
00329 void Snake::set_current_direction(Direction input)
00330 {
00331     
00332     // if true the direction cannot be CENTRE
00333     
00334     if(get_snake_direction() == CENTRE && input == CENTRE) {
00335         
00336     _d = _d;
00337     
00338     }
00339     
00340     
00341     else {
00342         
00343         _d = get_snake_direction();
00344         
00345         }
00346     
00347     _current = _d;
00348 
00349 }
00350 
00351 Direction Snake::get_current_direction()
00352 {
00353     
00354     Direction d = _current;
00355     
00356     return d;
00357     
00358 }
00359 
00360 void Snake::set_snake_position(Direction next)
00361 {
00362     next = get_snake_direction();
00363     
00364     switch(next) {
00365         
00366             case N:
00367             
00368             // y increments (inverted due to N5110 class) x is static
00369         
00370             _pos.x = _pos.x;
00371             --_pos.y;
00372         
00373             break;
00374         
00375             case E:
00376             
00377             // x increments y is static
00378             
00379             ++_pos.x;
00380             _pos.y = _pos.y;
00381         
00382             break;
00383         
00384             case S:
00385             
00386             // y decrements x is static
00387             
00388             _pos.x = _pos.x;
00389             ++_pos.y;
00390         
00391             break;
00392         
00393             case W:
00394             
00395             // x decrements y is static
00396             
00397             --_pos.x;
00398             _pos.y = _pos.y;
00399         
00400             break;
00401             
00402             default:
00403             
00404             _pos.x = _pos.x;
00405             _pos.y = _pos.y;
00406             
00407             break;
00408             
00409             }
00410             
00411 }
00412 
00413 Vector2D Snake::get_snake_position()
00414 {
00415     
00416     Vector2D pos = _pos;
00417     
00418     return pos; 
00419     
00420 }
00421 
00422  
00423  // FSM Attempt
00424  
00425  /* 
00426     int state = N;
00427      
00428     StateDirection fsm[4] = {
00429         
00430     {N,{N,E,N,W}},  
00431     {E,{N,E,S,E}},  
00432     {S,{S,E,S,W}}, 
00433     {W,{N,W,S,W}} 
00434      
00435 };
00436 
00437     _direction = fsm[state].output;  // set ouput depending on current state
00438     state = fsm[state].nextState[input];  // read input and update curent state
00439       */
00440         
00441 
00442