boxman.c

Boxman(推箱子)源码

{
	return TRUE;
}
static boolean Boxman_Suspend(CBoxman * pApp)
{

   IBitmap* pDeviceBitmap;

   
   /* Create a bitmap that captures the current state of the screen */
    if( IDISPLAY_GetDeviceBitmap( pApp->a.m_pIDisplay, &pDeviceBitmap ) != SUCCESS )
      return FALSE;
    if( IBITMAP_CreateCompatibleBitmap( pDeviceBitmap, 
    					&pApp->m_pSuspendBitmap, 
    					(uint16) ( pApp->m_nScrWidth ), 
    					(uint16) ( pApp->m_nScrHeight ) 
    					) 
    					!= SUCCESS )
    {
      IBITMAP_Release( pDeviceBitmap );
      return FALSE;
    }
    IBITMAP_BltIn( pApp->m_pSuspendBitmap, 
    		   0, 
    		   0, 
    		   (uint16) ( pApp->m_nScrWidth ), 
    		   (uint16) ( pApp->m_nScrHeight ), 
    		   pDeviceBitmap, 
    		   0, 
    		   0, 
    		   AEE_RO_COPY );
    IBITMAP_Release( pDeviceBitmap );
    
    /* do the other work neccessary */
    
    //add code here...
    
    return TRUE;
}
static boolean Boxman_Resume(CBoxman * pApp)
{

    /* Copy the capture bitmap to the screen to restroe the display */
     
    IDISPLAY_BitBlt( pApp->a.m_pIDisplay, 
    		     0, 
    		     0, 
    		     pApp->m_nScrWidth, 
    		     pApp->m_nScrHeight, 
    		     pApp->m_pSuspendBitmap, 
    		     0, 
    		     0, 
    		     AEE_RO_COPY );
    		     
    Boxman_ReleaseObj( (void **)&pApp->m_pSuspendBitmap );
    
    
    /* do the other work neccessary */
    
    //add code here...
    
    return TRUE;
}
static boolean Boxman_HandleKey(CBoxman * pApp,
                                 uint16 wParam, 
                                 uint32 dwParam)
{
	switch( pApp->m_nState )
	{
		case STATE_MAINMENU:
			return	Boxman_MainMenuHandleKey(pApp,wParam,dwParam);
		
		case STATE_RUNGAME:

			return Boxman_GameHandleKey(pApp,wParam,dwParam);

		case STATE_SUCCESS:
			return Boxman_SuccessHandleKey(pApp,wParam,dwParam);

		case STATE_QUIT:
			return Boxman_QuitHandleKey(pApp,wParam,dwParam);
		case STATE_SELSTAGE:
			return Boxman_SelectStageHandleKey(pApp,wParam,dwParam);
		default:
		return FALSE;
	}
    
}
static boolean Boxman_HandleCommand(CBoxman * pApp,
                                     uint16 wParam, 
                                     uint32 dwParam)
{
    switch( pApp->m_nState )
	{
		case STATE_MAINMENU:
		return	Boxman_MainMenuHandleCommand(pApp,wParam,dwParam);
		
		default:
			return FALSE;
	}
    
    return TRUE;
}

static boolean Boxman_Notify(CBoxman *pApp,uint16 w,uint32 dw)
{
	return TRUE;
}
/* Display mainmenu */
static boolean Boxman_DisplayMainMenu(CBoxman * pApp)
{

	IMenuCtl* pMenuCtl=NULL;        
	CtlAddItem rMenuItem;
	AEERect nRect;
	AEEItemStyle nNormal;
	AEEItemStyle nSel;

	if(ISHELL_CreateInstance(pApp->a.m_pIShell, AEECLSID_MENUCTL, (void**)(&pApp->m_pObj)) != SUCCESS)
	return FALSE;
	pMenuCtl = (IMenuCtl*)pApp->m_pObj;
	IMENUCTL_Reset( pMenuCtl );
	IMENUCTL_SetActive(pMenuCtl, FALSE );

	rMenuItem.pText = NULL;
	rMenuItem.pImage = NULL;
	rMenuItem.pszResImage = rMenuItem.pszResText = BOXMAN_RES_FILE;//resource file name
	rMenuItem.wFont = AEE_FONT_NORMAL;//AEE_FONT_NORMAL

	rMenuItem.wText = IDS_START;//text id
	rMenuItem.wImage = IDB_START;//icon id
	rMenuItem.wItemID = IDS_START;//used for command
	IMENUCTL_AddItemEx( pMenuCtl, &rMenuItem );

	/*add IDS_SELSTAGE items*/
	rMenuItem.wText = IDS_SELSTAGE;
	rMenuItem.wImage = IDB_SELSTAGE;
	rMenuItem.wItemID = IDS_SELSTAGE;
	IMENUCTL_AddItemEx( pMenuCtl, &rMenuItem );

	/*add IDS_RESTART items*/
	rMenuItem.wText = IDS_RESTART;
	rMenuItem.wImage = IDB_RESTART;
	rMenuItem.wItemID = IDS_RESTART;
	IMENUCTL_AddItemEx( pMenuCtl, &rMenuItem );
	/*add IDS_PRESTAGE items*/
	rMenuItem.wText = IDS_PRESTAGE;
	rMenuItem.wImage = IDB_PRESTAGE;
	rMenuItem.wItemID = IDS_PRESTAGE;
	IMENUCTL_AddItemEx( pMenuCtl, &rMenuItem );
	/*add IDS_NEXTSTAGE items*/
	rMenuItem.wText = IDS_NEXTSTAGE;
	rMenuItem.wImage = IDB_NEXTSTAGE;
	rMenuItem.wItemID = IDS_NEXTSTAGE;
	IMENUCTL_AddItemEx( pMenuCtl, &rMenuItem );

	/*add IDS_QUIT items*/
	rMenuItem.wText = IDS_QUIT;
	rMenuItem.wImage = IDB_QUIT;
	rMenuItem.wItemID = IDS_QUIT;
	IMENUCTL_AddItemEx( pMenuCtl, &rMenuItem );
	
	nNormal.ft = AEE_FT_NONE;
	nNormal.xOffset = nNormal.yOffset = 0;
	nNormal.roImage = AEE_RO_TRANSPARENT;
	nSel.ft = AEE_FT_RAISED;
	nSel.xOffset = nSel.yOffset = 0;
	nSel.roImage = AEE_RO_TRANSPARENT;
	IMENUCTL_SetStyle(pMenuCtl,&nNormal,&nSel);

	
	IMENUCTL_SetProperties( pMenuCtl, IMENUCTL_GetProperties( pMenuCtl ) & ~(MP_ICON_TEXT_TOP) );//etc
	SETAEERECT( &nRect, 0, 0, pApp->m_nScrWidth, pApp->m_nScrHeight );
	IMENUCTL_SetRect( pMenuCtl, &nRect );
	IMENUCTL_SetActive( pMenuCtl, TRUE );
	//Boxman_ReleaseObj( (void **)&pMenuCtl );
	pApp->m_nState = STATE_MAINMENU;
	return TRUE;

}
static boolean Boxman_MainMenuHandleKey(CBoxman * pApp,
                                 uint16 wParam, 
                                 uint32 dwParam)
{
    return IMENUCTL_HandleEvent((IMenuCtl*)pApp->m_pObj,EVT_KEY,wParam,dwParam);
}
static boolean Boxman_MainMenuHandleCommand(CBoxman * pApp,
                                     uint16 wParam, 
                                     uint32 dwParam)
{
	switch(wParam)
	{
	case IDS_START:
		Boxman_ReleaseObj( (void **)&pApp->m_pObj);
		
		if(FALSE == Boxman_ReadMap(pApp,pApp->m_nCurMap))
			return FALSE;
		return Boxman_GameStart(pApp);
	case IDS_SELSTAGE:
		Boxman_ReleaseObj( (void **)&pApp->m_pObj);
		return Boxman_SelectStage(pApp);
	case IDS_RESTART:
		Boxman_ReleaseObj( (void **)&pApp->m_pObj);

		Boxman_ReadMap(pApp,pApp->m_nCurMap);
		
		return Boxman_GameStart(pApp);
	

	case IDS_PRESTAGE:
		Boxman_ReleaseObj( (void **)&pApp->m_pObj);
		pApp->m_nCurMap --;
		if(FALSE == Boxman_ReadMap(pApp,pApp->m_nCurMap))
		{
			pApp->m_nCurMap ++;
		}
		return Boxman_GameStart(pApp);
	case IDS_NEXTSTAGE:
		Boxman_ReleaseObj( (void **)&pApp->m_pObj);
		pApp->m_nCurMap ++;
		if(FALSE == Boxman_ReadMap(pApp,pApp->m_nCurMap))
		{
			pApp->m_nCurMap --;
		}
		return Boxman_GameStart(pApp);

	case IDS_QUIT:
		Boxman_ReleaseObj( (void **)&pApp->m_pObj);
		return Boxman_DisplayQuit(pApp);
		
	default:
		return FALSE;
	}
	return TRUE;
}

/* Update all drawing */
static void Boxman_CheckScreen(CBoxman* pApp) 
{
	IDISPLAY_Update(pApp->a.m_pIDisplay);
}

/* Clear the whole display */
static void Boxman_ClearDisplay(CBoxman* pApp) 
{
	IDISPLAY_ClearScreen(pApp->a.m_pIDisplay); 
}
static boolean Boxman_GameStart(CBoxman * pApp)
{
	
	S16 x,y;
	S16 width,height;
	AECHAR szText[32] = {0};
	IImage * pImage=ISHELL_LoadResImage(pApp->a.m_pIShell,
                                 BOXMAN_RES_FILE,
                                 IDB_BACKGROUND);
	Boxman_ClearDisplay(pApp);
	IIMAGE_Draw(pImage,0,0);
	IIMAGE_Release(pImage);
	
	
	/* Do work for starting app */
	
	pApp->m_Arrived = 0;
	pApp->m_BoxNum = 0;
	pApp->m_ManX = 0;
	pApp->m_ManY = 0;

	width = UPCBMPGetU16(wallbmp + kUPCBMPImageWidthOffset);
	height = UPCBMPGetU16(wallbmp + kUPCBMPImageHeightOffset);
	for(y=0;y<MAP_HEIGHT;y++)
	{
		for(x=0;x<MAP_WIDTH;x++)
		{
			switch(pApp->m_pMap[y*MAP_WIDTH+x])
			{
				
				case BKGR:
				Boxman_DrawBG(pApp,x,y);
				break;
				case WALL:
				Boxman_DrawWall(pApp,x,y);
				break;
				case BOX:
				Boxman_DrawBox(pApp,x,y);
				pApp->m_BoxNum ++;
				break;
				case DEST:
				Boxman_DrawDest(pApp,x,y);
				break;
				case MAN:
				pApp->m_ManX = x;
				pApp->m_ManY = y;
				Boxman_DrawMan(pApp,x,y);
				break;
				default:
				Boxman_DrawBG(pApp,x,y);
				break;
			}
			
		}
	}
	(void) ISHELL_LoadResString(pApp->a.m_pIShell,
                                 BOXMAN_RES_FILE,
                                 IDS_STAGEPROMPT,
                                 szText,
                                 sizeof(szText));
	szText[4] += pApp->m_nCurMap /10;
	szText[5] += pApp->m_nCurMap %10;
	IDISPLAY_DrawText(pApp->a.m_pIDisplay,    // Display instance
                           AEE_FONT_BOLD,       // Use BOLD font
                           szText,              // Text - Normally comes from resource
                           -1,                  // -1 = Use full string length
                           0,                   // Ignored - IDF_ALIGN_CENTER
                           MAP_HEIGHT*6+5,          // Ignored - IDF_ALIGN_MIDDLE
                           NULL,                // No clipping
                           IDF_ALIGN_CENTER|IDF_TEXT_TRANSPARENT );
	Boxman_CheckScreen(pApp);
	pApp->m_nState = STATE_RUNGAME;
	return TRUE;
}
static boolean Boxman_GameHandleKey(CBoxman * pApp,
                                     uint16 wParam, 
                                     uint32 dwParam)
{
	U8 first_point = BKGR;
	U8 second_point = BKGR;
    switch(wParam)
    {
        case AVK_CLR:
        return Boxman_DisplayMainMenu(pApp);

        
        case AVK_LEFT:
			pApp->m_ManX--;
			first_point = pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX];
			if(first_point & BOX) /* a box on the left side of the man*/
			{
				if(first_point & MAN)
				{
					pApp->m_ManX++;
					return TRUE;
				}
				second_point = pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX-1];
				switch(second_point)
				{
					case DEST:
						if(!(first_point & DEST)) //box not on the dest
						{
							pApp->m_Arrived++;
						}
						second_point |= BOX;
						pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX-1] = second_point;
						Boxman_DrawBox(pApp,(S16)(pApp->m_ManX-1),pApp->m_ManY);
						
						first_point = (first_point & ~BOX) | MAN;
						pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX] = first_point;
						Boxman_DrawMan(pApp,pApp->m_ManX,pApp->m_ManY);
					break;
						
					case BKGR:
					if(first_point & DEST) //box on the dest
						{
							pApp->m_Arrived--;
						}

					second_point |= BOX;
					pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX-1] = second_point;
					Boxman_DrawBox(pApp,(S16)(pApp->m_ManX-1),pApp->m_ManY);
					
					first_point = (first_point & ~BOX) | MAN;
					pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX] = first_point;
					Boxman_DrawMan(pApp,pApp->m_ManX,pApp->m_ManY);
					break;
					default:
						pApp->m_ManX++;
					return TRUE;
				}
			}
			else if(0 == (first_point & ~DEST) )
			{
				pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX] |= MAN;
				Boxman_DrawMan(pApp,pApp->m_ManX,pApp->m_ManY);
			}
			else
			{
				pApp->m_ManX++;
				return TRUE;
			}
			
			/* draw the map */
			pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX+1] &=  ~MAN;
			switch(pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX+1])
			{
				
				
				case DEST:
				Boxman_DrawDest(pApp,(S16)(pApp->m_ManX+1),pApp->m_ManY);
				break;
				default:
				Boxman_DrawBG(pApp,(S16)(pApp->m_ManX+1),pApp->m_ManY);
				break;
			}
			
			Boxman_CheckScreen(pApp);
        break;
        
        case AVK_RIGHT:
			pApp->m_ManX++;
			first_point = pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX];
			if(first_point & BOX) /* a box on the left side of the man*/
			{
				if(first_point & MAN)
				{
					pApp->m_ManX--;
					return TRUE;
				}
				second_point = pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX+1];
				switch(second_point)
				{
					case DEST:
						if(!(first_point & DEST)) //box not on the dest
						{
							pApp->m_Arrived++;
						}
					second_point |= BOX;
					pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX+1] = second_point;
					Boxman_DrawBox(pApp,(S16)(pApp->m_ManX+1),pApp->m_ManY);

					first_point = (first_point & ~BOX) | MAN;
					pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX] = first_point;
					Boxman_DrawMan(pApp,pApp->m_ManX,pApp->m_ManY);
					break;
					case BKGR:
						if(first_point & DEST) //box on the dest
						{
							pApp->m_Arrived--;
						}
					second_point |= BOX;
					pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX+1] = second_point;
					Boxman_DrawBox(pApp,(S16)(pApp->m_ManX+1),pApp->m_ManY);

					first_point = (first_point & ~BOX) | MAN;
					pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX] = first_point;
					Boxman_DrawMan(pApp,pApp->m_ManX,pApp->m_ManY);
					break;
					default:
						pApp->m_ManX--;
					return TRUE;
				}
			}
			else if(0 == (first_point & ~DEST) )
			{
				pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX] |= MAN;
				Boxman_DrawMan(pApp,pApp->m_ManX,pApp->m_ManY);
			}
			else
			{
				pApp->m_ManX--;
				return TRUE;
			}
			
			/* draw the map */
			pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX-1] &=  ~MAN;
			switch(pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX-1])
			{
				
				
				case DEST:
				Boxman_DrawDest(pApp,(S16)(pApp->m_ManX-1),pApp->m_ManY);
				break;
				default:
				Boxman_DrawBG(pApp,(S16)(pApp->m_ManX-1),pApp->m_ManY);
				break;
			}
			
			Boxman_CheckScreen(pApp);
        break;
        
        case AVK_UP:
			pApp->m_ManY--;

			first_point = pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX];
			if(first_point & BOX) /* a box on the left side of the man*/
			{
				if(first_point & MAN)
				{
					pApp->m_ManY++;
					return TRUE;
				}
				second_point = pApp->m_pMap[(pApp->m_ManY-1)*MAP_WIDTH+pApp->m_ManX];
				switch(second_point)
				{
					
					case DEST:
						if(!(first_point & DEST)) //box not on the dest
						{
							pApp->m_Arrived++;
						}
					second_point |= BOX;
					pApp->m_pMap[(pApp->m_ManY-1)*MAP_WIDTH+pApp->m_ManX] = second_point;
					Boxman_DrawBox(pApp,pApp->m_ManX,(S16)(pApp->m_ManY-1));

					first_point = (first_point & ~BOX) | MAN;
					pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX] = first_point;
					Boxman_DrawMan(pApp,pApp->m_ManX,pApp->m_ManY);
					break;
					case BKGR:
						if(first_point & DEST) //box on the dest
						{
							pApp->m_Arrived--;
						}
					second_point |= BOX;
					pApp->m_pMap[(pApp->m_ManY-1)*MAP_WIDTH+pApp->m_ManX] = second_point;
					Boxman_DrawBox(pApp,pApp->m_ManX,(S16)(pApp->m_ManY-1));

					first_point = (first_point & ~BOX) | MAN;
					pApp->m_pMap[pApp->m_ManY*MAP_WIDTH+pApp->m_ManX] = first_point;
					Boxman_DrawMan(pApp,pApp->m_ManX,pApp->m_ManY);