/************************************************
*
*	$Copyright    2001 Joseph J. Lemieux  ALL RIGHTS RESERVED. $
*
*	$Filename: C:\OSEKBook\src\CH06\src\cardgame.c $
*
*	Description: Main routine to handle the processing
*                    of the card game.
*
************************************************/
#ifndef CARDGAMEC
#define CARDGAMEC

/************************************************
*
*	Include files
*
************************************************/

#include "typedefs.h"
#include "os.h"
#include "keypad.h"
#include "dispdrv.h"
#include "carddeck.h"
#include "cardgame.h"

DeclareTask(OutputDisplay);

/************************************************
*
*	Local macros
*
************************************************/

/************************************************
*
*	Local type definitions
*
************************************************/
/*
* Defines the types of transitions that occur for the state
* machine. The event is processed in the function
* ProcessKeyPress
*/
typedef struct GameTransitionTableTypetag {
   GameState state;
   char key;
   GameTransitions event;
   }GameTransitionTableType;
/************************************************
*
*	Local Function Prototypes
*
************************************************/
GameTransitions CheckGameTransition(char keyPressed);
void EndGame(void);

/************************************************
*
*	Local Variables
*
************************************************/
/* 
* Current state of the game. Default is GAME_NORMAL
*/
GameState gameState = GAME_NORMAL;
/*
* Player specific variables - total score, position in hand (1-5), 
* and actual cards in hand.
*/
UINT8 dealerScore,playerScore;
UINT8 dealerPosition, playerPosition;
UINT8 dealerCards[5], playerCards[5];

/************************************************
*
*	Local Constants
*
************************************************/
/*
* Message that is shown on the LCD when game begins
*/
char const GameMessage[] = "\fDealer:\n\nPlayer:";

/*
* Table of Transitions
*/
GameTransitionTableType const gameTransitionTable[] = {
   {GAME_NORMAL,'D',START_SHUFFLING},
   {GAME_NORMAL,'C',NEW_GAME},
   {GAME_PLAYER_TURN,'A',DEAL_PLAYER_CARD},
   {GAME_PLAYER_TURN,'B',END_PLAYER_TURN},
   {GAME_PLAYER_TURN,'D',START_SHUFFLING},
   {GAME_DEALER_TURN,'D',START_SHUFFLING},
   {0,0,NO_ACTION}
   };
/************************************************
*
*	Functions
*
************************************************/

/************************************************
*
*   Task:         ProcessKeyPress
*
*   Description:  Main dispatching task that processes
*                 all key presses as they occur.
*
************************************************/
TASK(ProcessKeyPress)
{
EventMaskType eventMask;
BOOLEAN shuffleComplete;
char keyValue;
UINT8 i;

   while(1){
      WaitEvent(KEYPRESS);
      ClearEvent(KEYPRESS);
      while((keyValue = GetKeyValue())!= 0){
         switch(CheckGameTransition(keyValue)){
            case START_SHUFFLING:
               SetRelAlarm(SampleShuffleSwitchAlarm,10,10);
               ActivateTask(DealCards);
               ActivateTask(ShuffleCards);
               gameState = GAME_SHUFFLING;
               shuffleComplete = FALSE;
               do{
                  WaitEvent(KEYPRESS|SHUFFLED);
                  GetEvent(ProcessKeyPress,(EventMaskRefType)&eventMask);
                  if((eventMask & KEYPRESS)!= 0){
                     ClearEvent(KEYPRESS);
                     while((keyValue = GetKeyValue()) != 0){
                        if(keyValue == '#'){
                           CancelAlarm(ShuffleAlarm);
                           CancelAlarm(SampleShuffleSwitchAlarm);
                           SetEvent(DealCards,ABORT_SHUFFLE);
                           shuffleComplete = TRUE;
                        }
         }
                  }
                  else{
                     ClearEvent(SHUFFLED);
                     shuffleComplete = TRUE;
                  }
               }while(shuffleComplete == FALSE);
         break;
            case DEAL_PLAYER_CARD:
               playerCards[playerPosition] = DealCard(PLAYER,playerPosition,TRUE);
               playerScore += GetCardValue(playerCards[playerPosition]);
               if(playerScore > 21){
                  for(i=0;i<=playerPosition;i++){
                     if(GetCardValue(playerCards[i])==11){
                        playerCards[i] = ACE_IS_ONE;
                        playerScore -= 10;
                        break;
                     }
                  }
               }
               if((++playerPosition == 5) || (playerScore > 21)){
                  SetDisplayPosition(0,9);
                  DisplayCard(dealerCards[0]);
                  ActivateTask(OutputDisplay);
                  EndGame();
               }
               break;
            case END_PLAYER_TURN:
               gameState = GAME_DEALER_TURN;
               ActivateTask(DealerTurn);
               break;
            case NEW_GAME:
               ActivateTask(DealCards);
               if(GetRemainingCards() < GAME_MINIMUM_CARDS){
            SetRelAlarm(SampleShuffleSwitchAlarm,10,10);
            ActivateTask(ShuffleCards);
                  gameState = GAME_SHUFFLING;
                  shuffleComplete = FALSE;
                  do{
                     WaitEvent(KEYPRESS|SHUFFLED);
                     GetEvent(ProcessKeyPress,(EventMaskRefType)&eventMask);
                     if((eventMask & KEYPRESS)!= 0){
                        ClearEvent(KEYPRESS);
                        while((keyValue = GetKeyValue()) != 0){
                           if(keyValue == '#'){
                              CancelAlarm(ShuffleAlarm);
                              CancelAlarm(SampleShuffleSwitchAlarm);
                              SetEvent(DealCards,ABORT_SHUFFLE);
                              shuffleComplete = TRUE;
         }
                        }
                     }
                     else{
                        ClearEvent(SHUFFLED);
                        shuffleComplete = TRUE;
                     }
                  }while(shuffleComplete == FALSE);
               }
               else{
                  SetEvent(DealCards,SHUFFLED);
               }
               break;
            case NO_ACTION:
         break;
   }
      }
   }
}

/************************************************
*
*   Task:         DealCards
*
*   Description:  Deals the first 4 cards when a
*                 new game starts.
*
************************************************/
TASK(DealCards)
{
EventMaskType eventMask;

   WaitEvent(ABORT_SHUFFLE|SHUFFLED);
   GetEvent(DealCards,(EventMaskRefType)&eventMask);
   if((eventMask & SHUFFLED)!=0){
      strcpy(displayBuffer,GameMessage);
      ActivateTask(OutputDisplay);
      playerCards[0] = DealCard(PLAYER,0,TRUE);
      dealerCards[0] = DealCard(DEALER,0,FALSE);
      playerCards[1] = DealCard(PLAYER,1,TRUE);
      dealerCards[1] = DealCard(DEALER,1,TRUE);
      dealerScore = GetCardValue(dealerCards[0])+GetCardValue(dealerCards[1]);
      playerScore = GetCardValue(playerCards[0])+GetCardValue(playerCards[1]);
      dealerPosition = playerPosition = 2;
      gameState = GAME_PLAYER_TURN;
      ClearEvent(SHUFFLED);
   }
   else{
      ClearEvent(ABORT_SHUFFLE);
   gameState = GAME_NORMAL;
   }
   TerminateTask();
}

/************************************************
*
*   Task:         DealerTurn
*
*   Description:  Deals the cards for the dealer.
*                 Dealer stays at 16 hits at 17.
*
************************************************/
TASK(DealerTurn)
{
UINT8 i;

   SetDisplayPosition(0,9);
   DisplayCard(dealerCards[0]);
   ActivateTask(OutputDisplay);
   SetDisplayPosition(1,9);
   if(dealerScore < 17){
      dealerCards[dealerPosition] = DealCard(DEALER,dealerPosition,TRUE);
      dealerScore += GetCardValue(dealerCards[dealerPosition]);
      if(dealerScore > 21){
         for(i=0;i<=dealerPosition;i++){
            if(GetCardValue(dealerCards[i])==11){
               dealerCards[i] = ACE_IS_ONE;
               dealerScore -= 10;
               break;
            }
         }
      }
      if((++dealerPosition == 5) || (dealerScore > 21)){
         EndGame();
      }
   }
   else{
      EndGame();
   }
   if(gameState == GAME_DEALER_TURN){
      SetRelAlarm(DealerTurnAlarm,2000,0);
   }
   TerminateTask();
}

/************************************************
*
*   Function:     CheckGameTransition
*
*   Inputs:       keyPressed - Key that was pressed
*
*   Outputs:      None
*
*   Returns:      Event that occurs based upon the entry in the table
*
*   Description:  Navigates through the table of possible 
*                 game transitions and returns the event
*                 that has occurred based upon the key that
*                 was pressed. If no event, the last entry in
*                 the table returns NO_ACTION.
*
************************************************/
GameTransitions CheckGameTransition(char keyPressed)
{
const GameTransitionTableType * transitions = gameTransitionTable;

	while(transitions->key != 0){
      if((transitions->state == gameState) && (transitions->key == keyPressed)){
         break;
      }
      transitions++;
   }
return transitions->event;
}

/************************************************
*
*   Function:     EndGame
*
*   Inputs:       None
*
*   Outputs:      Displays scores on LCD
*
*   Returns:      None
*
*   Description:  Calculates scores, displays on LCD.
*
************************************************/
void EndGame(void)
{
   SetDisplayPosition(0,18);
   sprintf(displayBuffer,"%d",dealerScore);
   ActivateTask(OutputDisplay);
   SetDisplayPosition(2,18);
   sprintf(displayBuffer,"%d",playerScore);
   ActivateTask(OutputDisplay);
   gameState = GAME_NORMAL;
}

#endif /* CARDGAMEC */