//********************************************************
//* Project Name: helicopter
//* Date: July 28, 2017
//* Author: Dr. Meier
//* Provides: a simple helicopter game for kids
//* 
//* Requirements
//* - present welcome message
//* - play welcome music
//* - move helicopter to row 0 when up button pressed
//* - move helicopter to row 1 when down button pressed
//* - play helicopter propeller sound while flying
//* - play crash music when helicopter crashes
//* - keep track of user score and high score
//* - offers three lives 
//
//* How to Use
//* - attach speaker right between A1 and just left of VIN
//* - apply usb power
//* - use up/dn button to fly helicopter through maze
//* - press rst button at game over to start again
//********************************************************

// include lcd subroutine library
#include <LiquidCrystal.h>

// bring lcd panel object to life
// - objects are data types that include subroutines 
// - research object-oriented programming for more info
// - Discover LCD attaches to computer pins 8,9,4,5,6,7
// - object constructor needs pin numbers
LiquidCrystal lcd(8,9,4,5,6,7);

// declare other global variables used in the game
// - global variables are visible to all subroutines
// 
// - length = brick maze length
// - up = pin A0 voltage range when up button pressed
// - down = pin A0 voltage range when dn button pressed
// - track = brick maze icon matrix sized to length
// - left = left end of 16 brick icon window on lcd screen
const int length=500; const int up=100;
const int down=300;
int track[length];
int left=0;

// create helicopter icons as custom LCD characters
// - LCD characters are 5 dots wide
// - LCD characters are 7 dots tall
// - LCD character definition uses 1 = pixel on
// - LCD character definition uses 0 = pixel off
// - define first icon: blade horizontal
// - define second icon: blade coming out of LCD
// - define third icon: blade crashed down on cockpit
// - each definition is a collection {} of bytes
// - B = binary number
// - each binary number represents a character row
byte helicopter0[8]={
  B11111,
  B00100,
  B11110,
  B10001,
  B11110,
  B10000,
  B11111,
};

byte helicopter1[8]={
  B00100,
  B00100,
  B11110,
  B10001,
  B11110,
  B10000,
  B11111,
};

byte helicopter2[8]={
  B10001,
  B01110,
  B11110,
  B11111,
  B11110,
  B10000,
  B11111,
};

// Arduino mandatory setup function - runs once at reset
// - setup game environment: make brick maze
// - setup lcd panel: size, custom characters
// - display welcome message
// - play welcome music
// - display instructions 
// - clear LCD panel to enter operational mode
void setup() 
{
  createTrack();
  lcd.createChar(0,helicopter0);
  lcd.createChar(1,helicopter1);
  lcd.createChar(2,helicopter2);
  lcd.begin(16,2);
  welcomeMessage();
  welcomeMusic();
  instructions();  
  welcomeFlight();
  lcd.clear();
}

// Arduino mandatory loop function - runs after setup
// and runs continuously until Arduino is reset again
// 
// local variables
// - int heli: row helicopter icon prints on: 0 or 1
// - int icon: blade position icon to print: 0 or 1
// - int button: user button press voltage from pin A0
// - int brickColumn: brick maze column being displayed
// 
// control algorithm 
// - do while user hasn't flown through entire maze
// - 
// -   *** Handle Button Press and Helicopter Icon ***
// -   clear LCD panel
// -   read user button press
// -   if up button 
// -     clear icon from bottom row with blank space
// -     adjust heli position variable to row 0
// -   else if down button
// -     clear icon from top row with blank space
// -     adjust heli position variable to row 1
// -   print helicopter at heli position variable row
// -   (print icon uses divide-by-2 remainder)
// -   increment icon variable to prepare next icon
// - 
// -   *** Draw Track Onto Screen ***
// -   for each column of maze to be displayed
// -     check maze to determine which row for brick
// -     draw brick at brickColumn and appropriate row
// -
// -   ** Check for Helicopter Collision ***
// -   if heli row=brick row of left end of maze window
// -     draw crash icon
// -     make crash music
// -     display game over message
// -     enter infinite loop forcing press of reset
// -   else
// -    delay one quarter second for scroll speed    
// -    adjust left end of window to be displayed next
     
void loop() {
  int heli=0;
  int icon=0;
  int button;
  int brickColumn=0;
  int life=3;
  int best=0;

  do
  {
    // handle button press and helicopter icon draw
    lcd.clear();
    button=analogRead(A0);
    if(button>up && button<down)
    {
      lcd.setCursor(0,1);
      lcd.print(" ");
      heli=0;
    }
    else if(button>down && button<1000)
    {
      lcd.setCursor(0,0);
      lcd.print(" ");
      heli=1;
    }
    lcd.setCursor(0,heli);
    lcd.write(byte(icon%2));
    if((icon%2)==0) tone(A1,17);
    else tone(A1,19);
    icon=icon+1;

    // draw track on screen
    brickColumn=0;
    for(int i=left; i<left+16; i++)
    {
      if(track[i]==0)
      {
        lcd.setCursor(brickColumn,0);
        lcd.print(char(255));
      }
      else if(track[i]==1)
      {
        lcd.setCursor(brickColumn,1);
        lcd.print(char(255));
      }
      else lcd.print(" ");
      brickColumn++;
    }

    // check collision
    if(heli==track[left])
    {
      lcd.setCursor(0,heli);
      lcd.write(byte(2));
      siren();
      delay(1000);
      lcd.clear();
      if(best<left) best=left;
      life=life-1;
      lcd.setCursor(4,0);
      if(life==0) {
        lcd.print("Game Over");
        lcd.setCursor(1,1);
        lcd.print("High Score: ");
        lcd.print(best);
        delay(5000);
        lcd.clear();
        lcd.setCursor(4,0);
        lcd.print("Push RST");
        lcd.setCursor(1,1);
        lcd.print("To Play Again!");
        while(1);
      }
      else {
        lcd.print("Try Again!");
        lcd.setCursor(4,1);
        lcd.print("Score: ");
        lcd.print(left);
        delay(3000);
        left=0;
      }
        
    }

    // adjust brick maze window left end
    delay(250);
    left=left+1;
  } while(left<(length-15));

 // user beat game
 // display winning message
 // replay theme song
 // ask user to push reset to start over
 lcd.clear();
 lcd.setCursor(4,0);
 lcd.print("You Win!");
 lcd.setCursor(1,1);
 lcd.print("High Score: ");
 lcd.print(left);
 welcomeMusic();
 lcd.clear();
 lcd.setCursor(4,0);
 lcd.print("Push RST");
 lcd.setCursor(1,1);
 lcd.print("To Play Again!");
 // wait forever. do not allow loop
 // to run again automatically
 // force push of reset
 while(1); 
}

// ***********************************************
// my subroutines
// ***********************************************

// subroutine: welcomeMessage
// local variables:
// - none
// algorithm:
// - print game name to lcd panel
void welcomeMessage()
{
  lcd.setCursor(3,0);
  lcd.print("Helicopter");
}

// subroutine: welcomeMusic
// local variables:
// - frequencies: a collection of music note frequencies
// - durations: a collection of music note durations
// - note: a counter variable to move through the notes
// algorithm:
// - do
// -  if not a musical rest then play tone
// -  delay appropriate note length
// -  turn off any tone being played
// -  increment to next note
// - while note is less than collection size
//
// - Chosen Music: Airwolf TV Program Theme Song
// -               Airwolf was about a military 
// -               helicopter team. Wiki search it!
void welcomeMusic()
{
  int frequencies[43]={233,311,349,415,466,554,523,415,
                       466,554,523,415,466,415,523,394,
                       311,277,311,262,208, // french horns
                      
                       277,370,415,494,554,740,698,494,
                       554,740,698,494,554,494,622,415,
                       370,349,415,311,247,277 // trumpets
                      };
  int durations[43]={2,1,1,1,2,1,1,1,2,1,1,1,2,2,1,2,2,2,1,2,1,
                     2,1,1,1,2,1,1,1,2,1,1,1,2,2,1,2,2,2,1,2,1,2};  
  int note=0;
 
  do
  {
    tone(A1,frequencies[note]);
    delay(durations[note]*150);
    noTone(A1);
    note=note+1;
  }while(note<43);
}

// subroutine: welcomeFlight
// local variables:
// - columns: column of the LCD to print helicopter
// algorithm:
// - do
// -   draw helicopter on screen at column
// -   use remainder of column/2 to choose icon
// -   use remainder of column/2 to choose blade tone
// -   play blade tone
// -   delay a bit
// -   turn tone off
// -   increment column
// - while column is less than lcd size
void welcomeFlight()
{
  int column=0;
  do
  {
    lcd.setCursor(column,1);
    lcd.write(byte(column%2));
    if((column%2)==0) tone(A1,17);
    else tone(A1,19);
    delay(250);
    noTone(A1);
    lcd.setCursor(column,1);
    lcd.print(" ");
    column=column+1;
  }while(column<16);
}

// subroutine: instructions
// local variables:
// - none
// algorithm:
// - adjust lcd cursor to row 1
// - clear bottom row -- leaves game name on row 0
// - print first line of instructions
// - delay 3 seconds for user to read 
// - adjust lcd cursor back to row 1
// - print second line of instructions
// - delay 3 seconds for user to read
// - clear bottom row
void instructions()
{
  lcd.setCursor(0,1);
  lcd.print("Use Up/Dn to Fly");
  delay(3000);
  lcd.setCursor(0,1);
  lcd.print("Avoid the Bricks");
  delay(3000);
  lcd.setCursor(0,1);
  lcd.print("                ");
}

// subroutine: createTrack
// local variables:
// - column: a counter variable for lcd column
// - row: the current row being filled
// - n: a random number of bricks to fill on a row
// 
// algorithm:
// - seed the random number generator with pin A5 noise
// - (assumes nothing attached to pin A5)
// - 
// - *** Game Start Maze Fill ***
// - uses do-while to blank first 16 columns
// - (maze fills with 0=brick on row 0, 1=row1, 2=space)
// - 
// - *** Fill Rest of Maze ***
// - do 
// -   get random number n of bricks
// -   while n > 0
// -     set track at current column to row number
// -     decrement n toward 0 as bricks are added
// -     increment column toward end of maze 
// -   switch rows using if-else
// -   insert blank to fly through as rows switch
// - while column is less than maze length
void createTrack()
{
  int column=0;
  int row=0;
  int n;
  
  randomSeed(analogRead(A5));
  
  // fill first 16 bricks with spaces
  do
  {
    track[column]=2;
    column=column+1;
  }while(column<16);

  do
  {
    // fill random n columns with bricks on row
    n=random(10);
    while(n>0)
    {
      track[column]=row;
      n=n-1;
      column=column+1;
    }

    // adjust row
    if(row==0) row=1;
    else row=0;

    // insert blank to fly through as rows switch
    track[column]=2;
    column=column+1;
  }while(column<length);
}

// subroutine: siren
// local variables:
// - frequencies: a collection of music note frequencies
// - durations: a collection of music note durations
// - note: a counter variable to move through the notes
// algorithm:
// - do
// -  if not a musical rest then play tone
// -  delay appropriate note length
// -  turn off any tone being played
// -  increment to next note
// - while note is less than collection size
void siren()
{
  int frequencies[6]={880,440,880,440,880,440};
  int durations[6]={1,1,1,1,1,1};
  int note=0;
  do
  {
    tone(A1,frequencies[note]);
    delay(durations[note]*125);
    noTone(A1);
    note=note+1;
  }while(note<6);
}