示例#1
0
enum ActionMenu StageMain(int *stageState, char *mapName)
{
    static int bgm = - 1;
    static char name[MAX_PATH];
    
    switch (*stageState) {
    case 0:
        map = ReadMap(mapName);
#if !MAP_EDIT_MODE
        GetBgmName(name, mapName);
        bgm = LoadSound(name);
#endif        
        *stageState = 1;
        break;

    case 1:
        {
            InitMap(map);
            CreateObject(map);
            DrawMain = StageDraw;
            LoopSound(bgm);
            *stageState = 2;
        }
        break;

    case 2:
            MoveMap(map);
            MoveEnemy(map);
            MoveItem(map);
            MoveBomb(map);
            MoveEnemy(map);
            MovePlayer(map);
            if (IsPlayerDie()) {
                SoundPlay(res.sound_die);
                life--;
                if (life < 0) {
                    FreeStage(map, stageState, bgm);
                    return MENU_GAMEOVER;
                }
                *stageState = 1;
            }
            if (IsPlayerClear()) {
                FreeStage(map, stageState, bgm);
                return MENU_CLEAR;
            }
            break;
    }
    return MENU_STAGE;
}
// 보스를 움직이기:
// 보스를 구성하는 모든 적기에 대하여 순서대로 처리를 수행함.
void MoveComplexEnemy(COMPLEX_ENEMY* ce) {
	for (int i=0; i<ce->NumPart; i++) {

		// 적기를 움직이기:
		// 구체적인 처리는 MoveEnemy함수에서 수행함.
		MoveEnemy(ce->Part[i]);

		// 적기를 표시하기:
		// 모든 부품이 하나가 되어 움직이도록
		// 부품의 좌표를 보스 좌표로부터 상대 위치가 되도록 사용함.
		// 보스 전체를 움직이기 위해서는 ce->X와 ce->Y를 갱신함.
		// 구체적인 처리는 DrawEnemy함수에서 수행함.
		DrawEnemy(ce->Part[i],
			ce->Part[i]->X+ce->X, ce->Part[i]->Y+ce->Y);

		// 적기의 파괴:
		// 판정과 파괴의 구체적인 처리는 각각
		// Destroyed,DeleteEnemy함수에서 수행함.
		if (Destroyed(ce->Part[i])) {
			DeleteEnemy(ce->Part[i]);

			// 보스 전체의 파괴:
			// 치명적인 부품이 파괴되었을 때는
			// 보스 전체를 파괴시킴.
			if (ce->Fatal[i]) DeleteEnemy(ce);
		}
	}
}
示例#3
0
void Slowing(
	int& gauge,  // 슬로우 상태로 전환하기 위해 필요한 게이지
	bool button  // 슬로우 버튼을 눌렀는지 나타내는 플래그
) {
	// 타이머:
	// 슬로우 상태일 때 행동회수를 조절하기 위해 사용함.
	static int time=1;

	// 적기와 탄을 이동시킴:
	// 보통 상태일 때는 매번 이동시키고
	// 슬로우 상태일 때는 2번에 1번만 움직임.
	// 이동의 구체적인 처리는
	// MoveEnemy, MoveBullet 함수에서 수행하기로 함.
	if (!button || (gauge>0 && time==0)) {
		MoveEnemy();
		MoveBullet();
	}
	
	// 페널티:
	// 게이지가 0인데 슬로우 버튼을 눌렀다면
	// 페널티로서 탄을 1번 더 이동시킴.
	// 결과적으로 탄이 2배의 속도로 움직이게 됨.
	if (button && gauge==0) {
		MoveBullet();
	}

	// 타이머의 갱신
	if (time>0) time--; else time=1;
}
示例#4
0
// 게임 로직 처리
void PlayGame() {
  while(!game_quit) {
    Input();
    UpdateGameQuit();
    UpdateTime();
    MovePlayer();
    UseItem();
    MoveEnemy();
    MoveEffect();
    MoveBomb();
    Draw();
  }
}
示例#5
0
int DvigChel_1 (int x, int y)
{
     int time_end     = clock();

     Point_t loc      = {x, y};

     Score_t score    = {0};

     Chel_t chel      = {&loc, SPEED};

     Reaction_t react = {&loc, &score};

     PointEN_t locEN  = {291, 195, 5, 5};

     PointEN_t locEN2 = {500, 500, 1, 1};

     PointEN_t locEN3 = {400, 550, 4, 4};

     int time         = 0;

     int counter      = -2;

     int counteren    = 0;

     DrawLevel();

     HDC Cover        = txLoadImage ("Resourses\\Images\\Cover.bmp");

     txPlaySound ("Resourses\\Music\\track_1.wav", SND_ASYNC);

     DrawArbuz (386, 59);
     DrawArbuz (449, 269);
     DrawArbuz (95, 402);
     DrawArbuz (345, 449);
     DrawArbuz (723, 491);
     DrawArbuz (703, 294);

     while (1)
     {
        txBegin();

        DrawTimeTable();

        Interface      (&score, &time, &time_end);

        DrawWalls_1();

        Bonus (&score);

        txSetColor     (TX_YELLOW);
        txSetFillColor (TX_YELLOW);
        txRectangle    (locEN.x - 13, locEN.y - 13, locEN.x + 13, locEN.y + 13);

        MoveEnemy (&locEN);

        counteren++;

        if (counteren % 12 < 5) DrawEnemy_1 (&locEN);

        else
            if (counteren % 12 < 9) DrawEnemy_2 (&locEN);

            else DrawEnemy_3 (&locEN);

        if ((loc.x < locEN.x + 14) &&
            (loc.x > locEN.x - 12) &&
            (loc.y < locEN.y + 13) &&
            (loc.y > locEN.y - 12)) return 0;

        txSetColor     (TX_YELLOW);
        txSetFillColor (TX_YELLOW);
        txRectangle    (locEN2.x - 13, locEN2.y - 13, locEN2.x + 13, locEN2.y + 13);

        MoveEnemy (&locEN2);

        counteren++;

        if (counteren % 12 < 5) DrawEnemy_1 (&locEN2);

        else
            if (counteren % 12 < 9) DrawEnemy_2 (&locEN2);

            else DrawEnemy_3 (&locEN2);

        if ((loc.x < locEN2.x + 14) &&
            (loc.x > locEN2.x - 12) &&
            (loc.y < locEN2.y + 13) &&
            (loc.y > locEN2.y - 12)) return 0;

        txSetColor     (TX_YELLOW);
        txSetFillColor (TX_YELLOW);
        txRectangle    (locEN3.x - 13, locEN3.y - 13, locEN3.x + 13, locEN3.y + 13);

        MoveEnemy (&locEN3);

        counteren++;

        if (counteren % 12 < 5) DrawEnemy_1 (&locEN3);

        else
            if (counteren % 12 < 9) DrawEnemy_2 (&locEN3);

            else DrawEnemy_3 (&locEN3);

        if ((loc.x < locEN3.x + 14) &&
            (loc.x > locEN3.x - 12) &&
            (loc.y < locEN3.y + 13) &&
            (loc.y > locEN3.y - 12)) return 0;

        txTransparentBlt (txDC(), loc.x - 10, loc.y - 10, 21, 21, Cover, 0, 0, TX_WHITE);

        if (Controls (&react) == 1)   {DrawChel_1 (&loc); return 0;};

        if (ReactionEnd1 (&loc) == 1) 
                         {
                                if (score.points > 400) return score.points + 20 - time;
                         };
                         
        if (time > 40) return 0;

        counter++;

        if (counter > 2) counter = -2;

        if (counter < 0) DrawChel_1 (&loc);

           else DrawChel_2 (&loc);

		if (GetAsyncKeyState ('M')) sleep--;
		if (sleep < 0) sleep = 0;
        if (GetAsyncKeyState ('P')) sleep++;

        if (GetAsyncKeyState (VK_ESCAPE)) MenuInGame(&loc, 1);

        Sleep (sleep);
     }

     time_end = time;

     txDeleteDC (Cover);
}
// 허공에 나타나는 적기의 처리
void EmergingEnemy(
	int num_enemy,           // 적기의 갯수
	STATE_TYPE state[],      // 적기의 상태
	float ex[], float ey[],  // 적기의 좌표
	float alpha[],           // 알파 값
	int timer[]              // 타이머
) {
	// 모든 적기에 대하여 처리
	for (int i=0; i<num_enemy; i++) {
		
		// 상태에 따라 분기
		switch (state[i]) {
			
			// 준비(등장전):
			// 알파 값과 타이머 값을 초기화하고
			// 등장 상태로 이동.
			case READY:
				state[i]=APPEAR;
				alpha[i]=0;
				timer[i]=TIME;
				break;
			
			// 등장:
			// 알파 값을 점점 늘려줌.
			// 타이머가 0이 되었다면 활동 상태로 이동.
			case APPEAR:
				alpha[i]=(float)(TIME-timer[i])/TIME;
				timer[i]--;
				if (timer[i]==0) {
					state[i]=ACT;
					timer[i]=ACT_TIME;
				}
				break;
			
			// 활동:
			// 이동, 공격을 수행.
			// 타이머가 0이 되었다면 소실 상태로 이동.
			// 이동이나 공격의 구체적인 처리는
			// MoveEnemy 함수에서 수행하기로 함.
			case ACT:
				MoveEnemy(i);
				timer[i]--;
				if (timer[i]==0) {
					state[i]=DISAPPEAR;
					timer[i]=TIME;
				}
				break;
			
			// 소실:
			// 알파 값을 점점 작게 해 줌.
			// 타이머가 0이 되었다면 적기를 제거함.
			// 적기를 제거하는 구체적인 처리는
			// DeleteEnemy 함수에서 수행하기로 함.
			case DISAPPEAR:
				alpha[i]=(float)timer[i]/TIME;
				timer[i]--;
				if (timer[i]==0) {
					DeleteEnemy(i);
				}
				break;
		}
		
		// 적기의 표시:
		// 알파 값에 따라 알파 합성(알파 블렌딩)을 해서 표시함.
		DrawEnemy(ex[i], ey[i], alpha[i]);
	}
}
示例#7
0
void EnemyActions(const int frameTicks)
{
	MoveEnemy(frameTicks);
	MoveEnemyBullets(frameTicks);
}