/* Bulls and Cows v2

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

// Seven-segment definitions
const int charArrayLen = 36;
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  ' '
};

const int Dash = 11;
const int Space = 10;
const int rChar = 25;
const int ILose = 12;
const int HoHo = 18;
const int Error = 24;
const int Hello = 30;
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();
}

// 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;
}

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

// Wait for * key
void WaitForGo () {
  int key;
  do {
    do ; while (Key() == 0);
    key = Key();
    do ; while (Key() != 0);
  } 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 = 499;                  // Compare match at 250Hz
  TIMSK1 |= 1<<OCIE1A;          // Compare match interrupt enable
  ShowMessage(Hello);
}

void loop() {
  int Guesses[20];
  int Replies[20];
  int turn, Try, n, YourReply, Result;
  randomSeed(millis());
  // Start new game - choose a code
  int MyCode = random(10000);
  int Start = random(10000);
  turn = 0;
  Try = Start;
  YourReply = 0;
  Result = 0;
  do {
    // Start new turn
    // Prompt for your guess
    if (Result != 40) {
      Prompt(turn);
      int YourGuess = Read(4);
      Result = BullCow(YourGuess, MyCode);
      ShowScore(Result);
      WaitForGo();
      if (Result == 40) ShowMessage(ILose);
    }
    // Prompt for my guess
    if (YourReply != 40) {
      // Find guess compatible with all your previous replies
      ClearDisplay();
      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;
      } else {
        Display(Guesses[turn]);
        YourReply = Read(2);
        Replies[turn] = YourReply;
        if (YourReply == 40) ShowMessage(HoHo);
      }
    }
    turn++;
  } while (!((Result == 40) && (YourReply == 40)));
}