开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
Puzzle.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：71k
源码类别：

MTK

开发平台：

C/C++

Puzzle.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  35. /*****************************************************************************
  36.  * Filename:
  37.  * ---------
  38.  *  Puzzle.c
  39.  *
  40.  * Project:
  41.  * --------
  42.  *   Maui
  43.  *
  44.  * Description:
  45.  * ------------
  46.  *  Game Puzzle function.
  47.  *
  48.  * Author:
  49.  * -------
  50.  * -------
  51.  * -------
  52.  *
  53.  *============================================================================
  54.  *             HISTORY
  55.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  56.  *------------------------------------------------------------------------------
  57.  * removed!
  58.  *
  59.  * removed!
  60.  * removed!
  61.  * removed!
  62.  *
  63.  * removed!
  64.  * removed!
  65.  * removed!
  66.  *
  67.  * removed!
  68.  * removed!
  69.  * removed!
  70.  *
  71.  * removed!
  72.  * removed!
  73.  * removed!
  74.  *
  75.  * removed!
  76.  * removed!
  77.  * removed!
  78.  *
  79.  * removed!
  80.  * removed!
  81.  * removed!
  82.  *
  83.  * removed!
  84.  * removed!
  85.  * removed!
  86.  *
  87.  * removed!
  88.  * removed!
  89.  * removed!
  90.  *
  91.  * removed!
  92.  * removed!
  93.  * removed!
  94.  *
  95.  * removed!
  96.  * removed!
  97.  * removed!
  98.  *
  99.  * removed!
  100.  * removed!
  101.  * removed!
  102.  *
  103.  *------------------------------------------------------------------------------
  104.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  105.  *============================================================================
  106.  ****************************************************************************/
  108. #include "MMI_features.h"
  109. #include "GameDefs.h"
  111. #ifdef IS_PUZZLE_BASE_GAME
  113. #include "GameInc.h"
  114. #include "PuzzleProts.h"
  115. #include "PuzzleDefs.h"
  117. #ifdef __MMI_TOUCH_SCREEN__
  118. #include "wgui_touch_screen.h"
  119. #endif 
  121. /***************************************************************************** 
  122. * Define
  123. *****************************************************************************/
  124. #define MMI_GX_PUZZLE_BACKGROUND_COLOR (gui_color(71, 71, 71))
  125. #define MMI_GX_PUZZLE_LINE_COLOR       (gui_color(235, 235, 235))
  126. #define MMI_GX_PUZZLE_LIGHT_BORDER     (gui_color(133, 133, 133))
  127. #define MMI_GX_PUZZLE_DARK_BORDER      (gui_color(16, 16, 16))
  128. #define MMI_GX_PUZZLE_EASY             (0)
  129. #define MMI_GX_PUZZLE_NORMAL           (1)
  130. #define MMI_GX_PUZZLE_HARD             (2)
  132. #ifdef __MMI_GAME_PUZZLE_128x160__
  133. #define MMI_GX_PUZZLE_TIME_POSITION_X  (8)
  134. #define MMI_GX_PUZZLE_TIME_POSITION_Y  (14)
  135. #define MMI_GX_PUZZLE_STEP_POSITION_X  (90)
  136. #define MMI_GX_PUZZLE_STEP_POSITION_Y  (14)
  137. #define MMI_GX_PUZZLE_LCD_HEIGHT       (160)
  138. #define MMI_GX_PUZZLE_LCD_WIDTH        (128)
  139. #elif defined(__MMI_GAME_PUZZLE_128x128__)
  140. #define MMI_GX_PUZZLE_TIME_POSITION_X  (24)
  141. #define MMI_GX_PUZZLE_TIME_POSITION_Y  (49)
  142. #define MMI_GX_PUZZLE_STEP_POSITION_X  (24)
  143. #define MMI_GX_PUZZLE_STEP_POSITION_Y  (69)
  144. #define MMI_GX_PUZZLE_LCD_HEIGHT       (128)
  145. #define MMI_GX_PUZZLE_STATUS_POS_X     (17)
  146. #define MMI_GX_PUZZLE_STATUS_POS_Y     (40)
  147. #define MMI_GX_PUZZLE_STATUS_WIDTH     (90)
  148. #define MMI_GX_PUZZLE_STATUS_HEIGHT    (44)
  149. #define MMI_GX_PUZZLE_STATUS_SHADOW    (3)
  150. #define MMI_GX_PUZZLE_LCD_WIDTH        (128)
  151. #elif defined(__MMI_GAME_PUZZLE_176x220__)
  152. #define MMI_GX_PUZZLE_TIME_POSITION_X  (14)
  153. #define MMI_GX_PUZZLE_TIME_POSITION_Y  (63)
  154. #define MMI_GX_PUZZLE_STEP_POSITION_X  (123)
  155. #define MMI_GX_PUZZLE_STEP_POSITION_Y  (63)
  156. #define MMI_GX_PUZZLE_LCD_HEIGHT       (220)
  157. #define MMI_GX_PUZZLE_LCD_WIDTH        (176)
  158. #define MMI_GX_PUZZLE_BAR_COLOR        (MMI_GX_PUZZLE_LINE_COLOR)
  159. #elif defined(__MMI_GAME_PUZZLE_240x320__)
  160. #define MMI_GX_PUZZLE_TIME_POSITION_X  (20)
  161. #define MMI_GX_PUZZLE_TIME_POSITION_Y  (132)
  162. #define MMI_GX_PUZZLE_STEP_POSITION_X  (160)
  163. #define MMI_GX_PUZZLE_STEP_POSITION_Y  (132)
  164. #define MMI_GX_PUZZLE_BAR_COLOR        (MMI_GX_PUZZLE_LINE_COLOR)
  165. #define MMI_GX_PUZZLE_LCD_HEIGHT       (320)
  166. #define MMI_GX_PUZZLE_LCD_WIDTH        (240)
  167. #endif 
  169. #if defined(__MMI_GAME_PUZZLE_128x160__) || defined(__MMI_GAME_PUZZLE_128x128__)
  170. #define MMI_GX_PUZZLE_ORIGIN_X         (4)
  171. #define MMI_GX_PUZZLE_ORIGIN_Y         (4)
  172. #define MMI_GX_PUZZLE_SIZE             (120)
  173. #define MMI_GX_PUZZLE_LEFT_BAR_WIDTH   (4)
  174. #define MMI_GX_PUZZLE_RIGHT_BAR_WIDTH  (4)
  175. #define MMI_GX_PUZZLE_TOP_BAR_WIDTH    (4)
  176. #define MMI_GX_PUZZLE_BOTTOM_BAR_WIDTH (4)
  177. #define MMI_GX_PUZZLE_DIGIT_WIDTH      (4)
  178. #elif defined(__MMI_GAME_PUZZLE_176x220__)
  179. #define MMI_GX_PUZZLE_ORIGIN_X         (6)
  180. #define MMI_GX_PUZZLE_ORIGIN_Y         (6)
  181. #define MMI_GX_PUZZLE_SIZE             (165)
  182. #define MMI_GX_PUZZLE_LEFT_BAR_WIDTH   (6)
  183. #define MMI_GX_PUZZLE_RIGHT_BAR_WIDTH  (5)
  184. #define MMI_GX_PUZZLE_TOP_BAR_WIDTH    (6)
  185. #define MMI_GX_PUZZLE_BOTTOM_BAR_WIDTH (6)
  186. #define MMI_GX_PUZZLE_DIGIT_WIDTH      (6)
  188. #define MMI_GX_PUZZLE_SOFTKEY_X (150)
  189. #define MMI_GX_PUZZLE_SOFTKEY_Y (205)
  190. #define MMI_GX_PUZZLE_SOFTKEY_WIDTH (20)
  191. #define MMI_GX_PUZZLE_SOFTKEY_HEIGHT (10)
  192. #elif defined(__MMI_GAME_PUZZLE_240x320__)
  193. #define MMI_GX_PUZZLE_ORIGIN_X         (7)
  194. #define MMI_GX_PUZZLE_ORIGIN_Y         (7)
  195. #define MMI_GX_PUZZLE_SIZE             (225)
  196. #define MMI_GX_PUZZLE_LEFT_BAR_WIDTH   (8)
  197. #define MMI_GX_PUZZLE_RIGHT_BAR_WIDTH  (7)
  198. #define MMI_GX_PUZZLE_TOP_BAR_WIDTH    (8)
  199. #define MMI_GX_PUZZLE_BOTTOM_BAR_WIDTH (8)
  200. #define MMI_GX_PUZZLE_DIGIT_WIDTH      (9)
  202. #define MMI_GX_PUZZLE_SOFTKEY_X (190)
  203. #define MMI_GX_PUZZLE_SOFTKEY_Y (299)
  204. #define MMI_GX_PUZZLE_SOFTKEY_WIDTH (40)
  205. #define MMI_GX_PUZZLE_SOFTKEY_HEIGHT (20)
  207. #endif 
  209. /***************************************************************************** 
  210. * Typedef 
  211. *****************************************************************************/
  212. /* game context */
  213. typedef struct
  214. {
  215.     S16 x;
  216.     S16 y;
  217. } gx_puzzle_position_struct;
  219. typedef struct
  220. {
  221.     BOOL is_gameover;
  222.     BOOL is_new_game;
  223.     U8 game_level;
  224.     S16 game_grade;
  225.     U16 timer_elapse;
  226.     U16 step;
  227.     U16 tick;
  228.     U8 softkey_state;
  229.     U16 click;
  230.     S16 destination_x;
  231.     S16 destination_y;
  232.     S16 puzzle[5][5];
  233.     MMI_ID_TYPE image;
  234.     MMI_ID_TYPE small_image;
  235.     gx_puzzle_position_struct null_grid;
  236.     S32 long_tick;
  237. #ifdef __MMI_GAME_PUZZLE_128x128__
  238.     BOOL is_show_status;
  239. #endif 
  241. #if defined (__MMI_GAME_MULTICHANNEL_SOUND__)
  242.     S32 move_midi;
  243. #endif 
  245. } gx_puzzle_context_struct;
  247. /***************************************************************************** 
  248. * Local Variable
  249. *****************************************************************************/
  250. gx_puzzle_context_struct g_gx_puzzle_context = 
  251. {
  252.     FALSE,  /* is_gameover */
  253.     TRUE,   /* is_new_game */
  254.     0,      /* game_level */
  255.     0,      /* game_grade */
  256.     100,    /* timer_elapse */
  257.     0,      /* how many steps user went */
  258.     0,      /* global tick */
  259.     0,      /* softkey state */
  260.     0       /* user clicks */
  261. };
  263. /***************************************************************************** 
  264. * Local Function
  265. *****************************************************************************/
  266. /* Game framework related functions */
  267. S16 mmi_gx_puzzle_calc_best_grade(S16 old_grade, S16 new_grade);        /* descide which is best grade */
  268. void mmi_gx_puzzle_enter_game(void);    /* entry function of the game */
  269. void mmi_gx_puzzle_exit_game(void);     /* exit function - usually will stop timer and release buffer */
  270. void mmi_gx_puzzle_draw_gameover(void); /* draw gameover screen */
  272. /* Game play functions */
  273. void mmi_gx_puzzle_framemove(void);
  274. void mmi_gx_puzzle_render(void);
  275. void mmi_gx_puzzle_gameover(void);
  276. void mmi_gx_puzzle_cyclic_timer(void);
  277. void mmi_gx_puzzle_init_game(void); /* draw gameover screen */
  278. void mmi_gx_puzzle_draw_static_background(void);
  279. void mmi_gx_puzzle_key_2_release(void);
  280. void mmi_gx_puzzle_key_4_release(void);
  281. void mmi_gx_puzzle_key_6_release(void);
  282. void mmi_gx_puzzle_key_8_release(void);
  284. #ifdef __MMI_GAME_PUZZLE_128x128__
  285. void mmi_gx_puzzle_key_5_press(void);
  286. void mmi_gx_puzzle_key_5_release(void);
  287. #endif /* __MMI_GAME_PUZZLE_128x128__ */ 
  288. void mmi_gx_puzzle_show_puzzle(void);
  289. void mmi_gx_puzzle_move_and_show(void);
  290. void mmi_gx_puzzle_my_show_image(long x, long y, S16 input_image_id);
  291. void mmi_gx_puzzle_draw_seperation_line(void);
  293. #if defined(__MMI_GAME_PUZZLE_128x160__) || defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__)
  294. void mmi_gx_puzzle_draw_step(void);
  295. #endif 
  297. #ifdef __MMI_TOUCH_SCREEN__
  298. /* touch screen */
  299. void mmi_puzzle_pen_down_hdlr(mmi_pen_point_struct pos);
  300. void mmi_puzzle_pen_up_hdlr(mmi_pen_point_struct pos);
  301. #endif /* __MMI_TOUCH_SCREEN__ */ 
  303. /************************************************************************/
  304. /* Audio [Const]                                                        */
  305. /************************************************************************/
  306. #ifdef __MMI_GAME_MULTICHANNEL_SOUND__
  307. #define  PUZZLEMOVE  138
  308. __align(2)
  309.      const U8 PuzzleMove[138] = 
  310.      {
  311.          0x4D, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x03, 0xC0, 0x4D, 0x54, 0x72,
  312.          0x6B, 0x00, 0x00, 0x00, 0x74, 0x00, 0xFF, 0x02, 0x16, 0x43, 0x6F, 0x70, 0x79, 0x72, 0x69, 0x67,
  313.          0x68, 0x74, 0x20, 0x63, 0x20, 0x32, 0x30, 0x30, 0x33, 0x20, 0x62, 0x79, 0x20, 0x43, 0x43, 0x00,
  314.          0xFF, 0x01, 0x02, 0x43, 0x43, 0x00, 0xFF, 0x58, 0x04, 0x04, 0x02, 0x18, 0x08, 0x00, 0xFF, 0x59,
  315.          0x02, 0x00, 0x00, 0x00, 0xFF, 0x51, 0x03, 0x05, 0x24, 0xB7, 0x00, 0xC0, 0x0A, 0x00, 0xB0, 0x07,
  316.          0x60, 0x00, 0x90, 0x48, 0x64, 0x00, 0xC1, 0x61, 0x00, 0xB1, 0x07, 0x7C, 0x00, 0x91, 0x48, 0x64,
  317.          0x81, 0x70, 0x90, 0x48, 0x00, 0x00, 0x4A, 0x64, 0x81, 0x70, 0x4A, 0x00, 0x00, 0x4C, 0x64, 0x81,
  318.          0x70, 0x4C, 0x00, 0x00, 0x4F, 0x64, 0x81, 0x70, 0x4F, 0x00, 0x00, 0x54, 0x64, 0x81, 0x70, 0x54,
  319.          0x00, 0x00, 0x91, 0x48, 0x00, 0x00, 0xFF, 0x2F, 0x00
  320.      };
  322. #else /* __MMI_GAME_MULTICHANNEL_SOUND__ */ 
  323. #define  PUZZLEMOVE_DVI 890
  325. __align(2)
  326.      const U8 PuzzleMove_dvi[890] = 
  327.      {
  328.          0x77, 0xD7, 0x77, 0x77, 0x0E, 0x08, 0xB7, 0xB7, 0x08, 0x17, 0x8C, 0x10, 0x88, 0xA8, 0x89, 0x18,
  329.          0x32, 0x02, 0xB8, 0xAD, 0x8A, 0x42, 0x33, 0x92, 0xCC, 0xAB, 0x28, 0x44, 0x13, 0xB8, 0xBD, 0x9A,
  330.          0x42, 0x34, 0x81, 0xDA, 0xBB, 0x18, 0x44, 0x13, 0xA0, 0xDC, 0x8A, 0x30, 0x53, 0x82, 0xC9, 0xBB,
  331.          0x09, 0x53, 0x24, 0xA0, 0xDA, 0xAA, 0x20, 0x34, 0x23, 0xC9, 0xAD, 0x8A, 0x41, 0x24, 0x81, 0xC9,
  332.          0xAC, 0x19, 0x52, 0x13, 0x90, 0xDB, 0xAA, 0x18, 0x54, 0x12, 0xA8, 0xBC, 0x9A, 0x30, 0x25, 0x23,
  333.          0xA9, 0xCD, 0x8B, 0x30, 0x35, 0x02, 0xB8, 0xAD, 0x9B, 0x30, 0x35, 0x04, 0xA8, 0xCC, 0xA9, 0x30,
  334.          0x53, 0x13, 0x99, 0xCC, 0xAA, 0x28, 0x44, 0x13, 0x90, 0xBC, 0xCB, 0x19, 0x72, 0x22, 0x90, 0xBA,
  335.          0xCB, 0x89, 0x52, 0x34, 0x80, 0xC9, 0xBB, 0x0B, 0x51, 0x24, 0x03, 0xB9, 0xAE, 0x9A, 0x21, 0x34,
  336.          0x33, 0xA8, 0xBF, 0x9A, 0x10, 0x43, 0x34, 0x98, 0xBD, 0xAA, 0x08, 0x34, 0x25, 0x00, 0xAC, 0xAC,
  337.          0x09, 0x32, 0x26, 0x82, 0xCA, 0xBB, 0x98, 0x40, 0x45, 0x00, 0x99, 0xBB, 0x8D, 0x48, 0x42, 0x11,
  338.          0x98, 0xBC, 0xAB, 0x38, 0x54, 0x12, 0x80, 0xEB, 0x9B, 0x10, 0x31, 0x35, 0x91, 0xBC, 0xBA, 0x8A,
  339.          0x44, 0x24, 0x82, 0xCA, 0xCB, 0x8A, 0x61, 0x22, 0x11, 0xB8, 0xBE, 0x88, 0x10, 0x44, 0x02, 0xA8,
  340.          0xDB, 0xAA, 0x20, 0x44, 0x03, 0x80, 0xDC, 0x8B, 0x00, 0x42, 0x15, 0x98, 0xA9, 0xBC, 0x08, 0x43,
  341.          0x24, 0x00, 0xD9, 0xAC, 0x80, 0x30, 0x26, 0x80, 0xA8, 0xBC, 0x0A, 0x21, 0x26, 0x12, 0xC9, 0xAB,
  342.          0xAB, 0x68, 0x14, 0x21, 0xB0, 0xAD, 0xA9, 0x28, 0x44, 0x12, 0x90, 0xEB, 0x9B, 0x01, 0x51, 0x14,
  343.          0x88, 0xC9, 0x9C, 0x08, 0x42, 0x32, 0x91, 0xBB, 0xDC, 0x19, 0x12, 0x54, 0x91, 0x99, 0xBC, 0x89,
  344.          0x41, 0x33, 0x13, 0xBC, 0xDA, 0x8C, 0x12, 0x62, 0x82, 0x98, 0xCB, 0x9A, 0x40, 0x22, 0x16, 0x9A,
  345.          0xC8, 0x8C, 0x00, 0x43, 0x12, 0xA0, 0xCA, 0x9D, 0x10, 0x50, 0x03, 0x10, 0xCC, 0xA9, 0x08, 0x42,
  346.          0x14, 0x00, 0xF9, 0x89, 0x8A, 0x33, 0x41, 0x81, 0xC9, 0xAB, 0x8B, 0x25, 0x61, 0x91, 0x98, 0xBC,
  347.          0x88, 0x30, 0x44, 0x81, 0xB1, 0x9F, 0xA8, 0x31, 0x22, 0x14, 0xA9, 0x9D, 0xAB, 0x22, 0x71, 0x93,
  348.          0x81, 0xAD, 0xA9, 0x10, 0x34, 0x21, 0xE3, 0x8A, 0x9D, 0x01, 0x41, 0x12, 0x90, 0xE9, 0x0A, 0x1B,
  349.          0x05, 0x32, 0x98, 0xC9, 0xBB, 0x38, 0x68, 0x85, 0x01, 0xAB, 0xCA, 0x08, 0x32, 0x63, 0x90, 0xC0,
  350.          0x8C, 0x8A, 0x14, 0x32, 0x82, 0x9C, 0xFB, 0x00, 0x59, 0x01, 0x82, 0xB8, 0xAA, 0x1D, 0x81, 0x07,
  351.          0x20, 0x9A, 0xAA, 0x9A, 0x23, 0x72, 0x00, 0xD1, 0xA8, 0x8A, 0x30, 0x52, 0x92, 0xA1, 0x0F, 0x8B,
  352.          0x01, 0x33, 0x84, 0x08, 0x9F, 0xB8, 0x02, 0x52, 0x01, 0x88, 0x9D, 0xC8, 0x02, 0x51, 0x10, 0x88,
  353.          0xAC, 0xC8, 0x02, 0x61, 0x00, 0xA1, 0xAA, 0xD9, 0x82, 0x62, 0x28, 0x98, 0xB9, 0xBA, 0xA3, 0x36,
  354.          0x58, 0x89, 0xC9, 0x99, 0x80, 0x86, 0x13, 0x2A, 0xAC, 0xA9, 0x29, 0x13, 0x87, 0x93, 0x8C, 0x8C,
  355.          0x18, 0x60, 0x10, 0xB1, 0xD1, 0x99, 0x08, 0x23, 0x62, 0x2A, 0xAC, 0xB8, 0x18, 0x22, 0x97, 0xA4,
  356.          0xA8, 0x8B, 0x19, 0x52, 0x50, 0x1A, 0xBA, 0xC8, 0x00, 0x31, 0x96, 0xB4, 0xA0, 0x9B, 0x09, 0x15,
  357.          0x42, 0x3A, 0x8E, 0x9A, 0x08, 0x70, 0x28, 0x90, 0xD0, 0x98, 0x08, 0x02, 0x97, 0xB3, 0xB0, 0xA9,
  358.          0x90, 0x87, 0x83, 0x81, 0xAA, 0xCA, 0xA2, 0x15, 0x32, 0x1A, 0xBC, 0xCA, 0x81, 0x72, 0x30, 0x89,
  359.          0xD9, 0xA8, 0x18, 0x70, 0x20, 0x98, 0xC8, 0x99, 0x39, 0x78, 0x10, 0xA0, 0xC8, 0x89, 0x39, 0x78,
  360.          0x10, 0xA0, 0xC8, 0x99, 0x38, 0x60, 0x20, 0xA8, 0xD9, 0xA8, 0x20, 0x71, 0x28, 0x89, 0xCA, 0xA8,
  361.          0x02, 0x34, 0x30, 0x0B, 0x9F, 0x9A, 0x02, 0x06, 0x02, 0x89, 0x8D, 0x1C, 0x28, 0x13, 0x93, 0xD0,
  362.          0xBA, 0x09, 0x70, 0x40, 0x08, 0xA9, 0xBB, 0xA0, 0x15, 0x15, 0x00, 0x9B, 0x0F, 0x1A, 0x40, 0x21,
  363.          0x90, 0xE8, 0xB8, 0x00, 0x32, 0x43, 0x08, 0x9E, 0x0C, 0x29, 0x31, 0x23, 0xB1, 0xFA, 0xBA, 0x01,
  364.          0x24, 0x23, 0x88, 0x9E, 0x0C, 0x4A, 0x40, 0x20, 0x89, 0xBB, 0xBA, 0x12, 0x07, 0x84, 0xB0, 0xD8,
  365.          0x98, 0x11, 0x23, 0x02, 0x9A, 0x8F, 0x2B, 0x59, 0x40, 0x28, 0x0C, 0x0D, 0x2A, 0x38, 0x40, 0x08,
  366.          0x9B, 0x9C, 0x08, 0x33, 0x04, 0xB1, 0xDA, 0xA9, 0x81, 0x06, 0x83, 0xC2, 0xC8, 0xA8, 0x03, 0x06,
  367.          0xA2, 0xD8, 0xB9, 0x80, 0x24, 0x04, 0xA2, 0xE9, 0xB9, 0x00, 0x34, 0x15, 0x91, 0xEA, 0xAA, 0x80,
  368.          0x23, 0x25, 0x91, 0xDA, 0xAA, 0x08, 0x23, 0x15, 0xA1, 0xCA, 0x99, 0x11, 0x24, 0x83, 0xC9, 0xAC,
  369.          0x89, 0x25, 0x24, 0x91, 0xEB, 0xAA, 0x08, 0x42, 0x25, 0x91, 0xDA, 0xBB, 0x38, 0x35, 0x14, 0x90,
  370.          0xDC, 0xAA, 0x18, 0x34, 0x24, 0x90, 0xCC, 0xAA, 0x18, 0x53, 0x23, 0x91, 0xDB, 0xAC, 0x08, 0x52,
  371.          0x32, 0x80, 0xDA, 0xAA, 0x0A, 0x42, 0x24, 0x82, 0xCA, 0xBB, 0x8A, 0x42, 0x44, 0x12, 0xA8, 0xDB,
  372.          0xAB, 0x18, 0x53, 0x23, 0x81, 0xDB, 0xCB, 0x88, 0x31, 0x34, 0x03, 0xC9, 0xDB, 0x89, 0x20, 0x33,
  373.          0x10, 0xB9, 0xBB, 0xAB, 0x38, 0x34, 0x27, 0x81, 0xA8, 0xEB, 0xAA, 0x09, 0x73, 0x33, 0x93, 0xDB,
  374.          0xAD, 0x88, 0x32, 0x43, 0x23, 0xD9, 0xCD, 0x89, 0x22, 0x34, 0x03, 0xC8, 0xDB, 0x9B, 0x20, 0x44,
  375.          0x23, 0xA0, 0xBE, 0x9A, 0x00, 0x33, 0x25, 0xA2, 0xCB, 0xAC, 0x08, 0x62, 0x32, 0x80, 0xCB, 0xCB,
  376.          0x9A, 0x63, 0x24, 0x81, 0xBA, 0xBC, 0x0B, 0x51, 0x25, 0x01, 0xB8, 0xAE, 0x8A, 0x41, 0x33, 0x13,
  377.          0xDA, 0xCC, 0x89, 0x32, 0x25, 0x82, 0xC9, 0xBD, 0x09, 0x43, 0x33, 0x81, 0xEA, 0xAC, 0x08, 0x43,
  378.          0x32, 0x81, 0xDC, 0xAA, 0x19, 0x44, 0x13, 0x90, 0xCC, 0x9B, 0x28, 0x35, 0x03, 0xB8, 0xBD, 0x8B,
  379.          0x42, 0x34, 0x82, 0xCB, 0xBC, 0x18, 0x43, 0x33, 0xB1, 0xCD, 0x9A, 0x20, 0x44, 0x02, 0xAA, 0xBC,
  380.          0x89, 0x42, 0x24, 0x81, 0xDB, 0x9B, 0x20, 0x43, 0x84, 0xA9, 0xBC, 0x0A, 0x43, 0x24, 0x80, 0xCC,
  381.          0x9A, 0x20, 0x35, 0x82, 0xB9, 0xBD, 0x19, 0x33, 0x34, 0x90, 0xBD, 0xAB, 0x40, 0x25, 0x11, 0xD9,
  382.          0x8C, 0x88, 0x42, 0x02, 0x90, 0xCB, 0x9A, 0x41, 0x43, 0x81, 0xD9, 0xAB, 0x18, 0x53, 0x13, 0xA8,
  383.          0xBC, 0xAB, 0x52, 0x23, 0x13, 0xCC, 0xBA, 0x1B, 0x25, 0x34
  384.      };
  385. #endif /* __MMI_GAME_MULTICHANNEL_SOUND__ */ 
  386. /******************************************AUDIO************************************/
  389. /*****************************************************************************
  390.  * FUNCTION
  391.  *  mmi_gx_puzzle_enter_gfx
  392.  * DESCRIPTION
  393.  *  Set Game Framework (GFX) Parameter
  394.  * PARAMETERS
  395.  *  void
  396.  * RETURNS
  397.  *  void
  398.  *****************************************************************************/
  399. /* keep this game old naming style */
  400. void mmi_gx_puzzle_enter_gfx(void)
  401. {
  402.     /*----------------------------------------------------------------*/
  403.     /* Local Variables                                                */
  404.     /*----------------------------------------------------------------*/
  406.     /*----------------------------------------------------------------*/
  407.     /* Code Body                                                      */
  408.     /*----------------------------------------------------------------*/
  409.     /* Game menu */
  410.     GFX.game_data.game_img_id = IMG_ID_GX_PUZZLE_GAME_ICON; /* game icon img ID */
  411.     GFX.game_data.game_str_id = STR_ID_GX_PUZZLE_GAME_NAME; /* game name string ID */
  412.     GFX.game_data.menu_resume_str_id = STR_GAME_RESUME;     /* "Resume" string ID */
  413.     GFX.game_data.menu_new_str_id = STR_GAME_NEW;           /* "New Game" string ID */
  414.     GFX.game_data.menu_level_str_id = STR_GAME_LEVEL;       /* "Game Level" string ID */
  415.     GFX.game_data.menu_type_str_id = 0;                    /* "Game type" string ID */     //KP Jerry add on 2007-3-24
  416.     GFX.game_data.menu_grade_str_id = STR_GAME_GRADE;       /* "Best Grade" string ID */
  417.     GFX.game_data.menu_help_str_id = STR_GAME_HELP;         /* "Game Help" string ID */
  419.     /* level / grade */
  420.     GFX.game_data.level_count = 3;  /* how many levels */
  421.     GFX.game_data.level_str_id_list[0] = STR_ID_GX_PUZZLE_LEVEL_EASY;   /* level string ID */
  422.     GFX.game_data.level_str_id_list[1] = STR_ID_GX_PUZZLE_LEVEL_NORMAL; /* level string ID */
  423.     GFX.game_data.level_str_id_list[2] = STR_ID_GX_PUZZLE_LEVEL_HARD;   /* level string ID */
  425.     /* add slot in NVRAMEnum.h */
  426.     GFX.game_data.grade_nvram_id_list[0] = NVRAM_GX_PUZZLE_EASY_SCORE;  /* grade slot in NVRAM (short) */
  427.     GFX.game_data.grade_nvram_id_list[1] = NVRAM_GX_PUZZLE_NORMAL_SCORE;        /* grade slot in NVRAM */
  428.     GFX.game_data.grade_nvram_id_list[2] = NVRAM_GX_PUZZLE_HARD_SCORE;  /* grade slot in NVRAM */
  429.     GFX.game_data.level_nvram_id = NVRAM_GX_PUZZLE_LEVEL;   /* current lvl idnex  in NVRAM (byte) */
  431.     /* help */
  432. #if defined(__MMI_TOUCH_SCREEN__)
  433.     GFX.game_data.help_str_id = STR_ID_GX_PUZZLE_HELP_DESCRIPTION_TP;   /* help desciption string id */
  434. #elif defined(__MMI_GAME_PUZZLE_128x160__) || defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__)
  435.     GFX.game_data.help_str_id = STR_ID_GX_PUZZLE_HELP_DESCRIPTION;      /* help desciption string id */
  436. #elif defined(__MMI_GAME_PUZZLE_128x128__)
  437.     GFX.game_data.help_str_id = STR_ID_GX_PUZZLE_HELP_DESCRIPTION_128;  /* help desciption string id */
  438. #endif 
  440.     /* misc */
  441.     GFX.game_data.grade_value_ptr = (S16*) (&g_gx_puzzle_context.game_grade);  /* current level's grade (S16*) */
  442.     GFX.game_data.level_index_ptr = (U8*) (&g_gx_puzzle_context.game_level);   /* ptr to current level index (U8*) */
  443.     GFX.game_data.is_new_game = (BOOL*) (&g_gx_puzzle_context.is_new_game);    /* ptr to new game flag (BOOL*) */
  445.     /* function ptr */
  446.     GFX.game_data.best_grade_func_ptr = mmi_gx_puzzle_calc_best_grade;  /* function to calculate best grade */
  447.     GFX.game_data.enter_game_func_ptr = mmi_gx_puzzle_enter_game;       /* function to enter new game */
  448.     GFX.game_data.exit_game_func_ptr = mmi_gx_puzzle_exit_game; /* function to exit game */
  449.     GFX.game_data.draw_gameover_func_ptr = mmi_gx_puzzle_draw_gameover; /* function to draw gameover screen */
  451.     /* some flags */
  452.     GFX.game_data.is_keypad_audio_enable = FALSE;   /* play keypad tone or not */
  454.     mmi_gfx_entry_menu_screen();
  455. }
  458. /*****************************************************************************
  459.  * FUNCTION
  460.  *  mmi_gx_puzzle_calc_best_grade
  461.  * DESCRIPTION
  462.  *  Calculate new best grade [Callback required by GFX]
  463.  * PARAMETERS
  464.  *  old_grade       [IN]        
  465.  *  new_grade       [IN]        
  466.  * RETURNS
  467.  *  S16
  468.  *****************************************************************************/
  469. S16 mmi_gx_puzzle_calc_best_grade(S16 old_grade, S16 new_grade)
  470. {
  471.     /*----------------------------------------------------------------*/
  472.     /* Local Variables                                                */
  473.     /*----------------------------------------------------------------*/
  475.     /*----------------------------------------------------------------*/
  476.     /* Code Body                                                      */
  477.     /*----------------------------------------------------------------*/
  478.     /* compare the best grade and return it */
  479.     if (old_grade == 0)
  480.     {
  481.         return new_grade;
  482.     }
  484.     if (new_grade < old_grade)
  485.     {
  486.         return new_grade;
  487.     }
  488.     else
  489.     {
  490.         return old_grade;
  491.     }
  492. }
  495. /*****************************************************************************
  496.  * FUNCTION
  497.  *  mmi_gx_puzzle_draw_gameover
  498.  * DESCRIPTION
  499.  *  Draw Gameover Screen [Callback required by GFX]
  500.  * PARAMETERS
  501.  *  void
  502.  * RETURNS
  503.  *  void
  504.  *****************************************************************************/
  505. void mmi_gx_puzzle_draw_gameover(void)
  506. {
  507.     /*----------------------------------------------------------------*/
  508.     /* Local Variables                                                */
  509.     /*----------------------------------------------------------------*/
  511.     /*----------------------------------------------------------------*/
  512.     /* Code Body                                                      */
  513.     /*----------------------------------------------------------------*/
  514.     GFX_PLAY_AUDIO_COMPLETE();
  516.     /* call this function to draw standard gameover screen */
  517.     mmi_gfx_draw_gameover_screen(
  518.         IMG_ID_GX_PUZZLE_GOTEXT,
  519.         IMG_ID_GX_PUZZLE_GRADESMAP,
  520.         IMG_ID_GX_PUZZLE_GOPIC,
  521.         g_gx_puzzle_context.game_grade);
  522. }
  525. /*****************************************************************************
  526.  * FUNCTION
  527.  *  mmi_gx_puzzle_enter_game
  528.  * DESCRIPTION
  529.  *  Enter Game [Callback required by GFX]
  530.  * PARAMETERS
  531.  *  void
  532.  * RETURNS
  533.  *  void
  534.  *****************************************************************************/
  535. void mmi_gx_puzzle_enter_game(void)
  536. {
  537.     /*----------------------------------------------------------------*/
  538.     /* Local Variables                                                */
  539.     /*----------------------------------------------------------------*/
  541.     /*----------------------------------------------------------------*/
  542.     /* Code Body                                                      */
  543.     /*----------------------------------------------------------------*/
  544.     if (g_gx_puzzle_context.is_new_game == TRUE)
  545.     {
  546.         mmi_gx_puzzle_init_game();  /* is new game, otherwise resume game */
  547.     }
  549.     g_gx_puzzle_context.is_new_game = FALSE;
  550.     g_gx_puzzle_context.is_gameover = FALSE;
  552. #ifdef __MMI_GAME_PUZZLE_128x128__
  553.     g_gx_puzzle_context.is_show_status = FALSE;
  554.     SetKeyHandler(mmi_gx_puzzle_key_5_press, KEY_5, KEY_EVENT_DOWN);
  555.     SetKeyHandler(mmi_gx_puzzle_key_5_release, KEY_5, KEY_EVENT_UP);
  556. #endif /* __MMI_GAME_PUZZLE_128x128__ */ 
  558.     SetKeyHandler(mmi_gx_puzzle_key_2_release, KEY_2, KEY_EVENT_UP);
  559.     SetKeyHandler(mmi_gx_puzzle_key_2_release, KEY_UP_ARROW, KEY_EVENT_UP);
  560.     SetKeyHandler(mmi_gx_puzzle_key_4_release, KEY_4, KEY_EVENT_UP);
  561.     SetKeyHandler(mmi_gx_puzzle_key_4_release, KEY_LEFT_ARROW, KEY_EVENT_UP);
  562.     SetKeyHandler(mmi_gx_puzzle_key_6_release, KEY_6, KEY_EVENT_UP);
  563.     SetKeyHandler(mmi_gx_puzzle_key_6_release, KEY_RIGHT_ARROW, KEY_EVENT_UP);
  564.     SetKeyHandler(mmi_gx_puzzle_key_8_release, KEY_8, KEY_EVENT_UP);
  565.     SetKeyHandler(mmi_gx_puzzle_key_8_release, KEY_DOWN_ARROW, KEY_EVENT_UP);
  566. #ifdef __MMI_GAME_MULTICHANNEL_SOUND__
  567.     GFX_OPEN_SOUND_EFFECTS_MIDI(PuzzleMove, PUZZLEMOVE, 1, g_gx_puzzle_context.move_midi);
  568. #endif 
  570.     mmi_gx_puzzle_draw_static_background();
  571.     mmi_gx_puzzle_show_puzzle();
  572.     mmi_gx_puzzle_draw_seperation_line();
  574.     /* start game loop */
  575.     mmi_gx_puzzle_cyclic_timer();
  577. #ifdef __MMI_TOUCH_SCREEN__
  578.     wgui_register_pen_down_handler(mmi_puzzle_pen_down_hdlr);
  579.     wgui_register_pen_up_handler(mmi_puzzle_pen_up_hdlr);
  580. #endif /* __MMI_TOUCH_SCREEN__ */ 
  582. }
  585. /*****************************************************************************
  586.  * FUNCTION
  587.  *  mmi_gx_puzzle_draw_static_background
  588.  * DESCRIPTION
  589.  *  Draw the elements that only need to be drawn once
  590.  * PARAMETERS
  591.  *  void
  592.  * RETURNS
  593.  *  void
  594.  *****************************************************************************/
  595. void mmi_gx_puzzle_draw_static_background(void)
  596. {
  597.     /*----------------------------------------------------------------*/
  598.     /* Local Variables                                                */
  599.     /*----------------------------------------------------------------*/
  601.     /*----------------------------------------------------------------*/
  602.     /* Code Body                                                      */
  603.     /*----------------------------------------------------------------*/
  604.     gui_fill_rectangle(0, 0, MMI_GX_PUZZLE_LCD_WIDTH - 1, MMI_GX_PUZZLE_LCD_HEIGHT - 1, MMI_GX_PUZZLE_BACKGROUND_COLOR);
  606. #if defined(__MMI_GAME_PUZZLE_128x160__)
  607.     gui_show_image(49, 129, (PU8) GetImage(g_gx_puzzle_context.small_image));
  608. #elif defined(__MMI_GAME_PUZZLE_176x220__)
  609.     gui_show_image(68, 178, (PU8) GetImage(g_gx_puzzle_context.small_image));
  610.     if (g_gx_puzzle_context.game_level == MMI_GX_PUZZLE_NORMAL)
  611.     {
  612.         gui_draw_vertical_line(
  613.             0,
  614.             MMI_GX_PUZZLE_ORIGIN_Y + MMI_GX_PUZZLE_SIZE,
  615.             MMI_GX_PUZZLE_ORIGIN_X + MMI_GX_PUZZLE_SIZE - 1,
  616.             MMI_GX_PUZZLE_BAR_COLOR);
  617.         gui_draw_horizontal_line(
  618.             0,
  619.             MMI_GX_PUZZLE_LCD_WIDTH - 1,
  620.             MMI_GX_PUZZLE_ORIGIN_Y + MMI_GX_PUZZLE_SIZE - 1,
  621.             MMI_GX_PUZZLE_BAR_COLOR);
  622.     }
  623. #elif defined(__MMI_GAME_PUZZLE_240x320__)
  624.     gui_show_image(95, 245, (PU8) GetImage(g_gx_puzzle_context.small_image));
  625.     if (g_gx_puzzle_context.game_level == MMI_GX_PUZZLE_NORMAL)
  626.     {
  627.         gui_draw_vertical_line(
  628.             0,
  629.             MMI_GX_PUZZLE_ORIGIN_Y + MMI_GX_PUZZLE_SIZE,
  630.             MMI_GX_PUZZLE_ORIGIN_X + MMI_GX_PUZZLE_SIZE - 1,
  631.             MMI_GX_PUZZLE_BAR_COLOR);
  632.         gui_draw_horizontal_line(
  633.             0,
  634.             MMI_GX_PUZZLE_LCD_WIDTH - 1,
  635.             MMI_GX_PUZZLE_ORIGIN_Y + MMI_GX_PUZZLE_SIZE - 1,
  636.             MMI_GX_PUZZLE_BAR_COLOR);
  637.     }
  638. #endif 
  640. #if defined(__MMI_TOUCH_SCREEN__) && defined(__MMI_GAME_PUZZLE_240x320__)       /* || defined(__MMI_GAME_PUZZLE_176x220__)) */
  641.     /* draw softkay image */
  642.     gdi_image_draw_id(MMI_GX_PUZZLE_SOFTKEY_X, MMI_GX_PUZZLE_SOFTKEY_Y, IMG_ID_GX_PUZZLE_UP);
  644. #endif /* defined(__MMI_TOUCH_SCREEN__) && defined(__MMI_GAME_PUZZLE_240x320__) */ 
  645.     gui_show_image(
  646.         MMI_GX_PUZZLE_ORIGIN_X - MMI_GX_PUZZLE_LEFT_BAR_WIDTH,
  647.         MMI_GX_PUZZLE_ORIGIN_Y - MMI_GX_PUZZLE_TOP_BAR_WIDTH,
  648.         (PU8) GetImage(IMG_ID_GX_PUZZLE_TOP_BAR));
  650.     gui_show_image(
  651.         MMI_GX_PUZZLE_ORIGIN_X - MMI_GX_PUZZLE_LEFT_BAR_WIDTH,
  652.         MMI_GX_PUZZLE_ORIGIN_Y - MMI_GX_PUZZLE_TOP_BAR_WIDTH,
  653.         (PU8) GetImage(IMG_ID_GX_PUZZLE_LEFT_BAR));
  655.     gui_show_image(
  656.         MMI_GX_PUZZLE_ORIGIN_X - MMI_GX_PUZZLE_LEFT_BAR_WIDTH,
  657.         MMI_GX_PUZZLE_ORIGIN_Y + MMI_GX_PUZZLE_SIZE,
  658.         (PU8) GetImage(IMG_ID_GX_PUZZLE_BOTTOM_BAR));
  660.     gui_show_image(
  661.         MMI_GX_PUZZLE_ORIGIN_X + MMI_GX_PUZZLE_SIZE,
  662.         MMI_GX_PUZZLE_ORIGIN_Y - MMI_GX_PUZZLE_TOP_BAR_WIDTH,
  663.         (PU8) GetImage(IMG_ID_GX_PUZZLE_RIGHT_BAR));
  665.     gui_show_image(
  666.         MMI_GX_PUZZLE_ORIGIN_X - MMI_GX_PUZZLE_LEFT_BAR_WIDTH,
  667.         MMI_GX_PUZZLE_ORIGIN_Y - MMI_GX_PUZZLE_TOP_BAR_WIDTH,
  668.         (PU8) GetImage(IMG_ID_GX_PUZZLE_TOP_BAR));
  669. #if defined(__MMI_GAME_PUZZLE_128x160__) || defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__)
  670.     /* four lines */
  671.     gui_draw_horizontal_line(
  672.         2,
  673.         MMI_GX_PUZZLE_LCD_WIDTH - 1 - 2,
  674.         MMI_GX_PUZZLE_LCD_WIDTH + 1,
  675.         MMI_GX_PUZZLE_LIGHT_BORDER);
  676.     gui_draw_horizontal_line(
  677.         2,
  678.         MMI_GX_PUZZLE_LCD_WIDTH - 1 - 2,
  679.         MMI_GX_PUZZLE_LCD_HEIGHT - 1 - 1,
  680.         MMI_GX_PUZZLE_DARK_BORDER);
  681.     gui_draw_vertical_line(
  682.         MMI_GX_PUZZLE_LCD_WIDTH + 2,
  683.         MMI_GX_PUZZLE_LCD_HEIGHT - 1 - 1,
  684.         1,
  685.         MMI_GX_PUZZLE_LIGHT_BORDER);
  686.     gui_draw_vertical_line(
  687.         MMI_GX_PUZZLE_LCD_WIDTH + 2,
  688.         MMI_GX_PUZZLE_LCD_HEIGHT - 1 - 1,
  689.         MMI_GX_PUZZLE_LCD_WIDTH - 1 - 1,
  690.         MMI_GX_PUZZLE_DARK_BORDER);
  692.     gui_show_image(
  693.         MMI_GX_PUZZLE_TIME_POSITION_X,
  694.         MMI_GX_PUZZLE_TIME_POSITION_Y + 128,
  695.         (PU8) GetImage(IMG_ID_GX_PUZZLE_BOX));
  697. #ifndef __MMI_GAME_PUZZLE_240x320__
  698.     gui_show_image(MMI_GX_PUZZLE_TIME_POSITION_X + 2,
  699. #if defined(__MMI_GAME_PUZZLE_128x160__)
  700.                    MMI_GX_PUZZLE_TIME_POSITION_Y - 8 + 128,
  701. #elif defined(__MMI_GAME_PUZZLE_176x220__)
  702.                    MMI_GX_PUZZLE_TIME_POSITION_Y - 12 + 128,
  703. #endif 
  704.                    (PU8) GetImage(IMG_ID_GX_PUZZLE_TIME));
  705. #endif /* __MMI_GAME_PUZZLE_240x320__ */ 
  706.     gui_show_image(
  707.         MMI_GX_PUZZLE_STEP_POSITION_X,
  708.         MMI_GX_PUZZLE_STEP_POSITION_Y + 128,
  709.         (PU8) GetImage(IMG_ID_GX_PUZZLE_BOX));
  711. #ifndef __MMI_GAME_PUZZLE_240x320__
  712.     gui_show_image(MMI_GX_PUZZLE_STEP_POSITION_X + 2,
  713. #if defined(__MMI_GAME_PUZZLE_128x160__)
  714.                    MMI_GX_PUZZLE_STEP_POSITION_Y - 8 + 128,
  715. #elif defined(__MMI_GAME_PUZZLE_176x220__)
  716.                    MMI_GX_PUZZLE_STEP_POSITION_Y - 12 + 128,
  717. #endif 
  718.                    (PU8) GetImage(IMG_ID_GX_PUZZLE_STEP));
  719. #endif /* __MMI_GAME_PUZZLE_240x320__ */ 
  720.     mmi_gx_puzzle_draw_step();
  721. #endif /* defined(__MMI_GAME_PUZZLE_128x160__) || defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__) */ 
  722. }
  725. /*****************************************************************************
  726.  * FUNCTION
  727.  *  mmi_gx_puzzle_exit_game
  728.  * DESCRIPTION
  729.  *  Exit Game [Callback required by GFX]
  730.  * PARAMETERS
  731.  *  void
  732.  * RETURNS
  733.  *  void
  734.  *****************************************************************************/
  735. void mmi_gx_puzzle_exit_game(void)
  736. {
  737. #ifdef __MMI_GAME_MULTICHANNEL_SOUND__
  738.     /*----------------------------------------------------------------*/
  739.     /* Local Variables                                                */
  740.     /*----------------------------------------------------------------*/
  742.     /*----------------------------------------------------------------*/
  743.     /* Code Body                                                      */
  744.     /*----------------------------------------------------------------*/
  745.     GFX_STOP_SOUND_EFFECTS_MIDI(g_gx_puzzle_context.move_midi);
  746.     GFX_CLOSE_SOUND_EFFECTS_MIDI(g_gx_puzzle_context.move_midi);
  747. #endif /* __MMI_GAME_MULTICHANNEL_SOUND__ */ 
  749.     gui_cancel_timer(mmi_gx_puzzle_cyclic_timer);   /* cancle the looping timer */
  750. }
  753. /*****************************************************************************
  754.  * FUNCTION
  755.  *  mmi_gx_puzzle_draw_seperation_line
  756.  * DESCRIPTION
  757.  *  Draw seperation lines in the puzzle
  758.  * PARAMETERS
  759.  *  void
  760.  * RETURNS
  761.  *  void
  762.  *****************************************************************************/
  763. void mmi_gx_puzzle_draw_seperation_line(void)
  764. {
  765.     /*----------------------------------------------------------------*/
  766.     /* Local Variables                                                */
  767.     /*----------------------------------------------------------------*/
  768.     U8 i;
  769.     U8 grid_number;
  771.     /*----------------------------------------------------------------*/
  772.     /* Code Body                                                      */
  773.     /*----------------------------------------------------------------*/
  774.     grid_number = g_gx_puzzle_context.game_level + 3;
  775.     /* draw the seperation line */
  776.     for (i = 1; i < grid_number; i++)
  777.     {
  778.         gui_draw_vertical_line(
  779.             MMI_GX_PUZZLE_ORIGIN_Y,
  780.             MMI_GX_PUZZLE_ORIGIN_Y + MMI_GX_PUZZLE_SIZE - 1,
  781.             MMI_GX_PUZZLE_ORIGIN_X + i * MMI_GX_PUZZLE_SIZE / (g_gx_puzzle_context.game_level + 3) - 1,
  782.             MMI_GX_PUZZLE_LINE_COLOR);
  783.         gui_draw_horizontal_line(
  784.             MMI_GX_PUZZLE_ORIGIN_X,
  785.             MMI_GX_PUZZLE_ORIGIN_X + MMI_GX_PUZZLE_SIZE - 1,
  786.             MMI_GX_PUZZLE_ORIGIN_Y + i * MMI_GX_PUZZLE_SIZE / (g_gx_puzzle_context.game_level + 3) - 1,
  787.             MMI_GX_PUZZLE_LINE_COLOR);
  788.     }
  789.     gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  790. }
  793. /*****************************************************************************
  794.  * FUNCTION
  795.  *  mmi_gx_puzzle_show_puzzle
  796.  * DESCRIPTION
  797.  *  Draw all grids in the puzzle
  798.  * PARAMETERS
  799.  *  void
  800.  * RETURNS
  801.  *  void
  802.  *****************************************************************************/
  803. void mmi_gx_puzzle_show_puzzle(void)
  804. {
  805.     /*----------------------------------------------------------------*/
  806.     /* Local Variables                                                */
  807.     /*----------------------------------------------------------------*/
  808.     U8 grid_number;
  809.     U8 i;
  810.     U8 j;
  812.     /*----------------------------------------------------------------*/
  813.     /* Code Body                                                      */
  814.     /*----------------------------------------------------------------*/
  815.     grid_number = g_gx_puzzle_context.game_level + 3;
  817.     for (i = 0; i < grid_number; i++)
  818.     {
  819.         for (j = 0; j < grid_number; j++)
  820.         {
  821.             mmi_gx_puzzle_my_show_image(
  822.                 MMI_GX_PUZZLE_ORIGIN_X + MMI_GX_PUZZLE_SIZE / grid_number * j,
  823.                 MMI_GX_PUZZLE_ORIGIN_Y + MMI_GX_PUZZLE_SIZE / grid_number * i,
  824.                 g_gx_puzzle_context.puzzle[i][j]);
  825.         }
  826.     }
  828.     gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  829. }
  832. /*****************************************************************************
  833.  * FUNCTION
  834.  *  mmi_gx_puzzle_init_game
  835.  * DESCRIPTION
  836.  *  Game initilization
  837.  * PARAMETERS
  838.  *  void
  839.  * RETURNS
  840.  *  void
  841.  *****************************************************************************/
  842. void mmi_gx_puzzle_init_game(void)
  843. {
  844.     /*----------------------------------------------------------------*/
  845.     /* Local Variables                                                */
  846.     /*----------------------------------------------------------------*/
  847.     /* init game */
  849.     U16 i;
  850.     U16 j;
  851.     U8 bound_size;      /* height & width of the puzzle */
  852.     U8 index;
  853.     U16 shuffle_times;  /* shuffle for 'shuffle_times' times */
  854.     U8 move_type;
  855.     S16 destination_x;
  856.     S16 destination_y;
  857.     S16 tmp;
  859.     /*----------------------------------------------------------------*/
  860.     /* Code Body                                                      */
  861.     /*----------------------------------------------------------------*/
  862.     /* initialize */
  863.     j = 0;
  864.     bound_size = 0;
  865.     destination_x = 0;
  866.     destination_y = 0;
  868.     g_gx_puzzle_context.long_tick = 0;
  870.     g_gx_puzzle_context.step = 0;
  871.     g_gx_puzzle_context.click = 0;
  873. #ifdef __MMI_GAME_PUZZLE_128x128__
  874.     g_gx_puzzle_context.is_show_status = FALSE;
  875. #endif 
  877.     /* select the image for corresponding game level */
  878.     tmp = g_gx_puzzle_context.game_level;
  879.     if (g_gx_puzzle_context.game_level == MMI_GX_PUZZLE_EASY)
  880.     {
  881.         g_gx_puzzle_context.image = IMG_ID_GX_PUZZLE_3_1;
  882.     }
  883.     else
  884.     {
  885.         g_gx_puzzle_context.image = IMG_ID_GX_PUZZLE_3_1 + tmp * (tmp + 2) * (tmp + 2) / tmp;
  886.     }
  887.     g_gx_puzzle_context.small_image = IMG_ID_GX_PUZZLE_SMALL_3 + tmp;
  889.     /* init puzzle grids */
  890.     if (g_gx_puzzle_context.game_level == MMI_GX_PUZZLE_EASY)
  891.     {
  892.         bound_size = 3;
  893.     }
  894.     else if (g_gx_puzzle_context.game_level == MMI_GX_PUZZLE_NORMAL)
  895.     {
  896.         bound_size = 4;
  897.     }
  898.     else if (g_gx_puzzle_context.game_level == MMI_GX_PUZZLE_HARD)
  899.     {
  900.         bound_size = 5;
  901.     }
  903.     shuffle_times = bound_size * bound_size * 100;
  905.     index = 1;
  907.     for (i = 0; i < bound_size; i++)
  908.     {
  909.         for (j = 0; j < bound_size; j++)
  910.         {
  911.             g_gx_puzzle_context.puzzle[i][j] = index;
  912.             index = index + 1;
  913.         }
  914.     }
  916.     g_gx_puzzle_context.null_grid.y = i - 1;
  917.     g_gx_puzzle_context.null_grid.x = j - 1;
  919.     /* shuffle */
  920.     for (i = 0; i < shuffle_times; i++)
  921.     {
  922.         move_type = rand() % 4;
  924.         switch (move_type)
  925.         {
  926.             case 0: /* up */
  927.                 destination_x = 0;
  928.                 destination_y = -1;
  929.                 break;
  930.             case 1: /* left */
  931.                 destination_x = -1;
  932.                 destination_y = 0;
  933.                 break;
  934.             case 2: /* bottom */
  935.                 destination_x = 0;
  936.                 destination_y = 1;
  937.                 break;
  938.             case 3: /* right */
  939.                 destination_x = 1;
  940.                 destination_y = 0;
  941.                 break;
  942.         }
  944.         /* check if this shuffle is valid */
  945.         if (g_gx_puzzle_context.null_grid.x + destination_x < 0 ||
  946.             g_gx_puzzle_context.null_grid.x + destination_x >= bound_size ||
  947.             g_gx_puzzle_context.null_grid.y + destination_y < 0 ||
  948.             g_gx_puzzle_context.null_grid.y + destination_y >= bound_size)
  949.         {
  950.             i--;
  951.             continue;
  952.         }
  954.         /* switch the null grid and its neighboring grid */
  955.         tmp = g_gx_puzzle_context.puzzle[g_gx_puzzle_context.null_grid.y][g_gx_puzzle_context.null_grid.x];
  956.         g_gx_puzzle_context.puzzle[g_gx_puzzle_context.null_grid.y][g_gx_puzzle_context.null_grid.x] =
  957.             g_gx_puzzle_context.puzzle[g_gx_puzzle_context.null_grid.y +
  958.                                        destination_y][g_gx_puzzle_context.null_grid.x + destination_x];
  959.         g_gx_puzzle_context.puzzle[g_gx_puzzle_context.null_grid.y + destination_y][g_gx_puzzle_context.null_grid.x +
  960.                                                                                     destination_x] = tmp;
  962.         g_gx_puzzle_context.null_grid.x = g_gx_puzzle_context.null_grid.x + destination_x;
  963.         g_gx_puzzle_context.null_grid.y = g_gx_puzzle_context.null_grid.y + destination_y;
  964.     }
  965. }
  968. /*****************************************************************************
  969.  * FUNCTION
  970.  *  mmi_gx_puzzle_framemove
  971.  * DESCRIPTION
  972.  *  Framemove - process the game logic
  973.  * PARAMETERS
  974.  *  void
  975.  * RETURNS
  976.  *  void
  977.  *****************************************************************************/
  978. void mmi_gx_puzzle_framemove(void)
  979. {
  980.     /*----------------------------------------------------------------*/
  981.     /* Local Variables                                                */
  982.     /*----------------------------------------------------------------*/
  984.     /*----------------------------------------------------------------*/
  985.     /* Code Body                                                      */
  986.     /*----------------------------------------------------------------*/
  987.     /* add logic code here */
  988. }
  991. /*****************************************************************************
  992.  * FUNCTION
  993.  *  mmi_gx_puzzle_render
  994.  * DESCRIPTION
  995.  *  Render the game images
  996.  * PARAMETERS
  997.  *  void
  998.  * RETURNS
  999.  *  void
  1000.  *****************************************************************************/
  1001. void mmi_gx_puzzle_render(void)
  1002. {
  1003.     /*----------------------------------------------------------------*/
  1004.     /* Local Variables                                                */
  1005.     /*----------------------------------------------------------------*/
  1006.     /* add drawing code here */
  1008.     U16 tmp_tick;
  1010. #ifdef __MMI_GAME_PUZZLE_128x128__
  1011.     U16 tmp_click;
  1012. #endif 
  1013.     S16 position_shift;     /* the position offset of digit displayed */
  1014.     MMI_ID_TYPE image_id;   /* store the last digit of tick */
  1016.     /*----------------------------------------------------------------*/
  1017.     /* Code Body                                                      */
  1018.     /*----------------------------------------------------------------*/
  1019. #if defined(__MMI_TOUCH_SCREEN__) && defined(__MMI_GAME_PUZZLE_240x320__)       /* || defined(__MMI_GAME_PUZZLE_176x220__)) */
  1020.     /* softkey */
  1021.     if (g_gx_puzzle_context.softkey_state == 1)
  1022.     {
  1023.     #if defined(__MMI_GAME_PUZZLE_240x320__)
  1024.         gui_fill_rectangle(
  1025.             MMI_GX_PUZZLE_SOFTKEY_X,
  1026.             MMI_GX_PUZZLE_SOFTKEY_Y,
  1027.             MMI_GX_PUZZLE_SOFTKEY_X + MMI_GX_PUZZLE_SOFTKEY_WIDTH,
  1028.             MMI_GX_PUZZLE_SOFTKEY_Y + MMI_GX_PUZZLE_SOFTKEY_HEIGHT,
  1029.             MMI_GX_PUZZLE_BACKGROUND_COLOR);
  1030.     #elif defined(__MMI_GAME_PUZZLE_176x220__)
  1031.         gui_fill_rectangle(
  1032.             MMI_GX_PUZZLE_SOFTKEY_X,
  1033.             MMI_GX_PUZZLE_SOFTKEY_Y,
  1034.             MMI_GX_PUZZLE_SOFTKEY_X + MMI_GX_PUZZLE_SOFTKEY_WIDTH,
  1035.             MMI_GX_PUZZLE_SOFTKEY_Y + MMI_GX_PUZZLE_SOFTKEY_HEIGHT,
  1036.             MMI_GX_PUZZLE_BACKGROUND_COLOR);
  1037.     #endif 
  1039.         gdi_image_draw_id(MMI_GX_PUZZLE_SOFTKEY_X, MMI_GX_PUZZLE_SOFTKEY_Y, IMG_ID_GX_PUZZLE_DOWN);
  1040.         g_gx_puzzle_context.softkey_state = 0;
  1041.     }
  1042.     else if (g_gx_puzzle_context.softkey_state == 2)
  1043.     {
  1044.     #if defined(__MMI_GAME_PUZZLE_240x320__)
  1045.         gui_fill_rectangle(
  1046.             MMI_GX_PUZZLE_SOFTKEY_X,
  1047.             MMI_GX_PUZZLE_SOFTKEY_Y,
  1048.             MMI_GX_PUZZLE_SOFTKEY_X + MMI_GX_PUZZLE_SOFTKEY_WIDTH,
  1049.             MMI_GX_PUZZLE_SOFTKEY_Y + MMI_GX_PUZZLE_SOFTKEY_HEIGHT,
  1050.             MMI_GX_PUZZLE_BACKGROUND_COLOR);
  1051.     #elif defined(__MMI_GAME_PUZZLE_176x220__)
  1052.         gui_fill_rectangle(
  1053.             MMI_GX_PUZZLE_SOFTKEY_X,
  1054.             MMI_GX_PUZZLE_SOFTKEY_Y,
  1055.             MMI_GX_PUZZLE_SOFTKEY_X + MMI_GX_PUZZLE_SOFTKEY_WIDTH,
  1056.             MMI_GX_PUZZLE_SOFTKEY_Y + MMI_GX_PUZZLE_SOFTKEY_HEIGHT,
  1057.             MMI_GX_PUZZLE_BACKGROUND_COLOR);
  1058.     #endif 
  1059.         gdi_image_draw_id(MMI_GX_PUZZLE_SOFTKEY_X, MMI_GX_PUZZLE_SOFTKEY_Y, IMG_ID_GX_PUZZLE_UP);
  1060.         g_gx_puzzle_context.softkey_state = 0;
  1061.     }
  1062. #endif /* defined(__MMI_TOUCH_SCREEN__) && defined(__MMI_GAME_PUZZLE_240x320__) */ 
  1064. #if defined(__MMI_GAME_PUZZLE_128x160__) || defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__)
  1065.     /* update TIME every second */
  1066.     if (g_gx_puzzle_context.long_tick % 10 == 0)
  1067.     {
  1068.         tmp_tick = g_gx_puzzle_context.long_tick / 10;
  1069.     #if defined(__MMI_GAME_PUZZLE_128x160__)
  1070.         position_shift = MMI_GX_PUZZLE_TIME_POSITION_X + 15;
  1071.     #elif defined(__MMI_GAME_PUZZLE_176x220__)
  1072.         position_shift = MMI_GX_PUZZLE_TIME_POSITION_X + 17;
  1073.     #elif  defined(__MMI_GAME_PUZZLE_240x320__)
  1074.         position_shift = MMI_GX_PUZZLE_TIME_POSITION_X + 22;
  1075.     #endif 
  1077.         do
  1078.         {
  1079.             image_id = IMG_ID_GX_PUZZLE_NUMBER_0 + (tmp_tick % 10);
  1080.             tmp_tick = tmp_tick / 10;
  1081.             gui_show_image(MMI_GX_PUZZLE_TIME_POSITION_X + position_shift,
  1082.         #if defined(__MMI_GAME_PUZZLE_240x320__)
  1083.                            MMI_GX_PUZZLE_TIME_POSITION_Y + 5 + 128,
  1084.         #else 
  1085.                            MMI_GX_PUZZLE_TIME_POSITION_Y + 2 + 128,
  1086.         #endif 
  1087.                            (PU8) GetImage(image_id));
  1088.         #if defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__)
  1089.             position_shift = position_shift - MMI_GX_PUZZLE_DIGIT_WIDTH - 1;
  1090.         #else 
  1091.             position_shift = position_shift - MMI_GX_PUZZLE_DIGIT_WIDTH;
  1092.         #endif 
  1094.         } while (tmp_tick != 0);
  1095.     }
  1096. #elif defined(__MMI_GAME_PUZZLE_128x128__)
  1097.     /* draw status ? */
  1098.     if (g_gx_puzzle_context.is_show_status != FALSE)
  1099.     {
  1100.         gui_fill_rectangle(
  1101.             MMI_GX_PUZZLE_STATUS_POS_X + MMI_GX_PUZZLE_STATUS_SHADOW,
  1102.             MMI_GX_PUZZLE_STATUS_POS_Y + MMI_GX_PUZZLE_STATUS_SHADOW,
  1103.             MMI_GX_PUZZLE_STATUS_POS_X + MMI_GX_PUZZLE_STATUS_WIDTH - 1 + MMI_GX_PUZZLE_STATUS_SHADOW,
  1104.             MMI_GX_PUZZLE_STATUS_POS_Y + MMI_GX_PUZZLE_STATUS_HEIGHT - 1 + MMI_GX_PUZZLE_STATUS_SHADOW,
  1105.             gui_color(155, 155, 155));
  1107.         gui_fill_rectangle(
  1108.             MMI_GX_PUZZLE_STATUS_POS_X,
  1109.             MMI_GX_PUZZLE_STATUS_POS_Y,
  1110.             MMI_GX_PUZZLE_STATUS_POS_X + MMI_GX_PUZZLE_STATUS_WIDTH - 1,
  1111.             MMI_GX_PUZZLE_STATUS_POS_Y + MMI_GX_PUZZLE_STATUS_HEIGHT - 1,
  1112.             MMI_GX_PUZZLE_BACKGROUND_COLOR);
  1114.         gui_show_image(
  1115.             MMI_GX_PUZZLE_TIME_POSITION_X,
  1116.             MMI_GX_PUZZLE_TIME_POSITION_Y,
  1117.             (PU8) GetImage(IMG_ID_GX_PUZZLE_BOX));
  1119.         gui_show_image(
  1120.             MMI_GX_PUZZLE_TIME_POSITION_X + 2,
  1121.             MMI_GX_PUZZLE_TIME_POSITION_Y - 8,
  1122.             (PU8) GetImage(IMG_ID_GX_PUZZLE_TIME));
  1124.         gui_show_image(
  1125.             MMI_GX_PUZZLE_STEP_POSITION_X,
  1126.             MMI_GX_PUZZLE_STEP_POSITION_Y,
  1127.             (PU8) GetImage(IMG_ID_GX_PUZZLE_BOX));
  1129.         gui_show_image(
  1130.             MMI_GX_PUZZLE_STEP_POSITION_X + 2,
  1131.             MMI_GX_PUZZLE_STEP_POSITION_Y - 8,
  1132.             (PU8) GetImage(IMG_ID_GX_PUZZLE_STEP));
  1134.         gui_show_image(66, 47, (PU8) GetImage(g_gx_puzzle_context.small_image));
  1136.         /* update TIME */
  1137.         tmp_tick = g_gx_puzzle_context.long_tick / 10;
  1138.         position_shift = MMI_GX_PUZZLE_TIME_POSITION_X + 0;
  1140.         do
  1141.         {
  1142.             image_id = IMG_ID_GX_PUZZLE_NUMBER_0 + (tmp_tick % 10);
  1143.             tmp_tick = tmp_tick / 10;
  1144.             gui_show_image(
  1145.                 MMI_GX_PUZZLE_TIME_POSITION_X + position_shift,
  1146.                 MMI_GX_PUZZLE_TIME_POSITION_Y + 2,
  1147.                 (PU8) GetImage(image_id));
  1148.             position_shift = position_shift - 4;
  1149.         } while (tmp_tick != 0);
  1151.         /* draw how many step user went */
  1152.         tmp_click = g_gx_puzzle_context.click;
  1153.         position_shift = MMI_GX_PUZZLE_TIME_POSITION_X + 0;
  1155.         do
  1156.         {
  1157.             image_id = IMG_ID_GX_PUZZLE_NUMBER_0 + (tmp_click % 10);
  1158.             tmp_click = tmp_click / 10;
  1159.             gui_show_image(
  1160.                 MMI_GX_PUZZLE_TIME_POSITION_X + position_shift,
  1161.                 MMI_GX_PUZZLE_TIME_POSITION_Y + 2 + 20,
  1162.                 (PU8) GetImage(image_id));
  1163.             position_shift = position_shift - 4;
  1164.         } while (tmp_click != 0);
  1165.     }
  1166. #endif 
  1168.     gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  1169. }
  1172. /*****************************************************************************
  1173.  * FUNCTION
  1174.  *  mmi_gx_puzzle_gameover
  1175.  * DESCRIPTION
  1176.  *  Gameover function
  1177.  * PARAMETERS
  1178.  *  void
  1179.  * RETURNS
  1180.  *  void
  1181.  *****************************************************************************/
  1182. void mmi_gx_puzzle_gameover(void)
  1183. {
  1184.     /*----------------------------------------------------------------*/
  1185.     /* Local Variables                                                */
  1186.     /*----------------------------------------------------------------*/
  1188.     /*----------------------------------------------------------------*/
  1189.     /* Code Body                                                      */
  1190.     /*----------------------------------------------------------------*/
  1191.     g_gx_puzzle_context.is_gameover = TRUE;
  1192.     g_gx_puzzle_context.is_new_game = TRUE;
  1194.     g_gx_puzzle_context.game_grade = g_gx_puzzle_context.long_tick / 10;
  1196.     /* call this function to draw gameover screen */
  1197.     mmi_gfx_entry_gameover_screen();
  1198. }
  1201. /*****************************************************************************
  1202.  * FUNCTION
  1203.  *  mmi_gx_puzzle_cyclic_timer
  1204.  * DESCRIPTION
  1205.  *  Timer trigger function - looping
  1206.  * PARAMETERS
  1207.  *  void
  1208.  * RETURNS
  1209.  *  void
  1210.  *****************************************************************************/
  1211. void mmi_gx_puzzle_cyclic_timer(void)
  1212. {
  1213.     /*----------------------------------------------------------------*/
  1214.     /* Local Variables                                                */
  1215.     /*----------------------------------------------------------------*/
  1217.     /*----------------------------------------------------------------*/
  1218.     /* Code Body                                                      */
  1219.     /*----------------------------------------------------------------*/
  1220.     g_gx_puzzle_context.long_tick++;
  1221.     if (g_gx_puzzle_context.long_tick > 6553600)
  1222.     {
  1223.         g_gx_puzzle_context.long_tick = 0;
  1224.     }
  1226.     gui_start_timer(g_gx_puzzle_context.timer_elapse, mmi_gx_puzzle_cyclic_timer);
  1228.     if (g_gx_puzzle_context.is_gameover == FALSE)
  1229.     {
  1230.         mmi_gx_puzzle_framemove();
  1231.         mmi_gx_puzzle_render();
  1232.     }
  1233. }
  1236. /*****************************************************************************
  1237.  * FUNCTION
  1238.  *  mmi_gx_puzzle_key_2_release
  1239.  * DESCRIPTION
  1240.  *  Key handling
  1241.  * PARAMETERS
  1242.  *  void
  1243.  * RETURNS
  1244.  *  void
  1245.  *****************************************************************************/
  1246. void mmi_gx_puzzle_key_2_release(void)
  1247. {
  1248.     /*----------------------------------------------------------------*/
  1249.     /* Local Variables                                                */
  1250.     /*----------------------------------------------------------------*/
  1252.     /*----------------------------------------------------------------*/
  1253.     /* Code Body                                                      */
  1254.     /*----------------------------------------------------------------*/
  1255.     g_gx_puzzle_context.destination_x = 0;
  1256.     g_gx_puzzle_context.destination_y = 1;
  1258.     mmi_gx_puzzle_move_and_show();
  1259. }
  1262. /*****************************************************************************
  1263.  * FUNCTION
  1264.  *  mmi_gx_puzzle_key_4_release
  1265.  * DESCRIPTION
  1266.  *  Key handling
  1267.  * PARAMETERS
  1268.  *  void
  1269.  * RETURNS
  1270.  *  void
  1271.  *****************************************************************************/
  1272. void mmi_gx_puzzle_key_4_release(void)
  1273. {
  1274.     /*----------------------------------------------------------------*/
  1275.     /* Local Variables                                                */
  1276.     /*----------------------------------------------------------------*/
  1278.     /*----------------------------------------------------------------*/
  1279.     /* Code Body                                                      */
  1280.     /*----------------------------------------------------------------*/
  1281.     g_gx_puzzle_context.destination_x = 1;
  1282.     g_gx_puzzle_context.destination_y = 0;
  1284.     mmi_gx_puzzle_move_and_show();
  1285. }
  1288. /*****************************************************************************
  1289.  * FUNCTION
  1290.  *  mmi_gx_puzzle_key_6_release
  1291.  * DESCRIPTION
  1292.  *  Key handling
  1293.  * PARAMETERS
  1294.  *  void
  1295.  * RETURNS
  1296.  *  void
  1297.  *****************************************************************************/
  1298. void mmi_gx_puzzle_key_6_release(void)
  1299. {
  1300.     /*----------------------------------------------------------------*/
  1301.     /* Local Variables                                                */
  1302.     /*----------------------------------------------------------------*/
  1304.     /*----------------------------------------------------------------*/
  1305.     /* Code Body                                                      */
  1306.     /*----------------------------------------------------------------*/
  1307.     g_gx_puzzle_context.destination_x = -1;
  1308.     g_gx_puzzle_context.destination_y = 0;
  1310.     mmi_gx_puzzle_move_and_show();
  1311. }
  1314. /*****************************************************************************
  1315.  * FUNCTION
  1316.  *  mmi_gx_puzzle_key_8_release
  1317.  * DESCRIPTION
  1318.  *  Key handling
  1319.  * PARAMETERS
  1320.  *  void
  1321.  * RETURNS
  1322.  *  void
  1323.  *****************************************************************************/
  1324. void mmi_gx_puzzle_key_8_release(void)
  1325. {
  1326.     /*----------------------------------------------------------------*/
  1327.     /* Local Variables                                                */
  1328.     /*----------------------------------------------------------------*/
  1330.     /*----------------------------------------------------------------*/
  1331.     /* Code Body                                                      */
  1332.     /*----------------------------------------------------------------*/
  1333.     g_gx_puzzle_context.destination_x = 0;
  1334.     g_gx_puzzle_context.destination_y = -1;
  1336.     mmi_gx_puzzle_move_and_show();
  1337. }
  1339. #ifdef __MMI_GAME_PUZZLE_128x128__
  1342. /*****************************************************************************
  1343.  * FUNCTION
  1344.  *  mmi_gx_puzzle_key_5_press
  1345.  * DESCRIPTION
  1346.  *  Key handling
  1347.  * PARAMETERS
  1348.  *  void
  1349.  * RETURNS
  1350.  *  void
  1351.  *****************************************************************************/
  1352. void mmi_gx_puzzle_key_5_press(void)
  1353. {
  1354.     /*----------------------------------------------------------------*/
  1355.     /* Local Variables                                                */
  1356.     /*----------------------------------------------------------------*/
  1358.     /*----------------------------------------------------------------*/
  1359.     /* Code Body                                                      */
  1360.     /*----------------------------------------------------------------*/
  1361.     g_gx_puzzle_context.is_show_status = TRUE;
  1362. }
  1365. /*****************************************************************************
  1366.  * FUNCTION
  1367.  *  mmi_gx_puzzle_key_5_release
  1368.  * DESCRIPTION
  1369.  *  Key handling
  1370.  * PARAMETERS
  1371.  *  void
  1372.  * RETURNS
  1373.  *  void
  1374.  *****************************************************************************/
  1375. void mmi_gx_puzzle_key_5_release(void)
  1376. {
  1377.     /*----------------------------------------------------------------*/
  1378.     /* Local Variables                                                */
  1379.     /*----------------------------------------------------------------*/
  1381.     /*----------------------------------------------------------------*/
  1382.     /* Code Body                                                      */
  1383.     /*----------------------------------------------------------------*/
  1384.     gui_push_clip();
  1385.     gui_set_clip(
  1386.         MMI_GX_PUZZLE_STATUS_POS_X,
  1387.         MMI_GX_PUZZLE_STATUS_POS_Y,
  1388.         MMI_GX_PUZZLE_STATUS_POS_X + MMI_GX_PUZZLE_STATUS_WIDTH - 1 + MMI_GX_PUZZLE_STATUS_SHADOW,
  1389.         MMI_GX_PUZZLE_STATUS_POS_Y + MMI_GX_PUZZLE_STATUS_HEIGHT - 1 + MMI_GX_PUZZLE_STATUS_SHADOW);
  1391.     g_gx_puzzle_context.is_show_status = FALSE;
  1392.     mmi_gx_puzzle_show_puzzle();
  1393.     mmi_gx_puzzle_draw_seperation_line();
  1395.     gui_pop_clip();
  1397.     gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  1398. }
  1399. #endif /* __MMI_GAME_PUZZLE_128x128__ */ 
  1402. /*****************************************************************************
  1403.  * FUNCTION
  1404.  *  mmi_gx_puzzle_move_and_show
  1405.  * DESCRIPTION
  1406.  *  Move the grid (in memory) and show the movement
  1407.  * PARAMETERS
  1408.  *  void
  1409.  * RETURNS
  1410.  *  void
  1411.  *****************************************************************************/
  1412. void mmi_gx_puzzle_move_and_show(void)
  1413. {
  1414.     /*----------------------------------------------------------------*/
  1415.     /* Local Variables                                                */
  1416.     /*----------------------------------------------------------------*/
  1417.     S16 tmp;
  1418.     U8 bound_size;
  1420. #ifdef __MMI_GAME_PUZZLE_128x128__
  1421.     MMI_ID_TYPE image_id;   /* store the last digit of tick */
  1422.     U8 position_shift;      /* the position offset of digit displayed */
  1423. #endif /* __MMI_GAME_PUZZLE_128x128__ */ 
  1424.     U8 i;
  1425.     U8 j;
  1426.     BOOL is_gameover;
  1428.     /*----------------------------------------------------------------*/
  1429.     /* Code Body                                                      */
  1430.     /*----------------------------------------------------------------*/
  1431. #ifdef __MMI_GAME_PUZZLE_128x128__
  1432.     /* when the status shows, no action taken */
  1433.     if (g_gx_puzzle_context.is_show_status != FALSE)
  1434.     {
  1435.         return;
  1436.     }
  1437. #endif /* __MMI_GAME_PUZZLE_128x128__ */ 
  1439.     /* play moving sound */
  1440. #ifdef __MMI_GAME_MULTICHANNEL_SOUND__
  1441.     GFX_STOP_SOUND_EFFECTS_MIDI(g_gx_puzzle_context.move_midi);
  1443.     GFX_PLAY_SOUND_EFFECTS_MIDI(g_gx_puzzle_context.move_midi);
  1444. #else /* __MMI_GAME_MULTICHANNEL_SOUND__ */ 
  1445.     GFX_PLAY_AUDIO_DVI(PuzzleMove_dvi, PUZZLEMOVE_DVI, DEVICE_AUDIO_PLAY_ONCE);
  1446. #endif /* __MMI_GAME_MULTICHANNEL_SOUND__ */ 
  1448.     bound_size = g_gx_puzzle_context.game_level + 3;
  1450.     /* check if the movement is valid */
  1451.     if (g_gx_puzzle_context.null_grid.x + g_gx_puzzle_context.destination_x < 0 ||
  1452.         g_gx_puzzle_context.null_grid.x + g_gx_puzzle_context.destination_x >= bound_size ||
  1453.         g_gx_puzzle_context.null_grid.y + g_gx_puzzle_context.destination_y < 0 ||
  1454.         g_gx_puzzle_context.null_grid.y + g_gx_puzzle_context.destination_y >= bound_size)
  1455.     {
  1456.         return;
  1457.     }
  1459.     /* update the numbers user clicks */
  1460.     g_gx_puzzle_context.click = g_gx_puzzle_context.click + 1;
  1461.     if (g_gx_puzzle_context.click > 65534)
  1462.     {
  1463.         g_gx_puzzle_context.click = 0;
  1464.     }
  1466. #if defined(__MMI_GAME_PUZZLE_128x160__) || defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__)
  1467.     mmi_gx_puzzle_draw_step();
  1468. #endif 
  1470.     /* switch the null grid and its neighboring grid and draw them */
  1471.     tmp = g_gx_puzzle_context.puzzle[g_gx_puzzle_context.null_grid.y][g_gx_puzzle_context.null_grid.x];
  1473.     g_gx_puzzle_context.puzzle[g_gx_puzzle_context.null_grid.y][g_gx_puzzle_context.null_grid.x] =
  1474.         g_gx_puzzle_context.puzzle[g_gx_puzzle_context.null_grid.y +
  1475.                                    g_gx_puzzle_context.destination_y][g_gx_puzzle_context.null_grid.x +
  1476.                                                                       g_gx_puzzle_context.destination_x];
  1477.     mmi_gx_puzzle_my_show_image(
  1478.         MMI_GX_PUZZLE_ORIGIN_X + MMI_GX_PUZZLE_SIZE / bound_size * g_gx_puzzle_context.null_grid.x,
  1479.         MMI_GX_PUZZLE_ORIGIN_Y + MMI_GX_PUZZLE_SIZE / bound_size * g_gx_puzzle_context.null_grid.y,
  1480.         g_gx_puzzle_context.puzzle[g_gx_puzzle_context.null_grid.y + g_gx_puzzle_context.destination_y][g_gx_puzzle_context. null_grid.x + g_gx_puzzle_context. destination_x]);
  1482.     g_gx_puzzle_context.puzzle[g_gx_puzzle_context.null_grid.y +
  1483.                                g_gx_puzzle_context.destination_y][g_gx_puzzle_context.null_grid.x +
  1484.                                                                   g_gx_puzzle_context.destination_x] = tmp;
  1485.     mmi_gx_puzzle_my_show_image(
  1486.         MMI_GX_PUZZLE_ORIGIN_X + MMI_GX_PUZZLE_SIZE / bound_size * (g_gx_puzzle_context.null_grid.x + g_gx_puzzle_context.destination_x),
  1487.         MMI_GX_PUZZLE_ORIGIN_Y + MMI_GX_PUZZLE_SIZE / bound_size * (g_gx_puzzle_context.null_grid.y + g_gx_puzzle_context.destination_y),
  1488.         tmp);
  1490.     g_gx_puzzle_context.null_grid.x = g_gx_puzzle_context.null_grid.x + g_gx_puzzle_context.destination_x;
  1491.     g_gx_puzzle_context.null_grid.y = g_gx_puzzle_context.null_grid.y + g_gx_puzzle_context.destination_y;
  1493.     mmi_gx_puzzle_draw_seperation_line();
  1495.     gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  1497.     /* check if gameover */
  1498.     tmp = 1;
  1499.     is_gameover = TRUE;
  1500.     for (i = 0; i < bound_size; i++)
  1501.     {
  1502.         for (j = 0; j < bound_size; j++)
  1503.         {
  1504.             if (g_gx_puzzle_context.puzzle[i][j] != tmp)
  1505.             {
  1506.                 is_gameover = FALSE;
  1507.                 break;
  1508.             }
  1509.             tmp = tmp + 1;
  1510.         }
  1511.         if (is_gameover != TRUE)
  1512.         {
  1513.             break;
  1514.         }
  1515.     }
  1516.     if (is_gameover != FALSE)
  1517.     {
  1518.         mmi_gx_puzzle_gameover();
  1519.     }
  1520. }
  1522. #if defined(__MMI_GAME_PUZZLE_128x160__) || defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__)
  1525. /*****************************************************************************
  1526.  * FUNCTION
  1527.  *  mmi_gx_puzzle_draw_step
  1528.  * DESCRIPTION
  1529.  *  Draw steps
  1530.  * PARAMETERS
  1531.  *  void
  1532.  * RETURNS
  1533.  *  void
  1534.  *****************************************************************************/
  1535. void mmi_gx_puzzle_draw_step(void)
  1536. {
  1537.     /*----------------------------------------------------------------*/
  1538.     /* Local Variables                                                */
  1539.     /*----------------------------------------------------------------*/
  1540.     U16 tmp_click;
  1541.     U8 position_shift;      /* the position offset of digit displayed */
  1542.     MMI_ID_TYPE image_id;   /* store the last digit of tick */
  1544.     /*----------------------------------------------------------------*/
  1545.     /* Code Body                                                      */
  1546.     /*----------------------------------------------------------------*/
  1547.     tmp_click = g_gx_puzzle_context.click;
  1548. #if defined(__MMI_GAME_PUZZLE_128x160__)
  1549.     position_shift = MMI_GX_PUZZLE_STEP_POSITION_X + 15;
  1550. #elif defined(__MMI_GAME_PUZZLE_176x220__)|| defined(__MMI_GAME_PUZZLE_240x320__)
  1551.     position_shift = MMI_GX_PUZZLE_STEP_POSITION_X + 17;
  1552. #endif 
  1554.     do
  1555.     {
  1556.         image_id = IMG_ID_GX_PUZZLE_NUMBER_0 + (tmp_click % 10);
  1557.         tmp_click = tmp_click / 10;
  1558.         gui_show_image(MMI_GX_PUZZLE_TIME_POSITION_X + position_shift,
  1559.     #if defined(__MMI_GAME_PUZZLE_240x320__)
  1560.                        MMI_GX_PUZZLE_TIME_POSITION_Y + 5 + 128,
  1561.     #else 
  1562.                        MMI_GX_PUZZLE_TIME_POSITION_Y + 2 + 128,
  1563.     #endif 
  1564.                        (PU8) GetImage(image_id));
  1565.     #if defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__)
  1566.         position_shift = position_shift - MMI_GX_PUZZLE_DIGIT_WIDTH - 1;
  1567.     #else 
  1568.         position_shift = position_shift - MMI_GX_PUZZLE_DIGIT_WIDTH;
  1569.     #endif 
  1571.     } while (tmp_click != 0);
  1572. }
  1573. #endif /* defined(__MMI_GAME_PUZZLE_128x160__) || defined(__MMI_GAME_PUZZLE_176x220__) || defined(__MMI_GAME_PUZZLE_240x320__) */ 
  1576. /*****************************************************************************
  1577.  * FUNCTION
  1578.  *  mmi_gx_puzzle_my_show_image
  1579.  * DESCRIPTION
  1580.  *  Calculate which part of the image should be shown
  1581.  * PARAMETERS
  1582.  *  x                   [IN]        X position of the shown image
  1583.  *  y                   [IN]        Y position of the shown image
  1584.  *  input_image_id      [IN]        
  1585.  *  i  PU8 for the shown image(?)
  1586.  * RETURNS
  1587.  *  void
  1588.  *****************************************************************************/
  1589. void mmi_gx_puzzle_my_show_image(long x, long y, S16 input_image_id)
  1590. {
  1591.     /*----------------------------------------------------------------*/
  1592.     /* Local Variables                                                */
  1593.     /*----------------------------------------------------------------*/
  1594.     /*
  1595.      * U8                grid_size;
  1596.      * S16               output_x;
  1597.      * S16               output_y;
  1598.      */
  1599.     MMI_ID_TYPE null_image;
  1600.     MMI_ID_TYPE image_id;
  1602.     /*----------------------------------------------------------------*/
  1603.     /* Code Body                                                      */
  1604.     /*----------------------------------------------------------------*/
  1605.     /* initialize */
  1606.     null_image = 0;
  1607.     image_id = 0;
  1609.     if (input_image_id == (g_gx_puzzle_context.game_level + 3) * (g_gx_puzzle_context.game_level + 3))
  1610.     {
  1611.         switch (g_gx_puzzle_context.game_level)
  1612.         {
  1613.             case MMI_GX_PUZZLE_EASY:
  1614.                 null_image = IMG_ID_GX_PUZZLE_3_SPACE;
  1615.                 break;
  1616.             case MMI_GX_PUZZLE_NORMAL:
  1617.                 null_image = IMG_ID_GX_PUZZLE_4_SPACE;
  1618.                 break;
  1619.             case MMI_GX_PUZZLE_HARD:
  1620.                 null_image = IMG_ID_GX_PUZZLE_5_SPACE;
  1621.                 break;
  1622.         }
  1624.         gui_show_image(x, y, (PU8) GetImage(null_image));
  1625.     }
  1626.     else
  1627.     {
  1628.         /*
  1629.          * Old flash memory saving image drawing method
  1630.          * grid_size = MMI_GX_PUZZLE_SIZE / (g_gx_puzzle_context.game_level + 3);
  1631.          * output_x = x - grid_size * ((input_image_id - 1) % (g_gx_puzzle_context.game_level + 3));
  1632.          * output_y = y - grid_size * ((input_image_id - 1) / (g_gx_puzzle_context.game_level + 3));
  1633.          * 
  1634.          * gui_push_clip();
  1635.          * gui_set_clip(x, y, x + grid_size - 1, y + grid_size - 1);
  1636.          * gui_show_image(output_x, output_y, (PU8)GetImage(g_gx_puzzle_context.image));
  1637.          * gui_pop_clip();
  1638.          */
  1639.         switch (g_gx_puzzle_context.game_level)
  1640.         {
  1641.             case MMI_GX_PUZZLE_EASY:
  1642.                 image_id = IMG_ID_GX_PUZZLE_3_1;
  1643.                 break;
  1644.             case MMI_GX_PUZZLE_NORMAL:
  1645.                 image_id = IMG_ID_GX_PUZZLE_4_1;
  1646.                 break;
  1647.             case MMI_GX_PUZZLE_HARD:
  1648.                 image_id = IMG_ID_GX_PUZZLE_5_1;
  1649.                 break;
  1650.         }
  1651.         gui_show_image(x, y, (PU8) GetImage((U16) (image_id - 1 + input_image_id)));
  1652.     }
  1653. }
  1655. /* MTK Leo add */
  1656. #ifdef __MMI_TOUCH_SCREEN__
  1657. typedef enum
  1658. {
  1659.     PUZZLE_MOVE_NONE = 0,
  1660.     PUZZLE_MOVE_RIGHT = 5,
  1661.     PUZZLE_MOVE_DOWN = 4,
  1662.     PUZZLE_MOVE_LEFT = 7,
  1663.     PUZZLE_MOVE_UP = 8
  1664. } PUZZLE_MOVEMENT;
  1667. /*****************************************************************************
  1668.  * FUNCTION
  1669.  *  mmi_puzzle_is_puzzle_moveable
  1670.  * DESCRIPTION
  1671.  *  
  1672.  * PARAMETERS
  1673.  *  coord_x     [IN]        
  1674.  *  coord_y     [IN]        
  1675.  * RETURNS
  1676.  *  
  1677.  *****************************************************************************/
  1678. PUZZLE_MOVEMENT mmi_puzzle_is_puzzle_moveable(S32 coord_x, S32 coord_y)
  1679. {
  1680.     /*----------------------------------------------------------------*/
  1681.     /* Local Variables                                                */
  1682.     /*----------------------------------------------------------------*/
  1683.     U8 grid_number;
  1684.     S16 diff = abs(coord_x - g_gx_puzzle_context.null_grid.x) + abs(coord_y - g_gx_puzzle_context.null_grid.y);
  1686.     /*----------------------------------------------------------------*/
  1687.     /* Code Body                                                      */
  1688.     /*----------------------------------------------------------------*/
  1689.     grid_number = g_gx_puzzle_context.game_level + 3;
  1691.     if (coord_x < 0 || coord_x >= grid_number || coord_y < 0 || coord_y >= grid_number)
  1692.     {
  1693.         return PUZZLE_MOVE_NONE;
  1694.     }
  1695.     else if (diff == 1)
  1696.     {
  1697.         return ((coord_x - g_gx_puzzle_context.null_grid.x + 2) + 2 * (coord_y - g_gx_puzzle_context.null_grid.y + 2));
  1698.     }
  1699.     else
  1700.     {
  1701.         return PUZZLE_MOVE_NONE;
  1702.     }
  1703. }
  1704. #endif /* __MMI_TOUCH_SCREEN__ */ 
  1707. /*****************************************************************************
  1708.  * FUNCTION
  1709.  *  mmi_puzzle_pen_up_hdlr
  1710.  * DESCRIPTION
  1711.  *  pen up event handler
  1712.  * PARAMETERS
  1713.  *  pos     [IN]        Position of pen
  1714.  * RETURNS
  1715.  *  void
  1716.  *****************************************************************************/
  1717. #ifdef __MMI_TOUCH_SCREEN__
  1718. void mmi_puzzle_pen_up_hdlr(mmi_pen_point_struct pos)
  1719. {
  1720.     /*----------------------------------------------------------------*/
  1721.     /* Local Variables                                                */
  1722.     /*----------------------------------------------------------------*/
  1723.     S32 pos_x = pos.x, pos_y = pos.y;
  1725.     /*----------------------------------------------------------------*/
  1726.     /* Code Body                                                      */
  1727.     /*----------------------------------------------------------------*/
  1728.     g_gx_puzzle_context.softkey_state = 2;
  1730. #if defined(__MMI_TOUCH_SCREEN__) && defined(__MMI_GAME_PUZZLE_240x320__)       /* || defined(__MMI_GAME_PUZZLE_176x220__)) */
  1731.     if (pos_x > MMI_GX_PUZZLE_SOFTKEY_X && pos_x < MMI_GX_PUZZLE_SOFTKEY_X + MMI_GX_PUZZLE_SOFTKEY_WIDTH
  1732.         && pos_y > MMI_GX_PUZZLE_SOFTKEY_Y && pos_y < MMI_GX_PUZZLE_SOFTKEY_Y + MMI_GX_PUZZLE_SOFTKEY_HEIGHT)
  1733.     {
  1734.         GoBackHistory();
  1735.     }
  1736. #endif /* defined(__MMI_TOUCH_SCREEN__) && defined(__MMI_GAME_PUZZLE_240x320__) */ /* __MMI_TOUCH_SCREEN__ && ( __MMI_GAME_PUZZLE_240x320__ || __MMI_GAME_PUZZLE_176x220__ ) */
  1737. }
  1738. #endif /* __MMI_TOUCH_SCREEN__ */ 
  1740. #ifdef __MMI_TOUCH_SCREEN__
  1743. /*****************************************************************************
  1744.  * FUNCTION
  1745.  *  mmi_puzzle_pen_down_hdlr
  1746.  * DESCRIPTION
  1747.  *  
  1748.  * PARAMETERS
  1749.  *  pos     [IN]        
  1750.  * RETURNS
  1751.  *  void
  1752.  *****************************************************************************/
  1753. void mmi_puzzle_pen_down_hdlr(mmi_pen_point_struct pos)
  1754. {
  1755.     /*----------------------------------------------------------------*/
  1756.     /* Local Variables                                                */
  1757.     /*----------------------------------------------------------------*/
  1758.     U8 grid_number = g_gx_puzzle_context.game_level + 3;
  1759.     U16 puzzle_size = MMI_GX_PUZZLE_SIZE / grid_number;
  1761.     /* U8   i=0,j=0; */
  1762.     S32 pos_x = pos.x, pos_y = pos.y;   /* pen location */
  1763.     S32 coord_x = 0, coord_y = 0;       /* puzzle coordinate index */
  1765.     /*----------------------------------------------------------------*/
  1766.     /* Code Body                                                      */
  1767.     /*----------------------------------------------------------------*/
  1768. #if defined(__MMI_TOUCH_SCREEN__) && defined(__MMI_GAME_PUZZLE_240x320__)       /* || defined(__MMI_GAME_PUZZLE_176x220__)) */
  1769.     if (pos_x > MMI_GX_PUZZLE_SOFTKEY_X && pos_x < MMI_GX_PUZZLE_SOFTKEY_X + MMI_GX_PUZZLE_SOFTKEY_WIDTH
  1770.         && pos_y > MMI_GX_PUZZLE_SOFTKEY_Y && pos_y < MMI_GX_PUZZLE_SOFTKEY_Y + MMI_GX_PUZZLE_SOFTKEY_HEIGHT)
  1771.     {
  1772.         g_gx_puzzle_context.softkey_state = 1;
  1773.     }
  1774. #endif /* defined(__MMI_TOUCH_SCREEN__) && defined(__MMI_GAME_PUZZLE_240x320__) */ /* __MMI_TOUCH_SCREEN__ && ( __MMI_GAME_PUZZLE_240x320__ || __MMI_GAME_PUZZLE_176x220__ ) */
  1776.     coord_x = (pos_x - MMI_GX_PUZZLE_ORIGIN_X) / puzzle_size;
  1777.     coord_y = (pos_y - MMI_GX_PUZZLE_ORIGIN_Y) / puzzle_size;
  1778.     switch (mmi_puzzle_is_puzzle_moveable(coord_x, coord_y))
  1779.     {
  1780.         case PUZZLE_MOVE_UP:
  1781.             mmi_gx_puzzle_key_2_release();
  1782.             break;
  1783.         case PUZZLE_MOVE_LEFT:
  1784.             mmi_gx_puzzle_key_4_release();
  1785.             break;
  1786.         case PUZZLE_MOVE_RIGHT:
  1787.             mmi_gx_puzzle_key_6_release();
  1788.             break;
  1789.         case PUZZLE_MOVE_DOWN:
  1790.             mmi_gx_puzzle_key_8_release();
  1791.             break;
  1792.     }
  1793. }
  1794. #endif /* __MMI_TOUCH_SCREEN__ */ 
  1796. #endif /* IS_PUZZLE_BASE_GAME */