cpp

// Patrick Zirjacks, Group: Stephan Vedder, Aaron Bruch
#include "Exercise4.h"

//-------------------------------------------------------------------------------------
Exercise4::Exercise4(void)
{
}
//-------------------------------------------------------------------------------------
Exercise4::~Exercise4(void)
{
	for (int i = 0;i < mSegsA.size();++i)
	{
		delete mSegsA[i];
	}

	for (int i = 0;i < mSegsB.size();++i)
	{
		delete mSegsB[i];
	}

	for (int i = 0;i < mSegsC.size();++i)
	{
		delete mSegsC[i];
	}
}

//-------------------------------------------------------------------------------------
//called on startup, when the scene is created
void Exercise4::createScene(void)
{
	// Set the default lighting.
	mSceneMgr->setAmbientLight(Ogre::ColourValue(1.0f, 1.0f, 1.0f));

	// Set the camera to look at our handiwork
	mCamera->setPosition(50.0f, 250.0f, 500.0f);

	mat = Ogre::MaterialManager::getSingletonPtr()->getByName("Examples/Rockwall");
	mat->getTechnique(0)->getPass(0)->setCullingMode(Ogre::CULL_NONE);

	int segctr = 0;
	int segmente = 4;
	srand(time(NULL));

	for (int i = 0; i < segmente; i++)
	{
		int x = rand() % 3;

		switch (x)
		{
		case 0:
			{
				segmentA* segA = new segmentA();
				Ogre::SceneNode* segA1Node = segA->createSegA(mSceneMgr, Ogre::Vector3(0.0f, 0.0f, 200.0f + segctr * 3000));
				mSegsA.push_back(segA);
			}
			break;
		case 1:
			{
				segmentB* segB = new segmentB();
				Ogre::SceneNode* segB1Node = segB->createSegB(mSceneMgr, Ogre::Vector3(0.0f, 0.0f, 200.0f + segctr * 3000));
				mSegsB.push_back(segB);
			}
			break;
		case 2:
			{
				segmentC* segC = new segmentC();
				Ogre::SceneNode* segC1Node = segC->createSegC(mSceneMgr, Ogre::Vector3(0.0f, 0.0f, 200.0f + segctr * 3000));
				mSegsC.push_back(segC);
			}
			break;
		}
		segctr++;
	}

	// Exercise 2b
	/*
	// create SegmentA
	segmentA seg1A;
	Ogre::SceneNode* segA1Node = seg1A.createSegA(mSceneMgr, Ogre::Vector3(0.0f, 0.0f, 200.0f));
	// create SegmentB
	segmentB seg1B;
	Ogre::SceneNode* segB1Node = seg1B.createSegB(mSceneMgr, Ogre::Vector3(0.0f,0.0f,3200.0f));
	
	segmentA seg2A;
	Ogre::SceneNode* segA2Node = seg2A.createSegA(mSceneMgr, Ogre::Vector3(0.0f, 0.0f, 6200.0f));
	*/
	// create SegmentA
	//segmentA seg2A;
	//Ogre::SceneNode* segA2Node = seg2A.createSegA(mSceneMgr, Ogre::Vector3(0.0f, 0.0f, 400.0f));
	/*// create SegmentB
	segmentB seg2B;
	Ogre::SceneNode* segB2Node = seg2B.createSegB(mSceneMgr, Ogre::Vector3(0.0f,0.0f,300.0f));
	// create SegmentA
	segmentA seg3A;
	Ogre::SceneNode* segA3Node = seg3A.createSegA(mSceneMgr, Ogre::Vector3(0.0f, 0.0f, 600.0f));
	// create SegmentB
	segmentB seg3B;
	Ogre::SceneNode* segB3Node = seg3B.createSegB(mSceneMgr, Ogre::Vector3(0.0f,0.0f,500.0f));
	*/
	mSceneMgr->_updateSceneGraph(mCamera);
	//mWalls.push_back(wall1Entity->getWorldBoundingBox());
	//mWalls.push_back(wall2Entity->getWorldBoundingBox());
	/*
	mWalls.push_back(seg1A.wall1AEntity->getWorldBoundingBox());
	mWalls.push_back(seg1A.wall2AEntity->getWorldBoundingBox());
	mWalls.push_back(seg1B.wall1BEntity->getWorldBoundingBox());
	mWalls.push_back(seg1B.wall2BEntity->getWorldBoundingBox());
	mWalls.push_back(seg1B.wall3BEntity->getWorldBoundingBox());
	*/
	/*
	mWalls.push_back(seg2A.wall1AEntity->getWorldBoundingBox());
	mWalls.push_back(seg2A.wall2AEntity->getWorldBoundingBox());
	mWalls.push_back(seg2B.wall1BEntity->getWorldBoundingBox());
	mWalls.push_back(seg2B.wall2BEntity->getWorldBoundingBox());
	mWalls.push_back(seg2B.wall3BEntity->getWorldBoundingBox());

  	mWalls.push_back(seg3A.wall1AEntity->getWorldBoundingBox());
	mWalls.push_back(seg3A.wall2AEntity->getWorldBoundingBox());
	mWalls.push_back(seg3B.wall1BEntity->getWorldBoundingBox());
	mWalls.push_back(seg3B.wall2BEntity->getWorldBoundingBox());
	mWalls.push_back(seg3B.wall3BEntity->getWorldBoundingBox());
	*/


	// Robot 2
	mRobot2.Create(mSceneMgr);
}

//called on startup, when the frame listener is created
void Exercise4::createFrameListener(void) {
	BaseApplication::createFrameListener();

	// 2nd Robot
	mRobot2.createFrameListener();
}


//called each frame, passes the frame event
bool Exercise4::frameRenderingQueued(const Ogre::FrameEvent &evt) {

	mRobot2.makeMove(evt,mWalls);

	return BaseApplication::frameRenderingQueued(evt);
}

//override the keyPressed event of BaseApplication
bool Exercise4::keyPressed(const OIS::KeyEvent &arg)
{
	BaseApplication::keyPressed(arg);
	mRobot2.keyDown(arg);
	return true;
}

//override the keyReleases event of BaseApplication
bool Exercise4::keyReleased(const OIS::KeyEvent &arg)
{
	BaseApplication::keyReleased(arg);
	mRobot2.keyUp(arg);
	return true;
}

#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#define WIN32_LEAN_AND_MEAN
#include "windows.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif

//program entry point
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
	INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT)
#else
	int main(int argc, char *argv[])
#endif
	{
		// Create application object
		Exercise4 app;

		try {
			app.go();
		}
		catch (Ogre::Exception& e) {
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
			MessageBox(NULL, e.getFullDescription().c_str(), "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#else
			std::cerr << "An exception has occured: " <<
				e.getFullDescription().c_str() << std::endl;
#endif
		}

		return 0;
	}

#ifdef __cplusplus
}
#endif

header

// Patrick Zirjacks, Group: Stephan Vedder, Aaron Bruch
#ifndef __Exercise4_h_
#define __Exercise4_h_
 
#include "BaseApplication.h"
#include "..\Player.h"
#include "..\SegmentA.h"
#include "..\SegmentB.h"
#include "..\SegmentC.h"
#include <vector>
#include <OgreMaterialManager.h>
#include <cstdlib>
#include <time.h> 
#include <vector>

class Exercise4 : public BaseApplication
{
public:
    Exercise4(void);
    virtual ~Exercise4(void);
 
protected:
    virtual void createScene(void);
    virtual void createFrameListener(void);
 
    virtual bool frameRenderingQueued(const Ogre::FrameEvent &evt);

	virtual bool keyPressed(const OIS::KeyEvent &arg);
	virtual bool keyReleased(const OIS::KeyEvent &arg);

	//void AttachSegments(char[]);

	std::vector<segmentA*> mSegsA;
	std::vector<segmentB*> mSegsB;
	std::vector<segmentC*> mSegsC;
	std::vector<Ogre::AxisAlignedBox> mWalls;

	// 2nd Robot
	Player mRobot2;

	//Material
	Ogre::MaterialPtr mat;

};
 
#endif // #ifndef __Exercise4_h_