示例#1
0
DummyObject::DummyObject(vector3df position,
						   double radius,
						   vector3df velocity,
						   double maxSpeed,
						   vector3df heading,
						   double mass,
						   vector3df scale,
						   double turnRate,
						   double maxForce,
						   DUMMY_OBJECT_TYPE initState,
						   u32 groupID)
	: BasePlayer(position, radius, velocity, maxSpeed, heading, mass, scale, turnRate, maxForce, PLAYER_ROLE_DUMMY)
{
	m_pStateMachine = new StateMachine<DummyObject>(this);
    
	// start from idle state
    m_pStateMachine->SetCurrentState(IdleDummy::Instance());

	// get ready sprite
#if USE_BILL_BOARD_SPRITE	
	ISceneManager* pSmgr = IrrDevice::GetInstance().GetSmgr();
	m_p2DSprite = new BillBoard(pSmgr->getRootSceneNode(), pSmgr, 300);
	m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
	ITexture* pTexture = IrrDevice::GetInstance().GetDriver()->getTexture("Rsrc/hero.bmp");
	m_p2DSprite->setMaterialTexture(0, pTexture);
	m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
	m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, false);
	m_p2DSprite->setPosition(position);
	m_p2DSprite->setID(0);
	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(0.5f,0.5f);	
#else
	ISceneManager* pSmgr = IrrDvc.GetSmgr();
	IVideoDriver* pDriver = IrrDvc.GetDriver();
	m_p2DSprite = pSmgr->addBillboardSceneNode();
	m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);	
	//video::ITexture* pTexture = pDriver->getTexture("Rsrc/bullet.tga");
	video::ITexture* pTexture = pDriver->getTexture("Rsrc/z_tunnel2.tga");
	pTexture->grab();
	m_p2DSprite->setMaterialTexture(0, pTexture);
	m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
	m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, true);
	m_p2DSprite->setMaterialFlag(video::EMF_ZWRITE_ENABLE, true);
	//m_p2DSprite->setSize(dimension2df(scale.X, scale.Y));
	m_p2DSprite->setPosition(position);
	m_p2DSprite->setID(ID());
//	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(0.5f,0.5f);	
	m_initState = initState;

	//patrol¿¡ »ç¿ëµÉ µ¥ÀÌŸ ÃßÈÄ ·¹º§ µðÀÚÀÎµÈ ½ºÅ©¸³Æ®¿¡ ÀÇÇØ ™VÆõǵµ·Ï ¼öÁ¤¿ä
	//ÇöÀç MoviingEntity ¿Í º¯¼ö ¿¬°áÀº ³ªÁß¿¡ AI Å×½ºÆ®¸¦ À§ÇØ Àӽ÷Π¸¸µê.
	m_fSpeed = 30.0f;
 	m_bDirection=true;
	m_3dfStart = this->Pos()-vector3df(30.0f,0.0f,0.0f);
    m_3dfDest= this->Pos()+vector3df(30.0f,0.0f,0.0f);
#endif
	// add into entity mamager	
	m_uGroupID = groupID;
	//EntityMgr.RegisterEntity(m_uGroupID,this);//test code Áö±ÝÀº ±×³É 1·Î ³ªÁß¿¡ ÀÎÀڷΠó¸®	
}
示例#2
0
FugitivePlayer::FugitivePlayer(vector3df position,
							   f64 radius,
							   vector3df velocity,
							   f64 maxSpeed,
							   vector3df heading,
							   f64 mass,
							   vector3df scale,
							   f64 turnRate,
							   f64 maxForce, 
							   s32 gameFieldID)
	: BasePlayer(position, radius, velocity, maxSpeed, heading, mass, scale, turnRate, maxForce, PLAYER_ROLE_CHASER),
	  m_gameFieldID(gameFieldID),
	  m_pRushLine(null)
{
	//
	m_patrolPoints.clear();

	// get ready state machine
	m_pStateMachine = new StateMachine<FugitivePlayer>(this);
    
	// start from nothing
    m_pStateMachine->ChangeState(IdleFugitive::Instance());

	// get ready sprite
	ISceneManager* pSmgr = IrrDvc.GetSmgr();
	IVideoDriver* pDriver = IrrDvc.GetDriver();
	m_p2DSprite = pSmgr->addBillboardSceneNode();
	m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
	video::ITexture* pTexture = pDriver->getTexture("Rsrc/hero.tga");
	// shkim, TODO.
	// why should I grap this texture here? as a result, get(+1)->grab(+1)->drop(-1) will give reference count as 1. 
	// that means nobody know when I release texture after using at all. how do I figure it out?
	// answer is, keeping texture resource during Proc life time. it means loading texture at Proc initializing time and releasing them at Proc releasing time.
	// for doing that, need to use grab/drop pair after getTexture()
	pTexture->grab();
	m_p2DSprite->setMaterialTexture(0, pTexture);
	m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
	m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, true);
	m_p2DSprite->setMaterialFlag(video::EMF_ZWRITE_ENABLE, true);
	m_p2DSprite->setSize(dimension2df(scale.X, scale.Y));
	m_p2DSprite->setPosition(position);
	m_p2DSprite->setID(ID());
	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(0.5f,0.5f);
	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureTranslate(0.f,0.5f); // 3th sprite

	// rush line scene node
	m_pRushLine = new RushLineSceneNode(pSmgr->getRootSceneNode(), pSmgr, ID(), this);

	// set weapon
	m_pWeapon[0] = new Pistol_Basic;
	m_pWeapon[1] = new Mechine_Gun;
	m_nCurrentWeaponNum = 0;

	// center point(player pos) in screen coordinates for getting shooting direction
	m_uPosinScreenCoord.X =(u32)(IrrDvc.GetDevice()->getVideoDriver()->getScreenSize().Width * 0.5f);
	m_uPosinScreenCoord.Y =(u32)(IrrDvc.GetDevice()->getVideoDriver()->getScreenSize().Height * 0.5f);	
}
示例#3
0
Human::Human(vector3df position,
			   f64 radius,
			   vector3df velocity,
			   f64 maxSpeed,
			   vector3df heading,
			   f64 mass,
			   vector3df scale,
			   f64 turnRate,
			   f64 maxForce,
			   HUMAN_STATE initState)
	: BasePlayer(position, radius, velocity, maxSpeed, heading, mass, scale, turnRate, maxForce)
{
	// get ready state machine
	m_pStateMachine = new StateMachine<Human>(this);
    
	// start from nothing
	if(HUMAN_STATE_IDLE == initState){
		m_State = HUMAN_STATE_IDLE;
		m_pStateMachine->ChangeState(StateHumanIdle::Instance());
	}

	// get ready sprite
	ISceneManager* pSmgr = IrrDvc.GetSmgr();
	IVideoDriver* pDriver = IrrDvc.GetDriver();
	m_p2DSprite = pSmgr->addBillboardSceneNode();
	m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
	video::ITexture* pTexture = pDriver->getTexture(HUMAN_TEXTUREFILENAME);
	// shkim, TODO.
	// why should I grap this texture here? as a result, get(+1)->grab(+1)->drop(-1) will give reference count as 1. 
	// that means nobody know when I release texture after using at all. how do I figure it out?
	// answer is, keeping texture resource during Proc life time. it means loading texture at Proc initializing time and releasing them at Proc releasing time.
	// for doing that, need to use grab/drop pair after getTexture()
	pTexture->grab();
	m_p2DSprite->setMaterialTexture(0, pTexture);
	m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
	m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, true);
	m_p2DSprite->setMaterialFlag(video::EMF_ZWRITE_ENABLE, true);
	m_p2DSprite->setSize(dimension2df(scale.X, scale.Y));
	m_p2DSprite->setPosition(position);	
	m_p2DSprite->setID(ID());
	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(0.5f,0.5f);
	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureTranslate(0.f,0.5f); // 3th sprite

	// get ready physics model
	m_pHumanPhaysics = new HumanPhysics(&Box2dWld.GetWorld(), ID());
	m_pHumanPhaysics->SetTransform(b2Vec2(position.X, position.Y), 0.f);

#ifdef AI_TEST_DISPLAY_HUMAN_STATE
	m_uScreenHalfWidth  = (u32)(IrrDvc.GetDevice()->getVideoDriver()->getScreenSize().Width * 0.5f);
	m_uScreenHalfHeight = (u32)(IrrDvc.GetDevice()->getVideoDriver()->getScreenSize().Height * 0.5f);
#endif

	m_fCurrentLifeEnergy = HUMAN_LIFE_ENERGY_DEFAULT;
	m_fMaxLifeEnerge = HUMAN_MAX_LIFE_ENERGY_DEFAULT;
	m_uStarvationTimeCount = 0;
	m_uIfectionTimeCount = 0;
}
示例#4
0
Car::Car(vector3df position,
		   f64 radius,
		   vector3df velocity,
		   f64 maxSpeed,
		   vector3df heading,
		   f64 mass,
		   vector3df scale,
		   f64 turnRate,
		   f64 maxForce)
	: MovingEntity(position, radius, velocity, maxSpeed, heading, mass, scale, turnRate, maxForce),
  	  m_pSceneNode(null),
	  m_pStateMachine(null),
	  m_p2DSprite(null),
	  m_pCarPhaysics(null),
	  m_pMesh(null)
{
	// get ready state machine
	 m_pStateMachine = new StateMachine<Car>(this);
    
	// start from nothing
    m_pStateMachine->ChangeState(IdleCar::Instance());

	// get ready sprite
	ISceneManager* pSmgr = IrrDvc.GetSmgr();
	IVideoDriver* pDriver = IrrDvc.GetDriver();
	m_p2DSprite = pSmgr->addBillboardSceneNode();
	m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
	video::ITexture* pTexture = pDriver->getTexture("Rsrc/car.tga");
	// shkim, TODO.
	// why should I grap this texture here? as a result, get(+1)->grab(+1)->drop(-1) will give reference count as 1. 
	// that means nobody know when I release texture after using at all. how do I figure it out?
	// answer is, keeping texture resource during Proc life time. it means loading texture at Proc initializing time and releasing them at Proc releasing time.
	// for doing that, need to use grab/drop pair after getTexture()
	pTexture->grab();
	m_p2DSprite->setMaterialTexture(0, pTexture);
	m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
	m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, true);
	m_p2DSprite->setMaterialFlag(video::EMF_ZWRITE_ENABLE, true);
	m_p2DSprite->setSize(dimension2df(scale.X, scale.Y));
	m_p2DSprite->setPosition(position);
	m_p2DSprite->setID(ID());	

	// get ready 3d scene node
#ifdef DRAW_CAR_3D_MODEL // shkim, do not draw mode now
	m_pMesh = pSmgr->getMesh("Rsrc/cube.xml");
	m_pSceneNode = pSmgr->addAnimatedMeshSceneNode(m_pMesh);
	m_pSceneNode->setPosition(vector3df(0.f, 0.f, 0.f));
	m_pSceneNode->setRotation(vector3df(0.f, 0.f, 0.f));
	m_pSceneNode->setScale(vector3df(4.f, 8.f, 1.f));
	m_pSceneNode->setMaterialFlag(EMF_LIGHTING, false);
#endif // DRAW_CAR_3D_MODEL
	// get ready physics model
	m_pCarPhaysics = new iforce2d_TopdownCar(&Box2dWld.GetWorld());	
}
示例#5
0
Ztunnel::Ztunnel(vector3df position,
				 double radius,
				 irr::core::vector3df velocity,
				 double maxSpeed,
				 irr::core::vector3df heading,
				 double mass,
				 irr::core::vector3df scale,
				 double turnRate,
				 double maxForce,
				 ZTUNNEL_TYPE initState,
				 BlackBoard* pbb)
				 : BasePlayer(position, radius, velocity, maxSpeed, heading, mass, scale, turnRate, maxForce)
{
	m_pStateMachine = new StateMachine<Ztunnel>(this);
    
	// start from idle state
    m_pStateMachine->SetCurrentState(IdleZtunnel::Instance());

	// get ready sprite
	ISceneManager* pSmgr = IrrDvc.GetSmgr();
	IVideoDriver* pDriver = IrrDvc.GetDriver();
	m_p2DSprite = pSmgr->addBillboardSceneNode();
	m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);	
	video::ITexture* pTexture = pDriver->getTexture("Rsrc/z_tunnel2.tga");

	pTexture->grab();
	m_p2DSprite->setMaterialTexture(0, pTexture);
	m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
	m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, true);
	m_p2DSprite->setMaterialFlag(video::EMF_ZWRITE_ENABLE, true);
	//m_p2DSprite->setSize(dimension2df(scale.X, scale.Y));
	m_p2DSprite->setPosition(position);
	m_p2DSprite->setID(ID());
//	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(0.5f,0.5f);	
	m_State = initState;

	//create skill
	CreateBasicZSkill* pcreatebasicZskill = new CreateBasicZSkill("CreateBasicZ", this, 0.5);//name,baseplayer, prof
	skills.insert(pair<std::string,Skill*>(pcreatebasicZskill->getName(), pcreatebasicZskill));

	//create mission
	
	m_pBlacBoard = pbb;
	
	Mission* pMissionCreateBasdiZ = new Mission("CreateBasicZ",1,1);
    m_pBlacBoard->addMission(pMissionCreateBasdiZ);

	Mission* pMissionAttackBuilding = new LocatableMission("AttackBuilding",2,1,vector2df(-75,-75));
	m_pBlacBoard->addMission(pMissionAttackBuilding);
	}
示例#6
0
/** Tests the offset capability of the fly circle animator */
bool flyCircleAnimator(void)
{
	IrrlichtDevice *device = createDevice(video::EDT_BURNINGSVIDEO,
										core::dimension2du(160,120), 32);
	if (!device)
		return false;

	IVideoDriver* driver = device->getVideoDriver();
	ISceneManager* smgr = device->getSceneManager();

	const f32 offsetDegrees[] = { 0.f, 45.f, 135.f, 270.f };

	for(u32 i = 0; i < sizeof(offsetDegrees) / sizeof(offsetDegrees[0]); ++i)
	{
		IBillboardSceneNode * node = smgr->addBillboardSceneNode();
		// Have the animator rotate around the Z axis plane, rather than the default Y axis
		ISceneNodeAnimator * animator = smgr->createFlyCircleAnimator(
				vector3df(0, 0, 0), 30.f, 0.001f,
				vector3df(0, 0, 1), (offsetDegrees[i] / 360.f));
		if(!node || !animator)
			return false;

		node->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR );
		node->setMaterialTexture(0, driver->getTexture("../media/particle.bmp"));
		node->setMaterialFlag(video::EMF_LIGHTING, false);

		node->addAnimator(animator);
		animator->drop();
	}

	(void)smgr->addCameraSceneNode(0, vector3df(0, 0, -50), vector3df(0, 0, 0));

	bool result = false;

	// Don't do device->run() since I need the time to remain at 0.
	if (driver->beginScene(true, true, video::SColor(0, 80, 80, 80)))
	{
		smgr->drawAll();
		driver->endScene();
		result = takeScreenshotAndCompareAgainstReference(driver, "-flyCircleAnimator.png", 100);
	}

	device->closeDevice();
	device->run();
	device->drop();

	return result;
}
示例#7
0
/** The result should be as follows: We have three times the same image, a billboard with a cube and the text in front.
They are replicated three times, one centered in the screen without viewport, one in the upper left (qurter screen) and
one on the right (half screen). The latter is stretched due to the changed aspect ratio.
The two viewport scenes get the texture drawn over the center as well, using draw2dimage. This should mark the proper
image position with the top left corner of the texture.
Finally, each scene has a checkbox drawn at the left side, vertically centered. This will show whether GUI elements adhere
to viewports as well. */
static bool viewPortText(E_DRIVER_TYPE driverType)
{
	IrrlichtDevice *device = createDevice( driverType, dimension2d<u32>(160, 120), 32);
	if (!device)
		return true; // Treat a failure to create a driver as benign; this saves a lot of #ifdefs

	IVideoDriver* driver = device->getVideoDriver();
	ISceneManager * smgr = device->getSceneManager();
	IGUIEnvironment* env = smgr->getGUIEnvironment();

	stabilizeScreenBackground(driver);

	env->addCheckBox(true, core::recti(10,60,28,82));

	logTestString("Testing driver %ls\n", driver->getName());

	IBillboardSceneNode * bnode = smgr->addBillboardSceneNode(0,dimension2d<f32>(32,32),core::vector3df(0,0,10));
	bnode->setMaterialFlag(video::EMF_LIGHTING, false);
	bnode->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
	bnode->setMaterialTexture(0, driver->getTexture("../media/fire.bmp"));

	smgr->addTextSceneNode(device->getGUIEnvironment()->getBuiltInFont(), L"TEST", video::SColor(255,255,255,255), 0);
	smgr->addCubeSceneNode();
	smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));

	driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, SColor(255,100,101,140));
	smgr->drawAll();
	env->drawAll();
	driver->setViewPort(rect<s32>(0,0,160/2,120/2));
	smgr->drawAll();
	env->drawAll();
	driver->draw2DImage(driver->getTexture("../media/fire.bmp"), core::vector2di(160/2,120/2));
	driver->setViewPort(rect<s32>(160/2,0,160,120));
	smgr->drawAll();
	env->drawAll();
	driver->draw2DImage(driver->getTexture("../media/fire.bmp"), core::vector2di(160/2,120/2));
	driver->endScene(); 

	bool result = takeScreenshotAndCompareAgainstReference(driver, "-viewPortText.png", 98.71f);

	device->closeDevice();
	device->run();
	device->drop();

	return result;
}
示例#8
0
NaviPlayer::NaviPlayer(vector3df position,
							   f64 radius,
							   vector3df velocity,
							   f64 maxSpeed,
							   vector3df heading,
							   f64 mass,
							   vector3df scale,
							   f64 turnRate,
							   f64 maxForce)
	: BasePlayer(position, radius, velocity, maxSpeed, heading, mass, scale, turnRate, maxForce, PLAYER_ROLE_CHASER)	  
{
	// get ready state machine
	m_pStateMachine = new StateMachine<NaviPlayer>(this);
    
	// start from nothing
    m_pStateMachine->ChangeState(IdleNavi::Instance());

	// get ready sprite
	ISceneManager* pSmgr = IrrDvc.GetSmgr();
	IVideoDriver* pDriver = IrrDvc.GetDriver();
	m_p2DSprite = pSmgr->addBillboardSceneNode();
	m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
	video::ITexture* pTexture = pDriver->getTexture("Rsrc/hero.tga");
	// shkim, TODO.
	// why should I grap this texture here? as a result, get(+1)->grab(+1)->drop(-1) will give reference count as 1. 
	// that means nobody know when I release texture after using at all. how do I figure it out?
	// answer is, keeping texture resource during Proc life time. it means loading texture at Proc initializing time and releasing them at Proc releasing time.
	// for doing that, need to use grab/drop pair after getTexture()
	pTexture->grab();
	m_p2DSprite->setMaterialTexture(0, pTexture);
	m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
	m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, true);
	m_p2DSprite->setMaterialFlag(video::EMF_ZWRITE_ENABLE, true);
	m_p2DSprite->setSize(dimension2df(scale.X, scale.Y));
	m_p2DSprite->setPosition(position);
	m_p2DSprite->setID(ID());
	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(0.5f,0.5f);
	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureTranslate(0.f,0.5f); // 3th sprite
}
示例#9
0
int main()
{
	Input input;
	IrrlichtDevice *device = createDevice(video::EDT_DIRECT3D9, dimension2d<u32>(800, 600), 16, false, true, false, &input);
	device->setWindowCaption(L"Seas of Gold");
	IVideoDriver* driver = device->getVideoDriver();
	ISceneManager* smgr = device->getSceneManager();
	IGUIEnvironment* guienv = device->getGUIEnvironment();
	E_DRIVER_TYPE driverType = driverChoiceConsole();
	EffectHandler *effect = new EffectHandler(device, driver->getScreenSize(), false, true);
	E_FILTER_TYPE filterType = (E_FILTER_TYPE)core::clamp<u32>((u32)3 - '1', 0, 4);
	MapID currentMap;
	int skyR = 30, skyG = 30, skyB = 70;
	int timer = 0;
	SColor sky = SColor(255, skyR, skyG, skyB);
	float plPos_x = 0.0f, plPos_y = 0.0f, plPos_z = 0.0f;
	bool updateCam = true;
	bool menu1 = false;
	int state = Main;
	int frameCount = 0;
	LoadMap loadMap;
	Player player;
	Interface playerInterface(driver);
	ITriangleSelector* selector = 0;
	ISceneNodeAnimator* anim = 0;
	Vendor southVendor;
	Vendor eastVendor;
	Vendor northVendor;
	//InitializeVendors(northVendor, southVendor, eastVendor, itemD);

	//ItemDatabase* itemD = new ItemDatabase;
	ItemDatabase itemD;
	itemD.Initialize();

	//initialize player's inventory
	player.AddGold(1000);
	player.getInventory()->addItem(itemD.getItem(bronzeOre), 50);
	player.getInventory()->addItem(itemD.getItem(ironOre), 50);
	player.getInventory()->addItem(itemD.getItem(goldOre), 50);

	//initialize south vendor's inventory
	southVendor.getInventory()->addItem(itemD.getItem(bronzeOre), 100);
	southVendor.getInventory()->addItem(itemD.getItem(coalOre), 100);
	southVendor.getInventory()->addItem(itemD.getItem(supplies), 1000);

	//initialize north vendor's inventory
	northVendor.getInventory()->addItem(itemD.getItem(obsidianOre), 50);
	northVendor.getInventory()->addItem(itemD.getItem(supplies), 1000);

	//initialize south vendor's inventory
	eastVendor.getInventory()->addItem(itemD.getItem(goldOre), 100);
	eastVendor.getInventory()->addItem(itemD.getItem(ironOre), 100);
	eastVendor.getInventory()->addItem(itemD.getItem(supplies), 1000);

	//Item item(0, "bronzeOre", "Sprites/ore_Bronze.png");
	//Item item2 = item;
	//Item* item2 = itemD.getItem(3);
	//inventory.addItem(&item, 2);
	//inventory.addItem(&item, 2);
	//inventory.addItem(item2, 2);

	//int test = 0;

	// Load the map scene
	//loadMap.Load(smgr, device, Map_Africa);
	//loadMap.Load(smgr, device, Map_India);
	//loadMap.Load(smgr, device, selector, plyrNode, anim, Map_England);

	IAnimatedMeshSceneNode* plyrNode = player.loadPlayerNode(device, smgr);
	//plyrNode->setDebugDataVisible((scene::E_DEBUG_SCENE_TYPE)(plyrNode->isDebugDataVisible() ^ scene::EDS_BBOX));

	ICameraSceneNode* camera = smgr->addCameraSceneNode(0, plyrNode->getPosition() + vector3df(0, 2, 2), vector3df(0, 0, 100));

	loadMap.Load(smgr, device, selector, plyrNode, anim, driver, Map_Africa);
	currentMap = Map_Africa;
	//loadMap.setCollisions(smgr, selector, plyrNode, anim);

	if (loadMap.CollNode)
	{
		selector = smgr->createOctreeTriangleSelector(loadMap.CollNode->getMesh(), loadMap.CollNode, 32);
		for (int i = 0; i < loadMap.CollNode->getMaterialCount(); i++)
		{
			loadMap.CollNode->getMaterial(i).NormalizeNormals = true;
		}
		loadMap.CollNode->setTriangleSelector(selector);
	}

	if (selector)
	{
		anim = smgr->createCollisionResponseAnimator(selector, plyrNode, vector3df(0.6f, 0.75f, 0.4f), core::vector3df(0.0f, -0.05f, 0.0f),
			core::vector3df(0.0f, -0.725f, 0.0f));

		plyrNode->addAnimator(anim);
	}

	ISceneCollisionManager* collMan = smgr->getSceneCollisionManager();

	////////////// The Sun ////////////
	ILightSceneNode *sun_node;
	SLight sun_data;
	ISceneNode *sun_billboard;
	float sun_angle = 0;
	video::SColorf Diffuse_Night = video::SColorf(0.0f, 0.0f, 0.0f, 1.0f);
	video::SColorf Diffuse_Day = video::SColorf(1.0f, 1.0f, 1.0f, 1.0f);

	sun_node = smgr->addLightSceneNode();
	sun_data.Direction = vector3df(0, 0, 0);
	sun_data.Type = video::ELT_DIRECTIONAL;
	sun_data.AmbientColor = video::SColorf(0.1f, 0.1f, 0.1f, 1);
	sun_data.SpecularColor = video::SColorf(0, 0, 0, 0);
	sun_data.DiffuseColor = Diffuse_Day;
	sun_data.CastShadows = true;
	sun_node->setLightData(sun_data);
	sun_node->setPosition(vector3df(0, 0, 0));
	sun_node->setRotation(vector3df(0, 0, 0));

	sun_billboard = smgr->addBillboardSceneNode(sun_node, core::dimension2d<f32>(60, 60));
	if (sun_billboard)
	{
		sun_billboard->setPosition(vector3df(0, 0, -100));
		sun_billboard->setMaterialFlag(video::EMF_LIGHTING, false);
		sun_billboard->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
		sun_billboard->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
		sun_billboard->setMaterialTexture(0, driver->getTexture("Assets/particlewhite.bmp"));
	}
	/////////// End ////////////

	//------- candleLight -----//
	ILightSceneNode *candleLight = smgr->addLightSceneNode();
	SLight candleLight_data;

	candleLight_data.Type = video::ELT_POINT;
	candleLight_data.DiffuseColor = SColorf(1.0f, 0.546f, 0.016f, 1.0f);
	candleLight_data.SpecularColor = video::SColorf(0, 0, 0, 0);
	candleLight->setPosition(vector3df(2.43467f, 1.55795f, -3.94657));
	candleLight_data.Radius = 1.5f;
	candleLight->setLightData(candleLight_data);
	//------- end -----//

	//// Make the player
	//player.AddGold(1000);
	//player.SetCurrentPort(eMapDest::South);
	//Item* itemCi = new Item("Iron Ore", 1);
	//player.getItems()->addItem(itemCi);
	//Item* itemCb = new Item("Bronze Ore", 1);
	//player.getItems()->addItem(itemCb);

	//Vendor vN;
	//Item* itemG = new Item("Gold Ore", 1000);
	//vN.getItems()->addItem(itemG);
	//Vendor vS;
	//Item* itemI = new Item("Iron Ore", 1000);
	//vS.getItems()->addItem(itemI);
	//Vendor vE;
	//Item* itemB = new Item("Bronze Ore", 1000);
	//vE.getItems()->addItem(itemB);
	//Vendor northVendor

	//delete &itemD;

	int test99 = 0;


	// Make the menus
	MainMenu mainMenu(device, driver);

	MapMenu mapMenu(device, driver);
	mapMenu.SetPlayer(&player);

	TradeMenu tradeMenu;
	tradeMenu.Initialize(device, driver, &player, &southVendor);
	//TradeMenu tradeMenu(device, driver);
	//tradeMenu.SetPlayer(&player);
	//tradeMenu.SetVendor(&vS);
	//
	CraftingMenu craftMenu(device, driver, &player, itemD);
	//craftMenu.SetPlayer(&player);

	//////////////////////////////////////////////////////////////////////////
	// Initialize timer to compute elapsed time between frames
	//////////////////////////////////////////////////////////////////////////
	__int64 cntsPerSec = 0;
	QueryPerformanceFrequency((LARGE_INTEGER*)&cntsPerSec);
	float secsPerCnt = 1.0f / (float)cntsPerSec;

	__int64 prevTimeStamp = 0;
	QueryPerformanceCounter((LARGE_INTEGER*)&prevTimeStamp);

	while (device->run())
	{
		//for scaling animation by time, not by frame
		__int64 currTimeStamp = 0;
		QueryPerformanceCounter((LARGE_INTEGER*)&currTimeStamp);
		float dt = (currTimeStamp - prevTimeStamp) * secsPerCnt;

		sun_node->setRotation(vector3df(sun_angle, 0.0f, 0.0f));
		sun_angle += dt;
		frameCount += 1;
		if ((sun_angle > 0 && sun_angle < 109) || (sun_angle>350))
		{
			timer++;
			if (timer > 10)
			{
				if (skyR < 100) skyR += 1;
				if (skyG < 100) skyG += 1;
				if (skyB < 140) skyB += 1;
				timer = 0;
			}
		}
		if (sun_angle > 170 && sun_angle < 330)
		{
			timer++;
			if (timer > 10)
			{
				if (skyR > 0) skyR -= 1;
				if (skyG > 0) skyG -= 1;
				if (skyB > 40) skyB -= 1;
				timer = 0;
			}
		}

		player.updatePlayer(plyrNode, dt, collMan, selector);
		playerInterface.update(plyrNode, loadMap, driver, device, input, updateCam, state);

		switch (state)
		{
		case Map:
		{
			int out = mapMenu.Update(&input, frameCount);

			switch (out)
			{
			case eMapDest::Exit:
			{
				state = None;
				break;
			}
			case eMapDest::East:
			{
				state = None;
				//Item* itemB = new Item("Bronze Ore", 1000);
				//vE.getItems()->addItem(itemB);
				tradeMenu.SetVendor(&eastVendor);
				loadMap.Load(smgr, device, selector, plyrNode, anim, driver, Map_India);
				currentMap = Map_India;
				if (loadMap.CollNode)
				{
					selector = smgr->createOctreeTriangleSelector(loadMap.CollNode->getMesh(), loadMap.CollNode, 32);

					for (int i = 0; i < loadMap.CollNode->getMaterialCount(); i++)
					{
						loadMap.CollNode->getMaterial(i).NormalizeNormals = true;
					}
					loadMap.CollNode->setTriangleSelector(selector);
				}

				if (selector)
				{
					anim = smgr->createCollisionResponseAnimator(selector, plyrNode, vector3df(0.6f, 0.75f, 0.4f), core::vector3df(0.0f, -0.05f, 0.0f),
						core::vector3df(0.0f, -0.725f, 0.0f));
					plyrNode->addAnimator(anim);
				}
				collMan = smgr->getSceneCollisionManager();
				break;
			}
			case eMapDest::North:
			{
				state = None;
				//Item *itemG = new Item("Gold Ore", 1000);
				//vN.getItems()->addItem(itemG);
				//tradeMenu.SetVendor(&vN);
				tradeMenu.SetVendor(&northVendor);
				loadMap.Load(smgr, device, selector, plyrNode, anim, driver, Map_England);
				currentMap = Map_England;
				if (loadMap.CollNode)
				{
					selector = smgr->createOctreeTriangleSelector(loadMap.CollNode->getMesh(), loadMap.CollNode, 32);

					for (int i = 0; i < loadMap.CollNode->getMaterialCount(); i++)
					{
						loadMap.CollNode->getMaterial(i).NormalizeNormals = true;
					}
					loadMap.CollNode->setTriangleSelector(selector);
				}

				if (selector)
				{
					anim = smgr->createCollisionResponseAnimator(selector, plyrNode, vector3df(0.6f, 0.75f, 0.4f), core::vector3df(0.0f, -0.05f, 0.0f),
						core::vector3df(0.0f, -0.725f, 0.0f));
					plyrNode->addAnimator(anim);
				}
				collMan = smgr->getSceneCollisionManager();
				break;
			}
			case eMapDest::South:
			{
				state = None;
				//Item *itemI = new Item("Iron Ore", 1000);
				//vS.getItems()->addItem(itemI);
				//tradeMenu.SetVendor(&vS);
				tradeMenu.SetVendor(&southVendor);
				loadMap.Load(smgr, device, selector, plyrNode, anim, driver, Map_Africa);
				currentMap = Map_Africa;
				if (loadMap.CollNode)
				{
					selector = smgr->createOctreeTriangleSelector(loadMap.CollNode->getMesh(), loadMap.CollNode, 32);

					for (int i = 0; i < loadMap.CollNode->getMaterialCount(); i++)
					{
						loadMap.CollNode->getMaterial(i).NormalizeNormals = true;
					}
					loadMap.CollNode->setTriangleSelector(selector);
				}

				if (selector)
				{
					anim = smgr->createCollisionResponseAnimator(selector, plyrNode, vector3df(0.6f, 0.75f, 0.4f), core::vector3df(0.0f, -0.05f, 0.0f),
						core::vector3df(0.0f, -0.725f, 0.0f));
					plyrNode->addAnimator(anim);
				}
				collMan = smgr->getSceneCollisionManager();
				break;
			}
			default:
				break;
			}

			break;
		}
		case Trade:
		{

			bool out = false;
			out = tradeMenu.Update(&input, frameCount, device, currentMap);
			if (out)
				state = None;
			break;
		}
		case Main:
		{
			int out = mainMenu.Update(&input, frameCount);

			switch (out)
			{
			case MSstart:
			{
				state = None;
				break;
			}
			case MSexit:
			{
				device->closeDevice();
				//return 0;
				break;
			}
			default:
				break;
			}

			break;
		}
		case Craft:
		{
			bool out = craftMenu.Update(&input, frameCount, device);
			if (out)
				state = None;
			break;
		}
		default:
			// Do nothing
			break;
		}

		if (updateCam) moveCameraControl(plyrNode, device, camera);

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

		if (sun_angle > 360) sun_angle = 0;
		if (sun_angle < 180) sun_data.DiffuseColor = Diffuse_Day; else sun_data.DiffuseColor = Diffuse_Night;
		sun_node->setLightData(sun_data);

		sky.setRed(skyR);
		sky.setGreen(skyG);
		sky.setBlue(skyB);
		driver->beginScene(true, true, sky);

		smgr->drawAll();

		playerInterface.render(driver, state);

		// Draw the menu
		switch (state)
		{
		case Map:
		{
			mapMenu.Draw(driver, device);
			break;
		}
		case Trade:
		{
			tradeMenu.Render(driver, device);
			break;
		}
		case Main:
		{
			mainMenu.Draw(driver);
			break;
		}
		case Craft:
		{
			craftMenu.Draw(driver);
			break;
		}
		default:
			// Do nothing
			break;
		}

		driver->endScene();
		
		// Update the prev time stamp to current
		prevTimeStamp = currTimeStamp;

	}

	device->drop();

	return 0;
}
示例#10
0
Ztunnel::Ztunnel(vector3df position,
				 double radius,
				 irr::core::vector3df velocity,
				 double maxSpeed,
				 irr::core::vector3df heading,
				 double mass,
				 irr::core::vector3df scale,
				 double turnRate,
				 double maxForce,
				 ZTUNNEL_TYPE initState,
				 u32 groupID,
				 BlackBoard* pbb)
				 : BasePlayer(position, radius, velocity, maxSpeed, heading, mass, scale, turnRate, maxForce, PLAYER_ROLE_DUMMY)
{
	m_pStateMachine = new StateMachine<Ztunnel>(this);
    
	// start from idle state
    m_pStateMachine->SetCurrentState(IdleZtunnel::Instance());

	// get ready sprite
#if USE_BILL_BOARD_SPRITE	
	ISceneManager* pSmgr = IrrDevice::GetInstance().GetSmgr();
	m_p2DSprite = new BillBoard(pSmgr->getRootSceneNode(), pSmgr, 300);
	m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
	ITexture* pTexture = IrrDevice::GetInstance().GetDriver()->getTexture("Rsrc/hero.bmp");
	m_p2DSprite->setMaterialTexture(0, pTexture);
	m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
	m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, false);
	m_p2DSprite->setPosition(position);
	m_p2DSprite->setID(0);
	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(0.5f,0.5f);	
#else
	ISceneManager* pSmgr = IrrDvc.GetSmgr();
	IVideoDriver* pDriver = IrrDvc.GetDriver();
	m_p2DSprite = pSmgr->addBillboardSceneNode();
	m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);	
	//video::ITexture* pTexture = pDriver->getTexture("Rsrc/bullet.tga");
	video::ITexture* pTexture = pDriver->getTexture("Rsrc/z_tunnel2.tga");
	pTexture->grab();
	m_p2DSprite->setMaterialTexture(0, pTexture);
	m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
	m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, true);
	m_p2DSprite->setMaterialFlag(video::EMF_ZWRITE_ENABLE, true);
	//m_p2DSprite->setSize(dimension2df(scale.X, scale.Y));
	m_p2DSprite->setPosition(position);
	m_p2DSprite->setID(ID());
//	m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(0.5f,0.5f);	
	m_initState = initState;


#endif
	// add into entity mamager	
	m_uGroupID = groupID;
	//EntityMgr.RegisterEntity(m_uGroupID,this);//test code 지금은 그냥 1로 나중에 인자로 처리

	//create skill
	CreateBasicZSkill* pcreatebasicZskill = new CreateBasicZSkill("CreateBasicZ", this, 0.5);//name,baseplayer, prof
	skills.insert(pair<std::string,Skill*>(pcreatebasicZskill->getName(), pcreatebasicZskill));

	//create mission
	pBlacBoard = pbb;
	Mission mission("CreateBasicZ",1,1);
	defendmezombieCreateMission = mission;
    pBlacBoard->addMission(defendmezombieCreateMission);
}
示例#11
0
ZombieLeader::ZombieLeader(vector3df position,
                           f64 radius,
                           vector3df velocity,
                           f64 maxSpeed,
                           vector3df heading,
                           f64 mass,
                           vector3df scale,
                           f64 turnRate,
                           f64 maxForce,
                           ZOMBIE_STATE initState,
                           BlackBoard* pbb)
{
    // get ready state machine
    m_pStateMachine = new StateMachine<ZombieLeader>(this);

    // start from nothing
    m_State = initState;//
    switch(initState)
    {
    case Zombie::ZOMBIE_STATE_IDLE:
        m_pStateMachine->ChangeState(StateZombieLeaderIdle::Instance());
        break;
    //case ZOMBIE_STATE_CHASERGROUPSTATE:
    //	m_pStateMachine->ChangeState(StateZomLeaderbieIdle::Instance());
    //	break;
    default:
        m_pStateMachine->ChangeState(StateZombieLeaderIdle::Instance());
        break;
    }

    // get ready sprite
    ISceneManager* pSmgr = IrrDvc.GetSmgr();
    IVideoDriver* pDriver = IrrDvc.GetDriver();
    m_p2DSprite = pSmgr->addBillboardSceneNode();
    m_p2DSprite->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
    video::ITexture* pTexture = pDriver->getTexture(ZOMBIELEADER_TEXTUREFILENAME);
    // shkim, TODO.
    // why should I grap this texture here? as a result, get(+1)->grab(+1)->drop(-1) will give reference count as 1.
    // that means nobody know when I release texture after using at all. how do I figure it out?
    // answer is, keeping texture resource during Proc life time. it means loading texture at Proc initializing time and releasing them at Proc releasing time.
    // for doing that, need to use grab/drop pair after getTexture()
    pTexture->grab();
    m_p2DSprite->setMaterialTexture(0, pTexture);
    m_p2DSprite->setMaterialFlag(video::EMF_LIGHTING, false);
    m_p2DSprite->setMaterialFlag(video::EMF_ZBUFFER, true);
    m_p2DSprite->setMaterialFlag(video::EMF_ZWRITE_ENABLE, true);
    m_p2DSprite->setSize(dimension2df(scale.X, scale.Y));
    m_p2DSprite->setPosition(position);
    m_p2DSprite->setID(ID());
    //m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureScale(0.5f,0.5f);
    m_p2DSprite->getMaterial(0).getTextureMatrix(0).setTextureTranslate(0.f,0.0f); // 1th sprite

    // get ready physics model
    m_pZombiePhaysics = new ZombiePhysics(&Box2dWld.GetWorld(), ID());
    m_pZombiePhaysics->SetTransform(b2Vec2(position.X, position.Y), 0.f);

    //create skill
    AttackBuildingSkill* pcreatebasicZskill = new AttackBuildingSkill("AttackBuilding", this, 0.5);//name,baseplayer, prof
    skills.insert(pair<std::string,Skill*>(pcreatebasicZskill->getName(), pcreatebasicZskill));


    m_VecRoamDest = position;
    m_uLockPosTime = 0;

    m_pBlacBoard = pbb;

    m_pCurrentMission = null;
    m_pMissionPending = null;
    m_pCurrentSkill = null;
}