almost finished gameplay

Pika/gameplay/containers/minecraftDungeons/mcDungeons.cpp

@@ -86,7 +86,7 @@ void  McDungeonsGameplay::checkCollisionBrute(PhysicsComponent &player, glm::vec
 
 	glm::vec2 &dimensions = player.size;
 
-	glm::ivec2 mapSize = {100,100};
+	glm::ivec2 mapSize = {150,150};
 
 	if (
 		(pos.y < -dimensions.y)

Pika/gameplay/containers/minecraftDungeons/mcDungeonsMenu.h

@@ -43,8 +43,6 @@ struct McDungeonsMenu : public Container
 		button = pika::gl2d::loadTexture(PIKA_RESOURCES_PATH "mcDungeons/button.png", requestedInfo);
 
 
-
-
 		return true;
 	}
 

Pika/gameplay/containers/minecraftDungeons/mcDungeonsgameplay.h

@@ -11,6 +11,8 @@
 #include <engineLibraresSupport/engineGL3DSupport.h>
 #include "blocks.h"
 #include <stringManipulation/stringManipulation.h>
+#include <engineLibraresSupport/engineGL2DSupport.h>
+#include <glui/glui.h>
 
 struct McDungeonsGameplay: public Container
 {
@@ -66,6 +68,8 @@ struct McDungeonsGameplay: public Container
 
 	std::vector<Zombie> enemies;
 
+	std::vector<gl3d::Entity> diamonds;
+
 
 	gl3d::Entity player;
 
@@ -81,16 +85,24 @@ struct McDungeonsGameplay: public Container
 	};
 
 
+	float winTimer = 4;
+	float cameraYoffset = 0;
+
 	gl2d::Renderer2D renderer2d;
 	gl3d::Renderer3D renderer;
 	gl3d::Model model;
 	gl3d::Entity entity;
 	GLuint blocksTexture;
+	gl3d::Model diamondModel;
+
+	gl2d::Texture diamondTexture;
+	gl2d::Font font;
 
 	gl3d::Entity sword;
 
 	PhysicsComponent playerPhysics;
-	
+	float diamondPeriod = 0;
+
 
 	pika::gl3d::General3DEditor editor;
 
@@ -406,6 +418,10 @@ struct McDungeonsGameplay: public Container
 
 		renderer2d.create();
 
+		diamondTexture = pika::gl2d::loadTexture(PIKA_RESOURCES_PATH "mcDungeons/diamond.png", requestedInfo, true, false);
+		font = pika::gl2d::loadFont(PIKA_RESOURCES_PATH "mcDungeons/CommodorePixeled.ttf", requestedInfo);
+
+
 		//todo close function for containers
 		//todo check out why mouse don't work in outside window
 
@@ -459,10 +475,12 @@ struct McDungeonsGameplay: public Container
 			return 0;
 		}
 
-
 		model = createWorld(renderer, defaultMat[0]);
 		entity = renderer.createEntity(model);
 
+		diamondModel = renderer.loadModel(PIKA_RESOURCES_PATH "mcDungeons/diamond.glb", 0, 1.f);
+		
+
 		auto zombieMat = renderer.loadMaterial(PIKA_RESOURCES_PATH "mcDungeons/zombie.mtl", 0);
 		if (zombieMat.size() != 1) { return false; }
 
@@ -486,7 +504,15 @@ struct McDungeonsGameplay: public Container
 
 		//enemies
 		{
-			enemies.push_back(Zombie(22, 33));
+			enemies.push_back(Zombie(18, 46));
+			enemies.push_back(Zombie(16, 46));
+			enemies.push_back(Zombie(65, 27));
+			enemies.push_back(Zombie(61, 23));
+			enemies.push_back(Zombie(68, 23));
+			enemies.push_back(Zombie(63, 48));
+			enemies.push_back(Zombie(66, 64));
+			enemies.push_back(Zombie(71, 63));
+			enemies.push_back(Zombie(56, 72));
 			
 
 			for (auto &i : enemies)
@@ -507,6 +533,17 @@ struct McDungeonsGameplay: public Container
 
 		}
 
+		//diamonds
+		{
+
+			diamonds.push_back(renderer.createEntity(diamondModel, {glm::vec3(16, 13, 56)}, false));
+			diamonds.push_back(renderer.createEntity(diamondModel, {glm::vec3(30, 13, 53)}, false));
+			diamonds.push_back(renderer.createEntity(diamondModel, {glm::vec3(116, 13, 63)}, false));
+			diamonds.push_back(renderer.createEntity(diamondModel, {glm::vec3(73, 13, 100)}, false));
+			diamonds.push_back(renderer.createEntity(diamondModel, {glm::vec3(100, 13, 45)}, false));
+		
+		}
+
 
 		renderer.camera.farPlane = 200;
 		renderer.directionalShadows.frustumSplits[0] = 0.06;
@@ -559,6 +596,7 @@ struct McDungeonsGameplay: public Container
 			}
 
 			ImGui::DragFloat3("camera pos", &renderer.camera.position[0]);
+			ImGui::DragFloat2("playerPos pos", &playerPhysics.position[0]);
 
 		}
 
@@ -582,6 +620,7 @@ struct McDungeonsGameplay: public Container
 			
 		#pragma region input
 			
+			if(!diamonds.empty())
 			{
 				glm::vec2 dir = {};
 
@@ -628,58 +667,58 @@ struct McDungeonsGameplay: public Container
 
 		#pragma endregion
 
-		#pragma region rotate
+			auto solveRotation = [deltaTime = input.deltaTime](PhysicsComponent &p)
 			{
 				const float pi2 = 3.1415926f * 2.f;
 
-				if (playerPhysics.desiredRotation != playerPhysics.rotation)
+				if (p.desiredRotation != p.rotation)
 				{
 					float pozDistance = 0;
 					float negDistance = 0;
-					if (playerPhysics.desiredRotation > playerPhysics.rotation)
+					if (p.desiredRotation > p.rotation)
 					{
-						pozDistance = playerPhysics.desiredRotation - playerPhysics.rotation;
-						negDistance = playerPhysics.rotation + pi2 - playerPhysics.desiredRotation;
+						pozDistance = p.desiredRotation - p.rotation;
+						negDistance = p.rotation + pi2 - p.desiredRotation;
 					}
 					else
 					{
-						pozDistance = pi2 - playerPhysics.rotation + playerPhysics.desiredRotation;
-						negDistance = playerPhysics.rotation - playerPhysics.desiredRotation;
+						pozDistance = pi2 - p.rotation + p.desiredRotation;
+						negDistance = p.rotation - p.desiredRotation;
 					}
 
-					float speed = input.deltaTime * 3.141592f * 2.f;
-					float oldRot = playerPhysics.rotation;
+					float speed = deltaTime * 3.141592f * 2.f;
+					float oldRot = p.rotation;
 					if (pozDistance > negDistance)
 					{
 						if (negDistance < speed)
 						{
-							playerPhysics.rotation = playerPhysics.desiredRotation;
+							p.rotation = p.desiredRotation;
 						}
 						else
 						{
-							playerPhysics.rotation -= speed;
+							p.rotation -= speed;
 						}
 					}
 					else
 					{
 						if (pozDistance < speed)
 						{
-							playerPhysics.rotation = playerPhysics.desiredRotation;
+							p.rotation = p.desiredRotation;
 						}
 						else
 						{
-							playerPhysics.rotation += speed;
+							p.rotation += speed;
 						}
 					}
 
-					if (playerPhysics.rotation > pi2) { playerPhysics.rotation -= pi2; }
-					
+					if (p.rotation > pi2) { p.rotation -= pi2; }
+
 
 				}
 
+			};
 
-			}
-		#pragma endregion
+			solveRotation(playerPhysics);
 
 			resolveConstrains(playerPhysics);
 			playerPhysics.updateMove();
@@ -703,6 +742,37 @@ struct McDungeonsGameplay: public Container
 
 			for (auto &e : enemies)
 			{
+				float d = glm::distance(e.physics.position, playerPhysics.position);
+				if (d < 8.f)
+				{
+					if (d > 1.f)
+					{
+						glm::vec2 dir = glm::normalize(playerPhysics.position - e.physics.position);
+						float speed = 1.4;
+						e.physics.position += dir * input.deltaTime * speed;
+						
+						e.physics.desiredRotation = std::atan2(dir.x, dir.y);
+
+						renderer.setEntityAnimationIndex(e.entity, Animations::zombieRun);
+					
+					}
+					else
+					{
+						renderer.setEntityAnimationIndex(e.entity, Animations::zombieAttack);
+
+						//attack
+					}
+				}
+				else
+				{
+					renderer.setEntityAnimationIndex(e.entity, Animations::zombieIdle);
+				}
+
+				solveRotation(e.physics);
+
+				resolveConstrains(e.physics);
+				e.physics.updateMove();
+
 				setTransform(e.physics, e.entity);
 			}
 
@@ -726,7 +796,6 @@ struct McDungeonsGameplay: public Container
 
 		#pragma region camera hover
 			{
-				static float cameraYoffset = 0;
 				cameraPos.y += cameraYoffset;
 
 				auto checkHit = [&](glm::vec3 pos) -> bool
@@ -743,25 +812,35 @@ struct McDungeonsGameplay: public Container
 							}
 					return false;
 				};
-				
-				
+
 				float hoverSpeed = 2;
-				if (checkHit(cameraPos))
+				if (!diamonds.empty())
 				{
-					cameraYoffset += input.deltaTime * hoverSpeed;
+					if (checkHit(cameraPos))
+					{
+						cameraYoffset += input.deltaTime * hoverSpeed;
+					}
+					else
+					{
+						if (cameraYoffset > 0)
+							if (!checkHit(cameraPos -= glm::vec3(0, 0.1f, 0)))
+							{
+								cameraYoffset -= input.deltaTime * hoverSpeed;
+							}
+					}
 				}
 				else
 				{
-					if(cameraYoffset>0)
-					if (!checkHit(cameraPos -= glm::vec3(0, 0.1f, 0)))
-					{
-						cameraYoffset -= input.deltaTime * hoverSpeed;
-					}
+					cameraYoffset += input.deltaTime;
 				}
+				
 
 				cameraYoffset = std::max(cameraYoffset, 0.f);
 
+				cameraPos.x = std::max(cameraPos.x, 2.f);
+
 			}
+		
 		#pragma endregion
 
 
@@ -779,6 +858,43 @@ struct McDungeonsGameplay: public Container
 		}
 	#pragma endregion
 
+		if (diamonds.empty())
+		{
+			winTimer -= input.deltaTime;
+			if (winTimer <= 0.f)
+			{
+				return 0;
+			}
+		}
+
+		diamondPeriod += input.deltaTime * 0.2;
+
+		while (diamondPeriod > 1) { diamondPeriod -= 1; }
+
+		for (int i=0; i<diamonds.size(); i++)
+		{
+
+			gl3d::Transform t = renderer.getEntityTransform(diamonds[i]);
+
+			glm::vec2 diamondPos(t.position.x, t.position.z);
+
+			if (glm::distance(diamondPos, playerPhysics.position) < 1.f)
+			{
+				renderer.deleteEntity(diamonds[i]);
+				diamonds.erase(diamonds.begin() + i);
+				i--;
+				continue;
+			}
+			
+			t.position.y = 13 + std::sin(diamondPeriod * 2.f * 3.1415926) *0.5 + 0.2;
+
+			t.rotation.y = diamondPeriod * 2.f * 3.1415926;
+
+			renderer.setEntityTransform(diamonds[i], t);
+
+		}
+
+
 
 
 	#pragma endregion
@@ -790,6 +906,32 @@ struct McDungeonsGameplay: public Container
 
 
 
+		{
+			glui::Frame screen({0,0,windowState.w, windowState.h});
+
+			{
+				glui::Frame diamondBox(glui::Box().xLeft(10).yTop(20).xDimensionPercentage(0.2).yAspectRatio(0.5)());
+
+				//renderer2d.renderRectangle(glui::Box().xLeft().yTop().xDimensionPercentage(1.f).yDimensionPercentage(1.f)(),
+				//	{1,0.5,0,0.5});
+
+				renderer2d.renderRectangle(glui::Box().xLeft(5).yTop(5).xDimensionPercentage(0.45).yAspectRatio(1.f), 
+					{1,1,1,0.5},
+					{}, 0,
+					diamondTexture);
+
+				std::string s;
+				s += std::to_string(5 - diamonds.size());
+				s += "/5";
+
+				renderer2d.renderText({glui::Box().xLeftPerc(0.5f).yTopPerc(0.9f)()}, s.c_str(), font,
+					{1,1,1,0.5}, 1.0f, 4, 3, false);
+					
+
+			}
+
+		}
+
 
 		renderer2d.flush();
 

Pika/resources/logs.txt

@@ -1,4 +1,4 @@
-#2023-03-14 12:50:30: Created container: Gameplay
-#2023-03-14 12:51:10: Created container: McDungeonsMenu
-#2023-03-14 12:51:12: Destroyed continer: Gameplay #1
-#2023-03-14 12:51:12: Destroyed continer: McDungeonsMenu #2
+#2023-03-15 14:01:10: Created container: Gameplay
+#2023-03-15 14:01:15: Created container: McDungeonsGameplay
+#2023-03-15 14:01:54: Destroyed continer: Gameplay #1
+#2023-03-15 14:03:02: Destroyed continer: McDungeonsGameplay #2

Pika/thirdparty/glui/include/glui/glui.h

@@ -1,12 +1,15 @@
 //////////////////////////////////////////////////
-//gl2d.h				1.0.0
+//gl2d.h				1.0.1
 //Copyright(c) 2023 Luta Vlad
 //https://github.com/meemknight/glui
 //
 //
 //	dependences: gl2d, glew, glm, stb_image, stb_trueType
 //
+// 1.0.1 added Frames and boxes
 //
+// 
+// 
 //////////////////////////////////////////////////
 
 
@@ -18,6 +21,9 @@
 namespace glui
 {
 
+	void defaultErrorFunc(const char *msg);
+	using errorFuncType = decltype(defaultErrorFunc);
+
 	struct RendererUi
 	{
 
@@ -130,10 +136,67 @@ namespace glui
 
 	};
 
+	class Frame
+	{
+		int lastW;
+		int lastH;
+		int lastX;
+		int lastY;
 
-	void defaultErrorFunc(const char* msg);
-	using errorFuncType = decltype(defaultErrorFunc);
+		bool loaded = 0;
+
+	public:
+
+		Frame(const Frame &other) = delete;
+		Frame(const Frame &&other) = delete;
+		Frame(glm::ivec4 size);
+		~Frame();
+	};
+
+	struct Box
+	{
+		glm::ivec4 dimensions = {};
+
+		float aspect = 0;
+
+		//-1 left
+		// 0 none
+		// 1 center
+		// 2 right
+		char XcenterState = 0;
+		char YcenterState = 0;
+
+		// 0 pixelSize
+		// 1 xDominant
+		// 2 yDominant
+		char dimensionsState;
+
+		//todo left percent
+		Box &xDistancePixels(int dist);
+		Box &yDistancePixels(int dist);
+		Box &xCenter(int dist = 0);
+		Box &yCenter(int dist = 0);
+		Box &xLeft(int dist = 0);
+		Box &xLeftPerc(float perc = 0);
+		Box &yTop(int dist = 0);
+		Box &yTopPerc(float perc = 0);
+		Box &xRight(int dist = 0);
+		Box &yBottom(int dist = 0);
+
+		Box &xDimensionPixels(int dim);
+		Box &yDimensionPixels(int dim);
+
+		Box &xDimensionPercentage(float p);
+		Box &yDimensionPercentage(float p);
+
+		Box &xAspectRatio(float r);
+		Box &yAspectRatio(float r);
+
+		glm::ivec4 operator()();
+
+		operator glm::vec4() { return (*this)(); }
+	};
 
-	
+	bool isInButton(const glm::vec2 &p, const glm::vec4 &box);
 
 };

Pika/thirdparty/glui/src/glui.cpp

@@ -1433,4 +1433,189 @@ namespace glui
 		PopIdInternal(*this);
 	}
 
+
+	//frames 
+
+	static int xPadd = 0;
+	static int yPadd = 0;
+	static int width = 0;
+	static int height = 0;
+
+	Frame::Frame(glm::ivec4 size)
+	{
+		this->loaded = 1;
+		lastW = width;
+		lastH = height;
+		lastX = xPadd;
+		lastY = yPadd;
+
+		width = size.z;
+		height = size.w;
+		xPadd = size.x;
+		yPadd = size.y;
+	}
+
+	Frame::~Frame()
+	{
+		if (loaded)
+		{
+			width = lastW;
+			height = lastH;
+			xPadd = lastX;
+			yPadd = lastY;
+		}
+	}
+
+	//todo fix frame
+	glm::ivec4 Box::operator()()
+	{
+
+		if (dimensionsState == 1)
+		{
+			dimensions.w = dimensions.z * aspect;
+		}
+		else
+			if (dimensionsState == 2)
+			{
+				dimensions.z = dimensions.w * aspect;
+			}
+
+		if (XcenterState == -1)
+		{
+			dimensions.x += xPadd;
+		}
+		if (YcenterState == -1)
+		{
+			dimensions.y += yPadd;
+		}
+
+		if (XcenterState == 1)
+		{
+			dimensions.x += xPadd + (width / 2) - (dimensions.z / 2);
+		}
+		if (YcenterState == 1)
+		{
+			dimensions.y += yPadd + (height / 2) - (dimensions.w / 2);
+		}
+
+		if (XcenterState == 2)
+		{
+			dimensions.x += xPadd + width - dimensions.z;
+		}
+
+		if (YcenterState == 2)
+		{
+			dimensions.y += yPadd + height - dimensions.w;
+		}
+
+
+		return dimensions;
+	}
+
+	Box &Box::xDistancePixels(int dist)
+	{
+		dimensions.x = dist;
+		XcenterState = 0;
+		return *this;
+	}
+
+	Box &Box::yDistancePixels(int dist)
+	{
+		dimensions.y = dist;
+		YcenterState = 0;
+		return *this;
+	}
+
+	Box &Box::xCenter(int dist)
+	{
+		dimensions.x = dist;
+		XcenterState = 1;
+		return *this;
+	}
+	Box &Box::yCenter(int dist)
+	{
+		dimensions.y = dist;
+		YcenterState = 1;
+		return *this;
+	}
+	Box &Box::xLeft(int dist)
+	{
+		dimensions.x = dist;
+		XcenterState = -1;
+		return *this;
+	}
+	Box &Box::xLeftPerc(float perc)
+	{
+		xLeft(perc * width);
+		return *this;
+	}
+	Box &Box::yTop(int dist)
+	{
+		dimensions.y = dist;
+		YcenterState = -1;
+		return *this;
+	}
+	Box &Box::yTopPerc(float perc)
+	{
+		yTop(perc * height);
+		return *this;
+	}
+	Box &Box::xRight(int dist)
+	{
+		dimensions.x = dist;
+		XcenterState = 2;
+		return *this;
+	}
+	Box &Box::yBottom(int dist)
+	{
+		dimensions.y = dist;
+		YcenterState = 2;
+		return *this;
+	}
+	Box &Box::xDimensionPixels(int dim)
+	{
+		dimensionsState = 0;
+		dimensions.z = dim;
+		return *this;
+	}
+	Box &Box::yDimensionPixels(int dim)
+	{
+		dimensionsState = 0;
+		dimensions.w = dim;
+		return *this;
+	}
+	Box &Box::xDimensionPercentage(float p)
+	{
+		dimensionsState = 0;
+		dimensions.z = p * width;
+		return *this;
+
+	}
+	Box &Box::yDimensionPercentage(float p)
+	{
+		dimensionsState = 0;
+		dimensions.w = p * height;
+		return *this;
+	}
+	Box &Box::xAspectRatio(float r)
+	{
+		dimensionsState = 2;
+		aspect = r;
+		return *this;
+	}
+	Box &Box::yAspectRatio(float r)
+	{
+		dimensionsState = 1;
+		aspect = r;
+		return *this;
+	}
+
+	bool isInButton(const glm::vec2 &p, const glm::vec4 &box)
+	{
+		return(p.x >= box.x && p.x <= box.x + box.z
+			&&
+			p.y >= box.y && p.y <= box.y + box.w
+			);
+	}
+
 };