예제 #1
0
void Engine::initSystems() {
	cout << "Initializing Systems" << endl;

	shared_ptr<BaseSystem> input(new InputSystem());
	systemList["input"] = input;

	// BaseSystem *player_input = new PlayerInputSystem();
	// player_input->init(this);
	// systemList["player_input"] = player_input;

	//Here we add the different input types;
	// InputSystem* myinput = (InputSystem*)systemList["input"];
	// input->inputList.push_back(input);

	// BaseSystem *animation = new AnimationSystem(12);
	// animation->init(this);
	// systemList["animation"] = animation;

	shared_ptr<BaseSystem> Terrain(new TerrainSystem(screenWidth, screenHeight));
	systemList["terrain"] = Terrain;

	shared_ptr<BaseSystem> Camera(new CameraSystem(screenWidth, screenHeight));
	systemList["camera"] = Camera;

	shared_ptr<BaseSystem> render(new RenderSystem(screenWidth, screenHeight, "Dynasty Warriors"));//"media/aztlan_bg_2x.png");
	systemList["render"] = render;

	for(auto it = systemList.begin(); it != systemList.end(); ++it) {
		it->second->init(this);
	}
}
예제 #2
0
Terrain loadMap(std::string p_fichier)
{

    std::ifstream fichier(p_fichier.c_str(), std::ios::in );  // on ouvre en lecture
    std::vector<std::pair<int,int>> temp;
    if(fichier)  // si l'ouverture a fonctionné
    {
        std::string line;  // déclaration d'une chaîne qui contiendra la ligne lue

        while(getline(fichier, line))  // tant que l'on peut mettre la ligne dans "contenu"
        {
            std::istringstream iss;
            iss.str(line);
            std::string i, j;
            iss >> i >> j ;

            temp.push_back(std::pair<int,int>(std::atoi(i.c_str()), std::atoi(j.c_str())));

        }
        fichier.close();
    }

    std::cout << temp.size() <<"_"<< std::endl;

    return Terrain(temp);
}
예제 #3
0
sint32 World::GetMaxShieldsFromTerrain()
{
	static sint32 max_prod = 0;

	if (max_prod != 0)
		return max_prod;

	for (sint32 i = 0; i < g_theTerrainDB->NumRecords(); i++) 
    {
        max_prod = std::max(max_prod, Terrain(g_theTerrainDB->Get(i)).GetShield());
	}

	return max_prod;
}
예제 #4
0
sint32 World::GetAvgGoldFromTerrain()
{
	static sint32 avg_gold = 0;

	if (avg_gold != 0)
		return avg_gold;

	for (sint32 i = 0; i < g_theTerrainDB->NumRecords(); i++) 
    {
		avg_gold += Terrain(g_theTerrainDB->Get(i)).GetGold();
	}
	avg_gold /= g_theTerrainDB->NumRecords();

	return avg_gold;
}
예제 #5
0
sint32 World::GetAvgShieldsFromTerrain()
{
	static sint32 avg_prod = 0;

	if (avg_prod != 0)
		return avg_prod;

	for (sint32 i = 0; i < g_theTerrainDB->NumRecords(); i++) 
    {
		avg_prod += Terrain(g_theTerrainDB->Get(i)).GetShield();
	}
	avg_prod /= g_theTerrainDB->NumRecords();

	return avg_prod;
}
예제 #6
0
void TerrainTests::testCreate()
{
	Terrain* t = OGRE_NEW Terrain(mSceneMgr);
	Image img;
	img.load("terrain.png", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

	Terrain::ImportData imp;
	imp.inputImage = &img;
	imp.terrainSize = 513;
	imp.worldSize = 1000;
	imp.minBatchSize = 33;
	imp.maxBatchSize = 65;
	t->prepare(imp);
	// don't load, this requires GPU access
	//t->load();

	OGRE_DELETE t;
}
예제 #7
0
파일: world.cpp 프로젝트: FerryT/OGO-2.3
World::World(double _width, double _height)
	: BoundedObject(Pd(), Qd(),
	  BoundingBox(Pd(-_width/2, -_height/2, 0), Pd(_width,0,0), Pd(0,_height,0), Pd(_width,_height,0), Pd(), Pd(), Pd(), Pd(_width/2, _height/2, HIGH)),
	  Assets::WorldMaterial)
{

	ObjectHandle tHandle;
	tHandle = Terrain(_width, _height);
	terrain = TO(Terrain, tHandle);
	children.insert(tHandle);

	ObjectHandle hudHandle;
	hudHandle = HUD(640, 480);
	hud = TO(HUD, hudHandle);
	children.insert(hudHandle);

	children.insert(Sky((int) _width, (int) _height));

	width = _width;
	height = _height;
}
예제 #8
0
int main(void)
{
	//Initialize allegro--------------------------------
	MainUtility.InitAllegro();
	if (MainUtility.Get_GameOver())
	{
		return -1;
	}


	srand(time(NULL));

	//variables-----------------------------------------
	const int FPS = 60;

	//Allegro variables---------------------------------
	ALLEGRO_EVENT_QUEUE *Event_Queue = NULL;
	ALLEGRO_TIMER *Timer = NULL;

	Event_Queue = al_create_event_queue();				
	Timer = al_create_timer(1.0 / FPS);

	Display MainDisplay(Event_Queue);

	if (!MainDisplay.TestDisplay())
	{
		return -1;
	}

	ALLEGRO_BITMAP *DungeonTiles = al_load_bitmap("Test.png");
	ALLEGRO_BITMAP *AIImage = al_load_bitmap("AI_Sprite.png");
	ALLEGRO_BITMAP *PlayerImage = al_load_bitmap("Player_Sprite.png");
	ALLEGRO_BITMAP *BowImage = al_load_bitmap("Bow_Sprite.png");
	ALLEGRO_BITMAP *SwordImage = al_load_bitmap("Sword_Sprite.png");

	Player MainPlayer(PlayerImage, SwordImage, BowImage, MainDisplay.Get_ScreenWidth(), MainDisplay.Get_ScreenHeight(), Event_Queue);
	Camera MainCamera(Event_Queue);
	AI_Group TestAIGroup;  // Instance of an AI_Group

	TerrainGenerator Terrain(1);
	Terrain.generateTerrain();

	DungeonGenerator Dungeon(Event_Queue, &MainPlayer);
	Dungeon.GenerateDungeon(MainDisplay);

	MainPlayer.SetXPosition(Dungeon.GetStartPosition().x());
	MainPlayer.SetYPosition(Dungeon.GetStartPosition().y());

	TestAIGroup.RandomSetup(4, Dungeon, AIImage);  // Generates 4 AI with random attributes in the group. Their spawn points will also be set randomly.
	TestAIGroup.GetPathToPlayer(MainPlayer);  // For testing, generate a path to the player's start position from each AI


	ALLEGRO_EVENT_SOURCE ProjectileEvent;
	al_init_user_event_source(&ProjectileEvent);

	

	
	al_register_event_source(Event_Queue, al_get_timer_event_source(Timer));
	al_register_event_source(Event_Queue, al_get_keyboard_event_source());
	al_register_event_source(Event_Queue, al_get_mouse_event_source());
	

	al_start_timer(Timer);
	//Main game loop------------------------------------
	while (!MainUtility.Get_GameOver())
	{
		ALLEGRO_EVENT ev;
		al_wait_for_event(Event_Queue, &ev);
		
		MainPlayer.EventHandler(ev, MainCamera.GetMouseXWorldCoordinate(), MainCamera.GetMouseYWorldCoordinate());
		TestAIGroup.ProcessAll(ev, MainPlayer);  // Process each AI in the group
		MainCamera.EventHandler(ev, MainPlayer.GetXPosition(), MainPlayer.GetYPosition());
		MainDisplay.Event_Handler(ev); 
		Dungeon.Event_Handler(ev);
		
		// Collide with AI
		if (TestAIGroup.CollideWithAI(MainPlayer.GetCollisionXBoundOne(), MainPlayer.GetCollisionYBoundOne()))
			MainPlayer.MovementCollidingBoundOne();
		if (TestAIGroup.CollideWithAI(MainPlayer.GetCollisionXBoundTwo(), MainPlayer.GetCollisionYBoundTwo()))
			MainPlayer.MovementCollidingBoundTwo();
		// Hit the AI
		TestAIGroup.HitAI(MainPlayer.GetWeaponHitBoxXBoundOne(), MainPlayer.GetWeaponHitBoxYBoundOne(), MainPlayer.GetWeaponDamage());
		TestAIGroup.HitAI(MainPlayer.GetWeaponHitBoxXBoundTwo(), MainPlayer.GetWeaponHitBoxYBoundTwo(), MainPlayer.GetWeaponDamage());

		if (Dungeon.Get_Map()->CheckMapCollision(Vec2f(MainPlayer.GetCollisionXBoundOne(), MainPlayer.GetCollisionYBoundOne())))
			MainPlayer.MovementCollidingBoundOne();
		if (Dungeon.Get_Map()->CheckMapCollision(Vec2f(MainPlayer.GetCollisionXBoundTwo(), MainPlayer.GetCollisionYBoundTwo())))
			MainPlayer.MovementCollidingBoundTwo();


		//Code Dealing with drawing to the screen goes within this if statement
		if (al_is_event_queue_empty(Event_Queue))
		{
			Dungeon.Draw();
			MainPlayer.DrawPlayer();
			//Terrain.draw();
			TestAIGroup.DrawAll();  // Draw all AI (magenta squares). Their generated paths will also be drawn (small magenta circles).
			
			//Draw display last
			MainDisplay.Draw();
		}
	}

	
	//Game Ending--------------------------------------

	return 0;
}
예제 #9
0
// Keyboard function
void keyboard(unsigned char key, int x, int y) {
    
    
    switch (key) {
        case 'q': // Exit window
        case 'Q':
            exit(0);
            break;
        case'[':
            camPos[1] += 1; // Go upwards in scene
            break;
        case ']':
            camPos[1] -= 1; // Go downwards in scene
            break;
        case 'r':
            case 'R': // Randomize terrain
            t = Terrain(tSize,80);
            t.setWireMode(wMode);
            t.setColMode(colMode);
            t.generate();
            t.vertexNormal();
            refresh = true;
            
            break;
        case 'w':
            case 'W': // Turn on/off Wiremode
            if (wMode == 1){
                wMode++;
            } else if (wMode == 2){
                wMode++;
            }else if (wMode == 3){
                wMode = 1;
            }
            
            t.setWireMode(wMode);
            break;
        case 'a':
            case 'A': // Increase size and randomize terrain
            if (tSize < 300){
                tSize+=50;
                t = Terrain(tSize,80);
                t.generate();
                t.vertexNormal();
                t.setWireMode(wMode);
            }

            break;
        case 's':
            case 'S': // Decrease and randomize terrain
            if (tSize > 50){
                tSize-=50;
                t = Terrain(tSize,80);
                t.generate();
                t.vertexNormal();
                t.setWireMode(wMode);
            }
            break;
        case 'l':
            case 'L': // Turn on lighting
            if (lightOn == false){
                lightOn = true;
                glEnable(GL_LIGHTING);
            } else if (lightOn == true){
                lightOn = false;
                glDisable(GL_LIGHTING);
            }
            
            t.setLight(lightOn);
            break;
          
            
        case 'd':
            case 'D': // Switch between each type of shading (Flat / Gourad)
            
            // If light mode is requested, turn the light on
            if (lightOn == true) {
            glEnable(GL_COLOR_MATERIAL);
            glEnable(GL_LIGHTING);
            glEnable(GL_LIGHT0);
            glEnable(GL_NORMALIZE);
            
            // Dictates what type of shading to use
            if (shadeMode == 0){
                shadeMode = 1;
            glShadeModel(GL_SMOOTH);
            } else if (shadeMode == 1){
                shadeMode = 0;
                glShadeModel(GL_FLAT);
            }
            }
            break;
        
        case 'c': // Enables/Disables colour mode
            case 'C':
            if (colMode == true){
                colMode = false;
            } else if (colMode == false){
                colMode = true;
            }
            t.setColMode(colMode);
            
            break;
            
    
    }
    glutPostRedisplay();
}
예제 #10
0
/* main function - program entry point */
int main(int argc, char** argv) {
    
    cout << "--LEGEND-- \n";
    cout << "Key 'q': Exits program \n";
    cout << "Key 'r': Random terrain generation \n";
    cout << "Key 'w': Enables/Disables full polygon/wireframe/full poly-wireframe mode \n";
    cout << "Key 'a': Generate new enlarged terrain (up to 300x300) \n";
    cout << "Key 's': Generate new smaller terrain (down to 50x50) \n";
    cout << "Key 'l': Enables/Disables lighting \n";
    cout << "Key 'd': Switches between flat/gourad shading \n";
    cout << "Key 'c': Switches on colour mode \n";
    cout << "\n";
    
    cout << "Please input the terrain size and number of iterations \n";
    cout << "Size: \n";
    int size;
    cin >> size;
    cout << "Iterations: \n";
    int cuts;
    cin >> cuts;
    
    
   
    
    
    
    // Generates a terrain on program startup
    t = Terrain(size,cuts);
    t.generate();
    t.vertexNormal();
    
    
    glutInit(&argc, argv);		//starts up GLUT
    
    //** 2-D OVERVIEW WINDOW **/
    
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(300, 300);
    glutInitWindowPosition(910, 100);
    
    glutCreateWindow("2-D Overview");	//creates the window
    glutDisplayFunc(overviewDisplay); //registers "overviewDisplay" as the display callback function
  
  
    
    //** MAIN TERRAIN WINDOW **
    
    
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    glutInitWindowSize(800, 800);
    glutInitWindowPosition(100, 100);
    
    glutCreateWindow("Terrain Generator");	//creates the window
    glutDisplayFunc(display);   //registers "display" as the display callback function
    glutKeyboardFunc(keyboard); // registers "keyboard" callback
    glutSpecialFunc(special); // registers "special key" callback
    glutReshapeFunc(reshape); // registers "reshape" callback
    init();
    

    
    glutMainLoop();				//starts the event loop
    
    
    return (0);					//return may not be necessary on all compilers
}
예제 #11
0
#  include <GL/gl.h>
#  include <GL/glu.h>
#  include <GL/freeglut.h>
#endif
#endif

#include "Terrain.h"
#include <stdlib.h>
#include <iostream>



// Defines all of our variables

float camPos[] = { 50, 60, 50 };
Terrain t = Terrain(300,300); // Create new instance of Terrain class
float L1Pos[4] = { 10, 50, 10, 0 }; //store position of light
int wMode = 1;
int tSize = 50;
bool lightOn = false;
int shadeMode = 0;
int height, width;
bool colMode = false;
bool refresh = false;



// Keyboard function
void keyboard(unsigned char key, int x, int y) {
    
    
예제 #12
0
//----------------------------------------------------------------------------
void Terrains::CreateScene ()
{
	// Create the root of the scene.
	mScene = new0 Node();

	// Load and initialize the sky dome.  It follows the camera.
	std::string skyMeshName = Environment::GetPathR("SkyDomePNT2.wmvf");
	Visual::PrimitiveType type;
	VertexFormat* vformat;
	VertexBuffer* vbuffer;
	IndexBuffer* ibuffer;
	Visual::LoadWMVF(skyMeshName, type, vformat, vbuffer, ibuffer);
	mSkyDome = new0 TriMesh(vformat, vbuffer, ibuffer);
	mScene->AttachChild(mSkyDome);

	APoint skyPosition = mCamera->GetPosition();
	skyPosition[2] = 0.0f;
	mSkyDome->LocalTransform.SetTranslate(skyPosition);
	mSkyDome->LocalTransform.SetUniformScale(mCamera->GetDMax());

	Texture2DEffect* skyEffect = new0 Texture2DEffect(
	                                 Shader::SF_LINEAR_LINEAR, Shader::SC_REPEAT, Shader::SC_REPEAT);
	std::string skyTextureName = Environment::GetPathR("SkyDome.wmtf");
	Texture2D* skyTexture = Texture2D::LoadWMTF(skyTextureName);
	skyTexture->GenerateMipmaps();
	mSkyDome->SetEffectInstance(skyEffect->CreateInstance(skyTexture));

	// Load the height field and create the terrain.
	vformat = VertexFormat::Create(3,
	                               VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
	                               VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0,
	                               VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 1);

	// For lower-resolution terrain, change the paths to Height64/Color64 or
	// Height32/Color32.
	std::string heightName = ThePath + "Data/Height128/height";
	std::string colorName = ThePath + "Data/Color128/color";

	mTerrain = new0 Terrain(heightName, vformat, mCamera);
	mScene->AttachChild(mTerrain);

	// The effect that is shared across all pages.
	std::string effectFile =
	    Environment::GetPathR("BaseMulDetailFogExpSqr.wmfx");
	TerrainEffect* terrainEffect = new0 TerrainEffect(effectFile);

	std::string detailName = Environment::GetPathR("Detail.wmtf");
	Texture2D* detailTexture = Texture2D::LoadWMTF(detailName);
	detailTexture->GenerateMipmaps();

	ShaderFloat* fogColorDensity = new0 ShaderFloat(1);
	(*fogColorDensity)[0] = 0.5686f;
	(*fogColorDensity)[1] = 0.7255f;
	(*fogColorDensity)[2] = 0.8353f;
	(*fogColorDensity)[3] = 0.0015f;

	// Attach an effect to each page.  Preload all resources to video memory.
	// This will avoid frame rate stalls when new terrain pages are
	// encountered as the camera moves.
	const int numRows = mTerrain->GetRowQuantity();
	const int numCols = mTerrain->GetColQuantity();
	for (int r = 0; r < numRows; ++r)
	{
		for (int c = 0; c < numCols; ++c)
		{
			TerrainPage* page = mTerrain->GetPage(r, c);

			char suffix[32];
			sprintf(suffix, ".%d.%d.wmtf", r, c);
			std::string colorTextureName = colorName + std::string(suffix);
			Texture2D* colorTexture = Texture2D::LoadWMTF(colorTextureName);
			colorTexture->GenerateMipmaps();

			VisualEffectInstance* instance = terrainEffect->CreateInstance(
			                                     colorTexture, detailTexture, fogColorDensity);

			page->SetEffectInstance(instance);

			mRenderer->Bind(page->GetVertexBuffer());
			mRenderer->Bind(page->GetVertexFormat());
			mRenderer->Bind(page->GetIndexBuffer());
			mRenderer->Bind(colorTexture);
		}
	}
}
예제 #13
0
파일: main.cpp 프로젝트: schnapple/LifeSim
void Run() {

		SetKey(GLFW_KEY_ESCAPE, std::bind(&Terminate));

		deltaTime = 1.0 / 60.0;
		InitializeWindow();


		//Init values and objects

		// Build the broadphase
		btBroadphaseInterface* broadphase = new btDbvtBroadphase();

		// Set up the collision configuration and dispatcher
		btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration();
		btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration);

		// The actual physics solver
		btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver;

		// The world.
		btDiscreteDynamicsWorld* world = new btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration);
		world->setGravity(btVector3(0, -9.82f*METER, 0));


		Terrain testObj = Terrain(world);
		Object* terrain = &testObj;
		objects.push_back(terrain);

		Anatomy testOrg = Anatomy(world);
		Object* testOrgP = &testOrg;
		objects.push_back(testOrgP);



		//timer info for loop
		double t = 0.0f;
		double currentTime = glfwGetTime();
		double accumulator = 0.0f;

		glfwPollEvents();		//stop loop when glfw exit is called
		glfwSetCursorPos(mainThread, SCREEN_SIZE.x / 2.0f, SCREEN_SIZE.y / 2.0f);



		while (!glfwWindowShouldClose(mainThread)) {
			double newTime = glfwGetTime();
			double frameTime = newTime - currentTime;
			//std::cout << "FPS:: " <<1.0f / frameTime << std::endl;

			//setting up timers
			if (frameTime > 0.25) {
				frameTime = 0.25;
			}
			currentTime = newTime;
			accumulator += frameTime;

			//# of updates based on accumulated time

			while (accumulator >= deltaTime) {

				
				MouseInput();//update mouse change
				glfwPollEvents(); //executes all set input callbacks

				CameraInput(); //bypasses input system for direct camera manipulation
				Update(deltaTime); //updates all objects based on the constant deltaTime.

				world->stepSimulation(deltaTime, 10);

				t += deltaTime;
				accumulator -= deltaTime;
			}


			//draw
			glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


			Draw();

			glfwSwapBuffers(mainThread);
	}



	//cleanup
		delete world;
		delete solver;
		delete dispatcher;
		delete collisionConfiguration;
		delete broadphase;

}
예제 #14
0
Terrain MapHandler::getNextTerrain()
{
    //find the appropriate tile graphic and store it
    Terrain temp = Terrain();
    Frame frame;
    switch(map[xTer][yTer])
    {
        //trees (picks from a selection of trees)
        case 'T':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 32, 64, 0, 0, 32, 64, SHEET_TERRAIN);
            frame.addStandBox(5, 40, 22, 20);
            temp.addFrame(frame);
            break;
            
        case '0':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 128, 0, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case '1':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 144, 0, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case '2':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 160, 0, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case '3':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 176, 0, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case '4':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 128, 16, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case '5':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 144, 16, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case '6':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 160, 16, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case '7':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 176, 16, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
            
        case '8':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 128, 32, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case '9':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 144, 32, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case 'A':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 160, 32, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case 'B':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 176, 32, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case 'C':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 128, 48, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case 'D':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 144, 48, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case 'E':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 160, 48, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
        
        case 'F':
            frame = Frame(0, xTer*TILES_X, yTer*TILES_Y+UI_HEIGHT, 16, 16, 176, 48, 16, 16, SHEET_TERRAIN);
            frame.addStandBox(0, 0, 16, 16);
            temp.addFrame(frame);
            break;
    }
    
    //increment x/y counters
    xTer++;
    if (xTer >= 30)
    {
        xTer = 0;
        yTer++;
    }
    
    return temp;
}