/* Bulls and Cows with Sleep v2

   David Johnson-Davies - www.technoblogy.com - 5th April 2015
   
   CC BY 4.0
   Licensed under a Creative Commons Attribution 4.0 International license: 
   http://creativecommons.org/licenses/by/4.0/
*/

#include <avr/sleep.h>
#define adc_disable()  (ADCSRA &= ~(1<<ADEN))

const long TimeToSleep = 30000; // 30 secs

// Seven-segment definitions
const int charArrayLen = 44;
char charArray[charArrayLen] = {
//  ABCDEFG  Segments
  0b1111110, // 0
  0b0110000, // 1
  0b1101101, // 2
  0b1111001, // 3
  0b0110011, // 4
  0b1011011, // 5
  0b1011111, // 6
  0b1110000, // 7
  0b1111111, // 8
  0b1111011, // 9
  0b0000000, // 10  Space
  0b0000001, // 11  Dash
  0b0110000, // 12  'I'
  0b0000000, // 13  ' '
  0b0001110, // 14  'L'
  0b1111110, // 15  'O'
  0b1011011, // 16  'S'
  0b1001111, // 17  'E'
  0b0110111, // 18  'H'
  0b1111110, // 19  'O'
  0b0000001, // 20  '-'
  0b0110111, // 21  'H'
  0b1111110, // 22  'O'
  0b0000000, // 23  ' '
  0b1001111, // 24  'E'
  0b0000101, // 25  'r'
  0b0000101, // 26  'r'
  0b0011101, // 27  'o'
  0b0000101, // 28  'r'
  0b0000000, // 29  ' '
  0b0110111, // 30  'H'
  0b1001111, // 31  'E'
  0b0001110, // 32  'L'
  0b0001110, // 33  'L'
  0b1111110, // 34  'O'
  0b0000000, // 35  ' '
  0b1011110, // 36  'G'
  0b0011101, // 37  'o'
  0b0001111, // 38  't'
  0b0000000, // 39  ' '
  0b0110000, // 40  'I'
  0b0001111, // 41  't'
  0b0010111, // 42  'h'
  0b0001101  // 43  'c'
};

const int Dash = 11;
const int Space = 10;
const int rChar = 25;
const int cChar = 43;
const int hChar = 42;
const int ILose = 12;
const int HoHo = 18;
const int Error = 24;
const int Hello = 30;
const int GotIt = 36;
const int Ndigits = 6;

volatile char Buffer[] = { Dash, Dash, Dash, Dash, Dash, Dash};
volatile char dp = 0;  // Decimal point position; one bit per digit
char digit = 0;

// Pin assignments
char Digits[] = {9, 10, 11, A4, 8, A5};
// Segments all go to port D; this specifies how they're wired up:
//                 g  f  e  d  c  b  a  dp
char Segments[] = {0, 7, 4, 3, 1, 6, 5, 2};

// Keyboard matrix
volatile char Keys[6];
char Matrix[] = {0, 1, 10, 0, 7, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0};

// Display multiplexer **********************************************

void ReorderBits() {
  char segs, newsegs;
  for (int i=0; i<charArrayLen; i++) {
    segs = charArray[i];
    newsegs = 0;
    for (int i=0; i<8; i++) {
      newsegs = newsegs | ((segs & 1)<<Segments[i]);
      segs = segs >> 1;
    }
    charArray[i]=newsegs;
  }  
}

void DisplayNextDigit() {
  char segs, row;
  pinMode(Digits[digit], INPUT);
  digitalWrite(Digits[digit], LOW);
  digit = (digit+1) % Ndigits;
  segs = charArray[Buffer[digit]];
  // Decimal points
  if ((dp & 1<<digit) != 0) segs = segs | (1<<Segments[7]);
  DDRD = 0;      // All inputs
  PORTD = ~segs; // 1 = low
  DDRD = segs;   // 1 = output
  pinMode(Digits[digit], OUTPUT);
  digitalWrite(Digits[digit], HIGH);
  // Check keyboard
  row = Matrix[PINC & 0x0F];
  if (row == 0) Keys[digit] = 0; else Keys[digit] = row + digit;
}

// Read keyboard matrix
int Key () {
  return Keys[0] + Keys[1] + Keys[2];
}

// Display a four digit decimal number
void Display (int i) {
  for (int d=3; d>=0 ; d--) {
    Buffer[d]=i % 10;
    i = i / 10;
  }
  dp = 1<<3;
}

// Display message
void ShowMessage (int message) {
  for (int d=0; d<6 ; d++) Buffer[d]=message + d;
  dp = 0;
  WaitForGo();
}

void ClearDisplay () {
  for (int d=0; d<6 ; d++) Buffer[d] = Space;
  // Show all decimal points
  dp = 0x3F;
}

// Timer interrupt - multiplexes display
ISR (TIMER1_COMPA_vect) {
  DisplayNextDigit();
}

// Handle sleep **********************************************

void Sleep () {
  // Turn off display multiplexing
  TIMSK1 &= ~(1<<OCIE1A);
  DDRD = 0;        // All segments inputs
  for (int d=0; d<6; d++) pinMode (Digits[d], INPUT);
  pinMode(9, OUTPUT);
  digitalWrite(9, HIGH);
  PCIFR = 1<<PCIF1;   // Clear any pending interrupts
  PCICR = 1<<PCIE1;   // Enable pin-change interrupt
  sleep_enable();
  sleep_cpu();
  // Continue after sleep
  digitalWrite(9, LOW);
  pinMode(9, INPUT);
  // Turn on display multiplexing
  TIMSK1 |= 1<<OCIE1A;
}

// Use PCINT1 to wake from sleep
ISR(PCINT1_vect) {
}

// Play Bulls and Cows **********************************************

// Display turn prompt
void Prompt (int i) {
  int j = (i + 1) / 10;
  if (j == 0) Buffer[4] = rChar; else Buffer[4] = j;
  Buffer[5] = (i + 1) % 10;
  dp = 1<<3;
}

// Display score - Bulls and Cows
void ShowScore (int i) {
  Buffer[4]=i / 10;
  Buffer[5]=i % 10;
}

void WaitKeyDown () {
  unsigned long time = millis();
  do {
    if ((millis()-time) > TimeToSleep) {
      Sleep();
      time = millis();
    }
  } while (Key() == 0);
}

void WaitKeyUp() {
  do ; while (Key() != 0);
}

// Read a four-digit guess or two-digit reply, display and return it
int Read (int length) {
  int key, first;
  if (length == 4) first = 0; else first = 4;
  int last = first + length;
  do {
    int d = first, result = 0;
    for (int d=first; d<last ; d++) Buffer[d]= Dash;
    // Read next key
    do {
      WaitKeyDown();
      key = Key();
      WaitKeyUp();
      // Return on *
      if (key == 10) { if (d == last) return result; }
      // Enter digit
      else if ((key <= 11) & (d < last)) {
        if (key == 11) key = 0;
        Buffer[d] = key;
        result = result*10 + key;
        d++;
      } else { if (d == first) return -1; }
    // # clears display
    } while (key != 12);
  } while (1);
}

// Wait for * key
void WaitForGo () {
  int key;
  do {
    WaitKeyDown();
    key = Key();
    WaitKeyUp();
  } while (key != 10);
}

// Calculate number of Bulls (hits) and Cows (correct misses) between two numbers
int BullCow (int a, int b) {
  int Spectrum[10];
  int cows = 0, bulls = 0;
  for (int x=0; x<10; x++) Spectrum[x] = 0;
  for (int digit=0; digit<4; digit++) {
    int digita = a % 10, digitb = b % 10;
    if (digita == digitb) bulls++;
    else {
      Spectrum[digita]++;
      if (Spectrum[digita] <= 0) cows++;
      Spectrum[digitb]--;
      if (Spectrum[digitb] >= 0) cows++;
    }
    a = a / 10; b = b / 10;
  }
  return bulls*10 + cows;
}

// Setup and main loop **********************************************

void setup() {
  ReorderBits();
  // Set up Timer1 to multiplex the display
  TCCR1A = 0<<WGM10;
  TCCR1B = 1<<WGM12 | 2<<CS10;  // Divide by 8
  OCR1A = 500;                  // Compare match at 250Hz
  TIMSK1 |= 1<<OCIE1A;          // Compare match interrupt enable
  // Set up sleep
  PCMSK1 = 1<<PCINT9;           // Enable pin-change interrupt on PCINT9
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  adc_disable(); // Doesn't use ADC
  ShowMessage(Hello);
  randomSeed(millis());
}

int MyWins = 0;
int YourWins = 0;

void loop() {
  int turn, Try, n, YourGuess;
  int Guesses[20];
  int Replies[20];
  int Mix[10];
  for (int x=0; x<10; x++) Mix[x] = x;
  for (int x=0; x<10; x++) {
    int i = random(10);
    int temp = Mix[x];
    Mix[x] = Mix[i];
    Mix[i] = temp;
  }
  // Start new game - choose a code
  int MyCode = random(10000);
  int Start = random(10000);
  turn = 0;
  Try = Start;
  int YourReply = 0;
  int Result = 0;
  do {
    // Start new turn
    if (YourReply != 40) {
      ClearDisplay();
      // On first two turns make guesses with 8 different random digits
      if (turn == 0) {
        Guesses[0] = Mix[0]*1000 + Mix[1]*100 +Mix[2]*10 + Mix[3];
      } else if (turn == 1) {
        Guesses[1] = Mix[4]*1000 + Mix[5]*100 +Mix[6]*10 + Mix[7];
      } else {
        // Find guess compatible with all your previous replies
        do {
          Try = (Try + 1) % 10000;
          Guesses[turn] = Try;
          Replies[turn] = 44;
          n=-1;
          do {
           n++;
          } while (BullCow(Try, Guesses[n]) == Replies[n]);
        } while ((n < turn) && (Try != Start));
        if (Try == Start) { 
          ShowMessage(Error);
          YourReply = 40;
        }
      }
    }
    // Prompt for your guess
    if (Result != 40) {
      Prompt(turn);
      YourGuess = Read(4);
      if (YourGuess != -1) {
        Result = BullCow(YourGuess, MyCode);
        ShowScore(Result);
        WaitForGo();
        if (Result == 40) {
          if (YourReply == 40) ShowMessage(GotIt);
          else { ShowMessage(ILose); YourWins++; }
        }
      }
    }
    // Prompt for my guess
    if ((YourReply != 40) && (YourGuess != -1)) {
      Display(Guesses[turn]);
      do { YourReply = Read(2); } while (YourReply == -1);
      Replies[turn] = YourReply;
      if (YourReply == 40) {
        if (Result == 40) ShowMessage(GotIt);
        else { ShowMessage(HoHo); MyWins++; }
      }
    }
    turn++;
  } while (((Result != 40) || (YourReply != 40)) && (YourGuess != -1));
  // Reset: display my code
  if (YourGuess == -1) {
    Display(MyCode);
    MyWins = 0; YourWins = 0;
    WaitForGo();
  } 
  // Display wins
  Buffer[0]=hChar; Buffer[1]=(YourWins/10) % 10; Buffer[2]=YourWins%10;
  Buffer[3]=cChar; Buffer[4]=(MyWins/10) % 10; Buffer[5]=MyWins%10;
  dp = 4;
  WaitForGo();
}