/*----------------------------------------------------------*/
/*

Copyright (C) 2012 TenScope Limited - all rights reserved

Registered in the UK
Company number: 06656008
Registered office :
136 Pinner Road
Northwood
Middlesex
HA6 1BP

*/
/*----------------------------------------------------------*/
/*
 FileName:     	<Application Name Here>.c
 Dependencies:	See INCLUDES section
 Processor:		PIC16F690 Microcontrollers

 Compiler:		HI-TECH C PRO for the PIC10/12/16 MCU Family (Lite)
 Company:		Microchip Technology, Inc.
 Engineer:		<Your Name Here>

 Software License Agreement:

 The software supplied herewith by Microchip Technology Incorporated
 (the "Company") for its PICŪ Microcontroller is intended and
 supplied to you, the Company's customer, for use solely and
 exclusively on Microchip PIC Microcontroller products. The
 software is owned by the Company and/or its supplier, and is
 protected under applicable copyright laws. All rights are reserved.
 Any use in violation of the foregoing restrictions may subject the
 user to criminal sanctions under applicable laws, as well as to
 civil liability for the breach of the terms and conditions of this
 license.

 THIS SOFTWARE IS PROVIDED IN AN "AS IS" CONDITION. NO WARRANTIES,
 WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
 TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
 IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
 CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
*/
/*----------------------------------------------------------*/

#define _LEGACY_HEADERS

#include	<pic.h>

#include <stdlib.h>

/*----------------------------------------------------------*/
 
	__CONFIG(INTIO & WDTDIS & PWRTDIS & MCLRDIS & UNPROTECT & BORDIS & IESODIS & FCMDIS);

/*----------------------------------------------------------*/

#define LED_GREEN_SCISSORS		RC0
#define LED_GREEN_PAPER			RC1
#define LED_GREEN_STONE			RC2

#define LED_RED_SCISSORS		RC3
#define LED_RED_PAPER			RC4
#define LED_RED_STONE			RC5

#define LED_GREEN_RESULT		RC6
#define LED_RED_RESULT			RC7

#define SWITCH_GREEN_SCISSORS	RA2
#define SWITCH_GREEN_PAPER		RA4
#define SWITCH_GREEN_STONE		RA5

#define SWITCH_RED_SCISSORS		RB4
#define SWITCH_RED_PAPER		RB5
#define SWITCH_RED_STONE		RB6

#define SWITCH_PLAY				RB7

#define CHOICE_INVALID	0
#define CHOICE_SCISSORS	1
#define CHOICE_PAPER	2
#define CHOICE_STONE	3

#define RESULT_GREEN	0
#define RESULT_RED		1
#define RESULT_VOID		2
#define RESULT_DRAW		3

#define STATE_INITIAL	0
#define STATE_START		1
#define STATE_PLAY		2
#define STATE_RESULT	3

#define LED_INTERVAL_MSEC 40

#define STATE_CYCLES_START	125
#define STATE_CYCLES_PLAY	50
#define STATE_CYCLES_RESULT	10

#define RESULT_TOGGLE_COUNT 10;

/*----------------------------------------------------------*/

unsigned char LEDValues = 0;

unsigned char GameState = STATE_INITIAL;

unsigned char StateCounter = 0;

unsigned char GamePlay = 0;

unsigned char ChoiceRed = 0;
unsigned char ChoiceGreen = 0;

unsigned char GameResult = 0;

unsigned char LEDResultState = 0;
unsigned char LEDResultStateGreen = 0;
unsigned char LEDResultStateRed = 0;

unsigned char ResultToggleCounter = 0;

/*----------------------------------------------------------*/

void Initialize(void);
void Get_Inputs(void);
void Decide(void);
void Do_Outputs(void);
void Timing(void);

/*----------------------------------------------------------*/

void Delay_ms(int msec) //approx.
{
	while(msec-- > 0)
	{
		T0IF = 0;

		TMR0 = 0;

		while (T0IF == 0)
		{
		}
	}
}

/*----------------------------------------------------------*/

void main(void)
{
	Initialize();
	
	while(1)
	{
		Get_Inputs();

		Decide();

		Do_Outputs();

		Timing();
	}
}

/*----------------------------------------------------------*/

void Initialize(void)
{
	PORTC = 0;

	ANS4 = 0;
	ANS5 = 0;
	ANS6 = 0;
	ANS7 = 0;
	ANS8 = 0;
	ANS9 = 0;

	TRISC0 = 0;
	TRISC1 = 0;
	TRISC2 = 0;
	TRISC3 = 0;
	TRISC4 = 0;
	TRISC5 = 0;
	TRISC6 = 0;
	TRISC7 = 0;

	PORTA = 0;
	PORTB = 0;

	ANS2 = 0;
	ANS3 = 0;
	ANS10 = 0;
	ANS11 = 0;

	TRISA2 = 1;
	TRISA4 = 1;
	TRISA5 = 1;

	TRISB4 = 1;
	TRISB5 = 1;
	TRISB6 = 1;

	TRISB7 = 1;

	RABPU = 0;

	WPUA2 = 1;
	WPUA4 = 1;
	WPUA5 = 1;

	WPUB4 = 1;
	WPUB5 = 1;
	WPUB6 = 1;
	WPUB7 = 1;

	T0CS = 0;

	T0SE = 0;

	PSA = 0;

	PS0 = 1;
	PS1 = 0;
	PS2 = 0;
}
	
/*----------------------------------------------------------*/

void Get_Inputs(void)
{
	switch(GameState)
	{
		case STATE_INITIAL :
		{
			GamePlay = 0;
			if(SWITCH_PLAY == 0)
			{
				Delay_ms(5);
				if(SWITCH_PLAY == 0)
				{
					GamePlay = 1;
				}
			}
		}

		case STATE_START :
		{
			break;
		}

		case STATE_PLAY :
		{
			if(StateCounter == 0)
			{
				{
					unsigned char ChoiceCount = 0;
					if(SWITCH_GREEN_SCISSORS == 0)
					{
						ChoiceGreen = CHOICE_SCISSORS;
						ChoiceCount++;
					}
					if(SWITCH_GREEN_PAPER == 0)
					{
						ChoiceGreen = CHOICE_PAPER;
						ChoiceCount++;
					}
					if(SWITCH_GREEN_STONE == 0)
					{
						ChoiceGreen = CHOICE_STONE;
						ChoiceCount++;
					}
					if(ChoiceCount != 1)
					{
						ChoiceGreen = CHOICE_INVALID;
					}
				}

				{
					unsigned char ChoiceCount = 0;
					if(SWITCH_RED_SCISSORS == 0)
					{
						ChoiceRed = CHOICE_SCISSORS;
						ChoiceCount++;
					}
					if(SWITCH_RED_PAPER == 0)
					{
						ChoiceRed = CHOICE_PAPER;
						ChoiceCount++;
					}
					if(SWITCH_RED_STONE == 0)
					{
						ChoiceRed = CHOICE_STONE;
						ChoiceCount++;
					}
					if(ChoiceCount != 1)
					{
						ChoiceRed = CHOICE_INVALID;
					}
				}
			}
			break;
		}

		case STATE_RESULT :
		{
			GamePlay = 0;
			if(SWITCH_PLAY == 0)
			{
				Delay_ms(5);
				if(SWITCH_PLAY == 0)
				{
					GamePlay = 1;
				}
			}
			break;
		}

		default :
		{
		}
	}
}

/*----------------------------------------------------------*/

void Decide(void)
{
	switch(GameState)
	{
		case STATE_INITIAL :
		{
			if(GamePlay)
			{
				GameState = STATE_START;
				StateCounter = STATE_CYCLES_START;
			}
			break;
		}

		case STATE_START :
		{
			if(StateCounter == 0)
			{
				GameState = STATE_PLAY;
				StateCounter = STATE_CYCLES_PLAY;
			}
			else
			{
				StateCounter--;
			}
			break;
		}

		case STATE_PLAY :
		{
			if(StateCounter == 0)
			{
				switch(ChoiceGreen)
				{
					case CHOICE_SCISSORS :
					{
						switch(ChoiceRed)
						{
							case CHOICE_SCISSORS :
							{
								GameResult = RESULT_DRAW;
								break;
							}

							case CHOICE_PAPER :
							{
								GameResult = RESULT_GREEN;
								break;
							}

							case CHOICE_STONE :
							{
								GameResult = RESULT_RED;
								break;
							}
	
							case CHOICE_INVALID :
							{
								GameResult = RESULT_GREEN;
								break;
							}

							default :
							{
								break;
							}
						}

						break;
					}

					case CHOICE_PAPER :
					{
						switch(ChoiceRed)
						{
							case CHOICE_SCISSORS :
							{
								GameResult = RESULT_RED;
								break;
							}

							case CHOICE_PAPER :
							{
								GameResult = RESULT_DRAW;
								break;
							}

							case CHOICE_STONE :
							{
								GameResult = RESULT_GREEN;
								break;
							}

							case CHOICE_INVALID :
							{
								GameResult = RESULT_GREEN;
								break;
							}

							default :
							{
								break;
							}
						}

						break;
					}

					case CHOICE_STONE :
					{
						switch(ChoiceRed)
						{
							case CHOICE_SCISSORS :
							{
								GameResult = RESULT_GREEN;
								break;
							}
	
							case CHOICE_PAPER :
							{
								GameResult = RESULT_RED;
								break;
							}
	
							case CHOICE_STONE :
							{
								GameResult = RESULT_DRAW;
								break;
							}
	
							case CHOICE_INVALID :
							{
								GameResult = RESULT_GREEN;
								break;
							}
	
							default :
							{
								break;
							}
						}

						break;
					}

					case CHOICE_INVALID :
					{
						switch(ChoiceRed)
						{
							case CHOICE_SCISSORS :
							{
								GameResult = RESULT_RED;
								break;
							}

							case CHOICE_PAPER :
							{
								GameResult = RESULT_RED;
								break;
							}

							case CHOICE_STONE :
							{
								GameResult = RESULT_RED;
								break;
							}

							case CHOICE_INVALID :
							{
								GameResult = RESULT_VOID;
								break;
							}

							default :
							{
								break;
							}
						}

						break;
					}

					default :
					{
						break;
					}
				}

				LEDResultState = 1;
				LEDResultStateGreen = 1;
				LEDResultStateRed = 1;
				StateCounter = STATE_CYCLES_RESULT;
				ResultToggleCounter = RESULT_TOGGLE_COUNT;

				GameState = STATE_RESULT;
			}
			else
			{
				StateCounter--;
			}
			break;
		}

		case STATE_RESULT :
		{
			if(GamePlay)
			{
				GameState = STATE_START;
				StateCounter = STATE_CYCLES_START;
			}
			else if(StateCounter == 0)
			{
				if(ResultToggleCounter == 0)
				{
					LEDResultState = 1;
					if(ChoiceGreen == CHOICE_INVALID)
					{
						LEDResultStateGreen = 0;
					}
					if(ChoiceRed == CHOICE_INVALID)
					{
						LEDResultStateRed = 0;
					}
				}
				else
				{
					ResultToggleCounter--;
					LEDResultState ^= 1;
					LEDResultStateGreen ^= 1;
					LEDResultStateRed ^= 1;
					StateCounter = STATE_CYCLES_RESULT;
				}
			}
			else
			{
				StateCounter--;
			}

			break;
		}

		default :
		{
		}
	}

	switch(GameState)
	{
		case STATE_INITIAL :
		{
			LEDValues = 0;
			break;
		}

		case STATE_START :
		{
			LEDValues = (unsigned char) rand();
			break;
		}

		case STATE_PLAY :
		{
			LEDValues = 0;
			break;
		}

		case STATE_RESULT :
		{
			break;
		}

		default :
		{
		}
	}
}

/*----------------------------------------------------------*/

void Do_Outputs(void)
{
	switch(GameState)
	{
		case STATE_INITIAL :
		{
			PORTC = LEDValues;
			break;
		}

		case STATE_START :
		{
			PORTC = LEDValues;
			break;
		}

		case STATE_PLAY :
		{
			PORTC = LEDValues;
			break;
		}

		case STATE_RESULT :
		{
			switch(ChoiceGreen)
			{
				case CHOICE_SCISSORS :
				{
					LED_GREEN_SCISSORS = LEDResultStateGreen;
					LED_GREEN_PAPER = 0;
					LED_GREEN_STONE = 0;
					break;
				}

				case CHOICE_PAPER :
				{
					LED_GREEN_SCISSORS = 0;
					LED_GREEN_PAPER = LEDResultStateGreen;
					LED_GREEN_STONE = 0;
					break;
				}

				case CHOICE_STONE :
				{
					LED_GREEN_SCISSORS = 0;
					LED_GREEN_PAPER = 0;
					LED_GREEN_STONE = LEDResultStateGreen;
					break;
				}

				case CHOICE_INVALID :
				{
					LED_GREEN_SCISSORS = LEDResultStateGreen;
					LED_GREEN_PAPER = LEDResultStateGreen;
					LED_GREEN_STONE = LEDResultStateGreen;
					break;
				}

				default :
				{
					break;
				}
			}

			switch(ChoiceRed)
			{
				case CHOICE_SCISSORS :
				{
					LED_RED_SCISSORS = LEDResultStateRed;
					LED_RED_PAPER = 0;
					LED_RED_STONE = 0;
					break;
				}

				case CHOICE_PAPER :
				{
					LED_RED_SCISSORS = 0;
					LED_RED_PAPER = LEDResultStateRed;
					LED_RED_STONE = 0;
					break;
				}

				case CHOICE_STONE :
				{
					LED_RED_SCISSORS = 0;
					LED_RED_PAPER = 0;
					LED_RED_STONE = LEDResultStateRed;
					break;
				}

				case CHOICE_INVALID :
				{
					LED_RED_SCISSORS = LEDResultStateRed;
					LED_RED_PAPER = LEDResultStateRed;
					LED_RED_STONE = LEDResultStateRed;
					break;
				}

				default :
				{
					break;
				}
			}

			switch(GameResult)
			{
				case RESULT_RED :
				{
					LED_GREEN_RESULT = 0;
					LED_RED_RESULT = LEDResultState;
					break;
				}

				case RESULT_GREEN :
				{
					LED_GREEN_RESULT = LEDResultState;
					LED_RED_RESULT = 0;
					break;
				}

				case RESULT_DRAW :
				{
					LED_GREEN_RESULT = LEDResultState;
					LED_RED_RESULT = LEDResultState;
					break;
				}

				case RESULT_VOID :
				{
					LED_GREEN_RESULT = LEDResultStateGreen;
					LED_RED_RESULT = LEDResultStateRed;
					break;
				}

				default :
				{
					break;
				}
			}

			break;
		}

		default :
		{
		}
	}
}

/*----------------------------------------------------------*/

void Timing(void)

{
	Delay_ms(LED_INTERVAL_MSEC);
}

/*----------------------------------------------------------*/