mirror of https://github.com/nealey/Simon-Says
642 lines
15 KiB
C
642 lines
15 KiB
C
/**
|
|
* 6-19-2007
|
|
* Copyright 2009, Spark Fun Electronics
|
|
* Nathan Seidle
|
|
* nathan at sparkfun.com
|
|
*
|
|
* Released under the Creative Commons Attribution Share-Alike 3.0 License
|
|
* http://creativecommons.org/licenses/by-sa/3.0
|
|
*
|
|
* Simon Game ported for the ATmega168
|
|
*
|
|
* Fixes and cleanup by Joshua Neal <joshua[at]trochotron.com>
|
|
*
|
|
* Generates random sequence, plays music, and displays button lights.
|
|
*
|
|
* Simon tones from Wikipedia
|
|
* - A (red, upper left) - 440Hz - 2.272ms - 1.136ms pulse
|
|
* - a (green, upper right, an octave higher than A) - 880Hz - 1.136ms,
|
|
* 0.568ms pulse
|
|
* - D (blue, lower left, a perfect fourth higher than the upper left)
|
|
* 587.33Hz - 1.702ms - 0.851ms pulse
|
|
* G (yellow, lower right, a perfect fourth higher than the lower left) -
|
|
* 784Hz - 1.276ms - 0.638ms pulse
|
|
*
|
|
* The tones are close, but probably off a bit, but they sound all right.
|
|
*
|
|
* The old version of SparkFun simon used an ATmega8. An ATmega8 ships
|
|
* with a default internal 1MHz oscillator. You will need to set the
|
|
* internal fuses to operate at the correct external 16MHz oscillator.
|
|
*
|
|
* Original Fuses:
|
|
* avrdude -p atmega8 -P lpt1 -c stk200 -U lfuse:w:0xE1:m -U hfuse:w:0xD9:m
|
|
*
|
|
* Command to set to fuses to use external 16MHz:
|
|
* avrdude -p atmega8 -P lpt1 -c stk200 -U lfuse:w:0xEE:m -U hfuse:w:0xC9:m
|
|
*
|
|
* The current version of Simon uses the ATmega168. The external osciallator
|
|
* was removed to reduce component count. This version of simon relies on the
|
|
* internal default 1MHz osciallator. Do not set the external fuses.
|
|
*/
|
|
|
|
#include <avr/io.h>
|
|
#include <avr/interrupt.h>
|
|
|
|
/* Uncomment one of the following, corresponding to the board you have. */
|
|
//#define BOARD_REV_6_25_08
|
|
//#define BOARD_REV_4_9_2009
|
|
//#define BOARD_REV_6_3_2009
|
|
#define BOARD_REV_PTH
|
|
|
|
#ifdef BOARD_REV_PTH
|
|
|
|
#define CHIP_ATMEGA168
|
|
|
|
#define LED_RED (1 << 0)
|
|
#define LED_GREEN (1 << 1)
|
|
#define LED_BLUE (1 << 2)
|
|
#define LED_YELLOW (1 << 3)
|
|
|
|
/* LED pin definitions */
|
|
#define LED_RED_PIN 2
|
|
#define LED_RED_PORT PORTB
|
|
#define LED_GREEN_PIN 3
|
|
#define LED_GREEN_PORT PORTD
|
|
#define LED_BLUE_PIN 5
|
|
#define LED_BLUE_PORT PORTB
|
|
#define LED_YELLOW_PIN 5
|
|
#define LED_YELLOW_PORT PORTD
|
|
|
|
/* Button pin definitions */
|
|
#define BUTTON_RED_PIN 1
|
|
#define BUTTON_RED_PORT PINB
|
|
#define BUTTON_GREEN_PIN 2
|
|
#define BUTTON_GREEN_PORT PIND
|
|
#define BUTTON_BLUE_PIN 4
|
|
#define BUTTON_BLUE_PORT PINB
|
|
#define BUTTON_YELLOW_PIN 6
|
|
#define BUTTON_YELLOW_PORT PIND
|
|
|
|
/* Buzzer pin definitions */
|
|
#define BUZZER1 4
|
|
#define BUZZER1_PORT PORTD
|
|
#define BUZZER2 7
|
|
#define BUZZER2_PORT PORTD
|
|
|
|
#endif /* BOARD_REV_PTH */
|
|
|
|
|
|
#ifdef BOARD_REV_6_25_08
|
|
|
|
#define CHIP_ATMEGA168
|
|
|
|
#define LED_RED (1 << 0)
|
|
#define LED_GREEN (1 << 1)
|
|
#define LED_BLUE (1 << 2)
|
|
#define LED_YELLOW (1 << 3)
|
|
|
|
/* LED pin definitions */
|
|
#define LED_RED_PIN 3
|
|
#define LED_RED_PORT PORTC
|
|
#define LED_GREEN_PIN 2
|
|
#define LED_GREEN_PORT PORTD
|
|
#define LED_BLUE_PIN 0
|
|
#define LED_BLUE_PORT PORTC
|
|
#define LED_YELLOW_PIN 5
|
|
#define LED_YELLOW_PORT PORTD
|
|
|
|
/* Button pin definitions */
|
|
#define BUTTON_RED_PIN 2
|
|
#define BUTTON_RED_PORT PINC
|
|
#define BUTTON_GREEN_PIN 5
|
|
#define BUTTON_GREEN_PORT PINC
|
|
#define BUTTON_BLUE_PIN 1
|
|
#define BUTTON_BLUE_PORT PINC
|
|
#define BUTTON_YELLOW_PIN 6
|
|
#define BUTTON_YELLOW_PORT PIND
|
|
|
|
/* Buzzer pin definitions */
|
|
#define BUZZER1 3
|
|
#define BUZZER1_PORT PORTD
|
|
#define BUZZER2 4
|
|
#define BUZZER2_PORT PORTD
|
|
|
|
#endif /* BOARD_REV_6_25_08 */
|
|
|
|
|
|
#ifdef BOARD_REV_4_9_2009
|
|
|
|
#define CHIP_ATMEGA168
|
|
|
|
/* LED pin definitions */
|
|
#define LED_BLUE_PIN 5
|
|
#define LED_BLUE_PORT PORTB
|
|
#define LED_YELLOW_PIN 5
|
|
#define LED_YELLOW_PORT PORTD
|
|
#define LED_RED_PIN 2
|
|
#define LED_RED_PORT PORTB
|
|
#define LED_GREEN_PIN 2
|
|
#define LED_GREEN_PORT PORTD
|
|
|
|
/* Button pin definitions */
|
|
#define BUTTON_RED_PIN 0
|
|
#define BUTTON_RED_PORT PINB
|
|
#define BUTTON_GREEN_PIN 1
|
|
#define BUTTON_GREEN_PORT PINB
|
|
#define BUTTON_BLUE_PIN 7
|
|
#define BUTTON_BLUE_PORT PIND
|
|
#define BUTTON_YELLOW_PIN 6
|
|
#define BUTTON_YELLOW_PORT PIND
|
|
|
|
/* Buzzer pin definitions */
|
|
#define BUZZER1 3
|
|
#define BUZZER1_PORT PORTD
|
|
#define BUZZER2 4
|
|
#define BUZZER2_PORT PORTD
|
|
|
|
#endif /* BOARD_REV_4_9_2009 */
|
|
|
|
#ifdef BOARD_REV_6_3_2009
|
|
|
|
#define CHIP_ATMEGA168
|
|
|
|
#define LED_RED (1 << 0)
|
|
#define LED_GREEN (1 << 1)
|
|
#define LED_BLUE (1 << 2)
|
|
#define LED_YELLOW (1 << 3)
|
|
|
|
/* LED pin definitions */
|
|
#define LED_RED_PIN 2
|
|
#define LED_RED_PORT PORTB
|
|
#define LED_GREEN_PIN 2
|
|
#define LED_GREEN_PORT PORTD
|
|
#define LED_BLUE_PIN 5
|
|
#define LED_BLUE_PORT PORTB
|
|
#define LED_YELLOW_PIN 5
|
|
#define LED_YELLOW_PORT PORTD
|
|
|
|
/* Button pin definitions */
|
|
#define BUTTON_RED_PIN 0
|
|
#define BUTTON_RED_PORT PINB
|
|
#define BUTTON_GREEN_PIN 1
|
|
#define BUTTON_GREEN_PORT PINB
|
|
#define BUTTON_BLUE_PIN 7
|
|
#define BUTTON_BLUE_PORT PIND
|
|
#define BUTTON_YELLOW_PIN 6
|
|
#define BUTTON_YELLOW_PORT PIND
|
|
|
|
/* Buzzer pin definitions */
|
|
#define BUZZER1 3
|
|
#define BUZZER1_PORT PORTD
|
|
#define BUZZER2 4
|
|
#define BUZZER2_PORT PORTD
|
|
|
|
#endif /* BOARD_REV_6_3_2009 */
|
|
|
|
/* Define game parameters */
|
|
#define MOVES_TO_WIN 14
|
|
#define TIME_LIMIT 3000 /* 3000ms = 3 sec */
|
|
|
|
#define sbi(port_name, pin_number) (port_name |= 1<<pin_number)
|
|
#define cbi(port_name, pin_number) \
|
|
((port_name) &= (uint8_t)~(1 << pin_number))
|
|
|
|
/* Declarations for static functions */
|
|
static void delay_us(uint16_t delay);
|
|
static void delay_ms(uint16_t delay);
|
|
static uint8_t check_button(void);
|
|
static void set_leds(uint8_t leds);
|
|
static void buzz_sound(uint16_t buzz_length_ms, uint16_t buzz_delay);
|
|
static void toner(uint8_t tone, uint16_t buzz_length_ms);
|
|
static void add_to_moves(void);
|
|
static void play_moves(void);
|
|
static void play_loser(void);
|
|
static void play_winner(void);
|
|
static void ioinit(void);
|
|
|
|
/* Game state */
|
|
uint8_t moves[32];
|
|
uint8_t nmoves = 0;
|
|
|
|
ISR (SIG_OVERFLOW2)
|
|
{
|
|
/*
|
|
* Prescalar of 1024
|
|
* Clock = 16MHz
|
|
* 15,625 clicks per second
|
|
* 64us per click
|
|
*/
|
|
|
|
/* Preload timer 2 for 125 clicks. Should be 8ms per ISR call */
|
|
TCNT2 = 131; /* 256 - 125 = 131 */
|
|
}
|
|
|
|
/* General short delays, using internal timer do a fairly accurate 1us */
|
|
#ifdef CHIP_ATMEGA168
|
|
static void delay_us(uint16_t delay)
|
|
{
|
|
while (delay > 256)
|
|
{
|
|
TIFR0 = (1<<TOV0); /* Clear any interrupt flags on Timer0 */
|
|
TCNT0 = 0;
|
|
while ( (TIFR0 & (1<<TOV0)) == 0);
|
|
|
|
delay -= 256;
|
|
}
|
|
|
|
TIFR0 = (1<<TOV0); /* Clear any interrupt flags on Timer0 */
|
|
/*
|
|
* 256 - 125 = 131 : Preload timer 0 for x clicks.
|
|
* Should be 1us per click
|
|
*/
|
|
TCNT0 = 256 - delay;
|
|
while ((TIFR0 & (1<<TOV0)) == 0) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* General short delays */
|
|
void delay_ms(uint16_t x)
|
|
{
|
|
while (x-- > 0) {
|
|
delay_us(1000);
|
|
}
|
|
}
|
|
|
|
/* Light the given set of LEDs */
|
|
static void set_leds(uint8_t leds)
|
|
{
|
|
if ((leds & LED_RED) != 0) {
|
|
sbi(LED_RED_PORT, LED_RED_PIN);
|
|
} else {
|
|
cbi(LED_RED_PORT, LED_RED_PIN);
|
|
}
|
|
if ((leds & LED_GREEN) != 0) {
|
|
sbi(LED_GREEN_PORT, LED_GREEN_PIN);
|
|
} else {
|
|
cbi(LED_GREEN_PORT, LED_GREEN_PIN);
|
|
}
|
|
if ((leds & LED_BLUE) != 0) {
|
|
sbi(LED_BLUE_PORT, LED_BLUE_PIN);
|
|
} else {
|
|
cbi(LED_BLUE_PORT, LED_BLUE_PIN);
|
|
}
|
|
if ((leds & LED_YELLOW) != 0) {
|
|
sbi(LED_YELLOW_PORT, LED_YELLOW_PIN);
|
|
} else {
|
|
cbi(LED_YELLOW_PORT, LED_YELLOW_PIN);
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef BOARD_REV_6_25_08
|
|
static void init_gpio(void)
|
|
{
|
|
/* 1 = output, 0 = input */
|
|
DDRB = 0b11111111;
|
|
DDRC = 0b00001001; /* LEDs and Buttons */
|
|
DDRD = 0b00111110; /* LEDs, buttons, buzzer, TX/RX */
|
|
|
|
PORTC = 0b00100110; /* Enable pull-ups on buttons 0,2,3 */
|
|
PORTD = 0b01000000; /* Enable pull-up on button 1 */
|
|
}
|
|
#endif /* BOARD_REV_6_25_08 */
|
|
|
|
#ifdef BOARD_REV_4_9_2009
|
|
static void init_gpio(void)
|
|
{
|
|
/* 1 = output, 0 = input */
|
|
DDRB = 0b11111100; /* button 2,3 on PB0,1 */
|
|
DDRD = 0b00111110; /* LEDs, buttons, buzzer, TX/RX */
|
|
|
|
PORTB = 0b00000011; /* Enable pull-ups on buttons 2,3 */
|
|
PORTD = 0b11000000; /* Enable pull-up on button 0,1 */
|
|
}
|
|
#endif /* BOARD_REV_4_9_2009 */
|
|
|
|
#ifdef BOARD_REV_PTH
|
|
static void init_gpio(void)
|
|
{
|
|
/* 1 = output, 0 = input */
|
|
DDRB = 0xFF & ~(1<<BUTTON_BLUE_PIN) & ~(1<<BUTTON_RED_PIN); // Buttons are inputs, LEDs outputs
|
|
DDRC = 0x00; //All pins are open GPIOs
|
|
DDRD = 0xFF & ~(1<<BUTTON_GREEN_PIN) & ~(1<<BUTTON_YELLOW_PIN); //
|
|
|
|
//DDRB = 0b11111100; /* button 2,3 on PB0,1 */
|
|
//DDRD = 0b00111110; /* LEDs, buttons, buzzer, TX/RX */
|
|
|
|
PORTB = (1<<BUTTON_BLUE_PIN) | (1<<BUTTON_RED_PIN); // Enable pull-ups on button
|
|
PORTC = 0xFF;
|
|
PORTD = (1<<BUTTON_GREEN_PIN) | (1<<BUTTON_YELLOW_PIN); // Enable pull-up on button
|
|
}
|
|
#endif /* BOARD_REV_PTH */
|
|
|
|
#ifdef BOARD_REV_6_3_2009
|
|
static void init_gpio(void)
|
|
{
|
|
/* 1 = output, 0 = input */
|
|
DDRB = 0xFF & ~(1<<BUTTON_GREEN_PIN) & ~(1<<BUTTON_RED_PIN); // Buttons are inputs, LEDs outputs
|
|
DDRC = 0x00; //All pins are open GPIOs
|
|
DDRD = 0xFF & ~(1<<BUTTON_BLUE_PIN) & ~(1<<BUTTON_YELLOW_PIN); //
|
|
|
|
PORTB = (1<<BUTTON_GREEN_PIN) | (1<<BUTTON_RED_PIN); // Enable pull-ups on button
|
|
PORTC = 0xFF;
|
|
PORTD = (1<<BUTTON_BLUE_PIN) | (1<<BUTTON_YELLOW_PIN); // Enable pull-up on button
|
|
}
|
|
#endif /* BOARD_REV_6_3_2009 */
|
|
|
|
|
|
void ioinit(void)
|
|
{
|
|
init_gpio();
|
|
|
|
/* Init timer 0 for delay_us timing (1,000,000 / 1 = 1,000,000) */
|
|
//TCCR0B = (1<<CS00); //Set Prescaler to No Prescaling. 1clk = 1us (assume we are running at internal 1MHz). CS00=1
|
|
TCCR0B = (1<<CS01); //Set Prescaler to clk/8 : 1click = 1us(assume we are running at internal 8MHz). CS01=1
|
|
//TCCR0B = (1<<CS00); /* Set Prescaler to 1. CS00=1 */
|
|
|
|
/* Init timer 2 */
|
|
ASSR = 0;
|
|
/* Set Prescaler to 1024. CS22=1, CS21=1,CS20=1 */
|
|
TCCR2B = (1<<CS22)|(1<<CS21)|(1<<CS20);
|
|
TIMSK2 = (1<<TOIE2); /* Enable Timer 2 Interrupt */
|
|
|
|
sei();
|
|
}
|
|
|
|
/* Returns a '1' bit in the position corresponding to LED_RED, etc. */
|
|
uint8_t check_button(void)
|
|
{
|
|
uint8_t button_pressed = 0;
|
|
|
|
if ((BUTTON_RED_PORT & (1 << BUTTON_RED_PIN)) == 0)
|
|
button_pressed |= LED_RED;
|
|
if ((BUTTON_GREEN_PORT & (1 << BUTTON_GREEN_PIN)) == 0)
|
|
button_pressed |= LED_GREEN;
|
|
if ((BUTTON_BLUE_PORT & (1 << BUTTON_BLUE_PIN)) == 0)
|
|
button_pressed |= LED_BLUE;
|
|
if ((BUTTON_YELLOW_PORT & (1 << BUTTON_YELLOW_PIN)) == 0)
|
|
button_pressed |= LED_YELLOW;
|
|
|
|
return button_pressed;
|
|
}
|
|
|
|
/* Play the loser sound/lights */
|
|
void play_loser(void)
|
|
{
|
|
set_leds(LED_RED|LED_GREEN);
|
|
buzz_sound(255, 1500);
|
|
|
|
set_leds(LED_BLUE|LED_YELLOW);
|
|
buzz_sound(255, 1500);
|
|
|
|
set_leds(LED_RED|LED_GREEN);
|
|
buzz_sound(255, 1500);
|
|
|
|
set_leds(LED_BLUE|LED_YELLOW);
|
|
buzz_sound(255, 1500);
|
|
}
|
|
|
|
/* Play the winner sound */
|
|
static void winner_sound(void)
|
|
{
|
|
uint8_t x, y;
|
|
|
|
/* Toggle the buzzer at various speeds */
|
|
for (x = 250; x > 70; x--) {
|
|
for (y = 0; y < 3; y++) {
|
|
sbi(BUZZER2_PORT, BUZZER2);
|
|
cbi(BUZZER1_PORT, BUZZER1);
|
|
|
|
delay_us(x);
|
|
|
|
cbi(BUZZER2_PORT, BUZZER2);
|
|
sbi(BUZZER1_PORT, BUZZER1);
|
|
|
|
delay_us(x);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Play the winner sound and lights */
|
|
void play_winner(void)
|
|
{
|
|
set_leds(LED_GREEN|LED_BLUE);
|
|
winner_sound();
|
|
set_leds(LED_RED|LED_YELLOW);
|
|
winner_sound();
|
|
set_leds(LED_GREEN|LED_BLUE);
|
|
winner_sound();
|
|
set_leds(LED_RED|LED_YELLOW);
|
|
winner_sound();
|
|
}
|
|
|
|
/* Plays the current contents of the game moves */
|
|
static void play_moves(void)
|
|
{
|
|
uint8_t move;
|
|
|
|
for (move = 0; move < nmoves; move++) {
|
|
toner(moves[move], 150);
|
|
delay_ms(150);
|
|
}
|
|
}
|
|
|
|
/* Adds a new random button to the game sequence, by sampling the timer */
|
|
static void add_to_moves(void)
|
|
{
|
|
uint8_t new_button;
|
|
|
|
/* Use the lower 2 bits of the timer for the random value */
|
|
new_button = 1 << (TCNT2 & 0x3);
|
|
|
|
moves[nmoves++] = new_button;
|
|
}
|
|
|
|
/* Toggle buzzer every buzz_delay_us, for a duration of buzz_length_ms. */
|
|
static void buzz_sound(uint16_t buzz_length_ms, uint16_t buzz_delay_us)
|
|
{
|
|
uint32_t buzz_length_us;
|
|
|
|
buzz_length_us = buzz_length_ms * (uint32_t)1000;
|
|
while (buzz_length_us > buzz_delay_us*2) {
|
|
buzz_length_us -= buzz_delay_us*2;
|
|
|
|
/* toggle the buzzer at various speeds */
|
|
cbi(BUZZER1_PORT, BUZZER1);
|
|
sbi(BUZZER2_PORT, BUZZER2);
|
|
delay_us(buzz_delay_us);
|
|
|
|
sbi(BUZZER1_PORT, BUZZER1);
|
|
cbi(BUZZER2_PORT, BUZZER2);
|
|
delay_us(buzz_delay_us);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Light an LED and play tone
|
|
*
|
|
* red, upper left: 440Hz - 2.272ms - 1.136ms pulse
|
|
* green, upper right: 880Hz - 1.136ms - 0.568ms pulse
|
|
* blue, lower left: 587.33Hz - 1.702ms - 0.851ms pulse
|
|
* yellow, lower right: 784Hz - 1.276ms - 0.638ms pulse
|
|
*/
|
|
static void toner(uint8_t which, uint16_t buzz_length_ms)
|
|
{
|
|
set_leds(which);
|
|
switch (which) {
|
|
case LED_RED:
|
|
buzz_sound(buzz_length_ms, 1136);
|
|
break;
|
|
|
|
case LED_GREEN:
|
|
buzz_sound(buzz_length_ms, 568);
|
|
break;
|
|
|
|
case LED_BLUE:
|
|
buzz_sound(buzz_length_ms, 851);
|
|
break;
|
|
|
|
case LED_YELLOW:
|
|
buzz_sound(buzz_length_ms, 638);
|
|
break;
|
|
}
|
|
|
|
/* Turn off all LEDs */
|
|
set_leds(0);
|
|
}
|
|
|
|
/* Show an "attract mode" display while waiting for user to press button. */
|
|
static void attract_mode(void)
|
|
{
|
|
while (1) {
|
|
set_leds(LED_RED);
|
|
delay_ms(100);
|
|
if (check_button() != 0x00)
|
|
return;
|
|
|
|
set_leds(LED_BLUE);
|
|
delay_ms(100);
|
|
if (check_button() != 0x00)
|
|
return;
|
|
|
|
set_leds(LED_GREEN);
|
|
delay_ms(100);
|
|
if (check_button() != 0x00)
|
|
return;
|
|
|
|
set_leds(LED_YELLOW);
|
|
delay_ms(100);
|
|
if (check_button() != 0x00)
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
/* Wait for a button to be pressed. Returns one of led colors (LED_RED, etc.)
|
|
* if successful, 0 if timed out */
|
|
static uint8_t wait_for_button(void)
|
|
{
|
|
uint16_t time_limit = TIME_LIMIT;
|
|
uint8_t released = 0;
|
|
uint8_t old_button;
|
|
|
|
while (time_limit > 0) {
|
|
uint8_t button;
|
|
|
|
/* Implement a small bit of debouncing */
|
|
old_button = button;
|
|
button = check_button();
|
|
|
|
/*
|
|
* Make sure we've seen the previous button
|
|
* released before accepting new buttons
|
|
*/
|
|
if (button == 0)
|
|
released = 1;
|
|
if (button == old_button && released == 1) {
|
|
/* Make sure just one button is pressed */
|
|
if (button == LED_RED ||
|
|
button == LED_BLUE ||
|
|
button == LED_GREEN ||
|
|
button == LED_YELLOW) {
|
|
return button;
|
|
}
|
|
}
|
|
|
|
delay_ms(1);
|
|
|
|
time_limit--;
|
|
}
|
|
return 0; /* Timed out */
|
|
}
|
|
|
|
|
|
|
|
/* Play the game. Returns 0 if player loses, or 1 if player wins. */
|
|
static int game_mode(void)
|
|
{
|
|
nmoves = 0;
|
|
while (nmoves < MOVES_TO_WIN) {
|
|
uint8_t move;
|
|
|
|
/* Add a button to the current moves, then play them back */
|
|
add_to_moves();
|
|
play_moves();
|
|
|
|
/* Then require the player to repeat the sequence. */
|
|
for (move = 0; move < nmoves; move++) {
|
|
uint8_t choice = wait_for_button();
|
|
|
|
/* If wait timed out, player loses. */
|
|
if (choice == 0)
|
|
return 0;
|
|
|
|
toner(choice, 150);
|
|
|
|
/* If the choice is incorect, player loses. */
|
|
if (choice != moves[move]) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Player was correct, delay before playing moves */
|
|
delay_ms(1000);
|
|
}
|
|
|
|
/* player wins */
|
|
return 1;
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
|
|
/* Setup IO pins and defaults */
|
|
ioinit();
|
|
|
|
/* Main loop */
|
|
while (1) {
|
|
/* Wait for user to start game */
|
|
attract_mode();
|
|
|
|
/* Indicate the start of game play */
|
|
set_leds(LED_RED|LED_GREEN|LED_BLUE|LED_YELLOW);
|
|
delay_ms(1000);
|
|
set_leds(0);
|
|
delay_ms(250);
|
|
|
|
if (game_mode() != 0) {
|
|
/* Player won, play winner tones */
|
|
play_winner();
|
|
} else {
|
|
/* Player lost, play loser tones */
|
|
play_loser();
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|