/*******************************************************************************

					CONDAT (UK)

********************************************************************************

 This software product is the property of Condat (UK) Ltd and may not be
 disclosed to any third party without the express permission of the owner.

********************************************************************************

 $Project name:	Basic MMI
 $Project code:	BMI (6349)
 $Module:		Game
 $File:		    Mmigame.c
 $Revision:		1.0

 $Author:		Condat(UK)
 $Date:		    03/07/01

********************************************************************************

 Description
	Aug 16, 2004    REF: CRR 24323   Deepa M.D
	Bug:Clenup of sprintf used for tracing
	Fix:Replace the char buf[]; sprintf (buf, "...", ...); TRACE_EVENT (buf); statements by TRACE_EVENT_PX

    This provides the main game (four in a row) functionality


********************************************************************************/


/*******************************************************************************

                                Include files

*******************************************************************************/

#define ENTITY_MFW

/* includes */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#if defined (NEW_FRAME)

#include "typedefs.h"
#include "vsi.h"
#include "pei.h"
#include "custom.h"
#include "gsm.h"

#else

#include "STDDEFS.H"
#include "custom.h"
#include "gsm.h"
#include "vsi.h"

#endif
#include "mfw_sys.h"

#include "cus_aci.h"

#include "mfw_mfw.h"
#include "mfw_win.h"
#include "mfw_kbd.h"
/* SPR#1428 - SH - New Editor changes */
#ifndef NEW_EDITOR
#include "mfw_edt.h"
#endif
#include "mfw_lng.h"
#include "mfw_tim.h"
#include "mfw_icn.h"
#include "mfw_mnu.h"
#include "mfw_phb.h"
#include "mfw_cm.h"
#include "mfw_sim.h"
#include "mfw_nm.h"
#include "mfw_sat.h"
#include "mfw_ss.h" /*for convert*/
#include "mfw_phb.h"
#include "ksd.h"
#include "psa.h"
#include "mfw_sms.h"
#include "mfw_cphs.h"
#include "mfw_sat.h"
#include "Mfw_band.h"
#include "mfw_ffs.h"
#include "Mmigame.h"

#include "dspl.h"

#include "MmiMmi.h"
#include "MmiDialogs.h"
#include "MmiLists.h"
#include "MmiBand.h"
#include "MmiCPHS.h"
/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
#include "ATBCommon.h"
#include "ATBDisplay.h"
#include "ATBEditor.h"
#include "AUIEditor.h"
#else
#include "MmiEditor.h"
#endif
#include"MmiBookShared.h"




#include "font_bitmaps.h"
#include "mmiColours.h"
#include "MmiResources.h"

#include "Mmigame.h"
//GW 14/09/01 Disable game when not required.
#ifdef MMIGAME
void dspl_show_bitmap(int x,int y,t_font_bitmap* current_bitmap,U32 attr );
/*******************************************************************************

                                internal data

*******************************************************************************/

#define FOUR_IN_A_ROW_INIT 121
#define MAX_X_BOARD 11
#define MAX_Y_BOARD 8
/*
*  The information related to every window must be encapsulated in such an structure
*/

typedef struct
{
    T_MMI_CONTROL   mmi_control;		// common control parameter
	T_MFW_HND win;
	T_MFW_HND kbd;
	T_MFW_HND	menu;
	T_MFW_HND 	parent_win;
	T_MFW_HND info_win;
	char board_array[MAX_Y_BOARD][MAX_X_BOARD];	//the virtual board
} T_four_in_a_row;

typedef struct
{
    /* administrative data */

    T_MMI_CONTROL     mmi_control;
    T_MFW_HND         win;
    T_MFW_HND         parent_win;
/* SPR#1428 - SH - New editor data */
#ifdef NEW_EDITOR
	T_AUI_EDITOR_DATA editor_data;
#else /* NEW_EDITOR */
    T_EDITOR_DATA   editor_data;
#endif /* NEW_EDITOR */

    /* internal data */
    char        buffer[80];
    UBYTE       status;

} tShowInfo;


/*
*  These are common functions xxx_create and xxx_destroy
*/
T_MFW_HND four_in_a_row_create(MfwHnd parent);
void four_in_a_row_destroy (T_MFW_HND);


/*
*  This dialog function (the same name as the window)
* is used to handle the comunication between different windows. The global macro SEND_EVENT can be used with parameter win
* and the corresponding events to send from one mmi dialog to another.
*/
void four_in_a_row (T_MFW_HND win, USHORT event, SHORT value, void * parameter);


/*
*  These are common optional functions handler
*/
int four_in_a_row_kbd_cb (MfwEvt e, MfwKbd *k);
int four_in_a_row_win_cb (MfwEvt e, MfwWin *w);

int Game_Result;


/*
*  This an optional function, used often to call, create and init a new dialog, with different parameters depending
* on the context
*/
T_MFW_HND four_in_a_row_start (T_MFW_HND win_parent,char *character);
int four_in_a_row_aktivate(MfwMnu* m, MfwMnuItem* i);

int check_column(T_four_in_a_row *data, int where_from);
void drop_stone(T_four_in_a_row *data);

int mobile_thinking(T_four_in_a_row *data);
int check_line(T_four_in_a_row *data, int x_value, int drop_position, int dx, int dy, BOOL where_from);
void check_for_winner(T_four_in_a_row *data, int check_out_position);
int random_scoring(void);  // RAVI

T_MFW_HND Game_Info(T_MFW_HND parent_window);
static T_MFW_HND ShowGame_Information(MfwHnd parent_window);
static void ShowGame_DialogCB(T_MFW_HND win, USHORT e,  SHORT identifier, void *parameter);
void ShowGameInfoEditor(T_MFW_HND win);
static void ShowInfoCB( T_MFW_HND win, USHORT Identifier,UBYTE reason);
void showGameInfo_destroy(MfwHnd own_window);

const char * info = "Welcome to Connect 4!";
const char * playAgain = "Play Again?";


//internal datas

int column;				//this is the current position of white player cursor
int x_runer;	//goes through the horizontal lines
int y_runer;	//goes through the vertical lines
char winner;	//describes the winner 0->nobody 'B'->black(mobile) 'W'->white(human player)
int column_black;	//this is the current position of black player cursor
int request_stone;	//helps to decide between black or white (for strategical things)



#ifndef BMP_FORMAT_BW_UNPACKED
#define BMP_FORMAT_BW_UNPACKED 1
#endif


t_font_bitmap  plWin1		={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)player_win1};
t_font_bitmap  plWin2		={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)player_win2};
t_font_bitmap  plLost1		={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)player_lost1};
t_font_bitmap  plLost2		={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)player_lost2};
t_font_bitmap  draw1		={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)board_full1};
t_font_bitmap  draw2		={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)board_full2};
t_font_bitmap  gameName1	={ 0, BMP_FORMAT_BW_UNPACKED, 18, 24, 0, (char*)game_name1};
t_font_bitmap  gameName2	={ 0, BMP_FORMAT_BW_UNPACKED, 24, 24, 0, (char*)game_name2};

#ifdef COLOURDISPLAY
char colBmp[256*4];
t_font_bitmap  allCol  ={ 0, BMP_FORMAT_256_COLOUR, 32, 32, 0, colBmp };
t_font_bitmap  stone_colour   ={ 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)black_stone_bw};
t_font_bitmap  gameCursor = { 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)game_cursor};
#else
#ifdef LSCREEN
t_font_bitmap  blackStone_bw ={ 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)black_stone_bw};
t_font_bitmap  whiteStone_bw ={ 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)white_stone_bw};
t_font_bitmap  gameCursor = { 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)game_cursor};
#else
t_font_bitmap  blackStone_bw ={ 0, BMP_FORMAT_BW_UNPACKED, 4, 4, 0, (char*)black_stone_bw};
t_font_bitmap  whiteStone_bw ={ 0, BMP_FORMAT_BW_UNPACKED, 4, 4, 0, (char*)white_stone_bw};
t_font_bitmap  gameCursor = { 0, BMP_FORMAT_BW_UNPACKED, 6, 6, 0, (char*)game_cursor};
#endif
#endif

t_font_bitmap *blackStone, *whiteStone;

/*******************************************************************************

 $Function:    	four_in_a_row_create

 $Description:

 $Returns:

 $Arguments:

*******************************************************************************/


T_MFW_HND four_in_a_row_create (T_MFW_HND parent_window)
{

    T_MFW_WIN     * win;

    /*
     * This window is dynamic, for that reason the associated data are allocated in the mfw heap
     */
	T_four_in_a_row *  data = (T_four_in_a_row *)ALLOC_MEMORY (sizeof (T_four_in_a_row));

	TRACE_FUNCTION ("four_in_a_row_create()");

    /*
     * Create window handler
     */

    data->win = win_create (parent_window, 0, E_WIN_VISIBLE, (T_MFW_CB)four_in_a_row_win_cb);

    if (data->win EQ 0)
      return 0;

	 /*
     * These assignments are necessary to attach the data to the window, and to handle the mmi event communication.
     */

	data->mmi_control.dialog    = (T_DIALOG_FUNC)four_in_a_row;
    data->mmi_control.data      = data;
	data->parent_win           = parent_window;
    win                         = ((T_MFW_HDR *)data->win)->data;
    win->user                   = (void *) data;

    /*
    * Create any other handler
    */

    data->kbd      = kbd_create (data->win,KEY_ALL,(T_MFW_CB)four_in_a_row_kbd_cb);

	column=0;	//set start value for game cursor
	winner ='0';			//game starts, so set winner to nobody

	/*clear the board*/
	for (y_runer=0;y_runer<MAX_Y_BOARD;y_runer++){
		for(x_runer=0;x_runer<MAX_X_BOARD;x_runer++){
			data->board_array[y_runer][x_runer] ='0';
		}
	}
	winShow(data->win);

  return data->win;
}

/*******************************************************************************

 $Function:    	four_in_a_rowr_destroy

 $Description:

 $Returns:

 $Arguments:

*******************************************************************************/

void four_in_a_row_destroy (T_MFW_HND own_window)
{
  T_MFW_WIN     * win;
  T_four_in_a_row       * data;

	TRACE_EVENT("four_in_a_row_destroy");

  if (own_window)
  {
    win  = ((T_MFW_HDR *)own_window)->data;
    data = (T_four_in_a_row *)win->user;

    if (data)
    {
      /*
       * Exit Keyboard Handler
       */
      /*
       * Delete WIN Handler
       */
      win_delete (data->win);
    }

   /*
   *  In this case the data attached to window must be also deleted.
   */
	FREE_MEMORY ((void *)data, sizeof (T_four_in_a_row));

   column=0;			//set the current column back to 0

  }
}

/*******************************************************************************

 $Function:    	four_in_a_row_start

 $Description:	 This function just creates and inits the new dialog

 $Returns:

 $Arguments:

*******************************************************************************/
T_MFW_HND four_in_a_row_start (T_MFW_HND win_parent,char *character)
{
  T_MFW_HND win;
 /*
 MmiTetrisStart();
 return;
 */
  win = four_in_a_row_create (win_parent);
  TRACE_EVENT("four_in_a_row_start");

  if (win NEQ NULL)
  {
		SEND_EVENT(win,FOUR_IN_A_ROW_INIT,0,character);
  }
  return win;

}

/*******************************************************************************

 $Function:    	four_in_a_row

 $Description:

 $Returns:

 $Arguments:

*******************************************************************************/



void four_in_a_row (T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
    T_MFW_WIN      * win_data = ((T_MFW_HDR *) win)->data;
    T_four_in_a_row       * data = (T_four_in_a_row *)win_data->user;

    TRACE_FUNCTION ("four_in_a_row()");

   /*
   *  In this case the communication is very simple (only one intern event)
   */


    switch (event)
	{
		case FOUR_IN_A_ROW_INIT:
			softKeys_displayId(TxtSearchName,TxtNull,0,COLOUR_IDLE);
			winShow(data->win);
		break;

	    default:
		return;
	}

}

/*******************************************************************************

 $Function:    	four_in_a_row_win_cb

 $Description:	win calback function of four in a row

 $Returns:

 $Arguments:

*******************************************************************************/


int four_in_a_row_win_cb (MfwEvt e, MfwWin *w)
{
//	T_DISPLAY_DATA display_info;  // RAVI
	T_four_in_a_row * data = (T_four_in_a_row *)w->user;
	int xOfs,yOfs, xScale, yScale;
	int manOfsX,manOfsY;
	int xPos,yPos;
	int y_axis;																	//goes through the vertical lines
	int x_axis;																	//goes through the horizontal lines
//	int x,y,i,b;     // RAVI
	int displayPosX, temp;

    TRACE_FUNCTION ("four_in_a_row_win_cb()");

	switch (e)
    {
        case MfwWinVisible:
#ifdef COLOURDISPLAY
				whiteStone = &stone_colour;
				blackStone = &stone_colour;

#else
				whiteStone = &blackStone_bw;
				blackStone = &whiteStone_bw;

#endif
#ifdef LSCREEN
				manOfsX = GAME_POS_X + 3;
				manOfsY = GAME_POS_Y + 3;
#else
				manOfsX = GAME_POS_X + 1;
				manOfsY = GAME_POS_Y + 1;
#endif
        		xOfs = GAME_POS_X;
        		yOfs = GAME_POS_Y;
        		xScale = GAME_SCALE_X;
        		yScale = GAME_SCALE_Y;

        		//dspl_ClearAll(); //Clears to white, not BGD!
        		TRACE_EVENT("display clear");
		     	resources_setColour( COLOUR_GAME );
    	  		dspl_Clear( 0,0, SCREEN_SIZE_X,SCREEN_SIZE_Y);
#ifdef LSCREEN
    	    	softKeys_displayId(TxtHelp,TxtExit,0,COLOUR_LIST_SUBMENU);
#endif

		     	resources_setColour( COLOUR_GAME );
    	  		dspl_Clear( xOfs, yOfs, xOfs+MAX_X_BOARD*xScale, yOfs+MAX_Y_BOARD*yScale ); //Clears to white, not BGD!
        		//dspl_BitBlt(column*xScale+xOfs+1,yOfs-yScale,8,8,0,(void*)game_cursor,0);	//place the cursor bitmap
		        dspl_show_bitmap(column*xScale+xOfs+1,yOfs-yScale, &gameCursor, 0 );
         		for (y_axis=0;y_axis<=MAX_Y_BOARD;y_axis++)
       			{
					dspl_DrawLine(	xOfs, 						yOfs+y_axis*yScale,
									xOfs+MAX_X_BOARD*xScale,	yOfs+y_axis*yScale);
       			}
				for(x_axis=0;x_axis<=MAX_X_BOARD;x_axis++)
				{
					dspl_DrawLine(	xOfs+x_axis*xScale,	yOfs,
									xOfs+x_axis*xScale,	yOfs+MAX_Y_BOARD*yScale);
				}

        		//go through the board-array and check for W or B and set the stones
       			for (y_axis=0;y_axis<MAX_Y_BOARD;y_axis++)
       			{
					for(x_axis=0;x_axis<MAX_X_BOARD;x_axis++)
					{
		       			xPos = manOfsX+x_axis*xScale;
		       			yPos = manOfsY+y_axis*yScale;
						if(data->board_array[y_axis][x_axis] EQ 'W'){			//found white
							//set white_stone bitmap
			        		dspl_SetFgdColour( COL_R );
		        			dspl_show_bitmap(xPos,yPos, whiteStone, 0 );
						}
						if(data->board_array[y_axis][x_axis] EQ 'B'){			//found black
							//set black_stone bitmap
			        		dspl_SetFgdColour( COL_G ); //0x00404040
		        			dspl_show_bitmap(xPos,yPos, blackStone, 0 );
						}
					}
				}
        		dspl_SetFgdColour( COL_RB );
        		dspl_SetBgdColour( COL_RG );
        		dspl_show_bitmap(GAME_NAMEPOSX1, GAME_NAMEPOSY1, &gameName1, 0 );
        		displayPosX = (SCREEN_SIZE_X/2);
				temp = strlen((char*)playAgain);
       			//this if-clause is to set the bitmap, for win or lost game
       			if(winner EQ 'W'){
       				//human player wins, so set win bitmap
#ifdef LSCREEN
	        		dspl_SetFgdColour( COL_BLK );
	        		dspl_SetBgdColour( COL_TRANSPARENT );
       				Game_Result = TRUE;
					softKeys_displayId(TxtYes,TxtNo,0,COLOUR_LIST_SUBMENU);
				    dspl_TextOut((displayPosX-((temp*CHAR_WIDTH)/2)),170,DSPL_TXTATTR_NORMAL,(char*)playAgain);
#endif
	        		dspl_SetFgdColour( COL_RB );
    	    		dspl_SetBgdColour( COL_GB );
					dspl_show_bitmap(GAME_WINPOSX1, GAME_WINPOSY1, &plWin1, 0 );
        			dspl_show_bitmap(GAME_WINPOSX2, GAME_WINPOSY2, &plWin2, 0 );
       			}
       			else
       			if(winner EQ 'B'){
       				//human player lost, so set lost bitmap
#ifdef LSCREEN
	        		dspl_SetFgdColour( COL_BLK );
	        		dspl_SetBgdColour( COL_TRANSPARENT );
       				Game_Result = TRUE;
					softKeys_displayId(TxtYes,TxtNo,0,COLOUR_LIST_SUBMENU);
				    dspl_TextOut((displayPosX-((temp*CHAR_WIDTH)/2)),170,DSPL_TXTATTR_NORMAL,(char*)playAgain);
#endif
	        		dspl_SetFgdColour( COL_RB );
    	    		dspl_SetBgdColour( COL_GB );
        			dspl_show_bitmap(GAME_WINPOSX1, GAME_WINPOSY1, &plLost1, 0 );
        			dspl_show_bitmap(GAME_WINPOSX2, GAME_WINPOSY2, &plLost2, 0 );
       			}
       			else
       			if(winner EQ 'N'){
					//board is full, nobody (N) wins
#ifdef LSCREEN
	        		dspl_SetFgdColour( COL_BLK );
					dspl_SetBgdColour( COL_TRANSPARENT );
       				Game_Result = TRUE;
					softKeys_displayId(TxtYes,TxtNo,0,COLOUR_LIST_SUBMENU);
				    dspl_TextOut((displayPosX-((temp*CHAR_WIDTH)/2)),170,DSPL_TXTATTR_NORMAL,(char*)playAgain);
#endif

	        		dspl_SetFgdColour( COL_R );
	        		dspl_SetBgdColour( COL_G );
        			dspl_show_bitmap(GAME_WINPOSX1, GAME_WINPOSY1, &draw1, 0 );
        			dspl_show_bitmap(GAME_WINPOSX2, GAME_WINPOSY2, &draw2, 0 );
       			}
       			else
       			{
        			dspl_SetFgdColour( COL_RB );
        			dspl_SetBgdColour( COL_RG );
        			dspl_show_bitmap(GAME_NAMEPOSX1, GAME_NAMEPOSY1, &gameName1, 0 );
        			dspl_show_bitmap(GAME_NAMEPOSX2, GAME_NAMEPOSY2, &gameName2, 0 );
        			dspl_show_bitmap(GAME_NAMEPOSX3, GAME_NAMEPOSY3, &gameName2, 0 );
       			}
        break;

        default:
        return 0;
    }

    return 1;
}

/*******************************************************************************

 $Function:    	four_in_a_row_kbd_cb

 $Description:

 $Returns:

 $Arguments:

*******************************************************************************/

int four_in_a_row_kbd_cb (MfwEvt e, MfwKbd *k)
{

	T_MFW_HND       win  = mfw_parent (mfw_header());
    T_MFW_WIN     * win_data = ((T_MFW_HDR *)win)->data;
    T_four_in_a_row         * data = (T_four_in_a_row *)win_data->user;

    TRACE_EVENT ("four_in_a_row_kbd_cb()");

	switch (k->code)
	{
			case KCD_HUP:						//quit the game "four in a row"
			case KCD_RIGHT:	 //quit the game "four in a row"
				TRACE_EVENT ("quit four_in_a_row");
				dspl_ClearAll();				//clear mobile screen
				four_in_a_row_destroy (win);	//destroy win-handler
			break;

			case KCD_MNULEFT:
			case KCD_1:
				if(winner EQ '0'){				//while nobody has won....
					TRACE_EVENT ("KCD_1");
					if(column > 0)
					{	//cursor must be greater than 0
						column=column-1;
					}
					winShow(data->win);
				}
			break;
			case KCD_MNUSELECT:
			case KCD_2:
				if(winner EQ '0'){				//while nobody has won....
					TRACE_EVENT ("KCD_2");
					drop_stone(data);			//drop stone
				}
				winShow(data->win);
			break;
			case KCD_MNURIGHT:
			case KCD_3:
				if(winner EQ '0'){				//while nobody has won....
					TRACE_EVENT ("KCD_3");
					if(column<MAX_X_BOARD-1 ){	//cursor must be less than 50
						column=column+1;
					}
					winShow(data->win);
				}
			break;
			case KCD_LEFT:
				if(Game_Result == TRUE)
				{
					Game_Result = FALSE;
					four_in_a_row_destroy(win);	//destroy win-handler
					four_in_a_row_start(win,0);
				}
				else
					Game_Info(win);
				break;
	}
    return MFW_EVENT_CONSUMED;
}

/*******************************************************************************

 $Function:    	four_in_a_row_aktivate

 $Description:	Starts the game function on user selection

 $Returns:		MFW_EVENT_CONSUMED if event handled, otherwise
				MFW_EVENT_PASSED

 $Arguments:	menu, menu item

*******************************************************************************/
int four_in_a_row_aktivate(MfwMnu* m, MfwMnuItem* i)
{

    T_MFW_HND	    	parent       = mfwParent( mfw_header());
    TRACE_EVENT("four_in_a_row_aktivate()");
    four_in_a_row_start(parent,0);
    return MFW_EVENT_CONSUMED;
}

/*******************************************************************************

 $Function:    	drop_stone

 $Description:	decide whether a stone can be droped and where it can be droped

 $Returns:

 $Arguments:	T_four_in_a_row

*******************************************************************************/
void drop_stone(T_four_in_a_row *data)
{
	int drop_position;											//position (y in current board column) where to drop the stone

	TRACE_EVENT("drop_stone()");
	request_stone=0;											//white is on turn
	drop_position=check_column(data,request_stone);				//set the drop position for the white stone in the current white, board column
	if(drop_position>=0){										//if the current column is not filled up set stone
		data->board_array[drop_position][column]='W';			//white is first and set a 'W' in the virtual board for a white stone
		check_for_winner(data,drop_position);					//check whether the last move(white) was a win-move...
		if(winner EQ '0'){										//...if not, then the mobile(black) is on turn
			drop_position=mobile_thinking(data);				//set the drop position for the black stone in the current black, board column
			data->board_array[drop_position][column_black]='B';	//set a 'B' for in the virtual board for a black stone
			check_for_winner(data,drop_position);				//check whether the last move(black) was a win-move...
		}
	}
}

/*******************************************************************************

 $Function:    	check_for_winner

 $Description:	checks the current drop position for a win-position

 $Returns:

 $Arguments:	T_four_in_a_row

*******************************************************************************/
void check_for_winner(T_four_in_a_row *data, int check_out_position)
{
	int check_with_this_color;				//set the color to check for
	int color_regulator;					//helps to switch between both colors
	int check_this_column;					//declares the column to check for

	TRACE_EVENT("check_for_winner()");
	if(data==NULL || check_out_position<0 || check_out_position>=MAX_Y_BOARD)
		{
		TRACE_ERROR("check_for_winner() invalid parameters");
		return;
		}
	color_regulator=0;						//at first, use white to check for
	winner='0';								//at first we don't know who wins, so nobody is set as winner
	while(color_regulator<2){				//while checking for white(0) and black(1) is not ready....
		if(color_regulator EQ 0){			//if color_regulator is 0, the board will be checked for white stones ('W')
			check_with_this_color='W';
		}else{								//if color_regulator is 1, the board will be checked for black stones ('B')
			check_with_this_color='B';
		}

		if(request_stone EQ 0){				//if the board will be checked for white, use column as the current column
			check_this_column=column;
		}else{								//if the board will be checked for black, use column_black as the current column
			check_this_column=column_black;
		}
		if(check_this_column<0 || check_this_column>=MAX_X_BOARD)
			{
			TRACE_ERROR("check_for_winner() invalid index check_this_column");
			break;
			}
		/*Begin with the checks, the mobile checks for vertical, horizontal and diagonal possibilities*/
		//check row
		if(check_this_column>=3 && check_this_column<=10 &&
			data->board_array[check_out_position][check_this_column-3] EQ check_with_this_color &&
			data->board_array[check_out_position][check_this_column-2] EQ check_with_this_color &&
			data->board_array[check_out_position][check_this_column-1] EQ check_with_this_color &&
			data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_this_column>=2 && check_this_column<=9 &&
				data->board_array[check_out_position][check_this_column-1] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column-2] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column+1] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_this_column>=0 && check_this_column<=7 &&
				data->board_array[check_out_position][check_this_column+1] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column+2] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column+3] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_this_column>=1 && check_this_column<=8 &&
				data->board_array[check_out_position][check_this_column-1] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column+1] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column+2] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
			//check column
		}else if(check_out_position<=4 &&
				data->board_array[check_out_position+1][check_this_column] EQ check_with_this_color &&
				data->board_array[check_out_position+2][check_this_column] EQ check_with_this_color &&
				data->board_array[check_out_position+3][check_this_column] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
			//check diagonal
		}else if(check_out_position<=4 && check_this_column>=3 && check_this_column<=10 &&
				data->board_array[check_out_position+1][check_this_column-1] EQ check_with_this_color &&
				data->board_array[check_out_position+2][check_this_column-2] EQ check_with_this_color &&
				data->board_array[check_out_position+3][check_this_column-3] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_out_position<=4 && check_this_column>=0 && check_this_column<=7 &&
				data->board_array[check_out_position+1][check_this_column+1] EQ check_with_this_color &&
				data->board_array[check_out_position+2][check_this_column+2] EQ check_with_this_color &&
				data->board_array[check_out_position+3][check_this_column+3] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_out_position>=3 && check_this_column>=0 && check_this_column<=7 &&
				data->board_array[check_out_position-1][check_this_column+1] EQ check_with_this_color &&
				data->board_array[check_out_position-2][check_this_column+2] EQ check_with_this_color &&
				data->board_array[check_out_position-3][check_this_column+3] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_out_position>=3 && check_this_column>=3 && check_this_column<=10 &&
				data->board_array[check_out_position-1][check_this_column-1] EQ check_with_this_color &&
				data->board_array[check_out_position-2][check_this_column-2] EQ check_with_this_color &&
				data->board_array[check_out_position-3][check_this_column-3] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_out_position<=6 && check_out_position>=2 && check_this_column>=1 && check_this_column<=8 &&
				data->board_array[check_out_position+1][check_this_column-1] EQ check_with_this_color &&
				data->board_array[check_out_position-1][check_this_column+1] EQ check_with_this_color &&
				data->board_array[check_out_position-2][check_this_column+2] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_out_position<=5 && check_out_position>=1 && check_this_column>=2 && check_this_column<=9 &&
				data->board_array[check_out_position+1][check_this_column-1] EQ check_with_this_color &&
				data->board_array[check_out_position+2][check_this_column-2] EQ check_with_this_color &&
				data->board_array[check_out_position-1][check_this_column+1] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_out_position<=5 && check_out_position>=1 && check_this_column>=1 && check_this_column<=8 &&
				data->board_array[check_out_position-1][check_this_column-1] EQ check_with_this_color &&
				data->board_array[check_out_position+1][check_this_column+1] EQ check_with_this_color &&
				data->board_array[check_out_position+2][check_this_column+2] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else if(check_out_position>=2 && check_out_position<=6 && check_this_column>=2 && check_this_column<=9 &&
				data->board_array[check_out_position-1][check_this_column-1] EQ check_with_this_color &&
				data->board_array[check_out_position-2][check_this_column-2] EQ check_with_this_color &&
				data->board_array[check_out_position+1][check_this_column+1] EQ check_with_this_color &&
				data->board_array[check_out_position][check_this_column] EQ check_with_this_color){
			winner=check_with_this_color;	//set the current color to check for as the winner
			break;
		}else{
			winner='0';						//no win-moves found, so nobody is the winner and the game goes on
		}
		color_regulator++;					//set the check color one up (to black)
	}
}
/*******************************************************************************

 $Function:    	check_column

 $Description:	checks for already set stones

 $Returns:		int unused_position

 $Arguments:	T_four_in_a_row

*******************************************************************************/
int check_column(T_four_in_a_row *data, int where_from)
{
	int unused_position;							//is for a free drop position
	int column_for_check;							//column (vertical board line) to check for

	if(where_from EQ 0){							//is the current game color(player) 0 then use column
		column_for_check=column;
	}else{											//is the current game color(player) 1 then use column_black
		column_for_check=column_black;
	}
	unused_position=-9999;
	for(y_runer=0;y_runer<MAX_Y_BOARD;y_runer++){	//test all vertical fields whether they are empty('0') or not
		if(data->board_array[y_runer][column_for_check] EQ '0'){
			unused_position=y_runer;				//.this field is empty, so it is a unused position
		}
	}
	return unused_position;							//return the unused position
}


/*******************************************************************************

 $Function:    	mobile_thinking

 $Description:	mobile moves

 $Returns:		drop position of black stone (drop_me)

 $Arguments:	T_four_in_a_row

*******************************************************************************/
int mobile_thinking(T_four_in_a_row *data)
{
	int position_score[11];									//this array takes the scoring values of each column in the game board
	int drop_position;										//drop position for stone
	int drop_me;											//buffer value
	int scores[4];											//this array keeps the scores for row, column and diagonals
	int add_random_score;

	TRACE_EVENT("mobile_thinking()");

	request_stone=1;										//black is
	//check for good spots to drop the black stone
	for(x_runer=0;x_runer<MAX_X_BOARD;x_runer++){
		//found the possible drop position
		column_black=x_runer;								//set the x_runer to the current column (column_black)
		drop_position=check_column(data,request_stone);		//check for possible drop positions
		if(drop_position>=0){								//if there is a possible drop position.....
			//check the scoring of the current point
			add_random_score=random_scoring();
			data->board_array[drop_position][x_runer]='B';				//set a test black stone
			scores[0]=check_line(data,x_runer,drop_position,1,0,0);		//scores row
			scores[1]=check_line(data,x_runer,drop_position,1,1,0);		//scores diagonal right-up/left-down
			scores[2]=check_line(data,x_runer,drop_position,1,-1,0);	//scores diagonal left-up/right-down
			scores[3]=check_line(data,x_runer,drop_position,0,1,0);		//scores down(column)
			position_score[x_runer]=scores[0]+scores[1]+scores[2]+scores[3];	//count all scores together to one total score
			if(drop_position-1 >=0){	//Is it possible to set a future stone here? If Yes go on...
				data->board_array[drop_position-1][x_runer]='W';		//set a test white stone for a possible next opponent move
				scores[0]=check_line(data,x_runer,drop_position-1,1,0,1);	//scores row
				scores[1]=check_line(data,x_runer,drop_position-1,1,1,1);	//scores diagonal right-up/left-down
				scores[2]=check_line(data,x_runer,drop_position-1,1,-1,1);	//scores diagonal left-up/right-down
				scores[3]=check_line(data,x_runer,drop_position-1,0,1,1);	//scores down(column)
				position_score[x_runer]=position_score[x_runer]-scores[0]-scores[1]-scores[2]-scores[3]+add_random_score;	//substraction of the future score from the normal score
				data->board_array[drop_position-1][x_runer]='0';		//remove test white stone
			}
			data->board_array[drop_position][x_runer]='0';				//remove test black stone
		}else{												//if there is no possible drop position set the score to -1
			position_score[x_runer]=-9999;
		}
	}

	drop_me=-9999;											//buffer is set to absolutely minus
	column_black=-9999;										//position of black cursor is left outer side of board
	for(x_runer=0;x_runer<MAX_X_BOARD;x_runer++){			//goes through the scoring array to find the highest score
		if(position_score[x_runer]>drop_me){
			drop_me=position_score[x_runer];
			column_black=x_runer;							//set the x_runer to the current column(column_black)
			drop_position=check_column(data,request_stone);	//this is the best drop position for the mobile
		}
	}
	if(column_black EQ -9999){								//if the column is -1, then the game board is filled up and nobody has won
		TRACE_EVENT("Board Full!!!");
		winner='N';											//set winner to nobody (N)
	}
	return drop_position;									//return the mobile drop position
}

/*******************************************************************************

 $Function:    	check_line

 $Description:	set score points for the mobile, so the mobile knows where to set the next stone

 $Returns:		total_score

 $Arguments:	T_four_in_a_row, x_value, drop_position, dx, dy, where_from

*******************************************************************************/
int check_line(T_four_in_a_row *data, int x_value, int y_value, int dx, int dy, BOOL where_from)
{
	int lSc,nSc,oSc,total_score,sx,sy,i,j;
	int pl_nSc; //no of empty squares that have a man under them (i.e. we/opponent can use next shot)
	total_score=0;
	for (i=0;i<4;i++){
		sx = x_value-i*dx;
		sy = y_value-i*dy;
		lSc=0;
		nSc=0;	pl_nSc=0;
		oSc=0;
		for (j=0;j<4;j++){
			if ((sx<0) || (sx>=MAX_X_BOARD) ||(sy<0) || (sy>=MAX_Y_BOARD)){ /*a0393213 lint warnings removal - 'Possible access of out-of-bounds pointer'*/
				lSc = -1;
			}else if (lSc>=0){
				if(where_from EQ 0){
					if (data->board_array[sy][sx] EQ 'B'){
							lSc++;
					}else if (data->board_array[sy][sx] EQ '0'){
						nSc++;
						if ((sy EQ (MAX_Y_BOARD-1)) || (data->board_array[sy+1][sx] NEQ '0'))	/*a0393213 lint warnings removal - 'Possible access of out-of-bounds pointer'*/
							pl_nSc++;
					}else if (data->board_array[sy][sx] EQ 'W'){
							oSc++;

					}else //edge of board found
						lSc=-1;
					sx = sx+dx;
					sy = sy+dy;
				}else{
					if (data->board_array[sy][sx] EQ 'W'){
							lSc++;
					}else if (data->board_array[sy][sx] EQ '0'){
						nSc++;
						if ((sy EQ (MAX_Y_BOARD-1)) || (data->board_array[sy+1][sx] NEQ '0'))	/*a0393213 lint warnings removal - 'Possible access of out-of-bounds pointer'*/
							pl_nSc++;
					}else if (data->board_array[sy][sx] EQ 'B'){
							oSc++;

					}else //edge of board found
						lSc=-1;
					sx = sx+dx;
					sy = sy+dy;
				}
			}
		}
		if (lSc >= 0){
			if (lSc EQ 4){
				return(9999);//got 4 in a row.
			}else if (oSc EQ 3) //and ISc==1
			{
				// 3 opp men - good spot!
				if(where_from EQ 0){
					total_score = total_score + 1000; //this is for the normal, current position score
				}else{
					total_score = -total_score - 1000; //this is for the possible future score, it must be minus, because it will be substracted from normal score
				}
			}else if ((lSc EQ 3) && (nSc EQ 1)){
				//playing here will form 3 in a row and a blank - good spot
				if (pl_nSc EQ 0) //can't reach the 4th position
					total_score = total_score + 75;
				else
					total_score = total_score + 125;//better if we can reach 4th position
			}else if ((oSc EQ 2) && (nSc EQ 1)){
				// 2 opp men + 1 blank- good spot!
				if (pl_nSc EQ 0) //can't reach the 4th position-not too bad
					total_score = total_score + 50;
				else
					total_score = total_score + 200;//can get to both positions - have to block.
			}else if ((lSc EQ 2) && (nSc EQ 2)){
				// 2 in a row and 2 blanks - OK spot
				if (pl_nSc EQ 0) //can't reach the 3rd or 4th position-not too good
					total_score = total_score + 20;
				else if (pl_nSc EQ 1) //can reach one of the 3rd or 4th position - good
					total_score = total_score + 45;
				else if (pl_nSc EQ 2) //can reach both 3rd and 4th position - very good
					total_score = total_score + 95;
			}else if ((lSc EQ 1) && (nSc EQ 3)){
				// 1 in a row and 3 blanks - OK spot, better if we can reach the other 3 points.
				total_score = total_score + 2*(pl_nSc+1);	//pl_nSc=0,1,2 or 3 sc=sc+2,4,6 or 8
			}
			//else //line is neither good nor bad.
		}
		else //line is not valid
			total_score = total_score - 1;
	}
	return(total_score);
}
/*******************************************************************************

 $Function:    	check_line

 $Description:	generates a random number to add on the field scores

 $Returns:		random_score_result

 $Arguments:

*******************************************************************************/
int random_scoring(void)
{
	return(rand()%100);
}



#define MAX_TET_X 11
#define MAX_TET_Y 20

typedef struct
{

	T_MMI_CONTROL   mmi_control;		// common control parameter
	T_MFW_HND win;
	T_MFW_HND hKbd;
	T_MFW_HND	menu;
	T_MFW_HND 	parent_win;
	T_MFW_HND       info_tim;

	int dropTime;
	int maxDropTime;
	int timeStep;

	int xPos;
	int yPos;

	int px;
	int py;
	int shapeId;
	char shapeStr[20];
	int rotateId;

	int score;
	int level;
	int linesToGo;

	int resetSpeed;

	int gameOver;

	char tetrisScreen[MAX_TET_X][MAX_TET_Y];

} T_TETRIS;


static MfwHnd TetrisCreate(MfwHnd hParentWin);
static void TetrisExecCb (MfwHnd hWin, USHORT uiE, SHORT iValue, void *pParameter);
static int TetrisKbdCb (MfwEvt uiE, MfwKbd *psK);
static int  tetris_tim_cb(MfwEvt e, MfwTim *t);
static int TetrisWinCb (MfwEvt uiE, MfwWin *psWin);


#define E_INIT 0x5000
#define E_EXIT 0x5001

void initTetGame(T_TETRIS *data)
{
	int x,y;
	for (y=0;y<MAX_TET_Y;y++)
	{
		for (x=0;x<MAX_TET_X;x++)
			data->tetrisScreen[x][y]=' ';
		data->tetrisScreen[0][y]='#';
		data->tetrisScreen[MAX_TET_X-1][y]='#';

	}
	for (x=0;x<MAX_TET_X;x++)
		data->tetrisScreen[x][MAX_TET_Y-1]='#';
}

#define MAX_SHAPE 7
void tetris_getShape(int shapeId, int rotate, char* shapeStr)
{
	int j,k;
	int index;
	const char* tetShape[4*4*MAX_SHAPE] =
		{	"    ", " A  ",	"  B ",	" C  ",	"    ",	"F   ",	"  G ",
			"EEEE", " AA ",	" BB ",	"CCC ",	" DD ",	"FFF ",	"GGG ",
			"    ", "  A ",	" B  ",	"    ",	" DD ",	"    ",	"    ",
			"    ", "    ",	"    ",	"    ",	"    ",	"    ",	"    ",
			" E  ", " AA ",	"BB  ",	" C  ",	"    ",	" FF ",	" G  ",
			" E  ", "AA  ",	" BB ",	" CC ",	" DD ",	" F  ",	" G  ",
			" E  ", "    ",	"    ",	" C  ",	" DD ", " F  ",	" GG ",
			" E  ", "    ",	"    ",	"    ",	"    ",	"    ",	"    ",
			"    ", " A  ",	"  B ",	"    ",	"    ",	"    ",	"    ",
			"EEEE", " AA ",	" BB ",	"CCC ",	" DD ",	"FFF ",	"GGG ",
			"    ", "  A ",	" B  ",	" C  ",	" DD ",	"  F ",	"G   ",
			"    ", "    ",	"    ",	"    ",	"    ",	"    ",	"    ",
			" E  ", " AA ",	"BB  ",	" C  ",	"    ",	" F  ",	"GG  ",
			" E  ", "AA  ",	" BB ",	"CC  ",	" DD ",	" F  ",	" G  ",
			" E  ", "    ",	"    ",	" C  ",	" DD ",	"FF  ",	" G  ",
			" E  ", "    ",	"    ",	"    ",	"    ",	"    ",	"    "
		};


	for (k=0;k<4;k++)
	{
		index = rotate*4*MAX_SHAPE+k*MAX_SHAPE;
		for (j=0;j<4;j++)
			shapeStr[j+k*4] = tetShape[index+shapeId][j];
	}
}

int tetris_getNextShapeId( void )
{
	static int shapeIndex = 0;
	shapeIndex = (shapeIndex+1) % MAX_SHAPE;
	return (shapeIndex);
}



void tetris_getNextShape(T_TETRIS *data)
{
	data->shapeId  = tetris_getNextShapeId( );
	data->rotateId = 0;
	tetris_getShape(data->shapeId, data->rotateId, data->shapeStr);
	data->px = (MAX_TET_X-2)/2;
	data->py = 0;
}

void tetris_getNextLevel(T_TETRIS *data)
{
	initTetGame(data);
	tetris_getNextShape(data);
	data->level = data->level+1;
	data->linesToGo = 5*(data->level+1);
    data->resetSpeed = 0;
   	data->maxDropTime = (120-data->level*5);
}

void initTetrisData( T_TETRIS *data )
{
	data->level = 0;
	data->score = 0;
	data->gameOver = 0;
	tetris_getNextLevel(data);
}

void dspl_FillRect( int x1, int y1, int sx, int sy)
{
	dspl_DrawFilledBgdRect(x1,y1,x1+sx,y1+sy);
}

void tetris_drawScreen( int allScreen, T_TETRIS *data)
{
	int x1,y1,x2,y2;
	int bCol;
	int xOfs =5;
	int yOfs=10;
	int xOfs2=30;
	int yOfs2=10;
	int sx,sy;
	int px,py;
//	U32 oldfCol=0;   // RAVI
//	U32 oldbCol=0;  // RAVI
	int x = data->px;
	int y = data->py;

//	char dbg[80];  // RAVI


#ifdef LSCREEN
	//Calculate size based on the screen properties
	sx = (SCREEN_SIZE_X-xOfs-xOfs2)/MAX_TET_X;
	sy = (SCREEN_SIZE_Y-yOfs-yOfs2-Mmi_layout_softkeyHeight())/MAX_TET_Y;
#else
	//Screen is very small - ensure shapes are as large as possible
	sy = SCREEN_SIZE_Y/MAX_TET_Y;
	sx = SCREEN_SIZE_X/MAX_TET_X;
	if (sx >sy+1)
		sx = sy+1;
	xOfs = 5;
	xOfs2 = SCREEN_SIZE_X - (sx*MAX_TET_X+xOfs);
	yOfs = 0;
	yOfs2 = SCREEN_SIZE_Y - (sy*MAX_TET_Y+xOfs);
#endif
//allScreen= 1;

	resources_setColour(COLOUR_GAME);

	if (allScreen)
	{	//redraw everything
		x1 = 0;
		y1 = 0;
		x2 = MAX_TET_X;
		y2 = MAX_TET_Y;

	}
	else //just draw+1 box around current man
	{
		x1 = x-1;
		y1 = y-1;
		x2 = x+5;
		y2 = y+4;
		if (x1<1)x1=1;
		if (y1<0)y1=0;
		if (x2>MAX_TET_X-1) x2=MAX_TET_X-1;
		if (y2>MAX_TET_Y-1) y2=MAX_TET_Y-1;
	}

#ifndef COLOURDISPLAY
	dspl_Clear  (xOfs+x1*sx,yOfs+y1*sy,xOfs+x2*sx-1,yOfs+y2*sy-1);
#endif
	for (px = x1;px<x2;px++)
	{
		for (py = y1;py<y2;py++)
		{
			char boardChr = data->tetrisScreen[px][py];
			if ((px >= x ) && (px < x+4) &&
			    (py >= y ) && (py < y+4))
			{
				int shapeX,shapeY;
				shapeX = px-x;
				shapeY = py-y;
				if (data->shapeStr[shapeX+shapeY*4] != ' ')
					boardChr = data->shapeStr[shapeX+shapeY*4];
			}
#ifdef COLOURDISPLAY
			switch (boardChr)
			{
			case '#':	bCol = 0x00FFFFFF;	break;
			case ' ':	bCol = 0x00404040;	break;
			case 'A':	bCol = 0x000000FF;	break;
			case 'B':	bCol = 0x0000FF00;	break;
			case 'C':	bCol = 0x00FF0000;	break;
			case 'D':	bCol = 0x0000FFFF;	break;
			case 'E':	bCol = 0x00FF00FF;	break;
			case 'F':	bCol = 0x00FFFF00;	break;
			default:	bCol = 0x00FFFFFF;	break;
			}
			dspl_SetBgdColour(bCol);
			dspl_FillRect(xOfs+px*sx,yOfs+py*sy,sx,sy);
//			dspl_SetFgdColour(0x00802040);
			if (boardChr != ' ')
				dspl_DrawRect (xOfs+px*sx,yOfs+py*sy,xOfs+px*sx+sx-1,yOfs+py*sy+sy-1);
#else
			if (boardChr != ' ')
				dspl_DrawRect (xOfs+px*sx,yOfs+py*sy,xOfs+px*sx+sx-1,yOfs+py*sy+sy-1);
#endif
		}
	}
	if (data->gameOver)
	{
		int oldfCol = dspl_SetFgdColour(0x00FFFF00);
		dspl_SetBgdColour(0x008000FF);
		dspl_FillRect(xOfs+sx*3-5,yOfs+sy*3-5, xOfs+sx*3+5+6*4,yOfs+sy*3+5+18);
		dspl_TextOut(xOfs+sx*3,yOfs+sy*3,    0, "GAME");
		dspl_TextOut(xOfs+sx*3,yOfs+sy*3+Mmi_layout_line_height()+4, 0, "OVER");
		dspl_SetFgdColour(oldfCol);

	}
	resources_restoreColour();
}



int tetris_addShapeToScreen(T_TETRIS *data)
{
	int x,y;
	for (x=0;x<4;x++)
		for (y=0;y<4;y++)
			if (data->shapeStr[x+y*4] != ' ')
			{
				if (data->tetrisScreen[data->px+x][data->py+y]!= ' ')
					return(1);
				else
					data->tetrisScreen[data->px+x][data->py+y] = data->shapeStr[x+y*4];
			}
	return(0);

}

int tetris_testForCompleteLines( T_TETRIS *data )
{
	int nLines=0;
	int x,y;
	int blanks;
	for (y=MAX_TET_Y-2;y>0;y--)
	{
		blanks = 0;

		for (x=1;x<MAX_TET_X-1;x++)
		{
			if (data->tetrisScreen[x][y] == ' ')
				blanks++;
			if (nLines >0)
				data->tetrisScreen[x][y+nLines] = data->tetrisScreen[x][y];
		}
		if (blanks==0)
			nLines++;

	}
	return (nLines);
}


void tetris_testGameOver( T_TETRIS *data )
{
	int linesComplete;

	data->gameOver = tetris_addShapeToScreen(data);
	if (!data->gameOver)
	{

		linesComplete = tetris_testForCompleteLines(data);
		if (linesComplete >0)
		{
			data->score		= data->score + linesComplete*linesComplete;
			data->linesToGo = data->linesToGo - linesComplete;
			if (data->linesToGo <0)
				tetris_getNextLevel(data);
		}
		tetris_getNextShape(data);
	}
}





void tetris_destroy (T_MFW_HND own_window)
{
  T_MFW_WIN     * win  = ((T_MFW_HDR *)own_window)->data;
  T_TETRIS  * data   = (T_TETRIS *)win->user;

  TRACE_EVENT ("tetris_destroy()");

  if (own_window == NULL)
  {
	TRACE_EVENT ("Error :- Called with NULL Pointer");
	return;
  }

  if (data)
  {
       /*
       * Exit ICON & KEYBOARD Handle
       */
       kbdDelete (data->hKbd);
       timDelete(data->info_tim);
       /*
       * Delete WIN Handler
       */
       winDelete (data->win);
       /*
       * Free Memory
       */
       FREE_MEMORY ((void *)data, sizeof (T_TETRIS));
 }
}



int MmiTetrisStart(void )
{
    	MfwHnd hWin;

	MfwHnd hParentWin = mfwParent(mfwHeader());

    	TRACE_FUNCTION ("TetrisStart()");

    	hWin = TetrisCreate (hParentWin);

   	if (hWin NEQ NULL)
	{
	    	SEND_EVENT (hWin, E_INIT, NULL, NULL);
	}

    	return 1;
}

void initTetrisData( T_TETRIS *data );
static MfwHnd TetrisCreate(MfwHnd hParentWin)
{
	T_TETRIS *psData = (T_TETRIS *)ALLOC_MEMORY (sizeof( T_TETRIS));
    MfwWin *psWin;
	MfwWinAttr *win_attr;

   	TRACE_FUNCTION ("TetrisCreate()");

   	if (psData == NULL)
   	{
		TRACE_EVENT ("ALLOC_MEMORY() failed");
   		return NULL;
   	}

	win_attr = (MfwWinAttr *) ALLOC_MEMORY (sizeof(MfwWinAttr));
	if (win_attr)
	{
		win_attr->win.px = 0;
		win_attr->win.py = 0;
		win_attr->win.sx = SCREEN_SIZE_X;
		win_attr->win.sy = SCREEN_SIZE_Y;
	}
   	psData->win = winCreate (hParentWin, win_attr, E_WIN_VISIBLE, (T_MFW_CB)TetrisWinCb);
    if (psData->win == NULL)
	{
		mfwFree((U8*) win_attr, sizeof(MfwWinAttr));
		FREE_MEMORY((void *)psData, sizeof (T_TETRIS));
	    	return NULL;
	}
    	psData->mmi_control.dialog = (T_DIALOG_FUNC)TetrisExecCb;
    	psData->mmi_control.data   = psData;
    	psData->timeStep = 150;
    	psData->maxDropTime = 120;
    	psData->dropTime = psData->maxDropTime;
    	psWin = ((MfwHdr *)psData->win)->data;
    	psWin->user = (void *)psData;
    	psData->parent_win = hParentWin;
		initTetrisData( psData );

    	return psData->win;
}

static int TetrisWinCb (MfwEvt uiE, MfwWin *psWin)
{
    	T_TETRIS *psData = (T_TETRIS *)psWin->user;

   	TRACE_FUNCTION ("TetrisWinCb()");

    switch (uiE)
	{
       case MfwWinVisible:
			dspl_ResetWindow();
			dspl_SetBgdColour(0x000000FF);
			dspl_Clear(0,0,SCREEN_SIZE_X-1,SCREEN_SIZE_Y-1 );
			tetris_drawScreen( 1, psData);

	    	break;

	case MfwWinFocussed:
	case MfwWinDelete:
       default:
	    	return MFW_EVENT_REJECTED;
	}
   TRACE_FUNCTION ("TetrisWinCb() - end");
	return MFW_EVENT_CONSUMED;
}

static void TetrisExecCb (MfwHnd hWin, USHORT uiE, SHORT iValue, void *pParameter)
{
	MfwWin *psWin = ((MfwHdr *) hWin)->data;
	T_TETRIS *psData = (T_TETRIS *)psWin->user;

	TRACE_FUNCTION ("TetrisExecCb()");

	switch (uiE)
	{
	case E_INIT:

          psData->info_tim  = timCreate(hWin, psData->timeStep, (MfwCb)tetris_tim_cb);
		  psData->hKbd = kbdCreate(psData->win, KEY_ALL, (MfwCb)TetrisKbdCb);
	      timStart(psData->info_tim);

		/*  */
	       winShow(hWin);

	       break;

    case E_EXIT:
            tetris_destroy(hWin);
            break;

	default:
	       return;
	}

	return;
}


static int tetris_checkPos( T_TETRIS *data, int px, int py, char* shape)
{
	int x,y;
	for (x=0;x<4;x++)
		for (y=0;y<4;y++)
			if (shape[x+y*4] != ' ')
			{
				if (data->tetrisScreen[px+x][py+y]!= ' ')
					return(1);
			}
	return(0);
}

static int tetris_moveDown(T_TETRIS *data,int *px, int *py)
{
	int cannotMove;
	cannotMove = tetris_checkPos(data,*px,*py+1,data->shapeStr);
	if (cannotMove)
		return (1);
	else
		*py = *py+1;
	return (0);
}
static int tetris_moveLeft(T_TETRIS *data, int *px, int *py)
{
	int cannotMove;
	cannotMove = tetris_checkPos(data,*px-1,*py,data->shapeStr);
	if (cannotMove)
		return (1);
	else
		*px = *px-1;
	return (0);
}
static int tetris_moveRight( T_TETRIS *data, int *px, int *py)
{
	int cannotMove;
	cannotMove = tetris_checkPos(data,*px+1,*py,data->shapeStr);
	if (cannotMove)
		return (1);
	else
		*px = *px+1;
	return (0);
}

static int tetris_rotateLeft( T_TETRIS *data, int *px, int *py )
{
	int i;
	int cannotMove;
	char tmpShape[20];
	tetris_getShape(data->shapeId,(data->rotateId+1)%4,tmpShape);
	cannotMove = tetris_checkPos(data,*px,*py,tmpShape);
	if (cannotMove)
		return (1);
	for (i=0;i<16;i++)
		data->shapeStr[i] = tmpShape[i];
	data->rotateId = (data->rotateId+1)%4;
	return (0);
}

static int tetris_rotateRight( T_TETRIS *data, int *px, int *py )
{
	int i;
	int cannotMove;
	char tmpShape[20];
	tetris_getShape(data->shapeId,(data->rotateId+3)%4,tmpShape);
	cannotMove = tetris_checkPos(data,*px,*py,tmpShape);
	if (cannotMove)
		return (1);
	for (i=0;i<16;i++)
		data->shapeStr[i] = tmpShape[i];
	data->rotateId = (data->rotateId+3)%4;
	return (0);
}
#define KEY_TET_MOVELEFT    KCD_1
#define KEY_TET_MOVERIGHT   KCD_3
#define KEY_TET_ROTATELEFT  KCD_4
#define KEY_TET_ROTATERIGHT KCD_6
#define KEY_TET_DROPALL		  KCD_5
#define KEY_TET_DROP		  KCD_2


static int TetrisKbdCb (MfwEvt uiE, MfwKbd *psK)
{
    	MfwHnd hWin = mfwParent(mfwHeader());
    	MfwWin *psWin = ((MfwHdr *)hWin)->data;
    	T_TETRIS *psData = (T_TETRIS *)psWin->user;
    	int cannotMove=0;


    	TRACE_FUNCTION ("TetrisKbdCb()");
		/***************************Go-lite Optimization changes Start***********************/
		//	Aug 16, 2004    REF: CRR 24323   Deepa M.D
		TRACE_EVENT_P1 ("Code : %d",(int)psK->code);
		/***************************Go-lite Optimization changes Start***********************/


	switch(psK->code )
	{
		case KEY_TET_MOVELEFT:
		case KCD_MNULEFT:
			tetris_moveLeft(psData,&psData->px,&psData->py);
			break;
		case KEY_TET_MOVERIGHT:
		case KCD_MNURIGHT:
			tetris_moveRight(psData,&psData->px,&psData->py);
			break;
		case KEY_TET_ROTATELEFT:
			tetris_rotateLeft(psData,&psData->px,&psData->py);
			break;
		case KCD_MNUSELECT:
		case KEY_TET_ROTATERIGHT:
			tetris_rotateRight(psData,&psData->px,&psData->py);
			break;
		case KEY_TET_DROP:
			cannotMove = tetris_moveDown(psData,&psData->px,&psData->py);
			if (cannotMove)
				tetris_testGameOver( psData );
			break;
		case KEY_TET_DROPALL:
			while(tetris_moveDown(psData,&psData->px,&psData->py) ==0)
			{ //loop until we hit the bottom

			}
			cannotMove = 1;
			tetris_testGameOver( psData );
			break;


		case KCD_RIGHT:
            SEND_EVENT (hWin, E_EXIT, 0, 0);
			return MFW_EVENT_CONSUMED;

		default:

		    	return MFW_EVENT_CONSUMED;
	}
	tetris_drawScreen(cannotMove, psData);

    	TRACE_FUNCTION ("TetrisKbdCb()-end");
    	return MFW_EVENT_CONSUMED;
}

static int  tetris_tim_cb(MfwEvt e, MfwTim *t)
{
      T_MFW_HND       win  = mfw_parent (mfw_header());
      T_MFW_WIN     * win_data = ((T_MFW_HDR *)win)->data;
      T_TETRIS   * data = (T_TETRIS *)win_data->user;
  	  static int nCycles = 0;
	  int cannotMove;

  		char bfr[80];
  		nCycles = nCycles+ data->timeStep;
  		if (nCycles > 1000)
  		{
  			nCycles = nCycles - 1000;
  			data->maxDropTime = data->maxDropTime-1;
		}
      TRACE_EVENT("tetris_tim_cb");
    	data->dropTime = data->dropTime - data->timeStep;
    	if (data->dropTime < 0)
    	{
    		if (data->maxDropTime > 90)
		    	data->dropTime = data->dropTime+75*10;
    		else if (data->maxDropTime > 60)
		    	data->dropTime = data->dropTime+(60+(data->maxDropTime-60)/2)*10;
    		else if (data->maxDropTime > 30)
		    	data->dropTime = data->dropTime+data->maxDropTime*10;
    		else
		    	data->dropTime = data->dropTime+(data->maxDropTime+90)/4*10;

    		if (data->dropTime < data->timeStep)
    			data->dropTime = data->timeStep;
    		else if (data->dropTime < data->timeStep)
    			data->dropTime = data->timeStep;

			resources_setColour(COLOUR_GAME);
			sprintf(bfr,"%d ",data->score);
			dspl_TextOut(SCREEN_SIZE_X-30 ,10, 0, bfr);
			sprintf(bfr,"%d ",data->linesToGo);
			dspl_TextOut(SCREEN_SIZE_X-30 ,12+Mmi_layout_line_height(), 0, bfr);
			resources_restoreColour();
			cannotMove = tetris_moveDown(data,&data->px,&data->py);
			tetris_getNextShapeId( );//To randomize it

			if (cannotMove)
			{
				tetris_testGameOver( data );
			}
			tetris_drawScreen(cannotMove, data);
		}

      timStart(data->info_tim);
      TRACE_EVENT("tetris_tim_cb-end");
      return 1;
}

T_MFW_HND Game_Info(T_MFW_HND parent_window)
{
  	T_MFW_HND       	win           = ShowGame_Information(parent_window);
	TRACE_FUNCTION("ShowVerion()");
    if (win NEQ NULL)
        {
           	SEND_EVENT (win, SHOWGAMEINFO_INIT, 0, 0);
        }

   return win;
}

static T_MFW_HND ShowGame_Information(MfwHnd parent_window)
{
	tShowInfo* data = (tShowInfo*)ALLOC_MEMORY (sizeof (tShowInfo));
	T_MFW_WIN* win;

	if (data EQ NULL)
	{
		return NULL;
	}

	// Create the window handler
	data->win = win_create (parent_window, 0, E_WIN_VISIBLE, NULL);
	if (data->win EQ NULL)
	{
		return NULL;
	}

	// connect the dialog data to the MFW window
	data->mmi_control.dialog = (T_DIALOG_FUNC)ShowGame_DialogCB;
	data->mmi_control.data  = data;

	win                    = ((T_MFW_HDR *)data->win)->data;
	win->user              = (void *)data;
	data->parent_win        = parent_window;

	return data->win;
}

static void ShowGame_DialogCB(T_MFW_HND win, USHORT e, SHORT identifier, void *parameter)
{
	T_MFW_WIN		*win_data = ((T_MFW_HDR *) win)->data;
	tShowInfo* data = (tShowInfo*) win_data->user;
	/* SPR#1428 - SH - New editor data */
#ifdef NEW_EDITOR
//	T_AUI_EDITOR_DATA editor_data;  // RAVI
#else /* NEW_EDITOR */
//	T_EDITOR_DATA editor_data;   // RAVI
#endif /* NEW_EDITOR */

	switch (e)
	{
		case SHOWGAMEINFO_INIT:
		{
			strcat(data->buffer, info);

			ShowGameInfoEditor(win);

			/* SPR#1428 - SH - New editor changes */
#ifdef NEW_EDITOR
			data->editor_data.Callback	= (T_AUI_EDIT_CB)ShowInfoCB;
			AUI_edit_Start(win, &(data->editor_data));
#else /* NEW_EDITOR */
			data->editor_data.Callback	= (T_EDIT_CB)ShowInfoCB;
			editor_start(win, &(data->editor_data));
#endif /* NEW_EDITOR */

			winShow(data->win);
		}
		break;

		default:
		{
			TRACE_EVENT("Show Game Info : Unknown Event");
		}
		break;
	}
}

void ShowGameInfoEditor (T_MFW_HND win)
{
	T_MFW_WIN *win_data = ((T_MFW_HDR *) win)->data;
	tShowInfo* data = (tShowInfo*) win_data->user;

/* SPR#1428 - SH - New editor changes */
#ifdef NEW_EDITOR
	AUI_edit_SetDefault(&data->editor_data);
	AUI_edit_SetDisplay(&data->editor_data, NULL, COLOUR_EDITOR, EDITOR_FONT);
	AUI_edit_SetTextStr(&data->editor_data, TxtSoftBack, TxtNull, TxtNull, NULL);
	AUI_edit_SetEvents(&data->editor_data, 0, TRUE, FOREVER, NULL);
	AUI_edit_SetBuffer(&data->editor_data, ATB_DCS_ASCII, (UBYTE *)data->buffer, 35);
	AUI_edit_SetMode(&data->editor_data, ED_MODE_READONLY, ED_CURSOR_NONE);
#else /* NEW_EDITOR */
	editor_attr_init(&((data->editor_data).editor_attr), NULL, edtCurNone, 0, (char*)data->buffer, 35, COLOUR_EDITOR);
	editor_data_init(&data->editor_data, NULL, TxtSoftBack, TxtNull, 0, 1, READ_ONLY_MODE, FOREVER);

	data->editor_data.hide			= FALSE;
	data->editor_data.Identifier	= 0;
	data->editor_data.TextString	= NULL;
	data->editor_data.destroyEditor	= TRUE;
#endif /* NEW_EDITOR */
}

static void ShowInfoCB( T_MFW_HND win, USHORT Identifier,UBYTE reason)
{
    T_MFW_WIN       *win_data   = ( (T_MFW_HDR *) win )->data;
    tShowInfo*data       = (tShowInfo*) win_data->user;


    TRACE_FUNCTION("ShowVerionCB()");

	switch (reason )
    {
      case INFO_KCD_LEFT:
	  case INFO_KCD_HUP:
      case INFO_KCD_RIGHT:

        default:
		showGameInfo_destroy(data->win);
		break;
	}
}

/*******************************************************************************

 $Function:    	showVersion_destroy

 $Description:	Destroys the editor

 $Returns:

 $Arguments:

*******************************************************************************/
void showGameInfo_destroy(MfwHnd own_window)
{
  T_MFW_WIN * win_data;

  tShowInfo* data = NULL;

	if (own_window == NULL)
	{
		TRACE_EVENT ("Error : showGameInfo_destroy called with NULL Pointer");
		return;
	}


	win_data = ((T_MFW_HDR *)own_window)->data;
		if (win_data != NULL)
			data = (tShowInfo*)win_data->user;

	  if (data)
		{
		TRACE_EVENT ("calc_destroy()");

			win_delete (data->win);
		  // Free Memory
			FREE_MEMORY ((void *)data, sizeof (tShowInfo));

		}
	  else
		{
			TRACE_EVENT ("calc_destroy() called twice");
		}
}
#endif