main.cpp

以前写的一个bughunt小游戏

#include <iostream>

#include <string>

#include <assert.h>

#include "ezwin.h"

#include "rect.h"

#include "ellipse.h"

#include "bitmap.h"

#include "uniform.h"

#include "time.h"

#include "CBug.h"

#include "CMan.h"

#include <vector>

using namespace std;

//////////////////////////////////////////////////////////////////////////

SimpleWindow W("                                  @_&  Rubish BugHunt of EzWin  Writer: @_&",24,16,Position(3,3));

float Time=0;

//////////////////////////////////////////////////////////////////////////

CMan man;

CMan helpman;

vector<CBug> bug;

vector<int> BugAlive;

int nBugAttack=0;

int nstring=0;

//////////////////////////////////////////////////////////////////////////


BitMap up,down,lef,righ,attack;

BitMap bmstart,bmend;

int tEraseorDarw=0;

//////////////////////////////////////////////////////////////////////////

int level=1;

//////////////////////////////////////////////////////////////////////////

int Start(const Position &MousePosn);

int MouseClick(const Position &MousePosn);

int PlayGame();

int ActionOfAll();

int CheckHurt();

int Start(const Position &MousePosn)
{

if(bmstart.IsInside(MousePosn))

PlayGame();

else if(bmend.IsInside(MousePosn))

W.Close();

return 0;

}

int ApiMain()

{

W.Open();

assert(W.GetStatus() == WindowOpen);

W.RenderRectangle(Position(0,0),Position(24,16),Cyan);

bmstart.SetWindow(W);

bmstart.Load("end.bmp");

bmstart.SetPosition(Position(11,5));

bmstart.Draw();

bmend.SetWindow(W);

bmend.Load("start.bmp");

bmend.SetPosition(Position(11,8));

bmend.Draw();

W.SetMouseClickCallback(Start);

return 0;

}

int ApiEnd()
{

	W.Close();

	return 0;

}

int PlayGame()

{

W.Erase(Position(0,0),25,18);

bug.clear();

BugAlive.clear();

nBugAttack=0;

nstring=0;

int tEraseorDarw=0;

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//Draw Game Control

up.Load("up.bmp");

up.SetWindow(W);

Position u(21,7.5f);

up.SetPosition(u);

up.Draw();

down.Load("down.bmp");

down.SetWindow(W);

Position d(21,10.5f);

down.SetPosition(d);

down.Draw();

lef.Load("left.bmp");

lef.SetWindow(W);

Position l(19.5,9.0f);

lef.SetPosition(l);

lef.Draw();

righ.Load("right.bmp");

righ.SetWindow(W);

Position r(22.5,9.0f);

righ.SetPosition(r);

righ.Draw();

attack.Load("act.bmp");

attack.SetWindow(W);

Position a(21,9.0f);

attack.SetPosition(a);

attack.Draw();

////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//Create Object

float HP=5.0f;

float speed=0.1f;

float arrowspeed=0.3f;

int nBug=level+1+Uniform(0,level+1);

nBugAttack=Uniform(0,nBug-1);

cout<<"Level: "<<level<<endl;

cout<<"nBug: "<<nBug<<endl;

string str1="",str2="";

str1+="Level: ";

str1+='0'+level;

str2+="nBug: ";

str2+='0'+nBug;

nstring++;

if(nstring>6)

{
	W.Erase(Position(18.8f,12),6,6);

	nstring=0;
}

W.RenderText(Position(19,12+0.5*nstring),Position(24,12.5+0.5*nstring),str1,Magenta);

nstring++;

if(nstring>6)

{
	W.Erase(Position(18.8f,12),6,6);

	nstring=0;
}

W.RenderText(Position(19,12+0.5*nstring),Position(24,12.5+0.5*nstring),str2,Magenta);

man.Create(W,HP,speed,arrowspeed,5.0f,5.0f);

helpman.Create(W,HP,speed,arrowspeed,8.0f,5.0f);

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

float bigorsmall=Uniform(0,1);

float HP=bigorsmall+1.0f;

float speed=(bigorsmall+1.0f)/10.0f;

float X=Uniform(0,16);

float Y=Uniform(0,15);

CBug sb;

sb.create(W , HP , bigorsmall ,speed, X ,Y );

cout<<"Bug["<<i<<"] Create ( HP: "<<HP<<" Speed: "<<speed

<<" Type: "<<bigorsmall<<" X: "<<X<<" Y: "<<Y<<endl;

bug.push_back(sb);

}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//Call Back

Time=5;

W.SetTimerCallback(ActionOfAll);

W.SetMouseClickCallback(MouseClick);

W.StartTimer(100/(level+1));

return 0;

}


int ActionOfAll()

{

Time-=0.005/level;

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//Man Protected Return Normal

if(man.bProtected)
{
	
man.tProtected++;

W.Erase(Position(man.x-3,man.y-4),6.0f,8.0f);

W.RenderEllipse(Position(man.x-0.5f,man.y-0.5f),
				
				Position(man.x+man.bmp.GetWidth()+0.5f,man.y+man.bmp.GetHeight()+0.5f),
				
				color( Uniform(3,7) ) );

	if(man.tProtected>=level+15)
	{

W.Erase(Position(man.x-3,man.y-4),6.0f,8.0f);
		
		man.tProtected=0;

		man.bProtected=FALSE;

	}
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//Button Erase Return Draw

if(!lef.Draw())
{

tEraseorDarw++;

if(tEraseorDarw>level+1)

   lef.Draw();
}


if(!righ.Draw())
{

tEraseorDarw++;

if(tEraseorDarw>level+1)

   righ.Draw();
}

if(!up.Draw())
{

tEraseorDarw++;

if(tEraseorDarw>level+1)

   up.Draw();
}

if(!down.Draw())
{

tEraseorDarw++;

if(tEraseorDarw>level+1)

   down.Draw();
}

if(!attack.Draw())
{

tEraseorDarw++;

if(tEraseorDarw>level+1)

   attack.Draw();
}

//////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//Game Control On Timer

if(Time<=0)
		{
		   W.StopTimer();

           MessageBox(W.hwnd,"Srroy","Time Over",MB_OK);

			W.Close();

		}

    CheckHurt();

if(CheckHurt()==1)
		{
		   W.StopTimer();

           MessageBox(W.hwnd,"Srroy","You Miss",MB_OK);

			W.Close();

		}

else if(CheckHurt()==2)
{
            W.StopTimer();

            MessageBox(W.hwnd,"Pass the Stage","Continue to Next",MB_OK);

			level++;

		    PlayGame();

}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//All Action

BugAlive.clear();

for(int i=0;i<bug.size();i++)

if(bug[i].alive)
{

bug[i].Action();

BugAlive.push_back(i);

}

if(bug[nBugAttack].hp<=0)
{

nBugAttack=BugAlive[Uniform(0,BugAlive.size()-1)];

}

//////////////////////////////////////////////////////////////////////////

for(int a=0;a<BugAlive.size();a++)
{

int b=BugAlive[a];

string str;

str+='0'+bug[b].hp;

W.RenderText(Position(bug[b].x+bug[b].bmp.GetWidth()/2-0.05,bug[b].y+bug[b].bmp.GetHeight()/2-0.05),
			 
			 Position(bug[b].x+bug[b].bmp.GetWidth()/2,bug[b].y+bug[b].bmp.GetHeight()/2),
			 
			 str,Cyan,Blue);

}

//////////////////////////////////////////////////////////////////////////


helpman.AoutoAction(W,bug[nBugAttack],nBugAttack,nstring); 

man.Action();

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////


W.Erase(Position(19,0),6,4);

BitMap bmp;

bmp=man.bmp;

bmp.SetPosition(Position(20,1.0f));

bmp.Draw();

bmp=helpman.bmp;

bmp.SetPosition(Position(22,1.0f));

bmp.Draw();

string str1,str2;

str1+="LEVEL: ";

str1+='0'+level;

str2+="ALIVE: ";

str2+='0'+BugAlive.size();

W.RenderText(Position(19,3.5),Position(21,4),str1,Blue);

W.RenderText(Position(21,3.5),Position(24,4),str2,Blue);

return 0;

}

int MouseClick(const Position &MousePosn)
{

if(lef.IsInside(MousePosn))

{
  
    lef.Erase();

	tEraseorDarw=0;

	man.Drection=0;

}
if(up.IsInside(MousePosn))

{   
	up.Erase();

	tEraseorDarw=0;

	man.Drection=1;


}

if(righ.IsInside(MousePosn))
{
	righ.Erase();

	tEraseorDarw=0;

    man.Drection=2;

}

if(down.IsInside(MousePosn))
{

down.Erase();

tEraseorDarw=0;

man.Drection=3;

}

if(attack.IsInside(MousePosn)&&man.bAttack==FALSE)

{

attack.Erase();

tEraseorDarw=0;

man.PrepareAttack();

}


return 0;
	
}

int CheckHurt()

{


Position Pos;

Pos.SetXDistance(man.xArrow+man.bmpAttack.GetWidth()/2);

Pos.SetYDistance(man.yArrow+man.bmpAttack.GetHeight()/2);

for(int i=0;i<bug.size();i++)

if(bug[i].alive)
{

//////////////////////////////////////////////////////////////////////////
//Check Bug

if(bug[i].bmp.IsInside(Pos)&&man.bAttack==TRUE)

{

bug[i].hp--;

man.xArrow=-1;

man.yArrow=-1;

man.bmpAttack.Erase();

string str1="",str2="";

str1+="Wonderful ! Bug[";

str1+='0'+i;

str1+="]  Shooted ";

str2+="HP leave: ";

str2+='0'+bug[i].hp;

nstring++;

if(nstring>6)

{
	W.Erase(Position(18.8f,12),6,6);

	nstring=0;
}

W.RenderText(Position(19,12+0.5*nstring),Position(24,12.5+0.5*nstring),str1,Magenta);

nstring++;

if(nstring>6)

{
	W.Erase(Position(18.8f,12),6,6);

	nstring=0;
}


W.RenderText(Position(19,12+0.5*nstring),Position(24,12.5+0.5*nstring),str2,Magenta);


if(bug[i].hp<=0)
{

bug[i].bmp.Erase();

bug[i].alive=FALSE;

string str="Poor Bug , He Dead ";

W.RenderText(Position(19,12+0.5*nstring),Position(24,12.5+0.5*nstring),str,Magenta);

nstring++;

}

man.bAttack=FALSE;

}

//////////////////////////////////////////////////////////////////////////
//Check Man

Position  Qos;

Qos.SetXDistance(bug[i].x+bug[i].bmp.GetWidth()/2);

Qos.SetYDistance(bug[i].y+bug[i].bmp.GetHeight()/2);

if(man.bmp.IsInside(Qos)&&man.bProtected==FALSE)

{

man.hp--;

string str1="",str2="";

str1+="You  Hurted by  Bug[";

str1+='0'+i;

str1+="]"; 

str2+="HP Leave: ";

str2+='0'+man.hp;

nstring++;

if(nstring>6)

{
	W.Erase(Position(18.8f,12),6,6);

	nstring=0;
}

W.RenderText(Position(19,12+0.5*nstring),Position(24,12.5+0.5*nstring),str1,Magenta);

nstring++;

if(nstring>6)

{
	W.Erase(Position(18.8f,12),6,6);

	nstring=0;
}

W.RenderText(Position(19,12+0.5*nstring),Position(24,12.5+0.5*nstring),str2,Magenta);

man.tProtected=0;

man.bProtected=TRUE;

}


}

//////////////////////////////////////////////////////////////////////////
//Draw HP and Time

W.RenderRectangle(Position(19.0f,4.5f),Position(24.0f,5.5f),Cyan,TRUE);

W.RenderRectangle(Position(19.05f,4.52f),Position(18.98f+man.hp,5.48f),Magenta);

W.RenderRectangle(Position(19.0f,6.0f),Position(24.0f,7.0f),Yellow,TRUE);

W.RenderRectangle(Position(19.05f,6.05f),Position(18.98f+Time,6.98f),Green);

//////////////////////////////////////////////////////////////////////////
//Return

if(man.hp<=0)

return 1;

else
{

int Bugliving=0;

for(int j=0;j<bug.size();j++)

if(bug[j].alive)

Bugliving++;

if(Bugliving==0)

return 2;

else

return 0;

}

}