Electronic Game Buddy

/*============================================================================================================
  Eight Dice Set

  CPU:  ATtiny1614
  Display: 0.91" OLED
 
  ATtiny1614 Code: jbrad2089@gmail.com
  Concept: raul7321 (https://www.instructables.com/Fully-IR-Customizable-Eight-dice-Set/)

  Modes:
  COIN: 2 choices       - Thumbs Up or Thumbs down
  RPS: 3 choices        - Rock, Paper Sissors
  DICE: 6 choices       - Standard dice
  CARD_RED: 52 choices  - All red decks share a single deck that is there won't be any duplicate
	                        cards shown t the same time. Cards are put back in the eck for the next
                          draw.
  CAD_BLACK: 52 choices - All black decks are concatenated and black cards are drawn from that
	                        concatenated deck. Cards are not pur back into the deck. There is a
                          random marker that when encountered causes all the cards to go back
                          in the decks and decks are resuffled.
  
  BOARD: ATtiny1614/1604/814/804/414/404/214/204
  Chip: ATtiny1614
  Clock Speed: 20MHz
  Programmer: jtag2updi (megaTinyCore)

  ATTiny1614 Pins mapped to Ardunio Pins

             +--------+
         VCC + 1   14 + GND
 (SS)  0 PA4 + 2   13 + PA3 10 (SCK)
       1 PA5 + 3   12 + PA2 9  (MISO)
 (DAC) 2 PA6 + 4   11 + PA1 8  (MOSI)
       3 PA7 + 5   10 + PA0 11 (UPDI)
 (RXD) 4 PB3 + 6    9 + PB0 7  (SCL)
 (TXD) 5 PB2 + 7    8 + PB1 6  (SDA)
             +--------+

  PA0 to PA7 can be analog or digital
  PWM on D0, D1, D6, D7, D10
  
==============================================================================================================*/

#include <EEPROM.h>
#include "symbols.h"
#include "button.h"
#include "SSD1306_ATtiny1614.h"

#define ROLL 0    //(PA4)
#define RANDOM 1  //(PA5)

//Uncomment next line to clear out EEPROM and reset all high scores
//#define RESET_EEPROM

#define NO_CURSOR -1
int cursor;
bool inMenu;

enum MODES {MODE_OFF, COIN, RPS, DICE, CARD_RED, CARD_BLACK, MODE_LAST};

#define ELEMENTS 8

//EEPROM handling
#define EEPROM_ADDRESS 0
#define EEPROM_MAGIC 0x0BAD0DAD
typedef struct {
  uint32_t magic;
  MODES mode[ELEMENTS];
  int value[ELEMENTS];
  long seed;
  long blackSeed;
  long blackCount;
} EEPROM_DATA;

EEPROM_DATA EepromData;      //Current EEPROM settings
MODES lastMode[ELEMENTS];

bool blackDecks[52 * ELEMENTS];
int maxBlackCards;
long blackRandomNext;

/* Timing constants that ontrol how the elements animate */
#define START_DELAY_TIME 10
#define INCREMENT_DELAY_TIME 5
#define MAX_DELAY_BEFORE_STOP 100
#define MIN_SPIN_TIME 1000
#define MAX_SPIN_TIME 3000

/* spinElement holds the timing information for each element */
struct spinElement 
{
  unsigned long delayTime;
  unsigned long spinTime;
  unsigned long frameTime;
  bool stopped;
};

spinElement spin[ELEMENTS]; 

#define SLEEP_TIMEOUT 10000  //Amount of time no switch is pressed before going to sleep
uint32_t sleepTimeout = 0;   //Used to timeout mode switch function to sleep function

#define FLASH_TIMEOUT 300    //Flash time for cursor
uint32_t flashTimeout = 0;   //Used to timeout mode cursor flash
bool flashInvert = false;    //Invert state

#define LONG_PRESS_PERIOD 500
void rollButtonRaised(void);
Button* rollButton;
uint32_t rollLongPeriod;

//--------------------------------------------------------------------
//Handle pin change interrupt when button is pressed
//This wakes up the ATtiny1614 from its slumber
void SwitchInterrupt()
{
}

//--------------------------------------------------------------------
//Program Setup
void setup() 
{
  pinMode(ROLL, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(ROLL),SwitchInterrupt,CHANGE);
  ssd1306_init();

  //Initialise button
  rollButton = new Button(ROLL);

  //Setup cards
  readEepromData();
  randomSeed(EepromData.seed);
  blackRandomNext = EepromData.blackSeed;
  createBlackCardDecks();

  //Finish setup
  setupAfterSleep();
}

//--------------------------------------------------------------------
//Reinitialise program after going to sleep
void setupAfterSleep()
{
  ssd1306_fillscreen(0x00);
  updateScreen(NO_CURSOR);
  sleepTimeout = millis() + SLEEP_TIMEOUT;
  inMenu = false;
}
  
//--------------------------------------------------------------------
//Program Loop
void loop() 
{
  if (inMenu)
  {
    doMenu(); 
  }
  else if (millis() >= sleepTimeout)
  {
    system_sleep();
  }
  else if (rollButton->Pressed())
  {
    if (rollButton->DownTime() >= LONG_PRESS_PERIOD)
    {
      //Enter menu mode
      cursor = 0;
      inMenu = true; 
      flashTimeout = millis() + FLASH_TIMEOUT;
      rollButton->Repeat(rollButtonPressed);
      for (int i = 0; i < ELEMENTS; i++)
      {
        lastMode[i] = EepromData.mode[i];   //Store each mode to test for changes
        switch (EepromData.mode[i])
        {
          case COIN: EepromData.value[i] = 1; break;
          case RPS: EepromData.value[i] = 2; break;
          case DICE: EepromData.value[i] = 2; break;
          case CARD_RED: EepromData.value[i] = 0; break; //Ace of Hearts
          case CARD_BLACK: EepromData.value[i] = 13 * 2; break; //Ace of Spades
        }
      }
    }
    else
    {
      //Perform a roll
      doRoll(); 
      sleepTimeout = millis() + SLEEP_TIMEOUT;
    }
  }
  else
  {
    delay(100);
  }
}

//--------------------------------------------------------------------
//Roll all items
void doRoll()
{
  //Reset wheels for the spin
  int stopCount = 0;  
  for (uint8_t j = 0; j < ELEMENTS; j++)
  {
    spin[j].stopped = (EepromData.mode[j] == MODE_OFF);
    if (spin[j].stopped)
    {
      stopCount++;
    }
    else
    {
      spin[j].delayTime = START_DELAY_TIME;
      spin[j].spinTime = random(MIN_SPIN_TIME, MAX_SPIN_TIME);
      spin[j].frameTime = millis() + spin[j].delayTime;
    }
  }

  bool hasBlackDecks = false;
  while (stopCount < ELEMENTS)
  {
    //Update each element
    for (uint8_t j = 0; j < ELEMENTS; j++)
    {
      hasBlackDecks |= (EepromData.mode[j] == CARD_BLACK);
      if (!spin[j].stopped && millis() > spin[j].frameTime)
      {
        spin[j].frameTime = millis() + spin[j].delayTime;
        switch (EepromData.mode[j])
        {
          case COIN: EepromData.value[j] = random(2); break;
          case RPS: EepromData.value[j] = random(3); break;
          case DICE: EepromData.value[j] = random(6); break;
          case CARD_RED: EepromData.value[j] = redRandom(j); break;
          case CARD_BLACK: EepromData.value[j] = random(52); break;
        }
        if (millis() > spin[j].spinTime)
        {
          //Stop if delayTime exceeds MAX_DELAY_BEFORE_STOP
          if (spin[j].delayTime > MAX_DELAY_BEFORE_STOP)
          {
            spin[j].stopped = true;
            stopCount++;
          }
          else
          {
            spin[j].delayTime = spin[j].delayTime + INCREMENT_DELAY_TIME;
          }
        }
      }
      updateScreen(NO_CURSOR);
    }
    yield();
  }

  //Black cards are special as they come from a concatenated deck and are not put back
  if (hasBlackDecks)
  {
    getBlackCards();
    //need to record cards removed from decks
    EepromData.seed = random(2147483647);
    writeEepromData();
  }
    
  updateScreen(NO_CURSOR);
}

//--------------------------------------------------------------------
//Ensure all red card picks are unique across every red pack
// element - current element to choose a card for
int redRandom(int element)
{
  int card;
  bool match = true;
  while (match)
  {
    card = random(52);
    match = false;
    for (int i = 0; i < ELEMENTS; i++)
    {
      if (i != element && EepromData.mode[i] == CARD_RED && EepromData.value[i] == card)
      {
        match = true;
        break;
      }
    }
  }
  return card;
}

//--------------------------------------------------------------------
//Populate all black cards from the black decks
void getBlackCards()
{
  //First clear out all black cards
  for (int i = 0; i < ELEMENTS; i++)
  {
    if (EepromData.mode[i] == CARD_BLACK)
    {
      EepromData.value[i] = -1;
    }
  }
  //Now assign the next card from the black decks
  for (int i = 0; i < ELEMENTS; i++)
  {
    if (EepromData.mode[i] == CARD_BLACK)
    {
      EepromData.value[i] = getNextBlackCard();
    }
  }
}

//--------------------------------------------------------------------
//Populate all black cards from the black decks
int getNextBlackCard()
{
  int card = 0;
  int tries = 0;
  do
  {
    card = getBlackRandom() % maxBlackCards;
    tries++;
  }
  while (blackDecks[card] && tries < 1000);

  //If we couldn't find a empty slot after 1000 attempts, shuffle the decks
  if (blackDecks[card])
  {
    //Shuffle deck
    shuffleDecks();
    card = getNextBlackCard();
  }
  else
  {
    //Stop card from being chosen again
    blackDecks[card] = true;
  }
  //card can be from any of the decks
  return card % 52;
}

//--------------------------------------------------------------------
//Black deck cards are drawn without putting back in the pack (eg blackjack)
void createBlackCardDecks()
{
  //Count how many actual black decks we have
  maxBlackCards = 0;
  for (int i = 0; i < ELEMENTS; i++)
  {
    if (EepromData.mode[i] == CARD_BLACK)
    {
      maxBlackCards = maxBlackCards + 52;
    }
  }
  if (maxBlackCards > 0)
  {
    //Clear out deck table
    for (int i = 0; i < (52 * ELEMENTS); i++)
    {
      blackDecks[i] = false;
    }
    //Fill up the table with cards already drawn from the pack
    long count = EepromData.blackCount;
    EepromData.blackCount = 0;
    for (long i = 0; i < count; i++)
    {
      blackDecks[getBlackRandom() % maxBlackCards] = true;
    }
  }
}

//--------------------------------------------------------------------
// Clear black deck tables ready for a new set of cards
void shuffleDecks()
{
  //Shuffle deck
  EepromData.blackCount = 0;
  EepromData.blackSeed = random(2147483647);
  blackRandomNext = EepromData.blackSeed;
  createBlackCardDecks();
}

//--------------------------------------------------------------------
//Random number generator taken from avr-libc-2.0.0\libc\stdlib\random.c
long getBlackRandom()
{
  /*
  * Compute x = (7^5 * x) mod (2^31 - 1)
  * wihout overflowing 31 bits:
  *      (2^31 - 1) = 127773 * (7^5) + 2836
  * From "Random number generators: good ones are hard to find",
  * Park and Miller, Communications of the ACM, vol. 31, no. 10,
  * October 1988, p. 1195.
  */
  long hi, lo, x;
  
  x = blackRandomNext;
  /* Can't be initialized with 0, so use another value. */
  if (x == 0)
      x = 123459876L;
  hi = x / 127773L;
  lo = x % 127773L;
  x = 16807L * lo - 2836L * hi;
  if (x < 0)
      x += 0x7fffffffL;
  blackRandomNext = x;
  EepromData.blackCount++;
  return x;
}

//--------------------------------------------------------------------
//Enter the menu
void doMenu()
{
  if (millis() >= flashTimeout)
  {
    flashInvert = !flashInvert;
    flashTimeout = millis() + FLASH_TIMEOUT;
    updateScreen((flashInvert) ? -1 : cursor);
  }
  rollLongPeriod = millis() + LONG_PRESS_PERIOD;
  if (rollButton->Pressed() && (millis() < rollLongPeriod))
  {
    //This is a short press - long presses are handled by the repeat function
    cursor = cursor + 1;
    if (cursor < ELEMENTS)
    {
      updateScreen((flashInvert) ? -1 : cursor);
    }
    else
    {
      //Exiting menu mode
      rollButton->Repeat(NULL);
      updateScreen(-1);
      inMenu = false;

      bool changed = false;
      bool blackChanged = false;
      bool hasBlackDecks = false;
      for (int i = 0; i < ELEMENTS; i++)
      {
        if (lastMode[i] != EepromData.mode[i])
        {
          blackChanged |= (lastMode[i] == CARD_BLACK);
          blackChanged |= (EepromData.mode[i] == CARD_BLACK);
          changed = true;
        }
      }

      if (changed)
      {
        if (blackChanged)
        {
          shuffleDecks();
        }
        //When modes have changed store it to EEPROM
        EepromData.seed = random(2147483647);
        writeEepromData();
      }
      
      sleepTimeout = millis() + SLEEP_TIMEOUT;
    }
  }
  delay(100);
}

//-----------------------------------------------------------------------------------
//Invoked via the repeat function of the roll button
void rollButtonPressed()
{
  if (millis() >= rollLongPeriod)
  {
    //Only do something on a long press
    EepromData.mode[cursor] = (EepromData.mode[cursor] == CARD_BLACK) ? MODE_OFF : (MODES)((int)EepromData.mode[cursor] + 1);
    switch (EepromData.mode[cursor])
    {
      case COIN: EepromData.value[cursor] = 1; break;
      case RPS: EepromData.value[cursor] = 2; break;
      case DICE: EepromData.value[cursor] = 2; break;
      case CARD_RED: EepromData.value[cursor] = 0; break; //Ace of Hearts
      case CARD_BLACK: EepromData.value[cursor] = 13 * 2; break; //Ace of Spades
    }
    updateScreen(cursor);
  }
}

//--------------------------------------------------------------------
//Update the screen with the current symbols
// c = -1 for no cursor, 0 to 7 to invert symbol
void updateScreen(int c)
{
  int x;
  int y;
  
  for (int i = 0; i < ELEMENTS; i++)
  {
    y = (i >= 4) ? 4 : 0;
    x = (i & 0x03) << 5;
    switch (EepromData.mode[i])
    {
      case MODE_OFF: drawEmptySpace(x, y, (i == c)); break;
      case COIN: drawThumbsUpDown(x, y, EepromData.value[i], (i == c)); break;
      case RPS: drawRockPaperSissors(x, y, EepromData.value[i], (i == c)); break;
      case DICE: drawDice(x, y, EepromData.value[i], (i == c)); break;
      case CARD_RED: 
      case CARD_BLACK: drawCard(x, y, EepromData.value[i], (i == c)); break;
    }
  }
}

//--------------------------------------------------------------------
//Draw thumbs up / thumbs down
// x = X position of mid point
// y = Y position of bottom point
void drawEmptySpace(int x, int y, bool invert)
{
  ssd1306_draw_bmp(x, y, 24, 3, space, invert);
}

//--------------------------------------------------------------------
//Draw thumbs up / thumbs down
// x = X position of mid point
// y = Y position of bottom point
// v = 0 or 1
void drawThumbsUpDown(int x, int y, int v, bool invert)
{
  ssd1306_draw_bmp(x, y, 24, 3, thumbs[v], invert);
}

//--------------------------------------------------------------------
//Draw rock / paper /sissors
// x = X position of mid point
// y = Y position of bottom point
// v = 0 or 1 or 2
void drawRockPaperSissors(int x, int y, int v, bool invert)
{
  ssd1306_draw_bmp(x, y, 24, 3, rps[v], invert);
}

//--------------------------------------------------------------------
//Draw standard dice
// x = X position of mid point
// y = Y position of bottom point
// v = 0 to 5
void drawDice(int x, int y, int v, bool invert)
{
  ssd1306_draw_bmp(x, y, 24, 3, dice[v], invert);
}  

//--------------------------------------------------------------------
//Draw card
// x = X position of mid point
// y = Y position of bottom point
// v = 0 to 51
void drawCard(int x, int y, int v, bool invert)
{
  int s = v / 13;
  int f = v % 13;
  ssd1306_draw_merge_bmp(x, y, 24, 3, cards[f], cards[s + 13], invert);
}

//--------------------------------------------------------------------
//Write the EepromData structure to EEPROM
void writeEepromData(void)
{
  //This function uses EEPROM.update() to perform the write, so does not rewrites the value if it didn't change.
  EEPROM.put(EEPROM_ADDRESS,EepromData);
}

//--------------------------------------------------------------------
//Read the EepromData structure from EEPROM, initialise if necessary
void readEepromData(void)
{
#ifndef RESET_EEPROM
  EEPROM.get(EEPROM_ADDRESS,EepromData);
  if (EepromData.magic != EEPROM_MAGIC)
  {
#endif  
    EepromData.magic = EEPROM_MAGIC;
    EepromData.seed = analogRead(RANDOM);
    EepromData.blackSeed = analogRead(RANDOM);
    EepromData.blackCount = 0;
    /*
    for (int x = 0; x < 8; x++)
    {
      EepromData.mode[x] = CARD_BLACK;
      EepromData.value[x] = 13 * 3;
    }
    */
    EepromData.mode[0] = COIN; EepromData.value[0] = 0;
    EepromData.mode[1] = COIN; EepromData.value[1] = 1;
    EepromData.mode[2] = CARD_RED; EepromData.value[2] = 0;
    EepromData.mode[3] = CARD_BLACK; EepromData.value[3] = 13 * 3;  
    EepromData.mode[4] = RPS; EepromData.value[4] = 0;
    EepromData.mode[5] = RPS; EepromData.value[5] = 1;
    EepromData.mode[6] = RPS; EepromData.value[6] = 2;
    EepromData.mode[7] = DICE; EepromData.value[7] = 4;
    writeEepromData();
#ifndef RESET_EEPROM
  }
#endif  
}

//--------------------------------------------------------------------
//Shut down OLED and put ATtiny to sleep
//Will wake up when LEFT button is pressed
void system_sleep() 
{
  interrupts();
  ssd1306_sleep();
  //Wait until on button is released
  while (digitalRead(ROLL) == LOW)
  {
    delay(100);
  }
  setupAfterSleep();
}