Merge branch 'developer' into enemy

# Conflicts:
#	CrystalPoint.cpp
#	Entity.cpp
#	Player.cpp
#	Player.h
#	World.cpp
#	World.h

CrystalPoint.cpp

@@ -6,10 +6,14 @@
 #include "WorldHandler.h"
 #include "Player.h"
 
+int CrystalPoint::width = 0;
+int CrystalPoint::height = 0;
+
 void CrystalPoint::init()
 {
 	player = Player::getInstance();
 	worldhandler = WorldHandler::getInstance();
+	//cursor = Cursor::getInstance();
 
 	lastFrameTime = 0;
 
@@ -34,23 +38,8 @@ void CrystalPoint::draw()
 	glLoadIdentity();
 
 	worldhandler->draw();
-	
-	//Draw Cursor
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	glOrtho(0,width, height,0,-10,10);
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
 
-	glDisable(GL_LIGHTING);
-	glDisable(GL_DEPTH_TEST);
-	glColor4f(1, cos(glutGet(GLUT_ELAPSED_TIME) / 1000.0f), sin(glutGet(GLUT_ELAPSED_TIME) / 1000.0f), 1);
-
-	glBegin(GL_TRIANGLES);
-	glVertex2f(mousePosition.x, mousePosition.y);
-	glVertex2f(mousePosition.x+15, mousePosition.y+15);
-	glVertex2f(mousePosition.x+5, mousePosition.y+20);
-	glEnd();
+	//cursor->draw();
 
 	glutSwapBuffers();
 }
@@ -78,7 +67,7 @@ void CrystalPoint::update()
 	if (player->rotation.x < -90)
 		player->rotation.x = -90;
 
-	float speed = 2;
+	float speed = 10;
 
 	Vec3f oldPosition = player->position;
 	if (keyboardState.keys['a']) player->setPosition(0, deltaTime*speed, false);
@@ -91,11 +80,12 @@ void CrystalPoint::update()
 	if (!worldhandler->isPlayerPositionValid())
 		player->position = oldPosition;
 
-	//player->position.y = worldhandler->getHeight(player->position.x, player->position.z) + 1.7f;
+	player->position.y = worldhandler->getHeight(player->position.x, player->position.z) + 1.7f;
 
 	worldhandler->update(deltaTime);
 
 	mousePosition = mousePosition + mouseOffset;
+	//cursor->update(mousePosition);
 
 	mouseOffset = Vec2f(0, 0);
 	prevKeyboardState = keyboardState;

CrystalPoint.h

@@ -24,12 +24,11 @@ public:
 	WorldHandler* worldhandler;
 	Player* player;
 
-	int width, height;
+	static int width, height;
 	KeyboardState keyboardState;
 	KeyboardState prevKeyboardState;
 
 	Vec2f mouseOffset;
-
 	Vec2f mousePosition;
 
 	float lastFrameTime;

CrystalPoint.vcxproj

@@ -152,9 +152,11 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="CrystalPoint.cpp" />
+    <ClCompile Include="Cursor.cpp" />
     <ClCompile Include="Enemy.cpp" />
     <ClCompile Include="Entity.cpp" />
     <ClCompile Include="HeightMap.cpp" />
+    <ClCompile Include="Interface.cpp" />
     <ClCompile Include="json.cpp" />
     <ClCompile Include="LevelObject.cpp" />
     <ClCompile Include="Main.cpp" />
@@ -167,9 +169,11 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="CrystalPoint.h" />
+    <ClInclude Include="Cursor.h" />
     <ClInclude Include="Enemy.h" />
     <ClInclude Include="Entity.h" />
     <ClInclude Include="HeightMap.h" />
+    <ClInclude Include="Interface.h" />
     <ClInclude Include="json.h" />
     <ClInclude Include="LevelObject.h" />
     <ClInclude Include="Main.h" />
@@ -184,6 +188,7 @@
   <ItemGroup>
     <None Include="worlds\fire.json" />
     <None Include="worlds\ice.json" />
+    <None Include="worlds\small.json" />
     <None Include="worlds\worlds.json" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

CrystalPoint.vcxproj.filters

@@ -63,6 +63,12 @@
     <ClCompile Include="CrystalPoint.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Cursor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Interface.cpp">
+      <Filter>Source Files\World</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="World.h">
@@ -77,9 +83,6 @@
     <ClInclude Include="LevelObject.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="vector.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Model.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -107,6 +110,15 @@
     <ClInclude Include="CrystalPoint.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Interface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Cursor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="vector.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="worlds\worlds.json">
@@ -118,5 +130,8 @@
     <None Include="worlds\ice.json">
       <Filter>Source Files\json</Filter>
     </None>
+    <None Include="worlds\small.json">
+      <Filter>Source Files\json</Filter>
+    </None>
   </ItemGroup>
 </Project>

Cursor.cpp

@@ -0,0 +1,58 @@
+#include "Cursor.h"
+#include <GL\freeglut.h>
+#include <cmath>
+#include "CrystalPoint.h"
+
+Cursor* Cursor::instance = NULL;
+
+Cursor::Cursor()
+{
+	enabled = false;
+}
+
+Cursor::~Cursor()
+{
+}
+
+Cursor* Cursor::getInstance(void)
+{
+	if (instance == nullptr)
+		instance = new Cursor();
+	
+	return instance;
+}
+
+void Cursor::enable(bool enable)
+{
+	enabled = enable;
+}
+
+bool Cursor::isEnabled(void)
+{
+	return enabled;
+}
+
+void Cursor::draw(void)
+{
+	//Draw Cursor
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	glOrtho(0, CrystalPoint::width, CrystalPoint::height, 0, -10, 10);
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
+
+	glDisable(GL_LIGHTING);
+	glDisable(GL_DEPTH_TEST);
+	glColor4f(1, cos(glutGet(GLUT_ELAPSED_TIME) / 1000.0f), sin(glutGet(GLUT_ELAPSED_TIME) / 1000.0f), 1);
+
+	glBegin(GL_TRIANGLES);
+	glVertex2f(mousePosition.x, mousePosition.y);
+	glVertex2f(mousePosition.x + 15, mousePosition.y + 15);
+	glVertex2f(mousePosition.x + 5, mousePosition.y + 20);
+	glEnd();
+}
+
+void Cursor::update(Vec2f newPosition)
+{
+	mousePosition = newPosition;
+}

Cursor.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "Vector.h"
+
+class Cursor
+{
+private:
+	Cursor();
+
+	static Cursor* instance;
+	bool enabled;
+	Vec2f mousePosition;
+public:
+	
+	~Cursor();
+
+	static Cursor* getInstance(void);
+	
+	void enable(bool enable);
+	bool isEnabled(void);
+
+	void draw(void);
+	void update(Vec2f newPosition);
+};
+

Entity.cpp

@@ -21,7 +21,6 @@ Entity::~Entity()
 
 void Entity::draw()
 {
-	//rotation.y += 0.05f;
 	if (model)
 	{
 		glPushMatrix();
@@ -31,7 +30,6 @@ void Entity::draw()
 		glRotatef(rotation.y, 0, 1, 0);
 		glRotatef(rotation.z, 0, 0, 1);
 		glScalef(scale, scale, scale);
-		//glTranslatef(-model->center.x, 0, -model->center.z);
 
 		glEnable(GL_CULL_FACE);
 		glCullFace(GL_BACK);

HeightMap.cpp

@@ -2,21 +2,31 @@
 #include "stb_image.h"
 #include "vector.h"
 
+#include "LevelObject.h"
+
 #include <GL/freeglut.h>
 #include <iostream>
 #include <string>
+#include "World.h"
 
+#define RED 0
+#define GREEN 1
+#define BLUE 2
+#define ALPHA 3
 
-HeightMap::HeightMap(const std::string &file, float scale)
+HeightMap::HeightMap(const std::string &file, World* world)
 {
-	this->scale = scale;
-
 	int bpp;
 	unsigned char* imgData = stbi_load(file.c_str(), &width, &height, &bpp, 4);
 
 	auto heightAt = [&](int x, int y)
 	{
-		return (imgData[(x + y * width) * 4] / 256.0f) * 100.0f;
+		return (imgData[(x + y * width) * 4 ] / 256.0f) * 50.0f;
+	};
+
+	auto valueAt = [&](int x, int y, int offset = 0)
+	{
+		return imgData[(x + y * width) * 4 + offset];
 	};
 
 	for (int y = 0; y < height-1; y++)
@@ -27,13 +37,18 @@ HeightMap::HeightMap(const std::string &file, float scale)
 			Vec3f ca(0, heightAt(x, y + 1) - heightAt(x, y), 1);
 			Vec3f ba(1, heightAt(x + 1, y) - heightAt(x, y), 0);
 
+			if (valueAt(x, y, GREEN) > 0)
+			{
+				world->addLevelObject(new LevelObject(world->getObjectFromValue(valueAt(x, y, GREEN)).first, Vec3f(x, heightAt(x, y), y), Vec3f(0, 0, 0), 1, world->getObjectFromValue(valueAt(x, y, GREEN)).second));
+			}
+
 			Vec3f normal = ca.cross(ba);
 			normal.Normalize();
 
 			for (int i = 0; i < 4; i++)
 			{
 				float h = heightAt(x + offsets[i][0], y + offsets[i][1]);
-				vertices.push_back(Vertex{ (float)(x + offsets[i][0])*scale, h*scale, (float)(y + offsets[i][1])*scale,
+				vertices.push_back(Vertex{ (float)(x + offsets[i][0]), h, (float)(y + offsets[i][1]),
 									normal.x, normal.y, normal.z,
 									(x + offsets[i][0]) / (float)height, (y + offsets[i][1]) / (float)width } );
 			}
@@ -91,13 +106,17 @@ void HeightMap::Draw()
 
 float HeightMap::GetHeight(float x, float y)
 {
-	x /= scale;
-	y /= scale;
 	int ix = x;
 	int iy = y;
 
 	int index = (ix + (width - 1) * iy) * 4;
 
+	if (index + 3 >= vertices.size())
+		index = vertices.size() - 4;
+
+	if (index < 0)
+		index = 0;
+
 	Vertex& a = vertices[index];
 	Vertex& b = vertices[index+1];
 	Vertex& c = vertices[index+3];

HeightMap.h

@@ -5,6 +5,8 @@
 #include <vector>
 #include <GL/freeglut.h>
 
+class World;
+
 class HeightMap
 {
 private:
@@ -12,9 +14,8 @@ private:
 	int width;
 
 	GLuint imageIndex;
-	int scale;
 public:
-	HeightMap(const std::string &file, float scale);
+	HeightMap(const std::string &file, World* world);
 	~HeightMap();
 
 	void Draw();

Interface.cpp

@@ -0,0 +1,94 @@
+#include "Interface.h"
+#include <GL\freeglut.h>
+#include "CrystalPoint.h"
+
+#include <string>
+
+#include "Player.h"
+
+//Prototype
+void glutBitmapString(std::string str, int x, int y);
+
+Interface::Interface()
+{
+}
+
+
+Interface::~Interface()
+{
+}
+
+void Interface::draw()
+{
+	Player* player = Player::getInstance();
+
+	//Switch view to Ortho
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	glOrtho(0, 1000, 1000, 0, -10, 10);
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
+
+	glDisable(GL_LIGHTING);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_TEXTURE_2D);
+	
+	//Draw interface
+
+	//Health bar
+	glBegin(GL_QUADS);
+	glColor4f(0,0,0, 1.0);
+	glVertex2f(250, 980);
+	glVertex2f(250, 965);
+	glVertex2f(750, 965);
+	glVertex2f(750, 980);
+	glEnd();
+
+	glBegin(GL_QUADS);
+	glColor4f(1.0f, 0.1f, 0.1f, 1.0);
+	glVertex2f(250, 980);
+	glVertex2f(250, 965);
+
+	glColor4f(1.0f, 0.5f, 0.5f, 1.0);
+	glVertex2f(250 + (player->health / 100 * 500), 965);
+	glVertex2f(250 + (player->health / 100 * 500), 980);
+	glEnd();
+
+	//XP bar
+	glBegin(GL_QUADS);
+	glColor4f(0, 0, 0, 1.0);
+	glVertex2f(250, 950);
+	glVertex2f(250, 935);
+	glVertex2f(750, 935);
+	glVertex2f(750, 950);
+	glEnd();
+
+	glBegin(GL_QUADS);
+	glColor4f(1.0f, 1.0f, 0.1f, 1.0);
+	glVertex2f(250, 950);
+	glVertex2f(250, 935);
+
+	glColor4f(1.0f, 1.0f, 0.5f, 1.0);
+	glVertex2f(250 + (player->xp / 100 * 500), 935);
+	glVertex2f(250 + (player->xp / 100 * 500), 950);
+	glEnd();
+
+	//Text: level
+	glColor4f(1.0f, 1.0f, 0.1f, 1.0);
+	glutBitmapString("Level: " + std::to_string(player->level), 490, 900);
+
+}
+
+void Interface::update(float deltaTime)
+{
+
+}
+
+void glutBitmapString(std::string str, int x, int y)
+{
+	glRasterPos2f(x, y);
+	for (int i = 0; i < str.size(); i++)
+	{
+		glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, str[i]);
+	}
+}

Interface.h

@@ -0,0 +1,11 @@
+#pragma once
+class Interface
+{
+public:
+	Interface();
+	~Interface();
+
+	void draw(void);
+	void update(float deltaTime);
+};
+

LevelObject.cpp

@@ -7,6 +7,8 @@ LevelObject::LevelObject(const std::string &fileName, const Vec3f &position, con
 {
 	model = Model::load(fileName);
 	this->position = position;
+	this->position.x -= model->center.x;
+	this->position.z -= model->center.z;
 	this->rotation = rotation;
 	this->scale = scale;
 	this->canCollide = hasCollision;

Main.cpp

@@ -21,7 +21,7 @@ int main(int argc, char* argv[])
 
 	glutDisplayFunc([]() { app->draw(); } );
 	glutIdleFunc([]() { app->update(); } );
-	glutReshapeFunc([](int w, int h) { app->width = w; app->height = h; glViewport(0, 0, w, h); });
+	glutReshapeFunc([](int w, int h) { CrystalPoint::width = w; CrystalPoint::height = h; glViewport(0, 0, w, h); });
 
 	//Keyboard
 	glutKeyboardFunc([](unsigned char c, int, int) { app->keyboardState.keys[c] = true; });
@@ -29,8 +29,7 @@ int main(int argc, char* argv[])
 	glutSpecialFunc([](int c, int, int) { app->keyboardState.special[c] = true; });
 	glutSpecialUpFunc([](int c, int, int) { app->keyboardState.special[c] = false; });
 	
-	//Mouse
-	glutPassiveMotionFunc([](int x, int y)
+	auto mousemotion = [](int x, int y)
 	{
 		if (justMoved)
 		{
@@ -41,11 +40,18 @@ int main(int argc, char* argv[])
 		int dy = y - app->height / 2;
 		if ((dx != 0 || dy != 0) && abs(dx) < 400 && abs(dy) < 400)
 		{
-			app->mouseOffset = app->mouseOffset + Vec2f(dx,dy);
+			app->mouseOffset = app->mouseOffset + Vec2f(dx, dy);
 			glutWarpPointer(app->width / 2, app->height / 2);
 			justMoved = true;
 		}
-	});
+	};
+
+	//Mouse
+	glutPassiveMotionFunc(mousemotion);
+	glutMotionFunc(mousemotion);
+
+	CrystalPoint::height = GLUT_WINDOW_HEIGHT;
+	CrystalPoint::width = GLUT_WINDOW_WIDTH;
 
 	glutMainLoop();
 	return 0;
@@ -86,5 +92,5 @@ void configureOpenGL()
 	glEnable(GL_LIGHTING);
 	glEnable(GL_LIGHT0);
 
-	glutSetCursor(GLUT_CURSOR_CROSSHAIR);
+	glutSetCursor(GLUT_CURSOR_NONE);
 }

Player.cpp

@@ -7,7 +7,10 @@ Player* Player::instance = NULL;
 
 Player::Player()
 {
-	
+	speed = 10;
+	health = 50;
+	xp = 75;
+	level = 10;
 }
 
 Player* Player::getInstance()

Player.h

@@ -22,4 +22,10 @@ public:
 
 	Model* leftWeapon;
 	Model* rightWeapon;
+
+	float health;
+	float xp;
+	int level;
+
+	float speed;
 };

World.cpp

@@ -1,16 +1,21 @@
 #include "World.h"
 #include <GL/freeglut.h>
 #include "Entity.h"
-#include "LevelObject.h"
 #include "json.h"
 #include "Model.h"
+#include "CrystalPoint.h"
 #include <fstream>
 #include <iostream>
 
 World::World(const std::string &fileName)
 {
+	//Store player instance
 	player = Player::getInstance();
 
+	//Create the interface
+	interface = new Interface();
+
+	//Open world json file
 	std::ifstream file(fileName);
 	if(!file.is_open())
 		std::cout<<"Error, can't open world file - " << fileName << "\n";
@@ -18,68 +23,94 @@ World::World(const std::string &fileName)
 	json::Value v = json::readJson(file);
 	file.close();
 
+	//Check file
 	if(v["world"].isNull() || v["world"]["heightmap"].isNull())
 		std::cout << "Invalid world file: world - " << fileName << "\n";
 	if (v["player"].isNull() || v["player"]["startposition"].isNull())
 		std::cout << "Invalid world file: player - " << fileName << "\n";
 	if (v["objects"].isNull())
 		std::cout << "Invalid world file: objects - " << fileName << "\n";
+	if (v["world"]["object-templates"].isNull())
+		std::cout << "Invalid world file: object templates - " << fileName << "\n";
 
-	float scale = 1.0f;
-	if (!v["world"]["scale"].isNull())
-		scale = v["world"]["scale"].asFloat();
+	//Load object templates
+	for (auto objt : v["world"]["object-templates"])
+	{
+		//collision
+		bool cancollide = true;
+		if (!objt["collision"].isNull())
+			cancollide = objt["collision"].asBool();
 
-	//heightmap = new HeightMap(v["world"]["heightmap"].asString(), scale);
+		objecttemplates.push_back(std::pair<int, std::pair<std::string, bool>>(objt["color"], std::pair<std::string, bool>(objt["file"], cancollide)));
+	}
 
-	/*if(!v["world"]["texture"].isNull())
-		heightmap->SetTexture(v["world"]["texture"].asString());*/
+	//Generate heightmap for this world
+	heightmap = new HeightMap(v["world"]["heightmap"].asString(), this);
 
-	player->position.x = v["player"]["startposition"][0].asFloat()*scale;
-	player->position.y = v["player"]["startposition"][1].asFloat()*scale;
-	player->position.z = v["player"]["startposition"][2].asFloat()*scale;
+	//Map different texture to heightmap if available
+	if(!v["world"]["texture"].isNull())
+		heightmap->SetTexture(v["world"]["texture"].asString());
 
+	//Set player starting position
+	player->position.x = v["player"]["startposition"][0].asFloat();
+	player->position.y = v["player"]["startposition"][1].asFloat();
+	player->position.z = v["player"]["startposition"][2].asFloat();
 
+	//Load and place objects into world
 	for (auto object : v["objects"])
 	{
+		//Collision
 		bool hasCollision = true;
 		if (!object["collide"].isNull())
 			hasCollision = object["collide"].asBool();
 
+		//Rotation
 		Vec3f rotation(0, 0, 0);
 		if(!object["rot"].isNull())
 			rotation = Vec3f(object["rot"][0].asFloat(), object["rot"][1].asFloat(), object["rot"][2].asFloat());
 
+		//Scale
 		float scale = 1;
 		if (!object["scale"].isNull())
 			scale = object["scale"].asFloat();
 		
+		//Position
 		if (object["pos"].isNull())
 			std::cout << "Invalid world file: objects pos - " << fileName << "\n";
+		
+		//File
+		if (object["file"].isNull())
+			std::cout << "Invalid world file: objects file - " << fileName << "\n";
 
+		//Create
 		Vec3f position(object["pos"][0].asFloat(), object["pos"][1].asFloat(), object["pos"][2].asFloat());
-		entities.push_back(new LevelObject(object["file"], position, rotation, scale, hasCollision));
+		entities.push_back(new LevelObject(object["file"].asString(), position, rotation, scale, hasCollision));
 	}
 
-	//Enemies
+	//Load and place enemies into world
 	for (auto e : v["enemies"])
 	{		
-		std::string fileName = "";
-		if (!e["file"].isNull())
-			fileName = e["file"].asString();
-
-		Vec3f position(0, 0, 0);
-		if (!e["pos"].isNull())
-			position = Vec3f(e["pos"][0].asFloat(), e["pos"][1].asFloat(), e["pos"][2].asFloat());
-
+		//Rotation
 		Vec3f rotation(0, 0, 0);
 		if (!e["rot"].isNull())
 			rotation = Vec3f(e["rot"][0].asFloat(), e["rot"][1].asFloat(), e["rot"][2].asFloat());
 
+		//Scale
 		float scale = 1.0f;
 		if (!e["scale"].isNull())
 			scale = e["scale"].asFloat();
 
-		enemies.push_back(new Enemy(fileName, position, rotation, scale));
+		//Position
+		if (e["pos"].isNull())
+			std::cout << "Invalid world file: enemies pos - " << fileName << "\n";
+
+		//File
+		if (e["file"].isNull())
+			std::cout << "Invalid world file: enemies file - " << fileName << "\n";
+
+		//Create
+		Vec3f position(e["pos"][0].asFloat(), e["pos"][1].asFloat(), e["pos"][2].asFloat());
+		enemies.push_back(new Enemy(e["file"].asString(), position, rotation, scale));
 
 	}
 }
@@ -90,9 +121,20 @@ World::~World()
 	//delete heightmap;
 }
 
+std::pair<std::string, bool> World::getObjectFromValue(int val)
+{
+	for (auto i : objecttemplates)
+	{
+		if (i.first == val)
+			return i.second;
+	}
+
+	return objecttemplates[0].second;
+}
+
 float World::getHeight(float x, float y)
 {
-	//return heightmap->GetHeight(x, y);
+	return heightmap->GetHeight(x, y);
 }
 
 void World::draw()
@@ -101,18 +143,18 @@ void World::draw()
 
 	float lightPosition[4] = { 0, 2, 1, 0 };
 	glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
-	float lightAmbient[4] = { 0.5, 0.5, 0.5, 1 };
+	float lightAmbient[4] = { 0.2, 0.2, 0.2, 1 };
 	glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);
 
-	glColor4f(1.0f,1.0f, 1.0f, 1.0f);
-	//heightmap->Draw();
-
+	heightmap->Draw();
 
 	for (auto &enemy : enemies)
 		enemy->draw();
 
 	for (auto &entity : entities)
 		entity->draw();
+
+	interface->draw();
 }
 
 void World::update(float elapsedTime)
@@ -146,6 +188,11 @@ void World::update(float elapsedTime)
 	}
 }
 
+void World::addLevelObject(LevelObject* obj)
+{
+	entities.push_back(obj);
+}
+
 bool World::isPlayerPositionValid()
 {
 	for (auto e : entities)

World.h

@@ -4,24 +4,31 @@
 #include "HeightMap.h"
 #include "Player.h"
 #include "Enemy.h"
+#include "LevelObject.h"
+#include "Interface.h"
 
 class Entity;
 
 class World
 {
-public:
-	World(const std::string &fileName);
-	~World();
+private:
+	std::vector<std::pair<int, std::pair<std::string, bool>>> objecttemplates;
+
+	Player* player;
+	HeightMap* heightmap;
+	Interface* interface;
 
 	std::vector<Entity*> entities;
 	std::vector<Enemy*> enemies;
-
-	Player* player;
-	//HeightMap* heightmap;
+public:
+	World(const std::string &fileName);
+	~World();
 
 	void draw();
 	void update(float elapsedTime);
 	bool isPlayerPositionValid();
 	float getHeight(float x, float y);
+	void addLevelObject(LevelObject* obj);
+	std::pair<std::string, bool> getObjectFromValue(int i);
 };
 

worlds/fire.json

@@ -2,7 +2,6 @@
    "world": {
     "heightmap": "worlds/hell.png",
     "texture": "worlds/helltexture.png",
-    "scale": 1,
 	    "object-templates": [
 			  {
 				  "color": 25,

worlds/ice.json

@@ -2,7 +2,13 @@
    "world": {
     "heightmap": "worlds/hmcs.png",
     "texture": "worlds/hmcstexture.png",
-    "scale": 2
+    "object-templates": [
+		{
+			"color":100,
+			"file": "models/boom/Boom.obj",
+			"collision": false
+		}
+	]
    },
   "player": {
     "startposition": [ 0, 1.7, 0]

worlds/small.json

@@ -1,7 +1,13 @@
 {
    "world": {
     "heightmap": "worlds/small.png",
-    "scale": 1
+	"object-templates": [
+		{
+			"color":100,
+			"file": "models/boom/Boom.obj",
+			"collision": false
+		}
+	]
    },
   "player": {
     "startposition": [ 20, 5, 20 ]

worlds/worlds.json

@@ -1,6 +1,7 @@
 {
-	"worlds": [
-			"worlds/ice.json",
-			"worlds/fire.json"
-	]
+  "worlds": [
+    "worlds/small.json",
+    "worlds/ice.json",
+    "worlds/fire.json"
+  ]
 }