0
+ − 1 /*******************************************************************************
+ − 2
+ − 3 CONDAT (UK)
+ − 4
+ − 5 ********************************************************************************
+ − 6
+ − 7 This software product is the property of Condat (UK) Ltd and may not be
+ − 8 disclosed to any third party without the express permission of the owner.
+ − 9
+ − 10 ********************************************************************************
+ − 11
+ − 12 $Project name: Basic MMI
+ − 13 $Project code: BMI (6349)
+ − 14 $Module: Game
+ − 15 $File: Mmigame.c
+ − 16 $Revision: 1.0
+ − 17
+ − 18 $Author: Condat(UK)
+ − 19 $Date: 03/07/01
+ − 20
+ − 21 ********************************************************************************
+ − 22
+ − 23 Description
+ − 24 Aug 16, 2004 REF: CRR 24323 Deepa M.D
+ − 25 Bug:Clenup of sprintf used for tracing
+ − 26 Fix:Replace the char buf[]; sprintf (buf, "...", ...); TRACE_EVENT (buf); statements by TRACE_EVENT_PX
+ − 27
+ − 28 This provides the main game (four in a row) functionality
+ − 29
+ − 30
+ − 31 ********************************************************************************/
+ − 32
+ − 33
+ − 34 /*******************************************************************************
+ − 35
+ − 36 Include files
+ − 37
+ − 38 *******************************************************************************/
+ − 39
+ − 40 #define ENTITY_MFW
+ − 41
+ − 42 /* includes */
+ − 43 #include <string.h>
+ − 44 #include <stdio.h>
+ − 45 #include <stdlib.h>
+ − 46
+ − 47 #if defined (NEW_FRAME)
+ − 48
+ − 49 #include "typedefs.h"
+ − 50 #include "vsi.h"
+ − 51 #include "pei.h"
+ − 52 #include "custom.h"
+ − 53 #include "gsm.h"
+ − 54
+ − 55 #else
+ − 56
+ − 57 #include "STDDEFS.H"
+ − 58 #include "custom.h"
+ − 59 #include "gsm.h"
+ − 60 #include "vsi.h"
+ − 61
+ − 62 #endif
+ − 63 #include "mfw_sys.h"
+ − 64
+ − 65 #include "cus_aci.h"
+ − 66
+ − 67 #include "mfw_mfw.h"
+ − 68 #include "mfw_win.h"
+ − 69 #include "mfw_kbd.h"
+ − 70 /* SPR#1428 - SH - New Editor changes */
+ − 71 #ifndef NEW_EDITOR
+ − 72 #include "mfw_edt.h"
+ − 73 #endif
+ − 74 #include "mfw_lng.h"
+ − 75 #include "mfw_tim.h"
+ − 76 #include "mfw_icn.h"
+ − 77 #include "mfw_mnu.h"
+ − 78 #include "mfw_phb.h"
+ − 79 #include "mfw_cm.h"
+ − 80 #include "mfw_sim.h"
+ − 81 #include "mfw_nm.h"
+ − 82 #include "mfw_sat.h"
+ − 83 #include "mfw_ss.h" /*for convert*/
+ − 84 #include "mfw_phb.h"
+ − 85 #include "ksd.h"
+ − 86 #include "psa.h"
+ − 87 #include "mfw_sms.h"
+ − 88 #include "mfw_cphs.h"
+ − 89 #include "mfw_sat.h"
+ − 90 #include "Mfw_band.h"
+ − 91 #include "mfw_ffs.h"
+ − 92 #include "Mmigame.h"
+ − 93
+ − 94 #include "dspl.h"
+ − 95
+ − 96 #include "MmiMmi.h"
+ − 97 #include "MmiDialogs.h"
+ − 98 #include "MmiLists.h"
+ − 99 #include "MmiBand.h"
+ − 100 #include "MmiCPHS.h"
+ − 101 /* SPR#1428 - SH - New Editor changes */
+ − 102 #ifdef NEW_EDITOR
+ − 103 #include "ATBCommon.h"
+ − 104 #include "ATBDisplay.h"
+ − 105 #include "ATBEditor.h"
+ − 106 #include "AUIEditor.h"
+ − 107 #else
+ − 108 #include "MmiEditor.h"
+ − 109 #endif
+ − 110 #include"MmiBookShared.h"
+ − 111
+ − 112
+ − 113
+ − 114
+ − 115 #include "font_bitmaps.h"
+ − 116 #include "mmiColours.h"
+ − 117 #include "MmiResources.h"
+ − 118
+ − 119 #include "Mmigame.h"
+ − 120 //GW 14/09/01 Disable game when not required.
+ − 121 #ifdef MMIGAME
+ − 122 void dspl_show_bitmap(int x,int y,t_font_bitmap* current_bitmap,U32 attr );
+ − 123 /*******************************************************************************
+ − 124
+ − 125 internal data
+ − 126
+ − 127 *******************************************************************************/
+ − 128
+ − 129 #define FOUR_IN_A_ROW_INIT 121
+ − 130 #define MAX_X_BOARD 11
+ − 131 #define MAX_Y_BOARD 8
+ − 132 /*
+ − 133 * The information related to every window must be encapsulated in such an structure
+ − 134 */
+ − 135
+ − 136 typedef struct
+ − 137 {
+ − 138 T_MMI_CONTROL mmi_control; // common control parameter
+ − 139 T_MFW_HND win;
+ − 140 T_MFW_HND kbd;
+ − 141 T_MFW_HND menu;
+ − 142 T_MFW_HND parent_win;
+ − 143 T_MFW_HND info_win;
+ − 144 char board_array[MAX_Y_BOARD][MAX_X_BOARD]; //the virtual board
+ − 145 } T_four_in_a_row;
+ − 146
+ − 147 typedef struct
+ − 148 {
+ − 149 /* administrative data */
+ − 150
+ − 151 T_MMI_CONTROL mmi_control;
+ − 152 T_MFW_HND win;
+ − 153 T_MFW_HND parent_win;
+ − 154 /* SPR#1428 - SH - New editor data */
+ − 155 #ifdef NEW_EDITOR
+ − 156 T_AUI_EDITOR_DATA editor_data;
+ − 157 #else /* NEW_EDITOR */
+ − 158 T_EDITOR_DATA editor_data;
+ − 159 #endif /* NEW_EDITOR */
+ − 160
+ − 161 /* internal data */
+ − 162 char buffer[80];
+ − 163 UBYTE status;
+ − 164
+ − 165 } tShowInfo;
+ − 166
+ − 167
+ − 168 /*
+ − 169 * These are common functions xxx_create and xxx_destroy
+ − 170 */
+ − 171 T_MFW_HND four_in_a_row_create(MfwHnd parent);
+ − 172 void four_in_a_row_destroy (T_MFW_HND);
+ − 173
+ − 174
+ − 175 /*
+ − 176 * This dialog function (the same name as the window)
+ − 177 * is used to handle the comunication between different windows. The global macro SEND_EVENT can be used with parameter win
+ − 178 * and the corresponding events to send from one mmi dialog to another.
+ − 179 */
+ − 180 void four_in_a_row (T_MFW_HND win, USHORT event, SHORT value, void * parameter);
+ − 181
+ − 182
+ − 183 /*
+ − 184 * These are common optional functions handler
+ − 185 */
+ − 186 int four_in_a_row_kbd_cb (MfwEvt e, MfwKbd *k);
+ − 187 int four_in_a_row_win_cb (MfwEvt e, MfwWin *w);
+ − 188
+ − 189 int Game_Result;
+ − 190
+ − 191
+ − 192 /*
+ − 193 * This an optional function, used often to call, create and init a new dialog, with different parameters depending
+ − 194 * on the context
+ − 195 */
+ − 196 T_MFW_HND four_in_a_row_start (T_MFW_HND win_parent,char *character);
+ − 197 int four_in_a_row_aktivate(MfwMnu* m, MfwMnuItem* i);
+ − 198
+ − 199 int check_column(T_four_in_a_row *data, int where_from);
+ − 200 void drop_stone(T_four_in_a_row *data);
+ − 201
+ − 202 int mobile_thinking(T_four_in_a_row *data);
+ − 203 int check_line(T_four_in_a_row *data, int x_value, int drop_position, int dx, int dy, BOOL where_from);
+ − 204 void check_for_winner(T_four_in_a_row *data, int check_out_position);
+ − 205 int random_scoring(void); // RAVI
+ − 206
+ − 207 T_MFW_HND Game_Info(T_MFW_HND parent_window);
+ − 208 static T_MFW_HND ShowGame_Information(MfwHnd parent_window);
+ − 209 static void ShowGame_DialogCB(T_MFW_HND win, USHORT e, SHORT identifier, void *parameter);
+ − 210 void ShowGameInfoEditor(T_MFW_HND win);
+ − 211 static void ShowInfoCB( T_MFW_HND win, USHORT Identifier,UBYTE reason);
+ − 212 void showGameInfo_destroy(MfwHnd own_window);
+ − 213
+ − 214 const char * info = "Welcome to Connect 4!";
+ − 215 const char * playAgain = "Play Again?";
+ − 216
+ − 217
+ − 218 //internal datas
+ − 219
+ − 220 int column; //this is the current position of white player cursor
+ − 221 int x_runer; //goes through the horizontal lines
+ − 222 int y_runer; //goes through the vertical lines
+ − 223 char winner; //describes the winner 0->nobody 'B'->black(mobile) 'W'->white(human player)
+ − 224 int column_black; //this is the current position of black player cursor
+ − 225 int request_stone; //helps to decide between black or white (for strategical things)
+ − 226
+ − 227 static T_MFW_HND info_window=0;
+ − 228
+ − 229 #ifndef BMP_FORMAT_BW_UNPACKED
+ − 230 #define BMP_FORMAT_BW_UNPACKED 1
+ − 231 #endif
+ − 232
+ − 233
+ − 234 t_font_bitmap plWin1 ={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)player_win1};
+ − 235 t_font_bitmap plWin2 ={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)player_win2};
+ − 236 t_font_bitmap plLost1 ={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)player_lost1};
+ − 237 t_font_bitmap plLost2 ={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)player_lost2};
+ − 238 t_font_bitmap draw1 ={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)board_full1};
+ − 239 t_font_bitmap draw2 ={ 0, BMP_FORMAT_BW_UNPACKED, 21, 24, 0, (char*)board_full2};
+ − 240 t_font_bitmap gameName1 ={ 0, BMP_FORMAT_BW_UNPACKED, 18, 24, 0, (char*)game_name1};
+ − 241 t_font_bitmap gameName2 ={ 0, BMP_FORMAT_BW_UNPACKED, 24, 24, 0, (char*)game_name2};
+ − 242
+ − 243 #ifdef COLOURDISPLAY
+ − 244 char colBmp[256*4];
+ − 245 t_font_bitmap allCol ={ 0, BMP_FORMAT_256_COLOUR, 32, 32, 0, colBmp };
+ − 246 t_font_bitmap stone_colour ={ 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)black_stone_bw};
+ − 247 t_font_bitmap gameCursor = { 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)game_cursor};
+ − 248 #else
+ − 249 #ifdef LSCREEN
+ − 250 t_font_bitmap blackStone_bw ={ 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)black_stone_bw};
+ − 251 t_font_bitmap whiteStone_bw ={ 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)white_stone_bw};
+ − 252 t_font_bitmap gameCursor = { 0, BMP_FORMAT_BW_UNPACKED, 8, 8, 0, (char*)game_cursor};
+ − 253 #else
+ − 254 t_font_bitmap blackStone_bw ={ 0, BMP_FORMAT_BW_UNPACKED, 4, 4, 0, (char*)black_stone_bw};
+ − 255 t_font_bitmap whiteStone_bw ={ 0, BMP_FORMAT_BW_UNPACKED, 4, 4, 0, (char*)white_stone_bw};
+ − 256 t_font_bitmap gameCursor = { 0, BMP_FORMAT_BW_UNPACKED, 6, 6, 0, (char*)game_cursor};
+ − 257 #endif
+ − 258 #endif
+ − 259
+ − 260 t_font_bitmap *blackStone, *whiteStone;
+ − 261
+ − 262 /*******************************************************************************
+ − 263
+ − 264 $Function: four_in_a_row_create
+ − 265
+ − 266 $Description:
+ − 267
+ − 268 $Returns:
+ − 269
+ − 270 $Arguments:
+ − 271
+ − 272 *******************************************************************************/
+ − 273
+ − 274
+ − 275 T_MFW_HND four_in_a_row_create (T_MFW_HND parent_window)
+ − 276 {
+ − 277
+ − 278 T_MFW_WIN * win;
+ − 279
+ − 280 /*
+ − 281 * This window is dynamic, for that reason the associated data are allocated in the mfw heap
+ − 282 */
+ − 283 T_four_in_a_row * data = (T_four_in_a_row *)ALLOC_MEMORY (sizeof (T_four_in_a_row));
+ − 284
+ − 285 TRACE_FUNCTION ("four_in_a_row_create()");
+ − 286
+ − 287 /*
+ − 288 * Create window handler
+ − 289 */
+ − 290
+ − 291 data->win = win_create (parent_window, 0, E_WIN_VISIBLE, (T_MFW_CB)four_in_a_row_win_cb);
+ − 292
+ − 293 if (data->win EQ 0)
+ − 294 return 0;
+ − 295
+ − 296 /*
+ − 297 * These assignments are necessary to attach the data to the window, and to handle the mmi event communication.
+ − 298 */
+ − 299
+ − 300 data->mmi_control.dialog = (T_DIALOG_FUNC)four_in_a_row;
+ − 301 data->mmi_control.data = data;
+ − 302 data->parent_win = parent_window;
+ − 303 win = ((T_MFW_HDR *)data->win)->data;
+ − 304 win->user = (void *) data;
+ − 305
+ − 306 /*
+ − 307 * Create any other handler
+ − 308 */
+ − 309
+ − 310 data->kbd = kbd_create (data->win,KEY_ALL,(T_MFW_CB)four_in_a_row_kbd_cb);
+ − 311
+ − 312 column=0; //set start value for game cursor
+ − 313 winner ='0'; //game starts, so set winner to nobody
+ − 314
+ − 315 /*clear the board*/
+ − 316 for (y_runer=0;y_runer<MAX_Y_BOARD;y_runer++){
+ − 317 for(x_runer=0;x_runer<MAX_X_BOARD;x_runer++){
+ − 318 data->board_array[y_runer][x_runer] ='0';
+ − 319 }
+ − 320 }
+ − 321 winShow(data->win);
+ − 322
+ − 323 return data->win;
+ − 324 }
+ − 325
+ − 326 /*******************************************************************************
+ − 327
+ − 328 $Function: four_in_a_rowr_destroy
+ − 329
+ − 330 $Description:
+ − 331
+ − 332 $Returns:
+ − 333
+ − 334 $Arguments:
+ − 335
+ − 336 *******************************************************************************/
+ − 337
+ − 338 void four_in_a_row_destroy (T_MFW_HND own_window)
+ − 339 {
+ − 340 T_MFW_WIN * win;
+ − 341 T_four_in_a_row * data;
+ − 342
+ − 343 TRACE_EVENT("four_in_a_row_destroy");
+ − 344
+ − 345 if (own_window)
+ − 346 {
+ − 347 win = ((T_MFW_HDR *)own_window)->data;
+ − 348 data = (T_four_in_a_row *)win->user;
+ − 349
+ − 350 if (data)
+ − 351 {
+ − 352 /*
+ − 353 * Exit Keyboard Handler
+ − 354 */
+ − 355 /*
+ − 356 * Delete WIN Handler
+ − 357 */
+ − 358 win_delete (data->win);
+ − 359 }
+ − 360
+ − 361 /*
+ − 362 * In this case the data attached to window must be also deleted.
+ − 363 */
+ − 364 FREE_MEMORY ((void *)data, sizeof (T_four_in_a_row));
+ − 365
+ − 366 column=0; //set the current column back to 0
+ − 367
+ − 368 }
+ − 369 }
+ − 370
+ − 371 /*******************************************************************************
+ − 372
+ − 373 $Function: four_in_a_row_start
+ − 374
+ − 375 $Description: This function just creates and inits the new dialog
+ − 376
+ − 377 $Returns:
+ − 378
+ − 379 $Arguments:
+ − 380
+ − 381 *******************************************************************************/
+ − 382 T_MFW_HND four_in_a_row_start (T_MFW_HND win_parent,char *character)
+ − 383 {
+ − 384 T_MFW_HND win;
+ − 385 /*
+ − 386 MmiTetrisStart();
+ − 387 return;
+ − 388 */
+ − 389 win = four_in_a_row_create (win_parent);
+ − 390 TRACE_EVENT("four_in_a_row_start");
+ − 391
+ − 392 if (win NEQ NULL)
+ − 393 {
+ − 394 SEND_EVENT(win,FOUR_IN_A_ROW_INIT,0,character);
+ − 395 }
+ − 396 return win;
+ − 397
+ − 398 }
+ − 399
+ − 400 /*******************************************************************************
+ − 401
+ − 402 $Function: four_in_a_row
+ − 403
+ − 404 $Description:
+ − 405
+ − 406 $Returns:
+ − 407
+ − 408 $Arguments:
+ − 409
+ − 410 *******************************************************************************/
+ − 411
+ − 412
+ − 413
+ − 414 void four_in_a_row (T_MFW_HND win, USHORT event, SHORT value, void * parameter)
+ − 415 {
+ − 416 T_MFW_WIN * win_data = ((T_MFW_HDR *) win)->data;
+ − 417 T_four_in_a_row * data = (T_four_in_a_row *)win_data->user;
+ − 418
+ − 419 TRACE_FUNCTION ("four_in_a_row()");
+ − 420
+ − 421 /*
+ − 422 * In this case the communication is very simple (only one intern event)
+ − 423 */
+ − 424
+ − 425
+ − 426 switch (event)
+ − 427 {
+ − 428 case FOUR_IN_A_ROW_INIT:
+ − 429 softKeys_displayId(TxtSearchName,TxtNull,0,COLOUR_IDLE);
+ − 430 winShow(data->win);
+ − 431 break;
+ − 432
+ − 433 default:
+ − 434 return;
+ − 435 }
+ − 436
+ − 437 }
+ − 438
+ − 439 /*******************************************************************************
+ − 440
+ − 441 $Function: four_in_a_row_win_cb
+ − 442
+ − 443 $Description: win calback function of four in a row
+ − 444
+ − 445 $Returns:
+ − 446
+ − 447 $Arguments:
+ − 448
+ − 449 *******************************************************************************/
+ − 450
+ − 451
+ − 452 int four_in_a_row_win_cb (MfwEvt e, MfwWin *w)
+ − 453 {
+ − 454 // T_DISPLAY_DATA display_info; // RAVI
+ − 455 T_four_in_a_row * data = (T_four_in_a_row *)w->user;
+ − 456 int xOfs,yOfs, xScale, yScale;
+ − 457 int manOfsX,manOfsY;
+ − 458 int xPos,yPos;
+ − 459 int y_axis; //goes through the vertical lines
+ − 460 int x_axis; //goes through the horizontal lines
+ − 461 // int x,y,i,b; // RAVI
+ − 462 int displayPosX, temp;
+ − 463
+ − 464 TRACE_FUNCTION ("four_in_a_row_win_cb()");
+ − 465
+ − 466 switch (e)
+ − 467 {
+ − 468 case MfwWinVisible:
+ − 469 #ifdef COLOURDISPLAY
+ − 470 whiteStone = &stone_colour;
+ − 471 blackStone = &stone_colour;
+ − 472
+ − 473 #else
+ − 474 whiteStone = &blackStone_bw;
+ − 475 blackStone = &whiteStone_bw;
+ − 476
+ − 477 #endif
+ − 478 #ifdef LSCREEN
+ − 479 manOfsX = GAME_POS_X + 3;
+ − 480 manOfsY = GAME_POS_Y + 3;
+ − 481 #else
+ − 482 manOfsX = GAME_POS_X + 1;
+ − 483 manOfsY = GAME_POS_Y + 1;
+ − 484 #endif
+ − 485 xOfs = GAME_POS_X;
+ − 486 yOfs = GAME_POS_Y;
+ − 487 xScale = GAME_SCALE_X;
+ − 488 yScale = GAME_SCALE_Y;
+ − 489
+ − 490 //dspl_ClearAll(); //Clears to white, not BGD!
+ − 491 TRACE_EVENT("display clear");
+ − 492 resources_setColour( COLOUR_GAME );
+ − 493 dspl_Clear( 0,0, SCREEN_SIZE_X,SCREEN_SIZE_Y);
+ − 494 #ifdef LSCREEN
+ − 495 softKeys_displayId(TxtHelp,TxtExit,0,COLOUR_LIST_SUBMENU);
+ − 496 #endif
+ − 497
+ − 498 resources_setColour( COLOUR_GAME );
+ − 499 dspl_Clear( xOfs, yOfs, xOfs+MAX_X_BOARD*xScale, yOfs+MAX_Y_BOARD*yScale ); //Clears to white, not BGD!
+ − 500 //dspl_BitBlt(column*xScale+xOfs+1,yOfs-yScale,8,8,0,(void*)game_cursor,0); //place the cursor bitmap
+ − 501 dspl_show_bitmap(column*xScale+xOfs+1,yOfs-yScale, &gameCursor, 0 );
+ − 502 for (y_axis=0;y_axis<=MAX_Y_BOARD;y_axis++)
+ − 503 {
+ − 504 dspl_DrawLine( xOfs, yOfs+y_axis*yScale,
+ − 505 xOfs+MAX_X_BOARD*xScale, yOfs+y_axis*yScale);
+ − 506 }
+ − 507 for(x_axis=0;x_axis<=MAX_X_BOARD;x_axis++)
+ − 508 {
+ − 509 dspl_DrawLine( xOfs+x_axis*xScale, yOfs,
+ − 510 xOfs+x_axis*xScale, yOfs+MAX_Y_BOARD*yScale);
+ − 511 }
+ − 512
+ − 513 //go through the board-array and check for W or B and set the stones
+ − 514 for (y_axis=0;y_axis<MAX_Y_BOARD;y_axis++)
+ − 515 {
+ − 516 for(x_axis=0;x_axis<MAX_X_BOARD;x_axis++)
+ − 517 {
+ − 518 xPos = manOfsX+x_axis*xScale;
+ − 519 yPos = manOfsY+y_axis*yScale;
+ − 520 if(data->board_array[y_axis][x_axis] EQ 'W'){ //found white
+ − 521 //set white_stone bitmap
+ − 522 dspl_SetFgdColour( COL_R );
+ − 523 dspl_show_bitmap(xPos,yPos, whiteStone, 0 );
+ − 524 }
+ − 525 if(data->board_array[y_axis][x_axis] EQ 'B'){ //found black
+ − 526 //set black_stone bitmap
+ − 527 dspl_SetFgdColour( COL_G ); //0x00404040
+ − 528 dspl_show_bitmap(xPos,yPos, blackStone, 0 );
+ − 529 }
+ − 530 }
+ − 531 }
+ − 532 dspl_SetFgdColour( COL_RB );
+ − 533 dspl_SetBgdColour( COL_RG );
+ − 534 dspl_show_bitmap(GAME_NAMEPOSX1, GAME_NAMEPOSY1, &gameName1, 0 );
+ − 535 displayPosX = (SCREEN_SIZE_X/2);
+ − 536 temp = strlen((char*)playAgain);
+ − 537 //this if-clause is to set the bitmap, for win or lost game
+ − 538 if(winner EQ 'W'){
+ − 539 //human player wins, so set win bitmap
+ − 540 #ifdef LSCREEN
+ − 541 dspl_SetFgdColour( COL_BLK );
+ − 542 dspl_SetBgdColour( COL_TRANSPARENT );
+ − 543 Game_Result = TRUE;
+ − 544 softKeys_displayId(TxtYes,TxtNo,0,COLOUR_LIST_SUBMENU);
+ − 545 dspl_TextOut((displayPosX-((temp*CHAR_WIDTH)/2)),170,DSPL_TXTATTR_NORMAL,(char*)playAgain);
+ − 546 #endif
+ − 547 dspl_SetFgdColour( COL_RB );
+ − 548 dspl_SetBgdColour( COL_GB );
+ − 549 dspl_show_bitmap(GAME_WINPOSX1, GAME_WINPOSY1, &plWin1, 0 );
+ − 550 dspl_show_bitmap(GAME_WINPOSX2, GAME_WINPOSY2, &plWin2, 0 );
+ − 551 }
+ − 552 else
+ − 553 if(winner EQ 'B'){
+ − 554 //human player lost, so set lost bitmap
+ − 555 #ifdef LSCREEN
+ − 556 dspl_SetFgdColour( COL_BLK );
+ − 557 dspl_SetBgdColour( COL_TRANSPARENT );
+ − 558 Game_Result = TRUE;
+ − 559 softKeys_displayId(TxtYes,TxtNo,0,COLOUR_LIST_SUBMENU);
+ − 560 dspl_TextOut((displayPosX-((temp*CHAR_WIDTH)/2)),170,DSPL_TXTATTR_NORMAL,(char*)playAgain);
+ − 561 #endif
+ − 562 dspl_SetFgdColour( COL_RB );
+ − 563 dspl_SetBgdColour( COL_GB );
+ − 564 dspl_show_bitmap(GAME_WINPOSX1, GAME_WINPOSY1, &plLost1, 0 );
+ − 565 dspl_show_bitmap(GAME_WINPOSX2, GAME_WINPOSY2, &plLost2, 0 );
+ − 566 }
+ − 567 else
+ − 568 if(winner EQ 'N'){
+ − 569 //board is full, nobody (N) wins
+ − 570 #ifdef LSCREEN
+ − 571 dspl_SetFgdColour( COL_BLK );
+ − 572 dspl_SetBgdColour( COL_TRANSPARENT );
+ − 573 Game_Result = TRUE;
+ − 574 softKeys_displayId(TxtYes,TxtNo,0,COLOUR_LIST_SUBMENU);
+ − 575 dspl_TextOut((displayPosX-((temp*CHAR_WIDTH)/2)),170,DSPL_TXTATTR_NORMAL,(char*)playAgain);
+ − 576 #endif
+ − 577
+ − 578 dspl_SetFgdColour( COL_R );
+ − 579 dspl_SetBgdColour( COL_G );
+ − 580 dspl_show_bitmap(GAME_WINPOSX1, GAME_WINPOSY1, &draw1, 0 );
+ − 581 dspl_show_bitmap(GAME_WINPOSX2, GAME_WINPOSY2, &draw2, 0 );
+ − 582 }
+ − 583 else
+ − 584 {
+ − 585 dspl_SetFgdColour( COL_RB );
+ − 586 dspl_SetBgdColour( COL_RG );
+ − 587 dspl_show_bitmap(GAME_NAMEPOSX1, GAME_NAMEPOSY1, &gameName1, 0 );
+ − 588 dspl_show_bitmap(GAME_NAMEPOSX2, GAME_NAMEPOSY2, &gameName2, 0 );
+ − 589 dspl_show_bitmap(GAME_NAMEPOSX3, GAME_NAMEPOSY3, &gameName2, 0 );
+ − 590 }
+ − 591 break;
+ − 592
+ − 593 default:
+ − 594 return 0;
+ − 595 }
+ − 596
+ − 597 return 1;
+ − 598 }
+ − 599
+ − 600 /*******************************************************************************
+ − 601
+ − 602 $Function: four_in_a_row_kbd_cb
+ − 603
+ − 604 $Description:
+ − 605
+ − 606 $Returns:
+ − 607
+ − 608 $Arguments:
+ − 609
+ − 610 *******************************************************************************/
+ − 611
+ − 612 int four_in_a_row_kbd_cb (MfwEvt e, MfwKbd *k)
+ − 613 {
+ − 614
+ − 615 T_MFW_HND win = mfw_parent (mfw_header());
+ − 616 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
+ − 617 T_four_in_a_row * data = (T_four_in_a_row *)win_data->user;
+ − 618
+ − 619 TRACE_EVENT ("four_in_a_row_kbd_cb()");
+ − 620
+ − 621 switch (k->code)
+ − 622 {
+ − 623 case KCD_HUP: //quit the game "four in a row"
+ − 624 case KCD_RIGHT: //quit the game "four in a row"
+ − 625 TRACE_EVENT ("quit four_in_a_row");
+ − 626 dspl_ClearAll(); //clear mobile screen
+ − 627 four_in_a_row_destroy (win); //destroy win-handler
+ − 628 break;
+ − 629
+ − 630 case KCD_MNULEFT:
+ − 631 case KCD_1:
+ − 632 if(winner EQ '0'){ //while nobody has won....
+ − 633 TRACE_EVENT ("KCD_1");
+ − 634 if(column > 0)
+ − 635 { //cursor must be greater than 0
+ − 636 column=column-1;
+ − 637 }
+ − 638 winShow(data->win);
+ − 639 }
+ − 640 break;
+ − 641 case KCD_MNUSELECT:
+ − 642 case KCD_2:
+ − 643 if(winner EQ '0'){ //while nobody has won....
+ − 644 TRACE_EVENT ("KCD_2");
+ − 645 drop_stone(data); //drop stone
+ − 646 }
+ − 647 winShow(data->win);
+ − 648 break;
+ − 649 case KCD_MNURIGHT:
+ − 650 case KCD_3:
+ − 651 if(winner EQ '0'){ //while nobody has won....
+ − 652 TRACE_EVENT ("KCD_3");
+ − 653 if(column<MAX_X_BOARD-1 ){ //cursor must be less than 50
+ − 654 column=column+1;
+ − 655 }
+ − 656 winShow(data->win);
+ − 657 }
+ − 658 break;
+ − 659 case KCD_LEFT:
+ − 660 if(Game_Result == TRUE)
+ − 661 {
+ − 662 Game_Result = FALSE;
+ − 663 four_in_a_row_destroy(win); //destroy win-handler
+ − 664 four_in_a_row_start(win,0);
+ − 665 }
+ − 666 else
+ − 667 Game_Info(win);
+ − 668 break;
+ − 669 }
+ − 670 return MFW_EVENT_CONSUMED;
+ − 671 }
+ − 672
+ − 673 /*******************************************************************************
+ − 674
+ − 675 $Function: four_in_a_row_aktivate
+ − 676
+ − 677 $Description: Starts the game function on user selection
+ − 678
+ − 679 $Returns: MFW_EVENT_CONSUMED if event handled, otherwise
+ − 680 MFW_EVENT_PASSED
+ − 681
+ − 682 $Arguments: menu, menu item
+ − 683
+ − 684 *******************************************************************************/
+ − 685 int four_in_a_row_aktivate(MfwMnu* m, MfwMnuItem* i)
+ − 686 {
+ − 687 T_four_in_a_row * data;
+ − 688 T_MFW_HND parent = mfwParent( mfw_header());
+ − 689 TRACE_EVENT("four_in_a_row_aktivate()");
+ − 690 four_in_a_row_start(parent,0);
+ − 691 return MFW_EVENT_CONSUMED;
+ − 692 }
+ − 693
+ − 694 /*******************************************************************************
+ − 695
+ − 696 $Function: drop_stone
+ − 697
+ − 698 $Description: decide whether a stone can be droped and where it can be droped
+ − 699
+ − 700 $Returns:
+ − 701
+ − 702 $Arguments: T_four_in_a_row
+ − 703
+ − 704 *******************************************************************************/
+ − 705 void drop_stone(T_four_in_a_row *data)
+ − 706 {
+ − 707 int drop_position; //position (y in current board column) where to drop the stone
+ − 708
+ − 709 TRACE_EVENT("drop_stone()");
+ − 710 request_stone=0; //white is on turn
+ − 711 drop_position=check_column(data,request_stone); //set the drop position for the white stone in the current white, board column
+ − 712 if(drop_position>=0){ //if the current column is not filled up set stone
+ − 713 data->board_array[drop_position][column]='W'; //white is first and set a 'W' in the virtual board for a white stone
+ − 714 check_for_winner(data,drop_position); //check whether the last move(white) was a win-move...
+ − 715 if(winner EQ '0'){ //...if not, then the mobile(black) is on turn
+ − 716 drop_position=mobile_thinking(data); //set the drop position for the black stone in the current black, board column
+ − 717 data->board_array[drop_position][column_black]='B'; //set a 'B' for in the virtual board for a black stone
+ − 718 check_for_winner(data,drop_position); //check whether the last move(black) was a win-move...
+ − 719 }
+ − 720 }
+ − 721 }
+ − 722
+ − 723 /*******************************************************************************
+ − 724
+ − 725 $Function: check_for_winner
+ − 726
+ − 727 $Description: checks the current drop position for a win-position
+ − 728
+ − 729 $Returns:
+ − 730
+ − 731 $Arguments: T_four_in_a_row
+ − 732
+ − 733 *******************************************************************************/
+ − 734 void check_for_winner(T_four_in_a_row *data, int check_out_position)
+ − 735 {
+ − 736 int check_with_this_color; //set the color to check for
+ − 737 int color_regulator; //helps to switch between both colors
+ − 738 int check_this_column; //declares the column to check for
+ − 739
+ − 740 TRACE_EVENT("check_for_winner()");
+ − 741 color_regulator=0; //at first, use white to check for
+ − 742 winner='0'; //at first we don't know who wins, so nobody is set as winner
+ − 743 while(color_regulator<2){ //while checking for white(0) and black(1) is not ready....
+ − 744 if(color_regulator EQ 0){ //if color_regulator is 0, the board will be checked for white stones ('W')
+ − 745 check_with_this_color='W';
+ − 746 }else{ //if color_regulator is 1, the board will be checked for black stones ('B')
+ − 747 check_with_this_color='B';
+ − 748 }
+ − 749
+ − 750 if(request_stone EQ 0){ //if the board will be checked for white, use column as the current column
+ − 751 check_this_column=column;
+ − 752 }else{ //if the board will be checked for black, use column_black as the current column
+ − 753 check_this_column=column_black;
+ − 754 }
+ − 755
+ − 756 /*Begin with the checks, the mobile checks for vertical, horizontal and diagonal possibilities*/
+ − 757 //check row
+ − 758 if(data->board_array[check_out_position][check_this_column-3] EQ check_with_this_color &&
+ − 759 data->board_array[check_out_position][check_this_column-2] EQ check_with_this_color &&
+ − 760 data->board_array[check_out_position][check_this_column-1] EQ check_with_this_color &&
+ − 761 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 762 check_this_column>=3 && check_this_column<=10){
+ − 763 winner=check_with_this_color; //set the current color to check for as the winner
+ − 764 break;
+ − 765 }else if(data->board_array[check_out_position][check_this_column-1] EQ check_with_this_color &&
+ − 766 data->board_array[check_out_position][check_this_column-2] EQ check_with_this_color &&
+ − 767 data->board_array[check_out_position][check_this_column+1] EQ check_with_this_color &&
+ − 768 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 769 check_this_column>=2 && check_this_column<=9){
+ − 770 winner=check_with_this_color; //set the current color to check for as the winner
+ − 771 break;
+ − 772 }else if(data->board_array[check_out_position][check_this_column+1] EQ check_with_this_color &&
+ − 773 data->board_array[check_out_position][check_this_column+2] EQ check_with_this_color &&
+ − 774 data->board_array[check_out_position][check_this_column+3] EQ check_with_this_color &&
+ − 775 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 776 check_this_column>=0 && check_this_column<=7){
+ − 777 winner=check_with_this_color; //set the current color to check for as the winner
+ − 778 break;
+ − 779 }else if(data->board_array[check_out_position][check_this_column-1] EQ check_with_this_color &&
+ − 780 data->board_array[check_out_position][check_this_column+1] EQ check_with_this_color &&
+ − 781 data->board_array[check_out_position][check_this_column+2] EQ check_with_this_color &&
+ − 782 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 783 check_this_column>=1 && check_this_column<=8){
+ − 784 winner=check_with_this_color; //set the current color to check for as the winner
+ − 785 break;
+ − 786 //check column
+ − 787 }else if(data->board_array[check_out_position+1][check_this_column] EQ check_with_this_color &&
+ − 788 data->board_array[check_out_position+2][check_this_column] EQ check_with_this_color &&
+ − 789 data->board_array[check_out_position+3][check_this_column] EQ check_with_this_color &&
+ − 790 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 791 check_out_position<=4){
+ − 792 winner=check_with_this_color; //set the current color to check for as the winner
+ − 793 break;
+ − 794 //check diagonal
+ − 795 }else if(data->board_array[check_out_position+1][check_this_column-1] EQ check_with_this_color &&
+ − 796 data->board_array[check_out_position+2][check_this_column-2] EQ check_with_this_color &&
+ − 797 data->board_array[check_out_position+3][check_this_column-3] EQ check_with_this_color &&
+ − 798 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 799 check_out_position<=4 && check_this_column>=3 && check_this_column<=10){
+ − 800 winner=check_with_this_color; //set the current color to check for as the winner
+ − 801 break;
+ − 802 }else if(data->board_array[check_out_position+1][check_this_column+1] EQ check_with_this_color &&
+ − 803 data->board_array[check_out_position+2][check_this_column+2] EQ check_with_this_color &&
+ − 804 data->board_array[check_out_position+3][check_this_column+3] EQ check_with_this_color &&
+ − 805 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 806 check_out_position<=4 && check_this_column>=0 && check_this_column<=7){
+ − 807 winner=check_with_this_color; //set the current color to check for as the winner
+ − 808 break;
+ − 809 }else if(data->board_array[check_out_position-1][check_this_column+1] EQ check_with_this_color &&
+ − 810 data->board_array[check_out_position-2][check_this_column+2] EQ check_with_this_color &&
+ − 811 data->board_array[check_out_position-3][check_this_column+3] EQ check_with_this_color &&
+ − 812 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 813 check_out_position>=3 && check_this_column>=0 && check_this_column<=7){
+ − 814 winner=check_with_this_color; //set the current color to check for as the winner
+ − 815 break;
+ − 816 }else if(data->board_array[check_out_position-1][check_this_column-1] EQ check_with_this_color &&
+ − 817 data->board_array[check_out_position-2][check_this_column-2] EQ check_with_this_color &&
+ − 818 data->board_array[check_out_position-3][check_this_column-3] EQ check_with_this_color &&
+ − 819 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 820 check_out_position>=3 && check_this_column>=3 && check_this_column<=10){
+ − 821 winner=check_with_this_color; //set the current color to check for as the winner
+ − 822 break;
+ − 823 }else if(data->board_array[check_out_position+1][check_this_column-1] EQ check_with_this_color &&
+ − 824 data->board_array[check_out_position-1][check_this_column+1] EQ check_with_this_color &&
+ − 825 data->board_array[check_out_position-2][check_this_column+2] EQ check_with_this_color &&
+ − 826 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 827 check_out_position<=6 && check_out_position>=2 && check_this_column>=1 && check_this_column<=8){
+ − 828 winner=check_with_this_color; //set the current color to check for as the winner
+ − 829 break;
+ − 830 }else if(data->board_array[check_out_position+1][check_this_column-1] EQ check_with_this_color &&
+ − 831 data->board_array[check_out_position+2][check_this_column-2] EQ check_with_this_color &&
+ − 832 data->board_array[check_out_position-1][check_this_column+1] EQ check_with_this_color &&
+ − 833 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 834 check_out_position<=5 && check_out_position>=1 && check_this_column>=2 && check_this_column<=9){
+ − 835 winner=check_with_this_color; //set the current color to check for as the winner
+ − 836 break;
+ − 837 }else if(data->board_array[check_out_position-1][check_this_column-1] EQ check_with_this_color &&
+ − 838 data->board_array[check_out_position+1][check_this_column+1] EQ check_with_this_color &&
+ − 839 data->board_array[check_out_position+2][check_this_column+2] EQ check_with_this_color &&
+ − 840 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 841 check_out_position<=5 && check_out_position>=1 && check_this_column>=1 && check_this_column<=8){
+ − 842 winner=check_with_this_color; //set the current color to check for as the winner
+ − 843 break;
+ − 844 }else if(data->board_array[check_out_position-1][check_this_column-1] EQ check_with_this_color &&
+ − 845 data->board_array[check_out_position-2][check_this_column-2] EQ check_with_this_color &&
+ − 846 data->board_array[check_out_position+1][check_this_column+1] EQ check_with_this_color &&
+ − 847 data->board_array[check_out_position][check_this_column] EQ check_with_this_color &&
+ − 848 check_out_position>=2 && check_out_position<=6 && check_this_column>=2 && check_this_column<=9){
+ − 849 winner=check_with_this_color; //set the current color to check for as the winner
+ − 850 break;
+ − 851 }else{
+ − 852 winner='0'; //no win-moves found, so nobody is the winner and the game goes on
+ − 853 }
+ − 854 color_regulator++; //set the check color one up (to black)
+ − 855 }
+ − 856 }
+ − 857 /*******************************************************************************
+ − 858
+ − 859 $Function: check_column
+ − 860
+ − 861 $Description: checks for already set stones
+ − 862
+ − 863 $Returns: int unused_position
+ − 864
+ − 865 $Arguments: T_four_in_a_row
+ − 866
+ − 867 *******************************************************************************/
+ − 868 int check_column(T_four_in_a_row *data, int where_from)
+ − 869 {
+ − 870 int unused_position; //is for a free drop position
+ − 871 int column_for_check; //column (vertical board line) to check for
+ − 872
+ − 873 if(where_from EQ 0){ //is the current game color(player) 0 then use column
+ − 874 column_for_check=column;
+ − 875 }else{ //is the current game color(player) 1 then use column_black
+ − 876 column_for_check=column_black;
+ − 877 }
+ − 878 unused_position=-9999;
+ − 879 for(y_runer=0;y_runer<MAX_Y_BOARD;y_runer++){ //test all vertical fields whether they are empty('0') or not
+ − 880 if(data->board_array[y_runer][column_for_check] EQ '0'){
+ − 881 unused_position=y_runer; //.this field is empty, so it is a unused position
+ − 882 }
+ − 883 }
+ − 884 return unused_position; //return the unused position
+ − 885 }
+ − 886
+ − 887
+ − 888 /*******************************************************************************
+ − 889
+ − 890 $Function: mobile_thinking
+ − 891
+ − 892 $Description: mobile moves
+ − 893
+ − 894 $Returns: drop position of black stone (drop_me)
+ − 895
+ − 896 $Arguments: T_four_in_a_row
+ − 897
+ − 898 *******************************************************************************/
+ − 899 int mobile_thinking(T_four_in_a_row *data)
+ − 900 {
+ − 901 int position_score[11]; //this array takes the scoring values of each column in the game board
+ − 902 int drop_position; //drop position for stone
+ − 903 int drop_me; //buffer value
+ − 904 int scores[4]; //this array keeps the scores for row, column and diagonals
+ − 905 int add_random_score;
+ − 906
+ − 907 TRACE_EVENT("mobile_thinking()");
+ − 908
+ − 909 request_stone=1; //black is
+ − 910 //check for good spots to drop the black stone
+ − 911 for(x_runer=0;x_runer<MAX_X_BOARD;x_runer++){
+ − 912 //found the possible drop position
+ − 913 column_black=x_runer; //set the x_runer to the current column (column_black)
+ − 914 drop_position=check_column(data,request_stone); //check for possible drop positions
+ − 915 if(drop_position>=0){ //if there is a possible drop position.....
+ − 916 //check the scoring of the current point
+ − 917 add_random_score=random_scoring();
+ − 918 data->board_array[drop_position][x_runer]='B'; //set a test black stone
+ − 919 scores[0]=check_line(data,x_runer,drop_position,1,0,0); //scores row
+ − 920 scores[1]=check_line(data,x_runer,drop_position,1,1,0); //scores diagonal right-up/left-down
+ − 921 scores[2]=check_line(data,x_runer,drop_position,1,-1,0); //scores diagonal left-up/right-down
+ − 922 scores[3]=check_line(data,x_runer,drop_position,0,1,0); //scores down(column)
+ − 923 position_score[x_runer]=scores[0]+scores[1]+scores[2]+scores[3]; //count all scores together to one total score
+ − 924 if(drop_position-1 >=0){ //Is it possible to set a future stone here? If Yes go on...
+ − 925 data->board_array[drop_position-1][x_runer]='W'; //set a test white stone for a possible next opponent move
+ − 926 scores[0]=check_line(data,x_runer,drop_position-1,1,0,1); //scores row
+ − 927 scores[1]=check_line(data,x_runer,drop_position-1,1,1,1); //scores diagonal right-up/left-down
+ − 928 scores[2]=check_line(data,x_runer,drop_position-1,1,-1,1); //scores diagonal left-up/right-down
+ − 929 scores[3]=check_line(data,x_runer,drop_position-1,0,1,1); //scores down(column)
+ − 930 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
+ − 931 data->board_array[drop_position-1][x_runer]='0'; //remove test white stone
+ − 932 }
+ − 933 data->board_array[drop_position][x_runer]='0'; //remove test black stone
+ − 934 }else{ //if there is no possible drop position set the score to -1
+ − 935 position_score[x_runer]=-9999;
+ − 936 }
+ − 937 }
+ − 938
+ − 939 drop_me=-9999; //buffer is set to absolutely minus
+ − 940 column_black=-9999; //position of black cursor is left outer side of board
+ − 941 for(x_runer=0;x_runer<MAX_X_BOARD;x_runer++){ //goes through the scoring array to find the highest score
+ − 942 if(position_score[x_runer]>drop_me){
+ − 943 drop_me=position_score[x_runer];
+ − 944 column_black=x_runer; //set the x_runer to the current column(column_black)
+ − 945 drop_position=check_column(data,request_stone); //this is the best drop position for the mobile
+ − 946 }
+ − 947 }
+ − 948 if(column_black EQ -9999){ //if the column is -1, then the game board is filled up and nobody has won
+ − 949 TRACE_EVENT("Board Full!!!");
+ − 950 winner='N'; //set winner to nobody (N)
+ − 951 }
+ − 952 return drop_position; //return the mobile drop position
+ − 953 }
+ − 954
+ − 955 /*******************************************************************************
+ − 956
+ − 957 $Function: check_line
+ − 958
+ − 959 $Description: set score points for the mobile, so the mobile knows where to set the next stone
+ − 960
+ − 961 $Returns: total_score
+ − 962
+ − 963 $Arguments: T_four_in_a_row, x_value, drop_position, dx, dy, where_from
+ − 964
+ − 965 *******************************************************************************/
+ − 966 int check_line(T_four_in_a_row *data, int x_value, int y_value, int dx, int dy, BOOL where_from)
+ − 967 {
+ − 968 int lSc,nSc,oSc,total_score,sx,sy,i,j;
+ − 969 int pl_nSc; //no of empty squares that have a man under them (i.e. we/opponent can use next shot)
+ − 970 total_score=0;
+ − 971 for (i=0;i<4;i++){
+ − 972 sx = x_value-i*dx;
+ − 973 sy = y_value-i*dy;
+ − 974 lSc=0;
+ − 975 nSc=0; pl_nSc=0;
+ − 976 oSc=0;
+ − 977 for (j=0;j<4;j++){
+ − 978 if ((sx<0) || (sx>MAX_X_BOARD) ||(sy<0) || (sy>MAX_Y_BOARD)){
+ − 979 lSc = -1;
+ − 980 }else if (lSc>=0){
+ − 981 if(where_from EQ 0){
+ − 982 if (data->board_array[sy][sx] EQ 'B'){
+ − 983 lSc++;
+ − 984 }else if (data->board_array[sy][sx] EQ '0'){
+ − 985 nSc++;
+ − 986 if ((sy EQ MAX_Y_BOARD) || (data->board_array[sy+1][sx] NEQ '0'))
+ − 987 pl_nSc++;
+ − 988 }else if (data->board_array[sy][sx] EQ 'W'){
+ − 989 oSc++;
+ − 990
+ − 991 }else //edge of board found
+ − 992 lSc=-1;
+ − 993 sx = sx+dx;
+ − 994 sy = sy+dy;
+ − 995 }else{
+ − 996 if (data->board_array[sy][sx] EQ 'W'){
+ − 997 lSc++;
+ − 998 }else if (data->board_array[sy][sx] EQ '0'){
+ − 999 nSc++;
+ − 1000 if ((sy EQ MAX_Y_BOARD) || (data->board_array[sy+1][sx] NEQ '0'))
+ − 1001 pl_nSc++;
+ − 1002 }else if (data->board_array[sy][sx] EQ 'B'){
+ − 1003 oSc++;
+ − 1004
+ − 1005 }else //edge of board found
+ − 1006 lSc=-1;
+ − 1007 sx = sx+dx;
+ − 1008 sy = sy+dy;
+ − 1009 }
+ − 1010 }
+ − 1011 }
+ − 1012 if (lSc >= 0){
+ − 1013 if (lSc EQ 4){
+ − 1014 return(9999);//got 4 in a row.
+ − 1015 }else if (oSc EQ 3) //and ISc==1
+ − 1016 {
+ − 1017 // 3 opp men - good spot!
+ − 1018 if(where_from EQ 0){
+ − 1019 total_score = total_score + 1000; //this is for the normal, current position score
+ − 1020 }else{
+ − 1021 total_score = -total_score - 1000; //this is for the possible future score, it must be minus, because it will be substracted from normal score
+ − 1022 }
+ − 1023 }else if ((lSc EQ 3) && (nSc EQ 1)){
+ − 1024 //playing here will form 3 in a row and a blank - good spot
+ − 1025 if (pl_nSc EQ 0) //can't reach the 4th position
+ − 1026 total_score = total_score + 75;
+ − 1027 else
+ − 1028 total_score = total_score + 125;//better if we can reach 4th position
+ − 1029 }else if ((oSc EQ 2) && (nSc EQ 1)){
+ − 1030 // 2 opp men + 1 blank- good spot!
+ − 1031 if (pl_nSc EQ 0) //can't reach the 4th position-not too bad
+ − 1032 total_score = total_score + 50;
+ − 1033 else
+ − 1034 total_score = total_score + 200;//can get to both positions - have to block.
+ − 1035 }else if ((lSc EQ 2) && (nSc EQ 2)){
+ − 1036 // 2 in a row and 2 blanks - OK spot
+ − 1037 if (pl_nSc EQ 0) //can't reach the 3rd or 4th position-not too good
+ − 1038 total_score = total_score + 20;
+ − 1039 else if (pl_nSc EQ 1) //can reach one of the 3rd or 4th position - good
+ − 1040 total_score = total_score + 45;
+ − 1041 else if (pl_nSc EQ 2) //can reach both 3rd and 4th position - very good
+ − 1042 total_score = total_score + 95;
+ − 1043 }else if ((lSc EQ 1) && (nSc EQ 3)){
+ − 1044 // 1 in a row and 3 blanks - OK spot, better if we can reach the other 3 points.
+ − 1045 total_score = total_score + 2*(pl_nSc+1); //pl_nSc=0,1,2 or 3 sc=sc+2,4,6 or 8
+ − 1046 }
+ − 1047 //else //line is neither good nor bad.
+ − 1048 }
+ − 1049 else //line is not valid
+ − 1050 total_score = total_score - 1;
+ − 1051 }
+ − 1052 return(total_score);
+ − 1053 }
+ − 1054 /*******************************************************************************
+ − 1055
+ − 1056 $Function: check_line
+ − 1057
+ − 1058 $Description: generates a random number to add on the field scores
+ − 1059
+ − 1060 $Returns: random_score_result
+ − 1061
+ − 1062 $Arguments:
+ − 1063
+ − 1064 *******************************************************************************/
+ − 1065 int random_scoring(void)
+ − 1066 {
+ − 1067 return(rand()%100);
+ − 1068 }
+ − 1069
+ − 1070
+ − 1071
+ − 1072 #define MAX_TET_X 11
+ − 1073 #define MAX_TET_Y 20
+ − 1074
+ − 1075 typedef struct
+ − 1076 {
+ − 1077
+ − 1078 T_MMI_CONTROL mmi_control; // common control parameter
+ − 1079 T_MFW_HND win;
+ − 1080 T_MFW_HND hKbd;
+ − 1081 T_MFW_HND menu;
+ − 1082 T_MFW_HND parent_win;
+ − 1083 T_MFW_HND info_tim;
+ − 1084
+ − 1085 int dropTime;
+ − 1086 int maxDropTime;
+ − 1087 int timeStep;
+ − 1088
+ − 1089 int xPos;
+ − 1090 int yPos;
+ − 1091
+ − 1092 int px;
+ − 1093 int py;
+ − 1094 int shapeId;
+ − 1095 char shapeStr[20];
+ − 1096 int rotateId;
+ − 1097
+ − 1098 int score;
+ − 1099 int level;
+ − 1100 int linesToGo;
+ − 1101
+ − 1102 int resetSpeed;
+ − 1103
+ − 1104 int gameOver;
+ − 1105
+ − 1106 char tetrisScreen[MAX_TET_X][MAX_TET_Y];
+ − 1107
+ − 1108 } T_TETRIS;
+ − 1109
+ − 1110
+ − 1111 static MfwHnd TetrisCreate(MfwHnd hParentWin);
+ − 1112 static void TetrisExecCb (MfwHnd hWin, USHORT uiE, SHORT iValue, void *pParameter);
+ − 1113 static int TetrisKbdCb (MfwEvt uiE, MfwKbd *psK);
+ − 1114 static int tetris_tim_cb(MfwEvt e, MfwTim *t);
+ − 1115 static int TetrisWinCb (MfwEvt uiE, MfwWin *psWin);
+ − 1116
+ − 1117
+ − 1118 #define E_INIT 0x5000
+ − 1119 #define E_EXIT 0x5001
+ − 1120
+ − 1121 void initTetGame(T_TETRIS *data)
+ − 1122 {
+ − 1123 int x,y;
+ − 1124 for (y=0;y<MAX_TET_Y;y++)
+ − 1125 {
+ − 1126 for (x=0;x<MAX_TET_X;x++)
+ − 1127 data->tetrisScreen[x][y]=' ';
+ − 1128 data->tetrisScreen[0][y]='#';
+ − 1129 data->tetrisScreen[MAX_TET_X-1][y]='#';
+ − 1130
+ − 1131 }
+ − 1132 for (x=0;x<MAX_TET_X;x++)
+ − 1133 data->tetrisScreen[x][MAX_TET_Y-1]='#';
+ − 1134 }
+ − 1135
+ − 1136 #define MAX_SHAPE 7
+ − 1137 void tetris_getShape(int shapeId, int rotate, char* shapeStr)
+ − 1138 {
+ − 1139 int j,k;
+ − 1140 int index;
+ − 1141 const char* tetShape[4*4*MAX_SHAPE] =
+ − 1142 { " ", " A ", " B ", " C ", " ", "F ", " G ",
+ − 1143 "EEEE", " AA ", " BB ", "CCC ", " DD ", "FFF ", "GGG ",
+ − 1144 " ", " A ", " B ", " ", " DD ", " ", " ",
+ − 1145 " ", " ", " ", " ", " ", " ", " ",
+ − 1146 " E ", " AA ", "BB ", " C ", " ", " FF ", " G ",
+ − 1147 " E ", "AA ", " BB ", " CC ", " DD ", " F ", " G ",
+ − 1148 " E ", " ", " ", " C ", " DD ", " F ", " GG ",
+ − 1149 " E ", " ", " ", " ", " ", " ", " ",
+ − 1150 " ", " A ", " B ", " ", " ", " ", " ",
+ − 1151 "EEEE", " AA ", " BB ", "CCC ", " DD ", "FFF ", "GGG ",
+ − 1152 " ", " A ", " B ", " C ", " DD ", " F ", "G ",
+ − 1153 " ", " ", " ", " ", " ", " ", " ",
+ − 1154 " E ", " AA ", "BB ", " C ", " ", " F ", "GG ",
+ − 1155 " E ", "AA ", " BB ", "CC ", " DD ", " F ", " G ",
+ − 1156 " E ", " ", " ", " C ", " DD ", "FF ", " G ",
+ − 1157 " E ", " ", " ", " ", " ", " ", " "
+ − 1158 };
+ − 1159
+ − 1160
+ − 1161 for (k=0;k<4;k++)
+ − 1162 {
+ − 1163 index = rotate*4*MAX_SHAPE+k*MAX_SHAPE;
+ − 1164 for (j=0;j<4;j++)
+ − 1165 shapeStr[j+k*4] = tetShape[index+shapeId][j];
+ − 1166 }
+ − 1167 }
+ − 1168
+ − 1169 int tetris_getNextShapeId( void )
+ − 1170 {
+ − 1171 static int shapeIndex = 0;
+ − 1172 shapeIndex = (shapeIndex+1) % MAX_SHAPE;
+ − 1173 return (shapeIndex);
+ − 1174 }
+ − 1175
+ − 1176
+ − 1177
+ − 1178 void tetris_getNextShape(T_TETRIS *data)
+ − 1179 {
+ − 1180 data->shapeId = tetris_getNextShapeId( );
+ − 1181 data->rotateId = 0;
+ − 1182 tetris_getShape(data->shapeId, data->rotateId, data->shapeStr);
+ − 1183 data->px = (MAX_TET_X-2)/2;
+ − 1184 data->py = 0;
+ − 1185 }
+ − 1186
+ − 1187 void tetris_getNextLevel(T_TETRIS *data)
+ − 1188 {
+ − 1189 initTetGame(data);
+ − 1190 tetris_getNextShape(data);
+ − 1191 data->level = data->level+1;
+ − 1192 data->linesToGo = 5*(data->level+1);
+ − 1193 data->resetSpeed = 0;
+ − 1194 data->maxDropTime = (120-data->level*5);
+ − 1195 }
+ − 1196
+ − 1197 void initTetrisData( T_TETRIS *data )
+ − 1198 {
+ − 1199 data->level = 0;
+ − 1200 data->score = 0;
+ − 1201 data->gameOver = 0;
+ − 1202 tetris_getNextLevel(data);
+ − 1203 }
+ − 1204
+ − 1205 void dspl_FillRect( int x1, int y1, int sx, int sy)
+ − 1206 {
+ − 1207 dspl_DrawFilledBgdRect(x1,y1,x1+sx,y1+sy);
+ − 1208 }
+ − 1209
+ − 1210 void tetris_drawScreen( int allScreen, T_TETRIS *data)
+ − 1211 {
+ − 1212 int x1,y1,x2,y2;
+ − 1213 int bCol;
+ − 1214 int xOfs =5;
+ − 1215 int yOfs=10;
+ − 1216 int xOfs2=30;
+ − 1217 int yOfs2=10;
+ − 1218 int sx,sy;
+ − 1219 int px,py;
+ − 1220 // U32 oldfCol=0; // RAVI
+ − 1221 // U32 oldbCol=0; // RAVI
+ − 1222 int x = data->px;
+ − 1223 int y = data->py;
+ − 1224
+ − 1225 // char dbg[80]; // RAVI
+ − 1226
+ − 1227
+ − 1228 #ifdef LSCREEN
+ − 1229 //Calculate size based on the screen properties
+ − 1230 sx = (SCREEN_SIZE_X-xOfs-xOfs2)/MAX_TET_X;
+ − 1231 sy = (SCREEN_SIZE_Y-yOfs-yOfs2-Mmi_layout_softkeyHeight())/MAX_TET_Y;
+ − 1232 #else
+ − 1233 //Screen is very small - ensure shapes are as large as possible
+ − 1234 sy = SCREEN_SIZE_Y/MAX_TET_Y;
+ − 1235 sx = SCREEN_SIZE_X/MAX_TET_X;
+ − 1236 if (sx >sy+1)
+ − 1237 sx = sy+1;
+ − 1238 xOfs = 5;
+ − 1239 xOfs2 = SCREEN_SIZE_X - (sx*MAX_TET_X+xOfs);
+ − 1240 yOfs = 0;
+ − 1241 yOfs2 = SCREEN_SIZE_Y - (sy*MAX_TET_Y+xOfs);
+ − 1242 #endif
+ − 1243 //allScreen= 1;
+ − 1244
+ − 1245 resources_setColour(COLOUR_GAME);
+ − 1246
+ − 1247 if (allScreen)
+ − 1248 { //redraw everything
+ − 1249 x1 = 0;
+ − 1250 y1 = 0;
+ − 1251 x2 = MAX_TET_X;
+ − 1252 y2 = MAX_TET_Y;
+ − 1253
+ − 1254 }
+ − 1255 else //just draw+1 box around current man
+ − 1256 {
+ − 1257 x1 = x-1;
+ − 1258 y1 = y-1;
+ − 1259 x2 = x+5;
+ − 1260 y2 = y+4;
+ − 1261 if (x1<1)x1=1;
+ − 1262 if (y1<0)y1=0;
+ − 1263 if (x2>MAX_TET_X-1) x2=MAX_TET_X-1;
+ − 1264 if (y2>MAX_TET_Y-1) y2=MAX_TET_Y-1;
+ − 1265 }
+ − 1266
+ − 1267 #ifndef COLOURDISPLAY
+ − 1268 dspl_Clear (xOfs+x1*sx,yOfs+y1*sy,xOfs+x2*sx-1,yOfs+y2*sy-1);
+ − 1269 #endif
+ − 1270 for (px = x1;px<x2;px++)
+ − 1271 {
+ − 1272 for (py = y1;py<y2;py++)
+ − 1273 {
+ − 1274 char boardChr = data->tetrisScreen[px][py];
+ − 1275 if ((px >= x ) && (px < x+4) &&
+ − 1276 (py >= y ) && (py < y+4))
+ − 1277 {
+ − 1278 int shapeX,shapeY;
+ − 1279 shapeX = px-x;
+ − 1280 shapeY = py-y;
+ − 1281 if (data->shapeStr[shapeX+shapeY*4] != ' ')
+ − 1282 boardChr = data->shapeStr[shapeX+shapeY*4];
+ − 1283 }
+ − 1284 #ifdef COLOURDISPLAY
+ − 1285 switch (boardChr)
+ − 1286 {
+ − 1287 case '#': bCol = 0x00FFFFFF; break;
+ − 1288 case ' ': bCol = 0x00404040; break;
+ − 1289 case 'A': bCol = 0x000000FF; break;
+ − 1290 case 'B': bCol = 0x0000FF00; break;
+ − 1291 case 'C': bCol = 0x00FF0000; break;
+ − 1292 case 'D': bCol = 0x0000FFFF; break;
+ − 1293 case 'E': bCol = 0x00FF00FF; break;
+ − 1294 case 'F': bCol = 0x00FFFF00; break;
+ − 1295 default: bCol = 0x00FFFFFF; break;
+ − 1296 }
+ − 1297 dspl_SetBgdColour(bCol);
+ − 1298 dspl_FillRect(xOfs+px*sx,yOfs+py*sy,sx,sy);
+ − 1299 // dspl_SetFgdColour(0x00802040);
+ − 1300 if (boardChr != ' ')
+ − 1301 dspl_DrawRect (xOfs+px*sx,yOfs+py*sy,xOfs+px*sx+sx-1,yOfs+py*sy+sy-1);
+ − 1302 #else
+ − 1303 if (boardChr != ' ')
+ − 1304 dspl_DrawRect (xOfs+px*sx,yOfs+py*sy,xOfs+px*sx+sx-1,yOfs+py*sy+sy-1);
+ − 1305 #endif
+ − 1306 }
+ − 1307 }
+ − 1308 if (data->gameOver)
+ − 1309 {
+ − 1310 int oldfCol = dspl_SetFgdColour(0x00FFFF00);
+ − 1311 dspl_SetBgdColour(0x008000FF);
+ − 1312 dspl_FillRect(xOfs+sx*3-5,yOfs+sy*3-5, xOfs+sx*3+5+6*4,yOfs+sy*3+5+18);
+ − 1313 dspl_TextOut(xOfs+sx*3,yOfs+sy*3, 0, "GAME");
+ − 1314 dspl_TextOut(xOfs+sx*3,yOfs+sy*3+Mmi_layout_line_height()+4, 0, "OVER");
+ − 1315 dspl_SetFgdColour(oldfCol);
+ − 1316
+ − 1317 }
+ − 1318 resources_restoreColour();
+ − 1319 }
+ − 1320
+ − 1321
+ − 1322
+ − 1323 int tetris_addShapeToScreen(T_TETRIS *data)
+ − 1324 {
+ − 1325 int x,y;
+ − 1326 for (x=0;x<4;x++)
+ − 1327 for (y=0;y<4;y++)
+ − 1328 if (data->shapeStr[x+y*4] != ' ')
+ − 1329 {
+ − 1330 if (data->tetrisScreen[data->px+x][data->py+y]!= ' ')
+ − 1331 return(1);
+ − 1332 else
+ − 1333 data->tetrisScreen[data->px+x][data->py+y] = data->shapeStr[x+y*4];
+ − 1334 }
+ − 1335 return(0);
+ − 1336
+ − 1337 }
+ − 1338
+ − 1339 int tetris_testForCompleteLines( T_TETRIS *data )
+ − 1340 {
+ − 1341 int nLines=0;
+ − 1342 int x,y;
+ − 1343 int blanks;
+ − 1344 for (y=MAX_TET_Y-2;y>0;y--)
+ − 1345 {
+ − 1346 blanks = 0;
+ − 1347
+ − 1348 for (x=1;x<MAX_TET_X-1;x++)
+ − 1349 {
+ − 1350 if (data->tetrisScreen[x][y] == ' ')
+ − 1351 blanks++;
+ − 1352 if (nLines >0)
+ − 1353 data->tetrisScreen[x][y+nLines] = data->tetrisScreen[x][y];
+ − 1354 }
+ − 1355 if (blanks==0)
+ − 1356 nLines++;
+ − 1357
+ − 1358 }
+ − 1359 return (nLines);
+ − 1360 }
+ − 1361
+ − 1362
+ − 1363 void tetris_testGameOver( T_TETRIS *data )
+ − 1364 {
+ − 1365 int linesComplete;
+ − 1366
+ − 1367 data->gameOver = tetris_addShapeToScreen(data);
+ − 1368 if (!data->gameOver)
+ − 1369 {
+ − 1370
+ − 1371 linesComplete = tetris_testForCompleteLines(data);
+ − 1372 if (linesComplete >0)
+ − 1373 {
+ − 1374 data->score = data->score + linesComplete*linesComplete;
+ − 1375 data->linesToGo = data->linesToGo - linesComplete;
+ − 1376 if (data->linesToGo <0)
+ − 1377 tetris_getNextLevel(data);
+ − 1378 }
+ − 1379 tetris_getNextShape(data);
+ − 1380 }
+ − 1381 }
+ − 1382
+ − 1383
+ − 1384
+ − 1385
+ − 1386
+ − 1387 void tetris_destroy (T_MFW_HND own_window)
+ − 1388 {
+ − 1389 T_MFW_WIN * win = ((T_MFW_HDR *)own_window)->data;
+ − 1390 T_TETRIS * data = (T_TETRIS *)win->user;
+ − 1391
+ − 1392 TRACE_EVENT ("tetris_destroy()");
+ − 1393
+ − 1394 if (own_window == NULL)
+ − 1395 {
+ − 1396 TRACE_EVENT ("Error :- Called with NULL Pointer");
+ − 1397 return;
+ − 1398 }
+ − 1399
+ − 1400 if (data)
+ − 1401 {
+ − 1402 /*
+ − 1403 * Exit ICON & KEYBOARD Handle
+ − 1404 */
+ − 1405 kbdDelete (data->hKbd);
+ − 1406 timDelete(data->info_tim);
+ − 1407 /*
+ − 1408 * Delete WIN Handler
+ − 1409 */
+ − 1410 winDelete (data->win);
+ − 1411 /*
+ − 1412 * Free Memory
+ − 1413 */
+ − 1414 FREE_MEMORY ((void *)data, sizeof (T_TETRIS));
+ − 1415 }
+ − 1416 }
+ − 1417
+ − 1418
+ − 1419
+ − 1420 int MmiTetrisStart(void )
+ − 1421 {
+ − 1422 MfwHnd hWin;
+ − 1423
+ − 1424 MfwHnd hParentWin = mfwParent(mfwHeader());
+ − 1425
+ − 1426 TRACE_FUNCTION ("TetrisStart()");
+ − 1427
+ − 1428 hWin = TetrisCreate (hParentWin);
+ − 1429
+ − 1430 if (hWin NEQ NULL)
+ − 1431 {
+ − 1432 SEND_EVENT (hWin, E_INIT, NULL, NULL);
+ − 1433 }
+ − 1434
+ − 1435 return 1;
+ − 1436 }
+ − 1437
+ − 1438 void initTetrisData( T_TETRIS *data );
+ − 1439 static MfwHnd TetrisCreate(MfwHnd hParentWin)
+ − 1440 {
+ − 1441 T_TETRIS *psData = (T_TETRIS *)ALLOC_MEMORY (sizeof( T_TETRIS));
+ − 1442 MfwWin *psWin;
+ − 1443 MfwWinAttr *win_attr;
+ − 1444
+ − 1445 TRACE_FUNCTION ("TetrisCreate()");
+ − 1446
+ − 1447 if (psData == NULL)
+ − 1448 {
+ − 1449 TRACE_EVENT ("ALLOC_MEMORY() failed");
+ − 1450 return NULL;
+ − 1451 }
+ − 1452
+ − 1453 win_attr = (MfwWinAttr *) ALLOC_MEMORY (sizeof(MfwWinAttr));
+ − 1454 if (win_attr)
+ − 1455 {
+ − 1456 win_attr->win.px = 0;
+ − 1457 win_attr->win.py = 0;
+ − 1458 win_attr->win.sx = SCREEN_SIZE_X;
+ − 1459 win_attr->win.sy = SCREEN_SIZE_Y;
+ − 1460 }
+ − 1461 psData->win = winCreate (hParentWin, win_attr, E_WIN_VISIBLE, (T_MFW_CB)TetrisWinCb);
+ − 1462 if (psData->win == NULL)
+ − 1463 {
+ − 1464 mfwFree((U8*) win_attr, sizeof(MfwWinAttr));
+ − 1465 FREE_MEMORY((void *)psData, sizeof (T_TETRIS));
+ − 1466 return NULL;
+ − 1467 }
+ − 1468 psData->mmi_control.dialog = (T_DIALOG_FUNC)TetrisExecCb;
+ − 1469 psData->mmi_control.data = psData;
+ − 1470 psData->timeStep = 150;
+ − 1471 psData->maxDropTime = 120;
+ − 1472 psData->dropTime = psData->maxDropTime;
+ − 1473 psWin = ((MfwHdr *)psData->win)->data;
+ − 1474 psWin->user = (void *)psData;
+ − 1475 psData->parent_win = hParentWin;
+ − 1476 initTetrisData( psData );
+ − 1477
+ − 1478 return psData->win;
+ − 1479 }
+ − 1480
+ − 1481 static int TetrisWinCb (MfwEvt uiE, MfwWin *psWin)
+ − 1482 {
+ − 1483 T_TETRIS *psData = (T_TETRIS *)psWin->user;
+ − 1484
+ − 1485 TRACE_FUNCTION ("TetrisWinCb()");
+ − 1486
+ − 1487 switch (uiE)
+ − 1488 {
+ − 1489 case MfwWinVisible:
+ − 1490 dspl_ResetWindow();
+ − 1491 dspl_SetBgdColour(0x000000FF);
+ − 1492 dspl_Clear(0,0,SCREEN_SIZE_X-1,SCREEN_SIZE_Y-1 );
+ − 1493 tetris_drawScreen( 1, psData);
+ − 1494
+ − 1495 break;
+ − 1496
+ − 1497 case MfwWinFocussed:
+ − 1498 case MfwWinDelete:
+ − 1499 default:
+ − 1500 return MFW_EVENT_REJECTED;
+ − 1501 }
+ − 1502 TRACE_FUNCTION ("TetrisWinCb() - end");
+ − 1503 return MFW_EVENT_CONSUMED;
+ − 1504 }
+ − 1505
+ − 1506 static void TetrisExecCb (MfwHnd hWin, USHORT uiE, SHORT iValue, void *pParameter)
+ − 1507 {
+ − 1508 MfwWin *psWin = ((MfwHdr *) hWin)->data;
+ − 1509 T_TETRIS *psData = (T_TETRIS *)psWin->user;
+ − 1510
+ − 1511 TRACE_FUNCTION ("TetrisExecCb()");
+ − 1512
+ − 1513 switch (uiE)
+ − 1514 {
+ − 1515 case E_INIT:
+ − 1516
+ − 1517 psData->info_tim = timCreate(hWin, psData->timeStep, (MfwCb)tetris_tim_cb);
+ − 1518 psData->hKbd = kbdCreate(psData->win, KEY_ALL, (MfwCb)TetrisKbdCb);
+ − 1519 timStart(psData->info_tim);
+ − 1520
+ − 1521 /* */
+ − 1522 winShow(hWin);
+ − 1523
+ − 1524 break;
+ − 1525
+ − 1526 case E_EXIT:
+ − 1527 tetris_destroy(hWin);
+ − 1528 break;
+ − 1529
+ − 1530 default:
+ − 1531 return;
+ − 1532 }
+ − 1533
+ − 1534 return;
+ − 1535 }
+ − 1536
+ − 1537
+ − 1538 static int tetris_checkPos( T_TETRIS *data, int px, int py, char* shape)
+ − 1539 {
+ − 1540 int x,y;
+ − 1541 for (x=0;x<4;x++)
+ − 1542 for (y=0;y<4;y++)
+ − 1543 if (shape[x+y*4] != ' ')
+ − 1544 {
+ − 1545 if (data->tetrisScreen[px+x][py+y]!= ' ')
+ − 1546 return(1);
+ − 1547 }
+ − 1548 return(0);
+ − 1549 }
+ − 1550
+ − 1551 static int tetris_moveDown(T_TETRIS *data,int *px, int *py)
+ − 1552 {
+ − 1553 int cannotMove;
+ − 1554 cannotMove = tetris_checkPos(data,*px,*py+1,data->shapeStr);
+ − 1555 if (cannotMove)
+ − 1556 return (1);
+ − 1557 else
+ − 1558 *py = *py+1;
+ − 1559 return (0);
+ − 1560 }
+ − 1561 static int tetris_moveLeft(T_TETRIS *data, int *px, int *py)
+ − 1562 {
+ − 1563 int cannotMove;
+ − 1564 cannotMove = tetris_checkPos(data,*px-1,*py,data->shapeStr);
+ − 1565 if (cannotMove)
+ − 1566 return (1);
+ − 1567 else
+ − 1568 *px = *px-1;
+ − 1569 return (0);
+ − 1570 }
+ − 1571 static int tetris_moveRight( T_TETRIS *data, int *px, int *py)
+ − 1572 {
+ − 1573 int cannotMove;
+ − 1574 cannotMove = tetris_checkPos(data,*px+1,*py,data->shapeStr);
+ − 1575 if (cannotMove)
+ − 1576 return (1);
+ − 1577 else
+ − 1578 *px = *px+1;
+ − 1579 return (0);
+ − 1580 }
+ − 1581
+ − 1582 static int tetris_rotateLeft( T_TETRIS *data, int *px, int *py )
+ − 1583 {
+ − 1584 int i;
+ − 1585 int cannotMove;
+ − 1586 char tmpShape[20];
+ − 1587 tetris_getShape(data->shapeId,(data->rotateId+1)%4,tmpShape);
+ − 1588 cannotMove = tetris_checkPos(data,*px,*py,tmpShape);
+ − 1589 if (cannotMove)
+ − 1590 return (1);
+ − 1591 for (i=0;i<16;i++)
+ − 1592 data->shapeStr[i] = tmpShape[i];
+ − 1593 data->rotateId = (data->rotateId+1)%4;
+ − 1594 return (0);
+ − 1595 }
+ − 1596
+ − 1597 static int tetris_rotateRight( T_TETRIS *data, int *px, int *py )
+ − 1598 {
+ − 1599 int i;
+ − 1600 int cannotMove;
+ − 1601 char tmpShape[20];
+ − 1602 tetris_getShape(data->shapeId,(data->rotateId+3)%4,tmpShape);
+ − 1603 cannotMove = tetris_checkPos(data,*px,*py,tmpShape);
+ − 1604 if (cannotMove)
+ − 1605 return (1);
+ − 1606 for (i=0;i<16;i++)
+ − 1607 data->shapeStr[i] = tmpShape[i];
+ − 1608 data->rotateId = (data->rotateId+3)%4;
+ − 1609 return (0);
+ − 1610 }
+ − 1611 #define KEY_TET_MOVELEFT KCD_1
+ − 1612 #define KEY_TET_MOVERIGHT KCD_3
+ − 1613 #define KEY_TET_ROTATELEFT KCD_4
+ − 1614 #define KEY_TET_ROTATERIGHT KCD_6
+ − 1615 #define KEY_TET_DROPALL KCD_5
+ − 1616 #define KEY_TET_DROP KCD_2
+ − 1617
+ − 1618
+ − 1619 static int TetrisKbdCb (MfwEvt uiE, MfwKbd *psK)
+ − 1620 {
+ − 1621 MfwHnd hWin = mfwParent(mfwHeader());
+ − 1622 MfwWin *psWin = ((MfwHdr *)hWin)->data;
+ − 1623 T_TETRIS *psData = (T_TETRIS *)psWin->user;
+ − 1624 int cannotMove=0;
+ − 1625
+ − 1626
+ − 1627 TRACE_FUNCTION ("TetrisKbdCb()");
+ − 1628 /***************************Go-lite Optimization changes Start***********************/
+ − 1629 // Aug 16, 2004 REF: CRR 24323 Deepa M.D
+ − 1630 TRACE_EVENT_P1 ("Code : %d",(int)psK->code);
+ − 1631 /***************************Go-lite Optimization changes Start***********************/
+ − 1632
+ − 1633
+ − 1634 switch(psK->code )
+ − 1635 {
+ − 1636 case KEY_TET_MOVELEFT:
+ − 1637 case KCD_MNULEFT:
+ − 1638 tetris_moveLeft(psData,&psData->px,&psData->py);
+ − 1639 break;
+ − 1640 case KEY_TET_MOVERIGHT:
+ − 1641 case KCD_MNURIGHT:
+ − 1642 tetris_moveRight(psData,&psData->px,&psData->py);
+ − 1643 break;
+ − 1644 case KEY_TET_ROTATELEFT:
+ − 1645 tetris_rotateLeft(psData,&psData->px,&psData->py);
+ − 1646 break;
+ − 1647 case KCD_MNUSELECT:
+ − 1648 case KEY_TET_ROTATERIGHT:
+ − 1649 tetris_rotateRight(psData,&psData->px,&psData->py);
+ − 1650 break;
+ − 1651 case KEY_TET_DROP:
+ − 1652 cannotMove = tetris_moveDown(psData,&psData->px,&psData->py);
+ − 1653 if (cannotMove)
+ − 1654 tetris_testGameOver( psData );
+ − 1655 break;
+ − 1656 case KEY_TET_DROPALL:
+ − 1657 while(tetris_moveDown(psData,&psData->px,&psData->py) ==0)
+ − 1658 { //loop until we hit the bottom
+ − 1659
+ − 1660 }
+ − 1661 cannotMove = 1;
+ − 1662 tetris_testGameOver( psData );
+ − 1663 break;
+ − 1664
+ − 1665
+ − 1666 case KCD_RIGHT:
+ − 1667 SEND_EVENT (hWin, E_EXIT, 0, 0);
+ − 1668 return MFW_EVENT_CONSUMED;
+ − 1669
+ − 1670 default:
+ − 1671
+ − 1672 return MFW_EVENT_CONSUMED;
+ − 1673 }
+ − 1674 tetris_drawScreen(cannotMove, psData);
+ − 1675
+ − 1676 TRACE_FUNCTION ("TetrisKbdCb()-end");
+ − 1677 return MFW_EVENT_CONSUMED;
+ − 1678 }
+ − 1679
+ − 1680 static int tetris_tim_cb(MfwEvt e, MfwTim *t)
+ − 1681 {
+ − 1682 T_MFW_HND win = mfw_parent (mfw_header());
+ − 1683 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
+ − 1684 T_TETRIS * data = (T_TETRIS *)win_data->user;
+ − 1685 static int nCycles = 0;
+ − 1686 int cannotMove;
+ − 1687
+ − 1688 char bfr[80];
+ − 1689 nCycles = nCycles+ data->timeStep;
+ − 1690 if (nCycles > 1000)
+ − 1691 {
+ − 1692 nCycles = nCycles - 1000;
+ − 1693 data->maxDropTime = data->maxDropTime-1;
+ − 1694 }
+ − 1695 TRACE_EVENT("tetris_tim_cb");
+ − 1696 data->dropTime = data->dropTime - data->timeStep;
+ − 1697 if (data->dropTime < 0)
+ − 1698 {
+ − 1699 if (data->maxDropTime > 90)
+ − 1700 data->dropTime = data->dropTime+75*10;
+ − 1701 else if (data->maxDropTime > 60)
+ − 1702 data->dropTime = data->dropTime+(60+(data->maxDropTime-60)/2)*10;
+ − 1703 else if (data->maxDropTime > 30)
+ − 1704 data->dropTime = data->dropTime+data->maxDropTime*10;
+ − 1705 else
+ − 1706 data->dropTime = data->dropTime+(data->maxDropTime+90)/4*10;
+ − 1707
+ − 1708 if (data->dropTime < data->timeStep)
+ − 1709 data->dropTime = data->timeStep;
+ − 1710 else if (data->dropTime < data->timeStep)
+ − 1711 data->dropTime = data->timeStep;
+ − 1712
+ − 1713 resources_setColour(COLOUR_GAME);
+ − 1714 sprintf(bfr,"%d ",data->score);
+ − 1715 dspl_TextOut(SCREEN_SIZE_X-30 ,10, 0, bfr);
+ − 1716 sprintf(bfr,"%d ",data->linesToGo);
+ − 1717 dspl_TextOut(SCREEN_SIZE_X-30 ,12+Mmi_layout_line_height(), 0, bfr);
+ − 1718 resources_restoreColour();
+ − 1719 cannotMove = tetris_moveDown(data,&data->px,&data->py);
+ − 1720 tetris_getNextShapeId( );//To randomize it
+ − 1721
+ − 1722 if (cannotMove)
+ − 1723 {
+ − 1724 tetris_testGameOver( data );
+ − 1725 }
+ − 1726 tetris_drawScreen(cannotMove, data);
+ − 1727 }
+ − 1728
+ − 1729 timStart(data->info_tim);
+ − 1730 TRACE_EVENT("tetris_tim_cb-end");
+ − 1731 return 1;
+ − 1732 }
+ − 1733
+ − 1734 T_MFW_HND Game_Info(T_MFW_HND parent_window)
+ − 1735 {
+ − 1736 T_MFW_HND win = ShowGame_Information(parent_window);
+ − 1737 TRACE_FUNCTION("ShowVerion()");
+ − 1738 if (win NEQ NULL)
+ − 1739 {
+ − 1740 SEND_EVENT (win, SHOWGAMEINFO_INIT, 0, 0);
+ − 1741 }
+ − 1742
+ − 1743 return win;
+ − 1744 }
+ − 1745
+ − 1746 static T_MFW_HND ShowGame_Information(MfwHnd parent_window)
+ − 1747 {
+ − 1748 tShowInfo* data = (tShowInfo*)ALLOC_MEMORY (sizeof (tShowInfo));
+ − 1749 T_MFW_WIN* win;
+ − 1750
+ − 1751 if (data EQ NULL)
+ − 1752 {
+ − 1753 return NULL;
+ − 1754 }
+ − 1755
+ − 1756 // Create the window handler
+ − 1757 data->win = win_create (parent_window, 0, E_WIN_VISIBLE, NULL);
+ − 1758 if (data->win EQ NULL)
+ − 1759 {
+ − 1760 return NULL;
+ − 1761 }
+ − 1762
+ − 1763 // connect the dialog data to the MFW window
+ − 1764 data->mmi_control.dialog = (T_DIALOG_FUNC)ShowGame_DialogCB;
+ − 1765 data->mmi_control.data = data;
+ − 1766
+ − 1767 win = ((T_MFW_HDR *)data->win)->data;
+ − 1768 win->user = (void *)data;
+ − 1769 data->parent_win = parent_window;
+ − 1770
+ − 1771 return data->win;
+ − 1772 }
+ − 1773
+ − 1774 static void ShowGame_DialogCB(T_MFW_HND win, USHORT e, SHORT identifier, void *parameter)
+ − 1775 {
+ − 1776 T_MFW_WIN *win_data = ((T_MFW_HDR *) win)->data;
+ − 1777 tShowInfo* data = (tShowInfo*) win_data->user;
+ − 1778 /* SPR#1428 - SH - New editor data */
+ − 1779 #ifdef NEW_EDITOR
+ − 1780 // T_AUI_EDITOR_DATA editor_data; // RAVI
+ − 1781 #else /* NEW_EDITOR */
+ − 1782 // T_EDITOR_DATA editor_data; // RAVI
+ − 1783 #endif /* NEW_EDITOR */
+ − 1784
+ − 1785 switch (e)
+ − 1786 {
+ − 1787 case SHOWGAMEINFO_INIT:
+ − 1788 {
+ − 1789 strcat(data->buffer, info);
+ − 1790
+ − 1791 ShowGameInfoEditor(win);
+ − 1792
+ − 1793 /* SPR#1428 - SH - New editor changes */
+ − 1794 #ifdef NEW_EDITOR
+ − 1795 data->editor_data.Callback = (T_AUI_EDIT_CB)ShowInfoCB;
+ − 1796 AUI_edit_Start(win, &(data->editor_data));
+ − 1797 #else /* NEW_EDITOR */
+ − 1798 data->editor_data.Callback = (T_EDIT_CB)ShowInfoCB;
+ − 1799 editor_start(win, &(data->editor_data));
+ − 1800 #endif /* NEW_EDITOR */
+ − 1801
+ − 1802 winShow(data->win);
+ − 1803 }
+ − 1804 break;
+ − 1805
+ − 1806 default:
+ − 1807 {
+ − 1808 TRACE_EVENT("Show Game Info : Unknown Event");
+ − 1809 }
+ − 1810 break;
+ − 1811 }
+ − 1812 }
+ − 1813
+ − 1814 void ShowGameInfoEditor (T_MFW_HND win)
+ − 1815 {
+ − 1816 T_MFW_WIN *win_data = ((T_MFW_HDR *) win)->data;
+ − 1817 tShowInfo* data = (tShowInfo*) win_data->user;
+ − 1818
+ − 1819 /* SPR#1428 - SH - New editor changes */
+ − 1820 #ifdef NEW_EDITOR
+ − 1821 AUI_edit_SetDefault(&data->editor_data);
+ − 1822 AUI_edit_SetDisplay(&data->editor_data, NULL, COLOUR_EDITOR, EDITOR_FONT);
+ − 1823 AUI_edit_SetTextStr(&data->editor_data, TxtSoftBack, TxtNull, TxtNull, NULL);
+ − 1824 AUI_edit_SetEvents(&data->editor_data, 0, TRUE, FOREVER, NULL);
+ − 1825 AUI_edit_SetBuffer(&data->editor_data, ATB_DCS_ASCII, (UBYTE *)data->buffer, 35);
+ − 1826 AUI_edit_SetMode(&data->editor_data, ED_MODE_READONLY, ED_CURSOR_NONE);
+ − 1827 #else /* NEW_EDITOR */
+ − 1828 editor_attr_init(&((data->editor_data).editor_attr), NULL, edtCurNone, 0, (char*)data->buffer, 35, COLOUR_EDITOR);
+ − 1829 editor_data_init(&data->editor_data, NULL, TxtSoftBack, TxtNull, 0, 1, READ_ONLY_MODE, FOREVER);
+ − 1830
+ − 1831 data->editor_data.hide = FALSE;
+ − 1832 data->editor_data.Identifier = 0;
+ − 1833 data->editor_data.TextString = NULL;
+ − 1834 data->editor_data.destroyEditor = TRUE;
+ − 1835 #endif /* NEW_EDITOR */
+ − 1836 }
+ − 1837
+ − 1838 static void ShowInfoCB( T_MFW_HND win, USHORT Identifier,UBYTE reason)
+ − 1839 {
+ − 1840 T_MFW_WIN *win_data = ( (T_MFW_HDR *) win )->data;
+ − 1841 tShowInfo*data = (tShowInfo*) win_data->user;
+ − 1842
+ − 1843
+ − 1844 TRACE_FUNCTION("ShowVerionCB()");
+ − 1845
+ − 1846 switch (reason )
+ − 1847 {
+ − 1848 case INFO_KCD_LEFT:
+ − 1849 case INFO_KCD_HUP:
+ − 1850 case INFO_KCD_RIGHT:
+ − 1851
+ − 1852 default:
+ − 1853 showGameInfo_destroy(data->win);
+ − 1854 break;
+ − 1855 }
+ − 1856 }
+ − 1857
+ − 1858 /*******************************************************************************
+ − 1859
+ − 1860 $Function: showVersion_destroy
+ − 1861
+ − 1862 $Description: Destroys the editor
+ − 1863
+ − 1864 $Returns:
+ − 1865
+ − 1866 $Arguments:
+ − 1867
+ − 1868 *******************************************************************************/
+ − 1869 void showGameInfo_destroy(MfwHnd own_window)
+ − 1870 {
+ − 1871 T_MFW_WIN * win_data;
+ − 1872
+ − 1873 tShowInfo* data = NULL;
+ − 1874
+ − 1875 if (own_window == NULL)
+ − 1876 {
+ − 1877 TRACE_EVENT ("Error : showGameInfo_destroy called with NULL Pointer");
+ − 1878 return;
+ − 1879 }
+ − 1880
+ − 1881
+ − 1882 win_data = ((T_MFW_HDR *)own_window)->data;
+ − 1883 if (win_data != NULL)
+ − 1884 data = (tShowInfo*)win_data->user;
+ − 1885
+ − 1886 if (data)
+ − 1887 {
+ − 1888 TRACE_EVENT ("calc_destroy()");
+ − 1889
+ − 1890 win_delete (data->win);
+ − 1891 // Free Memory
+ − 1892 FREE_MEMORY ((void *)data, sizeof (tShowInfo));
+ − 1893
+ − 1894 }
+ − 1895 else
+ − 1896 {
+ − 1897 TRACE_EVENT ("calc_destroy() called twice");
+ − 1898 }
+ − 1899 }
+ − 1900 #endif
+ − 1901
