状態遷移の考え方をすればいいんですよ。



ボスの初期状態を0としましょう。

状態0のままＨＰは段々減少していきます。

そして今800に差し掛かったとしましょう。



if(状態==0 && boss.hp<800){

　　エフェクト発動;

　　状態=1;

}



こうすればスキップされません。

さらに400以下になったときにまたエフェクトをかけたければ



if(状態==1 && boss.hp<400){

　　エフェクト発動;

　　状態=2;

}



こんな感じでしょう。

大ボスが第二形態に変身したりするようなエフェクトなら

バグさんの仰る方法がいいかもしれませんし、

もし東方風にやるなら状態遷移でしょう。



＞またHPの表示もそれぞれの部分で設定して

＞やらねばならず非常にプログラムが効率悪くなってしまいました 



ＨＰの表示を設定するとはどういうことでしょうか？

ＨＰの表示は描画部のボス担当部分でやればいいだけだと思います。



＞HPをそれぞれの弾幕に応じて設定してやればいいのではと思いましたが 

＞ボスを普通の敵と同じ構造体で扱っているためHPが0になると消滅してしまい…ｗ 

＞ボスの出現フラグを2などとしてみるなどすればいいのでしょうが… 



実は私もボスの構造体と雑魚の構造体は同じ物を使っています。

弾の量は違いますが、そこはベクターでどうにでも増えますし。

構造が同じなら同じ関数で処理できるのでこちらの方が楽なんですよね。



私は雑魚が死んだ状態で雑魚が発射した弾がまだ残っている時は２のフラグを

使っているのでボスは10にしました。

まぁその辺どうでもいいですが。

別にフラグが10の時は0になっても規定回数復活するようにすればいいと思いますよ。

if     (状態==0 && key[KEY_INPUT_D]==2)

    状態=1;

else if(状態==1 && key[KEY_INPUT_E]==2)

　　状態=2;

else if(状態==2 && key[KEY_INPUT_B]==2)

　　状態=3;

else if(状態==3 && key[KEY_INPUT_U]==2)

　　状態=4;

else if(状態==4 && key[KEY_INPUT_G]==2)

　　状態=5;

else if(他のキー入力があった)

　　状態=0;



if(状態==5){

　　デバッグモード発動;

　　状態=0;

}



こんな感じで状態が5になればデバッグモード発動です。

昔ストツーとかで

上Ｒ下ＬＹＢＸＡとかで裏ワザやったと思いますが、そういうのも状態遷移ではないでしょうか。

	if(enemy[i].counter%180==0){//180カウントに一回移動する角度を決める

		if(Player.x-enemy[i].x>0&&enemy[i].y<160&&enemy[i].x<340)

			enemy[i].angle=atan2(GetRand(5),GetRand(10));//右下へ移動

		if(Player.x-enemy[i].x<0&&enemy[i].y<160&&enemy[i].x>100)

			enemy[i].angle=atan2(GetRand(5),-GetRand(10));//左下へ移動

		if(Player.x-enemy[i].x>0&&enemy[i].y>160&&enemy[i].x<340)		

			enemy[i].angle=atan2(-GetRand(5),GetRand(10));//右上へ移動	

		if(Player.x-enemy[i].x<0&&enemy[i].y>160&&enemy[i].x>100)

			enemy[i].angle=atan2(-GetRand(5),-GetRand(10));//左上へ移動

	}		

	if(enemy[i].counter%180<60){//180カウントの内、60カウント間移動

		enemy[i].x+=3.0f*cos(enemy[i].angle);

		enemy[i].y+=3.0f*sin(enemy[i].angle);

	}

int main(){

  int Data[10][10];　

  int x,y,x2,y2,csum; 

  bool CFlg; 

/* x=たて　y=よこ */



/* 配列初期化 */

  for(x=0;x<10;x++){

    for(y=0;y<10;y++){

      Data[x][y]=0;

    }

  }



  for(x=0;x<8;x++){

    for(y=0;y<8;y++){

      /* チェックの基点となる座標をチェック */

      if(Data[x][y]==1){

        csum=0;

/* 3×3マスを集計する */

        for(x2=x;x2<x+2;x2++){

          for(y2=y;y2<y+2;y2++){

            csum *= Data[x2][y2];

          }

        }

/* 集計結果=1　・・・3×3マス全てが1 */

        if(csum==1){

          CFlg=True;

        } 

      }

    }

  }

}

   if(Data[x][y]==1){

        csum=1;

    ・

　　・

　　・

   if(Data[x][y]==1){

        csum=Data[x][y];

void CheckTable(bool pResult[TABLE_WIDTH][TABLE_HEIGHT], bool pTable[TABLE_WIDTH][TABLE_HEIGHT], int iPosX, int iPosY)

{

	for (int x = iPosX; x < iPosX + 3; x++)

	{

		for (int y = iPosY; y < iPosY + 3; y++)

		{

			// 配列の領域外が指定された場合は、それ以上の処理は無駄なので何もしない

			if (x < 0 || x >= TABLE_WIDTH ||

				y < 0 || y >= TABLE_HEIGHT)

				return;



			// 検査箇所の内、1箇所でもfalseが見つかった場合は、それ以上の処理は無駄なので何もしない

			if (pTable[x][y] == false)

				return;

		}

	}



	// 3×3マスが全てtrueだったので、バッファの3×3マスにtrueを代入する

	for (int x = iPosX; x < iPosX + 3; x++)

		for (int y = iPosY; y < iPosY + 3; y++)

			pResult[x][y] = true;

}

if(上方向が押されている){

	if(xが32で割り切れない位置){

		if(座標%32>=16)

			右に進ませる;

		else

			左に進ませる;

	}

	else{

		上に進ませる;

	}

}

if(下が押された){

	…

	if(左下が壁){

		（キャラのx座標）+=0.5+（0.5*スピード）;

	}

	（キャラのy座標）+=0.5+（0.5*スピード）;

	…

}

unsigned char STAGE_MAP_DATA[20*15]={

	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,

	0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, 0,0,0,0,0,

	0,1,0,1,0,1,0,1,0,1,0,1,0,1,0, 0,0,0,0,0,

	0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, 0,0,0,0,0,

	0,1,0,1,0,1,0,1,0,1,0,1,0,1,0, 0,0,0,0,0,

	0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, 0,0,0,0,0,

	0,1,0,1,0,1,0,1,0,1,0,1,0,1,0, 0,0,0,0,0,

	0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, 0,0,0,0,0,

	0,1,0,1,0,1,0,1,0,1,0,1,0,1,0, 0,0,0,0,0,

	0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, 0,0,0,0,0,

	0,1,0,1,0,1,0,1,0,1,0,1,0,1,0, 0,0,0,0,0,

	0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, 0,0,0,0,0,

	0,1,0,1,0,1,0,1,0,1,0,1,0,1,0, 0,0,0,0,0,

	0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, 0,0,0,0,0,

	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0

};

//キャラの上側のブロック当たり判定。0:動けない  1:動ける

unsigned char BlockJudge_U(int x,int y,unsigned char *map){

	if( map[ ((y+16)/16)*20 + (x+8)/16 ] == 0 ) return 0;

	else return 1;

};

if( Key[ KEY_INPUT_UP ] ){		//上ボタンが押されたら

	if(BlockJudge_U((int)ch.x,(int)ch.y,STAGE_MAP_DATA)==1){	//上が動けるブロックで

		if( (int)ch.x%16!=0 ){					//微妙な位置のとき、

			if( BlockJudge_L((int)ch.x,(int)ch.y-16,STAGE_MAP_DATA)==1 )	//左上が動けるなら（-16は1ブロック上の意）

				ch.x-=(0.5+ch.speed*0.5);				//xの値を１減らす

			if( BlockJudge_R((int)ch.x,(int)ch.y-16,STAGE_MAP_DATA)==1 )	//右上が動けるなら

				ch.x+=(0.5+ch.speed*0.5);				//xの値を１増やす

		}

		ch.y-=(0.5+ch.speed*0.5);				//yの値を１減らす

	}

}

unsigned char STAGE_MAP_DATA[15][20]=

{

	{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0},

	{0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, 0,0,0,0,0},



（略）



	{0,1,1,1,1,1,1,1,1,1,1,1,1,1,0, 0,0,0,0,0},

	{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0}

};



こういう形で初期化したとき、[y][x]になるので気をつけて下さい。

現在属している配列要素が



map[y][x]だとしたら、

上にいけるかどうかは単純に言えば



if(map[y-1][x]==1)

    return 通れる;



で判定できます。まぁここの判定は仰るようにちょっと面倒なわけですが。





そして



ch.x-=(0.5+ch.speed*0.5);



このspeedが大きいと、16の倍数の座標を通り越してしまうということが

問題だと仰っているのでしょうか？

足し算をするとき、私はループ分で行いました。



ch.x += 3;



じゃなく、



for(i=0;i<3;i++){

    ch.x += 1;

    if(ch.xが境界線なら)

        break;

}



こうすれば、境界線を踏み越える事がありません。

言語はC++ですか？Cだと、



>	void change(int, char **);

>	void sort(int, char **);



ここのところで、「ここで宣言はできない」という内容の

コンパイルエラーが出るはずですからね。



というわけで、上記はプロトタイプ宣言の書き方です。

change関数とsort関数を宣言しているだけで実行していません。



両関数の内容そのものは正しいようです。

main関数から、正しく呼び出してください。

#include<stdio.h>



void change(int, char **);

void sort(int, char **);



int main(int argc, char *argv[])

{

	int i;

	int cnt;

	int pp;



	if(argc <= 2)

	{

		printf("\nUsage %s STRING1 STRING2 [STRING3 ... ]\n",&argv[0]);　/*�@*/

		return 1;

	}



	printf("\n** String data **");

	

	for(i = 1; i < argc; ++i)

	{

		printf("\n%s",argv[i]);　　/*�A*/

	}



	printf("\n\n");



	change(argc, argv);　　/*�Bargc,argvどちらも*/

	sort(argc, argv);　　　/*�Cargc,argvどちらも*/



	printf("** Changed string **");



	for(i = 1; i < argc; ++i)

	{

		printf("\n%s",argv[i]);　　/*�D*/

	}

	

	printf("\n");



	return 0; 

}



void change(int cnt, char **pp)

{

	int i;

	char *p;

	

	for(i = 1; i < cnt; i ++)

	{

		for(p = pp[i]; *p !='\0'; p++)

		{

			if((*p>='a')&&(*p<='z'))

			{

				*p = *p - 'a' + 'A';

			}

		}

	}

}



void sort(int cnt, char **pp)

{

	int i;

	int j;

	int k;

	char *p;



	for(i = 0; i < cnt-1; i++)

	{ 

		for(j = cnt-1; 1 + i < j; j--)

		{

			for(k = 0; pp[j][k] == pp[j-1][k]; k ++);

			{

				if(pp[j][k] < pp[j-1][k])

				{

					p = pp[j];

					pp[j] = pp[j-1];

					pp[j-1] = p;

				}

			}

		}

	}

}

#include <stdio.h>



int main(void)

{

	int a[3],i;

	for(i=0;i<3;i++)

		printf("&a[%d]: %p\n",i,&a[i]),

		printf("(a+%d): %p\n",i,(a+i)),

		printf("\n");

 	return 0;

}

void sort(int cnt, char **pp)

{

	int i;

	int j;

	int k;

	char *p;



	for(i = 0; i < cnt-1; i++)

	{ 

		for(j = cnt-1; 1 + i < j; j--)

		{

			for(k = 0; *(*pp+j+k) == *(*pp+(j-1)+k); k ++);

			{

				if(*(pp+j+k) < *(pp+(j-1)+k))

				{

					*p = *(*pp+j);

					*(*pp+j) = *(*pp+(j-1));

					*(*pp+(j-1)) = *p;

				}

			}

		}

	}

}

３重ループではなく、２重ループでできるのではないか、

と思います。

また、



> 			for(k = 0; *(*pp+j+k) == *(*pp+(j-1)+k); k ++);



最後のセミコロンは、何を意味しているのでしょうか？

void sort(int cnt, char **pp)

{

	int i;

	int j;

	int k;

	char *p;



	for(i = 0; i < cnt-1; i++)

	{ 

		for(j = cnt-1; 1 + i < j; j--)

		{

			for(k = 0; *(*((pp+j)+k)) == *(*((pp+(j-1))+k)); k++)

			{

				if(*(*((pp+j)+k)) < *(*((pp+(j-1))+k)))

				{

					*p = *(*(pp+j));

					*(*(pp+j)) = *(*(pp+(j-1)));

					*(*(pp+(j-1))) = *p;

				}

			}

		}

	}

}

#include <stdio.h>



int main(void)

{

    printf("%c\n", 3["abcde"]);

    return 0;

}

enum {

    CH_CHANGE_NUM1_IDX0,

    CH_CHANGE_NUM1_IDX1,

    CH_CHANGE_NUM1_IDX2,



    CH_CHANGE_NUM1,

};



int img_cshot1[CH_CHANGE_NUM1];

img_cshot1[CH_CHANGE_NUM1_IDX0] = 0;

#include <iostream>

#include <vector>



int main(void)

{

    std::vector<int> ary(4);

    

    try {

        ary.at(5) = 10;

    } catch (std::out_of_range e) {

        std::cout << "配列オーバー：" << e.what() << std::endl;

    }

    return 0;

}

#include <iostream>

#include <vector>



template<class T>

class myvector : public std::vector<T> {

public :

	myvector(int n) :

	   std::vector<T>(n)

	{

	}

	~myvector() {

		std::vector<T>::~vector();

	}



	T& at(int idx, const char* file, int line) {

		if (idx < 0 || (unsigned int)idx >= size()) {

			std::cout << file << "：" << line << "行目 " << "配列オーバー" << std::endl;

			throw std::out_of_range("invalid myvector<T> subscript");

			//return std::vector<T>::operator[](0);

		}

		return std::vector<T>::operator[](idx);

	}

	const T& at(int idx, const char* file, int line) const {

		if (idx < 0 || (unsigned int)idx >= size()) {

			std::cout << file << "：" << line << "行目 " << "配列オーバー" << std::endl;

			throw std::out_of_range("invalid myvector<T> subscript");

			//return std::vector<T>::operator[](0);

		}

		return std::vector<T>::operator[](idx);

	}



	T& operator [](int idx) {

		if (idx < 0 || (unsigned int)idx >= size()) {

			std::cout << "配列オーバー：" << idx << std::endl;

			throw std::out_of_range("invalid myvector<T> subscript");

			//return std::vector<T>::operator[](0);

		}

		return std::vector<T>::operator[](idx);

	}

	const T& operator [](int idx) const {

		if (idx < 0 || (unsigned int)idx >= size()) {

			std::cout << "配列オーバー：" << idx << std::endl;

			throw std::out_of_range("invalid myvector<T> subscript");

			//return std::vector<T>::operator[](0);

		}

		return std::vector<T>::operator[](idx);

	}

};

#define at(n)		at(n, __FILE__, __LINE__)



int main(void)

{

	myvector<int> vec(1);



	try {

		vec[1] = 20;

	} catch (...) {

	}

	try {

		vec.at(1) = 20;

	} catch (...) {

	}



	return 0;

}

#include <iostream>

using namespace std;



class Hoge

{

	public:

	Hoge(){cout << "begin Hoge" << endl;}

	~Hoge(){cout << "end Hoge" << endl;}

	

};



class HogeHoge :public Hoge

{

	public:

	HogeHoge(){cout << "begin HogeHoge" << endl;}

	~HogeHoge(){cout << "end HogeHoge" << endl;}

};



int main()

{

	Hoge *p = new HogeHoge;

	delete p;

	return 0;

}

#ifdef _DEBUG

    typedef myvector<int> IntArray;

#else

    typedef std::vector<int> IntArray;

#endif

struct BulletData {

    int x, y, flg;

} bullet[100];

for (int i = 0; i < 100; ++i) {

    BulletData* p = &bullet[i];

    if (p->flg != 0) {

        p->x = 0;

        p->y = 0;

    }

}

template<class T>

class myvector : public std::vector<T> {

・・・

};



boost::shared_ptr<myvector<int> > vec;

int i, j, tate, yoko;



scanf("たて",&tate);

scanf("よこ",&yoko);



for(i=0;i<tate;i++){

  for(j=0;j<yoko;j++){

    printf("*");

  }

  printf("\n");

}

#include <stdio.h>



int main(void)

{

	int i,j;

	int x_Length=10, y_Length=10;

	for(i=0;i<y_Length;i++){

		for(j=0;j<x_Length;j++){

			if(j>=i && j<=i+4)

				printf("*");

			else

				printf(" ");

		}

		printf("\n");

	}

	printf("\n");

    return 0;

}





実行結果



*****

 *****

  *****

   *****

    *****

     *****

      ****

       ***

        **

         *

#include <iostream>

struct Data

{

	char name; 

	char job; 

	int hp, mp; 

};



class Charactor

{

public:

	Data data;

	void setData(){

	 	data.name = 'A';

		data.job = 'b';

		data.hp = 3;

		data.mp =1;

	}

};



class War

{

public:

	Data *p_data;

	War(Data *data)

	{

	 	this->p_data = data;

	}

	void showData()

	{

	 	std::cout << "data.name: " << this->p_data->name << std::endl;

		std::cout << "data.job:  " << this->p_data->job	 << std::endl;

		std::cout << "data.hp:  " << this->p_data->hp	 << std::endl;

		std::cout << "data.mp:  " << this->p_data->mp	 << std::endl;

	}

};



int main()

{

	Charactor chara; 

	War war(&chara.data);

	

	chara.setData();

	war.showData();

};

ThreadException(std::exception e):exception("Thread"),name(e.what()){}

ThreadException():exception("Thread"){}

ThreadException(const char * e)  :exception("Thread"),name(e){}

ThreadException operator=(ThreadException &e){return e;}

ThreadException& operator=(const ThreadException &e)

{

  std::string t(e.name);

  name.swap(t);

  return *this;

}

const char * getName(){return this->name.c_str();}

    {

        Thread thread1(std::bind2nd(std::ptr_fun(&bar2), critical));

    }        //ここでリーク

    {

        Thread thread1(std::bind2nd(std::ptr_fun(&bar1), &critical));

    }

    template<typename Run>

    class Thread<ThreadRunHolder<Run> >

    {

        ...

    };

    struct caller_run_void

    {

        template <typename T>

        static void run(ValueType &r, T)    { r.run(); }

    };

    struct caller_run_other

    {

        template <typename T>

        static void run(ValueType &r, T v)  { r.run(v); }

    };

    template <typename T, typename U>

    struct IsSameType       { enum { Result = false }; };

    template <typename T>

    struct IsSameType<T, T> { enum { Result = true }; };

    

    template <bool flag, typename T, typename U>

    struct SelectType               { typedef T Type; };

    template <typename T, typename U>

    struct SelectType<false, T, U>  { typedef U Type; };



    typedef SelectType<IsSameType<F, NullType>::Result, caller_run_void, caller_run_other>::Type Caller;

    Caller::run(run, *pf.t);

	void ThreadDetail::BaseParam::Wait()

	{

		if(started)	return;

		

		DWORD result = WaitForSingleObject(start_handle, INFINITE);

		if(result == WAIT_OBJECT_0)

		{

			CloseHandle(start_handle);

			start_handle =  0;

			started = true;

		}

		else

			throw ThreadLogicException();

	}