added movement

Pika/gameplay/containers.h

@@ -35,6 +35,7 @@ Container *getContainer(const char* name, pika::memory::MemoryArena *memoryArena
 
 
 #include "containers/isometricGame/isometricGameEditor.h"
+#include "containers/isometricGame/isometricGame.h"
 
 
 #if PIKA_PRODUCTION == 1
@@ -56,7 +57,8 @@ Container *getContainer(const char* name, pika::memory::MemoryArena *memoryArena
 	PIKA_DECLARE_CONTAINER(PikaTextEditor) \
 	PIKA_DECLARE_CONTAINER(ThreeDGameExample) \
 	PIKA_DECLARE_CONTAINER(ThreeDGameMenu) \
-	PIKA_DECLARE_CONTAINER(IsometricGameEditor)
+	PIKA_DECLARE_CONTAINER(IsometricGameEditor) \
+	PIKA_DECLARE_CONTAINER(IsometricGame)
 	//PIKA_DECLARE_CONTAINER(McDungeonsGameplay) \
 	//PIKA_DECLARE_CONTAINER(McDungeonsEditor)
 	//PIKA_DECLARE_CONTAINER(McDungeonsMenu)

Pika/gameplay/containers/isometricGame/isometricGame.cpp

@@ -0,0 +1,497 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include "glm/gtx/hash.hpp"
+
+#include <containers/isometricGame/isometricGame.h>
+#include <containers/isometricGame/isometricGameEditor.h>
+#include <glui/glui.h>
+#include <deque>
+#include <unordered_map>
+
+bool IsometricGame::create(RequestedContainerInfo &requestedInfo, pika::StaticString<256> commandLineArgument)
+{
+	renderer.create(requestedInfo.requestedFBO.fbo);
+
+	tiles = pika::gl2d::loadTextureWithPixelPadding(PIKA_RESOURCES_PATH "iso/tiles/Isometric-Tiles.png", requestedInfo, 32, true);
+	shadow = pika::gl2d::loadTexture(PIKA_RESOURCES_PATH "iso/tiles/shadow.png", requestedInfo, 32, true);
+	tilesAtlas = gl2d::TextureAtlasPadding(16, 8, tiles.GetSize().x, tiles.GetSize().y);
+
+	playerSprite = pika::gl2d::loadTexture(PIKA_RESOURCES_PATH "iso/tiles/IsoCharacter.png",
+		requestedInfo, true);
+	playerAtlas = gl2d::TextureAtlas(5, 4);
+
+
+	for (int i = 0; i < MAPS_COUNT; i++)
+	{
+		//editor.loadFromFile(renderer, commandLineArgument.to_string(), requestedInfo);
+		size_t s = 0;
+		std::string fileName = PIKA_RESOURCES_PATH "iso/maps/map" + std::to_string(i+1) + ".isomap";
+
+		glm::ivec3 mapSize = {};
+		bool created = 0;
+		if (requestedInfo.readEntireFileBinary(fileName, &mapSize, sizeof(mapSize), 0))
+		{
+			if (requestedInfo.getFileSizeBinary(fileName, s))
+			{
+
+				if (s == mapSize.x * mapSize.y * mapSize.z * sizeof(Block) + sizeof(mapSize))
+				{
+					created = 1;
+
+					levels[i].init(mapSize);
+
+					requestedInfo.readEntireFileBinary(fileName,
+						levels[i].mapData.data(), mapSize.x * mapSize.y * mapSize.z * sizeof(Block), sizeof(mapSize));
+
+				}
+			}
+		}
+
+		if (!created)
+		{
+			requestedInfo.consoleWrite("Error loading file: " + std::to_string(i) + "\n");
+			return 0;
+		}
+			
+	}
+
+	map = levels[0];
+	
+	return true;
+}
+
+static bool canPlayerStay(int type)
+{
+	return type == 0 || type == IsometricGameEditor::Blocks::redstone ||
+		type == IsometricGameEditor::Blocks::lever;
+}
+
+bool IsometricGame::update(pika::Input input, pika::WindowState windowState, RequestedContainerInfo &requestedInfo)
+{
+
+#pragma region clear stuff
+	glClear(GL_COLOR_BUFFER_BIT);
+	renderer.updateWindowMetrics(windowState.windowW, windowState.windowH);
+#pragma endregion
+
+	float size = 100;
+	
+#pragma region move
+
+	float cameraSpeed = input.deltaTime * size * 2.f;
+
+	if (input.buttons[pika::Button::A].held())
+	{
+		renderer.currentCamera.position.x -= cameraSpeed;
+	}
+	if (input.buttons[pika::Button::D].held())
+	{
+		renderer.currentCamera.position.x += cameraSpeed;
+	}
+
+	if (input.buttons[pika::Button::W].held())
+	{
+		renderer.currentCamera.position.y -= cameraSpeed;
+	}
+	if (input.buttons[pika::Button::S].held())
+	{
+		renderer.currentCamera.position.y += cameraSpeed;
+	}
+#pragma endregion
+
+
+	auto calculateBlockPos = [size](glm::ivec3 in)
+	{
+		glm::vec2 position = {};
+
+		position += glm::vec2(-size / 2.f, size / 4.f) * float(in.x);
+		position += glm::vec2(size / 2.f, size / 4.f) * float(in.z);
+
+		position += glm::vec2(0, -size / 2.f) * float(in.y);
+
+		return position;
+	};
+
+#pragma region camera
+
+	renderer.currentCamera.follow(calculateBlockPos({map.size.x / 2-1, 1, map.size.z / 2}),
+		100, 0, 0, windowState.windowW, windowState.windowH);
+
+#pragma endregion
+
+
+
+
+	glm::ivec3 currentSelectedBlockDelete{-1};
+	glm::ivec3 currentSelectedBlockPlace{-1};
+
+	glm::ivec3 currentBlockInteract{-1};
+	glm::ivec3 currentBlockMove{-1};
+
+	auto viewRect = renderer.getViewRect();
+
+	auto lerp = [](auto a, auto b, auto c)
+	{
+		return a * (1.f - c) + b * c;
+	};
+
+	glm::vec2 blockPositionScreen = lerp(glm::vec2(viewRect.x, viewRect.y),
+		glm::vec2(viewRect.x + viewRect.z, viewRect.y + viewRect.w),
+		glm::vec2(input.mouseX, input.mouseY) / glm::vec2(windowState.windowW, windowState.windowH));
+
+
+		for (int y = 0; y < map.size.y; y++)
+			for (int z = 0; z < map.size.z; z++)
+				for (int x = 0; x < map.size.x; x++)
+				{
+
+					auto checkPointInBox = [&](int x, int y, int z, bool reverse = 0)
+					{
+						auto b = map.getSafe({x,y,z});
+
+						if (!b) { return false; }
+
+						if ((b->get().x != 0 && !reverse)
+							|| (b->get().x == 0 && reverse)
+							)
+						{
+							glm::vec2 position = calculateBlockPos({x,y,z});
+							glm::vec4 box = renderer.toScreen({position, size, size});
+							//todo new functon
+
+							box.x += 1;
+							box.x /= 2.f;
+							box.x *= renderer.windowW;
+
+							box.y *= -1;
+							box.y += 1;
+							box.y /= 2.f;
+							box.y *= renderer.windowH;
+
+							box.z += 1;
+							box.z /= 2.f;
+							box.z *= renderer.windowW;
+
+							box.w *= -1;
+							box.w += 1;
+							box.w /= 2.f;
+							box.w *= renderer.windowH;
+
+							box.z = box.z - box.x;
+							box.w = box.w - box.y;
+
+							if (IsometricGameEditor::pointInBox(glm::vec2(input.mouseX, input.mouseY), box))
+							{
+								return true;
+							}
+
+						}
+
+						return false;
+					};
+
+					if (checkPointInBox(x,y,z))
+					{
+						currentSelectedBlockDelete = {x,y,z};
+
+						if (checkPointInBox(x + 1, y, z, true))
+						{
+							currentSelectedBlockPlace = {x + 1,y,z};
+						}
+
+						if (checkPointInBox(x, y + 1, z, true))
+						{
+							currentSelectedBlockPlace = {x,y + 1,z};
+						}
+
+						if (checkPointInBox(x, y, z + 1, true))
+						{
+							currentSelectedBlockPlace = {x,y,z + 1};
+						}
+					}
+
+				}
+
+		if (currentSelectedBlockDelete.y == 0)
+		{
+			if (currentSelectedBlockPlace == currentSelectedBlockDelete + glm::ivec3(0, 1, 0))
+			{
+				currentBlockMove = currentSelectedBlockPlace;
+			}
+		}
+		else if (currentSelectedBlockDelete.y == 1)
+		{
+			currentBlockInteract = currentSelectedBlockDelete;
+		}
+		else
+		{
+			currentSelectedBlockDelete = glm::vec3{-1};
+			currentSelectedBlockPlace = glm::vec3{-1};
+		}
+
+	for (int y = 0; y < map.size.y; y++)
+		for (int z = 0; z < map.size.z; z++)
+			for (int x = 0; x < map.size.x; x++)
+			{
+				auto b = map.getSafe({x,y,z});
+
+				if (b->get().x != 0)
+				{
+					glm::vec2 position = calculateBlockPos({x,y,z});
+
+					glm::vec4 color = Colors_White;
+
+					if (b->get().x == IsometricGameEditor::Blocks::redstone)
+					{
+						color = glm::vec4(0.8, 0.2, 0.2, 1.0);
+					}
+
+					if (b->get().x == IsometricGameEditor::Blocks::redstone || b->get().x == IsometricGameEditor::Blocks::lever
+						|| b->get().x == IsometricGameEditor::Blocks::redstoneTorch
+						)
+					{
+						auto cr = glm::vec4(0.8, 0.2, 0.2, 1.0);
+
+						auto b2 = map.getSafe({x,y,z - 1});
+						if (b2 && IsometricGameEditor::redstoneWire(b2->type))
+						{
+							renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+								tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 1));
+						}
+
+						b2 = map.getSafe({x - 1,y,z});
+						if (b2 && IsometricGameEditor::redstoneWire(b2->type))
+						{
+							renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+								tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 2));
+						}
+
+						b2 = map.getSafe({x + 1,y,z});
+						if (b2 && IsometricGameEditor::redstoneWire(b2->type))
+						{
+							renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+								tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 3));
+						}
+
+						b2 = map.getSafe({x,y,z + 1});
+						if (b2 && IsometricGameEditor::redstoneWire(b2->type))
+						{
+							renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+								tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 4));
+						}
+
+//redstone on wall
+
+b2 = map.getSafe({x - 1,y + 1,z});
+if (b2 && IsometricGameEditor::redstoneWire(b2->type))
+{
+	renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+		tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 2));
+
+	renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+		tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 5));
+}
+
+b2 = map.getSafe({x,y + 1,z - 1});
+if (b2 && IsometricGameEditor::redstoneWire(b2->type))
+{
+	renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+		tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 1));
+
+	renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+		tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 6));
+}
+
+
+//redstone down
+
+b2 = map.getSafe({x + 1,y - 1,z});
+if (b2 && IsometricGameEditor::redstoneWire(b2->type))
+{
+	renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+		tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 3));
+}
+
+b2 = map.getSafe({x,y - 1,z + 1});
+if (b2 && IsometricGameEditor::redstoneWire(b2->type))
+{
+	renderer.renderRectangle({position,size,size}, tiles, cr, {}, 0,
+		tilesAtlas.get(IsometricGameEditor::Blocks::redstone, 4));
+}
+
+					}
+
+					renderer.renderRectangle({position,size,size}, tiles, color, {}, 0,
+						tilesAtlas.get(b->get().x, b->get().y));
+
+					int advance = 1;
+					for (int y2 = y + 2; y2 < map.size.y; y2++)
+					{
+						advance++;
+
+						auto b2 = map.getSafe({x,y2,z});
+
+						if (b2 && b2->get().x != 0 && b->get().x != IsometricGameEditor::Blocks::redstone
+							&& b->get().x != IsometricGameEditor::Blocks::lever)
+						{
+							renderer.renderRectangle({position,size,size}, shadow,
+								{1,1,1,1.f / advance}
+							);
+							break;
+						}
+
+					}
+
+				}
+
+				//if (currentSelectedBlockDelete == glm::ivec3{x, y, z})
+				//{
+				//	glm::vec2 position = calculateBlockPos({x,y,z});
+				//
+				//	renderer.renderRectangle({position,size,size}, tiles, Colors_White, {}, 0,
+				//		tilesAtlas.get(0, 1));
+				//}
+
+				//if (currentSelectedBlockPlace == glm::ivec3{x, y, z})
+				//{
+				//	glm::vec2 position = calculateBlockPos({x,y,z});
+				//
+				//	renderer.renderRectangle({position,size,size}, tiles, {0.1,0.1,0.1,0.1}, {}, 0,
+				//		tilesAtlas.get(0, 1));
+				//}
+
+				if (currentBlockMove == glm::ivec3{x, y, z})
+				{
+					glm::vec2 position = calculateBlockPos({x,y,z});
+
+					renderer.renderRectangle({position,size,size}, tiles, {0.5,0.1,0.1,0.6}, {}, 0,
+						tilesAtlas.get(0, 1));
+				}
+
+				if (currentBlockInteract == glm::ivec3{x, y, z})
+				{
+					glm::vec2 position = calculateBlockPos({x,y,z});
+
+					renderer.renderRectangle({position,size,size}, tiles, {1,0.1,0.1,0.6}, {}, 0,
+						tilesAtlas.get(0, 1));
+				}
+
+			}
+
+
+#pragma region render player
+	{
+
+		playerAnimations.timer -= input.deltaTime;
+
+		if (playerAnimations.timer <= 0)
+		{
+			playerAnimations.timer += 0.2;
+			playerAnimations.indexX += 1;
+			if (playerAnimations.indexX >= 5)
+			{
+				playerAnimations.indexX = 0;
+			}
+		}
+
+		renderer.renderRectangle({calculateBlockPos(playerPosition),size,size}, playerSprite,
+			Colors_White, {}, 0.f, playerAtlas.get(playerAnimations.indexX, playerAnimations.indexY));
+
+	}
+#pragma endregion
+
+#pragma region Move
+
+	if (path.empty())
+	{
+		timerPath = 0.2;
+
+		if (input.lMouse.pressed() && currentBlockMove.x >= 0)
+		{
+			std::deque<glm::ivec2> positionsToSearch;
+
+			positionsToSearch.push_back({currentBlockMove.x,currentBlockMove.z});
+
+			std::unordered_map<glm::ivec2, glm::ivec2> searcehedPositions;
+			searcehedPositions[glm::ivec2{currentBlockMove.x, currentBlockMove.z}] = glm::ivec2{currentBlockMove.x,currentBlockMove.z};
+
+			while (!positionsToSearch.empty())
+			{
+				auto currentBlock = positionsToSearch.front();
+				positionsToSearch.pop_front();
+
+				if (currentBlock == glm::ivec2{playerPosition.x,playerPosition.z})
+				{
+					currentBlock = searcehedPositions[currentBlock];
+
+					while (true)
+					{
+						currentBlock = searcehedPositions[currentBlock];
+						path.push_back(currentBlock);
+						if (currentBlock == glm::ivec2{currentBlockMove.x, currentBlockMove.z})
+						{
+							break;
+						}
+					}
+
+					break;
+				}
+
+				auto tryBlock = [&](int x, int z)
+				{
+					auto b = map.getSafe({currentBlock.x + x, 1, currentBlock.y + z});
+					if (b && canPlayerStay(b->get().x) )
+					{
+						if (searcehedPositions.find({currentBlock.x + x, currentBlock.y + z})
+							== searcehedPositions.end())
+						{
+							searcehedPositions[glm::ivec2{currentBlock.x + x, currentBlock.y + z}] = glm::ivec2{currentBlock.x, currentBlock.y};
+							positionsToSearch.push_back({currentBlock.x + x, currentBlock.y + z});
+						}
+					}
+				};
+
+				tryBlock(1, 0);
+				tryBlock(-1, 0);
+				tryBlock(0, 1);
+				tryBlock(0, -1);
+
+
+			}
+
+		}
+	}
+	else
+	{
+		timerPath -= input.deltaTime;
+
+		if (timerPath < 0)
+		{
+			timerPath += 0.2;
+			playerPosition = glm::vec3{path[0].x, 1, path[0].y};
+			path.erase(path.begin());
+		}
+	}
+
+
+#pragma endregion
+
+
+
+	ImGui::Begin("Game debug");
+
+	ImGui::DragInt3("player position", &playerPosition[0], 1, 0, 20);
+
+	ImGui::End();
+
+	renderer.flush();
+
+
+
+	return true;
+}
+
+void IsometricGame::destruct(RequestedContainerInfo &requestedInfo)
+{
+	renderer.cleanup();
+
+}

Pika/gameplay/containers/isometricGame/isometricGame.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <gl2d/gl2d.h>
+#include <imgui.h>
+#include <baseContainer.h>
+#include <shortcutApi/shortcutApi.h>
+#include <pikaSizes.h>
+#include <fileChanged.h>
+#include <engineLibraresSupport/engineGL2DSupport.h>
+#include <containers/isometricGame/isometricGameEditor.h>
+
+
+struct IsometricGame: public Container
+{
+	static constexpr int MAPS_COUNT = 5;
+
+	IsometricGameEditor::Map levels[MAPS_COUNT] = {};
+
+	gl2d::Renderer2D renderer;
+
+	gl2d::Texture tiles;
+	gl2d::Texture shadow;
+	gl2d::TextureAtlasPadding tilesAtlas;
+
+	gl2d::Texture playerSprite;
+	gl2d::TextureAtlas playerAtlas;
+
+	glm::ivec3 playerPosition = {7, 1, 7};
+
+	struct PlayerAnimations
+	{
+		int indexX = 0;
+		int indexY = 0;
+		float timer = 0.2;
+	}playerAnimations;
+
+	std::vector<glm::ivec2> path;
+	float timerPath = 0.2;
+
+
+	static ContainerStaticInfo containerInfo()
+	{
+		ContainerStaticInfo info = {};
+		info.defaultHeapMemorySize = pika::MB(10);
+
+
+		info.requestImguiFbo = true;
+
+		return info;
+	}
+
+	bool create(RequestedContainerInfo &requestedInfo, pika::StaticString<256> commandLineArgument);
+	int currentBlock = 0;
+
+	struct Block
+	{
+		unsigned char type;
+		unsigned char secondType;
+
+		void set(unsigned char count, unsigned char down)
+		{
+			type = count;
+			secondType = down;
+		}
+
+		glm::ivec2 get()
+		{
+			return {type, secondType};
+		}
+	};
+
+	IsometricGameEditor::Map map;
+
+	bool update(pika::Input input, pika::WindowState windowState,
+		RequestedContainerInfo &requestedInfo) override;
+
+	void destruct(RequestedContainerInfo &requestedInfo) override;
+
+};

Pika/gameplay/containers/isometricGame/isometricGameEditor.cpp

@@ -1,9 +1,20 @@
 #include <containers/isometricGame/isometricGameEditor.h>
 #include <glui/glui.h>
 
-static int blocksCount = 16;
+static int blocksCount = 17;
 
-static bool pointInBox(glm::vec2 p, glm::vec4 box)
+
+bool IsometricGameEditor::redstoneWire(int type)
+{
+	return type == IsometricGameEditor::Blocks::redstone ||
+		type == IsometricGameEditor::Blocks::trapdor ||
+		type == IsometricGameEditor::Blocks::redstoneTorch ||
+		type == IsometricGameEditor::Blocks::redstoneBlock ||
+	type == IsometricGameEditor::Blocks::lever;
+}
+
+
+bool IsometricGameEditor::pointInBox(glm::vec2 p, glm::vec4 box)
 {
 	if
 		(
@@ -19,36 +30,25 @@ static bool pointInBox(glm::vec2 p, glm::vec4 box)
 	}
 }
 
-static bool redstoneWire(int type)
-{
-	return type == IsometricGameEditor::Blocks::redstone ||
-		type == IsometricGameEditor::Blocks::trapdor ||
-		type == IsometricGameEditor::Blocks::redstoneTorch ||
-		type == IsometricGameEditor::Blocks::redstoneBlock ||
-	type == IsometricGameEditor::Blocks::lever;
-}
-
-static bool canPlaceRedstoneOn(int type)
+bool IsometricGameEditor::canPlaceRedstoneOn(int type)
 {
 	return (type >= IsometricGameEditor::Blocks::clay &&
 		type <= IsometricGameEditor::Blocks::woddenPlank)
 		|| type == IsometricGameEditor::Blocks::redstoneBlock;
-		
 }
 
-
 bool IsometricGameEditor::create(RequestedContainerInfo &requestedInfo, pika::StaticString<256> commandLineArgument)
 {
 	renderer.create(requestedInfo.requestedFBO.fbo);
 
-	tiles = pika::gl2d::loadTextureWithPixelPadding(PIKA_RESOURCES_PATH "isoTiles/Isometric-Tiles.png", requestedInfo, 32, true);
-	shadow = pika::gl2d::loadTexture(PIKA_RESOURCES_PATH "isoTiles/shadow.png", requestedInfo, 32, true);
+	tiles = pika::gl2d::loadTextureWithPixelPadding(PIKA_RESOURCES_PATH "iso/tiles/Isometric-Tiles.png", requestedInfo, 32, true);
+	shadow = pika::gl2d::loadTexture(PIKA_RESOURCES_PATH "iso/tiles/shadow.png", requestedInfo, 32, true);
 
 	tilesAtlas = gl2d::TextureAtlasPadding(16, 8, tiles.GetSize().x, tiles.GetSize().y);
 
 	//fileChanged.setFile(mapFile.c_str());
 
-	loadedLevel.setInfo("Level", PIKA_RESOURCES_PATH, {".mcDungeons"});
+	loadedLevel.setInfo("Level", PIKA_RESOURCES_PATH "iso/maps", {".isomap"});
 
 	bool created = 0;
 	if (commandLineArgument.size() > 0)

Pika/gameplay/containers/isometricGame/isometricGameEditor.h

@@ -30,6 +30,7 @@ struct IsometricGameEditor: public Container
 		lever,
 		redstoneTorch,
 		redstoneBlock,
+		chest,
 	};
 
 
@@ -46,6 +47,13 @@ struct IsometricGameEditor: public Container
 
 	glm::ivec3 blockSelector = {};
 
+	static bool pointInBox(glm::vec2 p, glm::vec4 box);
+
+	static bool canPlaceRedstoneOn(int type);
+
+	static bool redstoneWire(int type);
+
+
 	static ContainerStaticInfo containerInfo()
 	{
 		ContainerStaticInfo info = {};
@@ -55,6 +63,8 @@ struct IsometricGameEditor: public Container
 
 		info.requestImguiFbo = true;
 
+		//todo option to not allow the user to close the container using the imgui x
+
 		return info;
 	}
 

Pika/resources/logs.txt

@@ -1,5 +1 @@
-#2024-01-06 13:16:02[error]: Couldn't allocate memory for constructing container: #1
-#2024-01-06 13:16:06[error]: Couldn't allocate memory for constructing container: #2
-#2024-01-06 13:16:34: Created container: ThreeDGameExample
-#2024-01-06 13:21:37: Reloaded dll
-#2024-01-06 13:22:20: Destroyed continer: ThreeDGameExample #3
+#2024-01-07 13:07:10: Created container: IsometricGame