pottedfish.c

以BREW为开发平台,以C为开发语言的小赛车游戏的程序

				NULL,
				IDF_ALIGN_CENTER | IDF_ALIGN_MIDDLE);
			IDISPLAY_Update(pMe->a.m_pIDisplay);
			FREE(pBuffer);
}

//*************初始化sprite和map******************//
static void PottedFish_Init(PottedFish *pMe)
{
	AEEDeviceInfo di;
	int i;
	int8 gridCntX;//网格
	
	pMe->direction = 5;     //角度5种
	pMe->keyLeft = FALSE;   //是否按下左键
	pMe->keyRight = FALSE;
	pMe->layer = 0;         //初始化化分数
	pMe->crashCounter = 0;
	
	ISHELL_GetDeviceInfo(pMe->a.m_pIShell, &di);
//cxScreen屏幕的实际宽,把屏幕分成8分
	gridCntX = ((di.cxScreen+12)/16 > 9) ? 9 : (di.cxScreen+12)/16;
	
	//tile索引数组
	MEMSET(pMe->BackGroundLayer,0,sizeof(pMe->BackGroundLayer));
    //BackGroundLayer[16]
    pMe->BackGroundLayer[0] = 3;
	pMe->BackGroundLayer[1] = 2;
	pMe->BackGroundLayer[3] = 4;
	pMe->BackGroundLayer[gridCntX-2] = 1;
	pMe->BackGroundLayer[gridCntX-1] = 3;
	pMe->BackGroundLayer[gridCntX] = 3;
	pMe->BackGroundLayer[15] = 3;
	
	pMe->frameMax.x = gridCntX*16;        //逻辑上的最大长宽
	pMe->frameMax.y = 256;
	
	pMe->frameStart.x = (di.cxScreen - pMe->frameMax.x)/2;     //逻辑上的坐标
	pMe->frameStart.y = 0;
	
	CALLBACK_Init(&pMe->cbTimer, PottedFish_NextFrame, pMe);   //设置通知函数和通知上下文 
	
	//sprite
	MEMSET(pMe->rgCmds, 0, sizeof(pMe->rgCmds));
	
	//wall障碍物
	for (i = 0; i < 3; i++) 
	{
		pMe->rgCmds[i].x = pMe->frameStart.x +20+ Random((int16) (pMe->frameMax.x - 8 -48));
		pMe->rgCmds[i].y = WALL_START_POS_Y + 56*i;//WALL_START_POS_Y=15
		pMe->rgCmds[i].unSpriteIndex = PIC_START_WALL;//13
		pMe->rgCmds[i].unSpriteSize = SPRITE_SIZE_16X16;
		pMe->rgCmds[i].unComposite = 0;
		pMe->rgCmds[i].unLayer = 0;
	}
		pMe->rgCmds[3].x = pMe->frameStart.x +20+ Random((int16) (pMe->frameMax.x - 8 -48));
		pMe->rgCmds[3].y = WALL_START_POS_Y + 56*i;//WALL_START_POS_Y=15
		pMe->rgCmds[3].unSpriteIndex = 14;
		pMe->rgCmds[3].unSpriteSize = SPRITE_SIZE_16X16;
		pMe->rgCmds[3].unComposite = 0;
		pMe->rgCmds[3].unLayer = 0;
	

	//score digit 初始分部分
	
        for (i = SPRITE_DIGIT; i < 4+SPRITE_DIGIT; i++) 
	{
		//SPRITE_DIGIT=4
		pMe->rgCmds[i].x = pMe->frameStart.x +SCORE_START_X + (i-SPRITE_DIGIT)*DIGIT_WEIGHT; 
		pMe->rgCmds[i].y = pMe->frameStart.y + 0;
		pMe->rgCmds[i].unSpriteIndex =PIC_START_DIGIT;//15
		pMe->rgCmds[i].unSpriteSize = SPRITE_SIZE_16X16;
		pMe->rgCmds[i].unComposite = 0;
		pMe->rgCmds[i].unLayer = 2;
	}
	//car
	pMe->rgCmds[SPRITE_CAR].x = pMe->frameStart.x + 50;
	pMe->rgCmds[SPRITE_CAR].y = pMe->frameStart.y + 30;
	pMe->rgCmds[SPRITE_CAR].unSpriteIndex = pMe->direction;//5
	pMe->rgCmds[SPRITE_CAR].unSpriteSize = SPRITE_SIZE_16X16;
	pMe->rgCmds[SPRITE_CAR].unComposite = 0;      //搂空
	pMe->rgCmds[SPRITE_CAR].unLayer = 1;

	//terminator
	pMe->rgCmds[SPRITE_CAR+1].unSpriteSize = SPRITE_SIZE_END;
	
	//tile
	MEMSET(pMe->rgMaps, 0, sizeof(pMe->rgMaps));
	
	pMe->rgMaps[0].pMapArray = (uint16*) pMe->BackGroundLayer;    //索引和属性数组
	pMe->rgMaps[0].x = pMe->frameStart.x;
	pMe->rgMaps[0].y = pMe->frameStart.y;
	pMe->rgMaps[0].w = MAP_SIZE_16;     //宽度尺寸
	pMe->rgMaps[0].h = MAP_SIZE_1;      //高度尺寸
	pMe->rgMaps[0].unTileSize = TILE_SIZE_16X16;
	pMe->rgMaps[0].unFlags = MAP_FLAG_WRAP;
}

//*************释放资源函数******************//
static void PottedFish_Free(PottedFish *pMe)
{
	PottedFish_UnloadResources(pMe);
}


//*************key控制函数******************//
static boolean PottedFish_HandleKeyEvent(PottedFish *pMe, AEEEvent eCode, uint16 wParam)
{
	switch (eCode) {
	case EVT_KEY_PRESS:   //按下
		switch (wParam) {
		case AVK_RIGHT:
			if (pMe->keyLeft == FALSE) 
			{
				pMe->keyRight = TRUE;
			}
			break;
		case AVK_LEFT:
			if (pMe->keyRight == FALSE)
			{
				pMe->keyLeft = TRUE;
			}
			break;
		case AVK_UP:
			if(pMe->keyDown == FALSE)
			{
				pMe->keyUp=TRUE;
			}
			break;
		case AVK_DOWN:
			if(pMe->keyUp == FALSE)
			{
				pMe->keyDown=TRUE;
			}
			break;
		default:
			return FALSE;
		}
		return TRUE;
		
		case EVT_KEY_RELEASE:     //松开
			switch (wParam) 
			{
				case AVK_RIGHT:
					pMe->keyRight = FALSE;
					break;
				case AVK_LEFT:
					pMe->keyLeft = FALSE;
					break;
				case AVK_UP:
					pMe->keyUp =FALSE;
					break;
				case AVK_DOWN:
					pMe->keyDown=FALSE;
			break;
			default:
				return FALSE;
			}
			return TRUE;
			default:
				return FALSE;
	}
}

//*************这个部分是游戏的主体，包括障碍的更新，map的更新，*//
//*************车的更新时间的控制等。******************//
static void PottedFish_NextFrame(PottedFish *pMe)
{
	int i;
	int time=140;
	
	//车的时间控制
	ISHELL_SetTimerEx(pMe->a.m_pIShell, time, &pMe->cbTimer);
	
	//车是否分解
	if (pMe->isCrash == FALSE)
	{
		pMe->isCrash = PottedFish_IsCrash(pMe);
		
		if(pMe->keyRight == TRUE )
		{
			if (pMe->direction<10) 
			{
				pMe->direction++;
			}		
		} 
		else if (pMe->keyLeft == TRUE )
		{
			if (pMe->direction>0)
			{
				pMe->direction--;
			}		
		}
		else if(pMe->keyUp == TRUE)
		{
			time=time-80;
			ISHELL_SetTimerEx(pMe->a.m_pIShell, time, &pMe->cbTimer);
		}
		else if(pMe->keyDown == TRUE)
		{
			time=time+80;
			ISHELL_SetTimerEx(pMe->a.m_pIShell, time, &pMe->cbTimer);
		}
		//update coordinate更新坐标
		pMe->rgMaps[0].y += speedTableY[pMe->direction];
		if (pMe->rgMaps[0].y >= MAX_HEIGHT) 
		{
			pMe->rgMaps[0].y -= MAX_HEIGHT;
		}
		
		//update wall
		for(i=0; i<4; i++)
		{
			if ((pMe->rgCmds[SPRITE_CAR].y >pMe->rgCmds[i].y+8-speedTableY[pMe->direction])
				&& pMe->rgCmds[SPRITE_CAR].y <= pMe->rgCmds[i].y+8) 
			{
				pMe->layer++;//分数加1
				//speedTableY[5] = { 6};
			}
			if (pMe->rgCmds[i].y < -8)
			{
				//init wall
				pMe->rgCmds[i].x = pMe->frameStart.x+16+Random((int16)(pMe->frameMax.x-16-48));
				pMe->rgCmds[i].y += 224;
				pMe->rgCmds[i].unSpriteIndex = PIC_START_WALL;
				pMe->rgCmds[i].unSpriteSize = SPRITE_SIZE_16X16;
				pMe->rgCmds[i].unComposite = 0;
				pMe->rgCmds[i].unLayer = 0;
			}
			//move wall
			pMe->rgCmds[i].y -= speedTableY[pMe->direction];
		}
		
		if ((pMe->rgCmds[SPRITE_CAR].y >pMe->rgCmds[i].y+8-speedTableY[pMe->direction])
				&& pMe->rgCmds[SPRITE_CAR].y <= pMe->rgCmds[i].y+8) 
			{
				pMe->layer++;     //分数加1

				//speedTableY[5] = { 6};
			}
			if (pMe->rgCmds[3].y < -8)
			{
				//init wall
				pMe->rgCmds[3].x = pMe->frameStart.x+20+Random((int16)(pMe->frameMax.x-16-48));
				pMe->rgCmds[3].y += 224;
				pMe->rgCmds[3].unSpriteIndex = 14;
				pMe->rgCmds[3].unSpriteSize = SPRITE_SIZE_16X16;
				pMe->rgCmds[3].unComposite = 0;
				pMe->rgCmds[3].unLayer = 0;
			}
			//move wall
			pMe->rgCmds[i].y -= speedTableY[pMe->direction];
		//update car
		pMe->rgCmds[SPRITE_CAR].x += speedTableX[pMe->direction]; 
		pMe->rgCmds[SPRITE_CAR].unSpriteIndex = pMe->direction;
		
		//update score digit
		pMe->rgCmds[SPRITE_DIGIT+0].unSpriteIndex = PIC_START_DIGIT +(pMe->layer/1000)%10;
		pMe->rgCmds[SPRITE_DIGIT+1].unSpriteIndex = PIC_START_DIGIT +(pMe->layer/100)%10;
		pMe->rgCmds[SPRITE_DIGIT+2].unSpriteIndex = PIC_START_DIGIT +(pMe->layer/10)%10;
		pMe->rgCmds[SPRITE_DIGIT+3].unSpriteIndex = PIC_START_DIGIT +pMe->layer%10;
	} 
	else
	{
		if(pMe->crashCounter == 1)
		{
			//update image to crash car
			pMe->rgCmds[SPRITE_CAR].x -= 8;
			pMe->rgCmds[SPRITE_CAR].y -= 8;
			pMe->rgCmds[SPRITE_CAR].unSpriteIndex = 0;
			pMe->rgCmds[SPRITE_CAR].unSpriteSize = SPRITE_SIZE_32X32;
			pMe->rgCmds[SPRITE_CAR].unComposite = 0;
			pMe->rgCmds[SPRITE_CAR].unLayer = 1;
		}
		else if (pMe->crashCounter == 4) 
		{
			//update crash image
			pMe->rgCmds[SPRITE_CAR].unSpriteIndex = 1;
		} 
		else if (pMe->crashCounter == 7) 
		{
			//game over
		//	ISHELL_CloseApplet(pMe->a.m_pIShell,FALSE);
			GameOver(pMe);

		}
		pMe->crashCounter++;
	}
	
	//update tiles and sprites
	ISPRITE_DrawTiles(pMe->pISprite, pMe->rgMaps);
	ISPRITE_DrawSprites(pMe->pISprite, pMe->rgCmds);
	IDISPLAY_Update(pMe->a.m_pIDisplay);
		
}

//*************加载资源函数******************//
static int PottedFish_LoadResources(PottedFish *pMe)
{
	IBitmap	*pbmScreen;
	
	//creates instance of ISprite
	ISHELL_CreateInstance(pMe->a.m_pIShell, AEECLSID_SPRITE, 
		(void**)&pMe->pISprite);
	//sets IDisplay as its destination
	pbmScreen = IDISPLAY_GetDestination(pMe->a.m_pIDisplay);
	ISPRITE_SetDestination(pMe->pISprite, pbmScreen);
	IBITMAP_Release(pbmScreen);
	
	//load image for tile
	PottedFish_LoadSprites(pMe, "bg16.bmp", TILE_SIZE_16X16, TRUE);
	
	//load image for sprite
	PottedFish_LoadSprites(pMe, "sprite16.bmp", SPRITE_SIZE_16X16, FALSE);
	PottedFish_LoadSprites(pMe, "sprite32.bmp", SPRITE_SIZE_32X32, FALSE);
	
	return SUCCESS;
}

//*************加载sprite******************//
static void PottedFish_LoadSprites(PottedFish *pMe, const char * pszFile, 
							 uint8 unSpriteSize, boolean isTile)
{
	IBitmap       *pbmScreen = NULL;
	IBitmap       *pbmDib = NULL;
	IBitmap       *pbmDdb = NULL;
	NativeColor    color;
	AEEBitmapInfo  bi;
	
	pbmScreen = IDISPLAY_GetDestination(pMe->a.m_pIDisplay);
	
	pbmDib = ISHELL_LoadBitmap(pMe->a.m_pIShell, pszFile);
	IBITMAP_GetInfo(pbmDib, &bi, sizeof(bi));
	IBITMAP_CreateCompatibleBitmap(pbmScreen, &pbmDdb, (uint16)bi.cx, (uint16)bi.cy);
	IBITMAP_BltIn(pbmDdb, 0, 0, (uint16)bi.cx, (uint16)bi.cy, pbmDib, 0, 0, AEE_RO_COPY);
	IBITMAP_Release(pbmDib);
	IBITMAP_GetPixel(pbmDdb, 0, 0, &color);
	IBITMAP_SetTransparencyColor(pbmDdb, color);
	if (isTile == TRUE)
	{
		ISPRITE_SetTileBuffer(pMe->pISprite, unSpriteSize, pbmDdb);
	}
	else 
	{
		ISPRITE_SetSpriteBuffer(pMe->pISprite, unSpriteSize, pbmDdb);
	}
	IBITMAP_Release(pbmDdb);
	IBITMAP_Release(pbmScreen);
}

//*************释放资源函数******************//
static void PottedFish_UnloadResources(PottedFish *pMe)
{
	if (pMe->pISprite)
	{
		ISPRITE_Release(pMe->pISprite);
		pMe->pISprite = NULL;
	}
}
//*************碰撞的判断******************//
static boolean PottedFish_IsCrash(PottedFish *pMe)
{
	int i;
	//判断是否撞边
	if (pMe->rgCmds[SPRITE_CAR].x - pMe->frameStart.x < 8 
		|| pMe->rgCmds[SPRITE_CAR].x - pMe->frameStart.x > pMe->frameMax.x - 24) 
	{
		return TRUE;
	}
	//判断是否撞到障碍
	for(i=0; i<4; i++)
	{
		if (pMe->rgCmds[SPRITE_CAR].x >= pMe->rgCmds[i].x-13 && pMe->rgCmds[SPRITE_CAR].x <= pMe->rgCmds[i].x+13) 
		{
			if (pMe->rgCmds[SPRITE_CAR].y >= pMe->rgCmds[i].y-14 && pMe->rgCmds[SPRITE_CAR].y <= pMe->rgCmds[i].y+14) {
				return TRUE;
			}
		}
	}
	return FALSE;
}
//*************随即函数******************//
static int16 Random(int16 range)
{
	uint16 rand;
	GETRAND((byte *)&rand,2);
	//生成随机字节，第一个参数存放随机字节的地方，第二个参数字节大小
	return range == 0 ? 0 : rand%range;
}

//*************背景音乐******************//
void PlayBGMedia(PottedFish *pMe)        //背景音效
{	
	AEEMediaData pmd;
	if(pMe->pIMedia)
	{
		IMEDIA_Stop(pMe->pIMedia);
		IMEDIA_RegisterNotify(pMe->pIMedia,NULL,NULL);
		IMEDIA_Release(pMe->pIMedia);
	}
	ISHELL_CreateInstance(pMe->a.m_pIShell,AEECLSID_MEDIAMIDI,(void**)&pMe->pIMedia);				
	pmd.clsData=MMD_FILE_NAME;
	pmd.pData=(void**)"12.mid";     //实际的数据指针
	pmd.dwSize=0;

	IMEDIA_SetMediaData(pMe->pIMedia,&pmd);                        //设置MEDIA数据
	IMEDIA_RegisterNotify(pMe->pIMedia,NULL/*MediaNotify*/,pMe);   //注册回调函数

	pMe->m_bIsContinue=TRUE;	//设置连续播放
	IMEDIA_Play(pMe->pIMedia);	//开始播放
}
//*************游戏结束******************//
void GameOver(PottedFish* pMe)
{
	IImage *pImage;
//	AEEImageInfo info;
	int mx=50,my=60;

	//音乐停止
	IMEDIA_Stop(pMe->pIMedia);
	IDISPLAY_ClearScreen(pMe->a.m_pIDisplay);
	pImage = ISHELL_LoadImage(pMe->a.m_pIShell,"logo.bmp");
	IIMAGE_Draw(pImage,mx,my);
	IDISPLAY_Update(pMe->a.m_pIDisplay);
	IIMAGE_Release(pImage);
	ISHELL_SetTimerEx(pMe->a.m_pIShell,10000,&pMe->cbtime);
	ISHELL_CloseApplet(pMe->a.m_pIShell,FALSE);
}