Add packer to AwoorwaeOLC

.gitignore

@@ -1,4 +1,5 @@
 awoorwa
 awoorwae
+packer
 *.exe
 *.o

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "files.associations": {
+        "*.py": "python",
+        "cstdint": "cpp",
+        "algorithm": "cpp",
+        "fstream": "cpp"
+    }
+}

LICENCE.md

@@ -1,6 +1,6 @@
 # License (OLC-3)
 
-Copyright 2018-2019 OneLoneCoder.com, Pabloader
+Copyright 2018-2019 OneLoneCoder.com
 
 Redistribution and use in source and binary forms, with or without 
 modification, are permitted provided that the following conditions 

Makefile

@@ -1,28 +1,29 @@
 # To compile this you will need MinGW with MSYS installed in PATH
 
-CFLAGS=-Wall -Wno-misleading-indentation -Werror -g
-CPPFLAGS=-Wall -Wno-misleading-indentation -Werror --std=c++1z -g
-LDFLAGS= 
-INCLUDES=-I./include
-ifeq ($(OS),Windows_NT)     # is Windows_NT on XP, 2000, 7, Vista, 10...
+CPPFLAGS=-Wall -Wno-misleading-indentation -Werror --std=c++1z -g -flto
+LDFLAGS=
+INCLUDES=-Ipge/include
+EXECUTABLE=awoorwae
+ifeq ($(OS),Windows_NT)
 	LIBRARIES=-luser32 -lgdi32 -lopengl32 -lgdiplus -lwinmm
-	EXECUTABLE=awoorwae.exe
+	EXECUTABLE+=.exe
 	LDFLAGS+=--machine=windows
 	CPP=i686-w64-mingw32-g++
 	CC=i686-w64-mingw32-gcc
 else
 	LIBRARIES=-lX11 -lGL -lpthread -lpng -lasound
-	EXECUTABLE=awoorwae
 	CC=gcc
 	CPP=g++
 endif
-SOURCES=$(wildcard src/*.cpp) $(wildcard src/**/*.cpp)
+SOURCES=$(wildcard src/*.cpp) $(wildcard src/**/*.cpp) $(wildcard pge/src/*.cpp)
 OBJECTS=$(SOURCES:.cpp=.o)
 
 all: $(SOURCES) $(EXECUTABLE)
+	$(MAKE) -C packer all
 
 clean: 
 	$(RM) $(OBJECTS) $(EXECUTABLE)
+	$(MAKE) -C packer clean
 	
 $(EXECUTABLE): $(OBJECTS) 
 	$(CPP) $(LDFLAGS) $(OBJECTS) -o $@ $(LIBRARIES)
@@ -30,8 +31,5 @@ $(EXECUTABLE): $(OBJECTS)
 .cpp.o:
 	$(CPP) $(INCLUDES) -c $(CPPFLAGS) $< -o $@
 
-debug: $(EXECUTABLE)
-	gdb $(EXECUTABLE)
-
 run: $(EXECUTABLE)
 	./$(EXECUTABLE)

pge/include/olcPGE_Common.h

@@ -0,0 +1,12 @@
+#ifndef OLC_PGE_COMMON
+#define OLC_PGE_COMMON
+
+namespace olc {
+    enum rcode {
+        FAIL = 0,
+        OK = 1,
+        NO_FILE = -1,
+    };
+}
+
+#endif

pge/include/olcPGE_ResourcePack.h

@@ -0,0 +1,40 @@
+#ifndef OLC_PGE_RESOURCE_PACK
+#define OLC_PGE_RESOURCE_PACK
+
+#include <cstdint>
+#include <string>
+#include <map>
+#include <vector>
+#include <streambuf>
+#include <iostream>
+#include <fstream>
+#include "olcPGE_Common.h"
+
+namespace olc {
+	class ResourcePack
+	{
+	public:
+		ResourcePack();
+		~ResourcePack();
+		struct sEntry : public std::streambuf {
+			uint32_t nID, nFileOffset, nFileSize; uint8_t* data; void _config() { this->setg((char*)data, (char*)data, (char*)(data + nFileSize)); }
+		};
+
+	public:
+		olc::rcode AddToPack(std::string sFile);
+		olc::rcode RemoveFromPack(std::string sFile);
+
+	public:
+		olc::rcode SavePack(std::string sFile);
+		olc::rcode LoadPack(std::string sFile);
+		olc::rcode ClearPack();
+
+	public:
+		olc::ResourcePack::sEntry GetStreamBuffer(std::string sFile);
+		std::vector<std::string> GetEntries();
+
+	private:
+		std::map<std::string, sEntry> mapFiles;
+	};
+}
+#endif

include/olcPixelGameEngine.h → pge/include/olcPixelGameEngine.h

@@ -227,6 +227,8 @@
 #include <map>
 #include <functional>
 #include <algorithm>
+#include "olcPGE_Common.h"
+#include "olcPGE_ResourcePack.h"
 
 #undef min
 #undef max
@@ -265,13 +267,6 @@ namespace olc // All OneLoneCoder stuff will now exist in the "olc" namespace
 		BLACK(0, 0, 0),
 		BLANK(0, 0, 0, 0);
 
-	enum rcode
-	{
-		FAIL = 0,
-		OK = 1,
-		NO_FILE = -1,
-	};
-
 	//==================================================================================
 
 	template <class T>
@@ -321,34 +316,6 @@ namespace olc // All OneLoneCoder stuff will now exist in the "olc" namespace
 
 	//=============================================================
 
-
-	class ResourcePack
-	{
-	public:
-		ResourcePack();
-		~ResourcePack();
-		struct sEntry : public std::streambuf {
-			uint32_t nID, nFileOffset, nFileSize; uint8_t* data; void _config() { this->setg((char*)data, (char*)data, (char*)(data + nFileSize)); }
-		};
-
-	public:
-		olc::rcode AddToPack(std::string sFile);
-
-	public:
-		olc::rcode SavePack(std::string sFile);
-		olc::rcode LoadPack(std::string sFile);
-		olc::rcode ClearPack();
-
-	public:
-		olc::ResourcePack::sEntry GetStreamBuffer(std::string sFile);
-
-	private:
-
-		std::map<std::string, sEntry> mapFiles;
-	};
-
-	//=============================================================
-
 	// A bitmap-like structure that stores a 2D array of Pixels
 	class Sprite
 	{

pge/src/olcPGE_ResourcePack.cpp

@@ -0,0 +1,163 @@
+#include "olcPGE_ResourcePack.h"
+
+namespace olc {
+	ResourcePack::ResourcePack()
+	{
+
+	}
+
+	ResourcePack::~ResourcePack()
+	{
+		ClearPack();
+	}
+
+	olc::rcode ResourcePack::AddToPack(std::string sFile)
+	{
+		std::ifstream ifs(sFile, std::ifstream::binary);
+		if (!ifs.is_open()) return olc::FAIL;
+
+		// Get File Size
+		std::streampos p = 0;
+		p = ifs.tellg();
+		ifs.seekg(0, std::ios::end);
+		p = ifs.tellg() - p;
+		ifs.seekg(0, std::ios::beg);
+
+		// Create entry
+		sEntry e;
+		e.data = nullptr;
+		e.nFileSize = (uint32_t)p;
+
+		// Read file into memory
+		e.data = new uint8_t[(uint32_t)e.nFileSize];
+		ifs.read((char*)e.data, e.nFileSize);
+		ifs.close();
+
+		// Add To Map
+		mapFiles[sFile] = e;
+		return olc::OK;
+	}
+
+	olc::rcode ResourcePack::RemoveFromPack(std::string sFile)
+	{	
+		if (mapFiles.count(sFile) > 0) {	
+			sEntry e = mapFiles.at(sFile);
+			if (e.data != nullptr) {
+				delete[] e.data;
+			}
+			mapFiles.erase(sFile);
+			return olc::OK;
+		} else {
+			return olc::FAIL;
+		}
+	}
+
+	olc::rcode ResourcePack::SavePack(std::string sFile)
+	{
+		std::ofstream ofs(sFile, std::ofstream::binary);
+		if (!ofs.is_open()) return olc::FAIL;
+
+		// 1) Write Map
+		size_t nMapSize = mapFiles.size();
+		ofs.write((char*)&nMapSize, sizeof(size_t));
+		for (auto &e : mapFiles)
+		{
+			size_t nPathSize = e.first.size();
+			ofs.write((char*)&nPathSize, sizeof(size_t));
+			ofs.write(e.first.c_str(), nPathSize);
+			ofs.write((char*)&e.second.nID, sizeof(uint32_t));
+			ofs.write((char*)&e.second.nFileSize, sizeof(uint32_t));
+			ofs.write((char*)&e.second.nFileOffset, sizeof(uint32_t));
+		}
+
+		// 2) Write Data
+		std::streampos offset = ofs.tellp();
+		for (auto &e : mapFiles)
+		{
+			e.second.nFileOffset = (uint32_t)offset;
+			ofs.write((char*)e.second.data, e.second.nFileSize);
+			offset += e.second.nFileSize;
+		}
+
+		// 3) Rewrite Map (it has been updated with offsets now)
+		ofs.seekp(std::ios::beg);
+		ofs.write((char*)&nMapSize, sizeof(size_t));
+		for (auto &e : mapFiles)
+		{
+			size_t nPathSize = e.first.size();
+			ofs.write((char*)&nPathSize, sizeof(size_t));
+			ofs.write(e.first.c_str(), nPathSize);
+			ofs.write((char*)&e.second.nID, sizeof(uint32_t));
+			ofs.write((char*)&e.second.nFileSize, sizeof(uint32_t));
+			ofs.write((char*)&e.second.nFileOffset, sizeof(uint32_t));
+		}
+		ofs.close();
+
+		return olc::OK;
+	}
+
+	olc::rcode ResourcePack::LoadPack(std::string sFile)
+	{
+		std::ifstream ifs(sFile, std::ifstream::binary);
+		if (!ifs.is_open()) return olc::FAIL;
+
+		// 1) Read Map
+		size_t nMapEntries;
+		ifs.read((char*)&nMapEntries, sizeof(size_t));
+		for (size_t i = 0; i < nMapEntries; i++)
+		{
+			size_t nFilePathSize = 0;
+			ifs.read((char*)&nFilePathSize, sizeof(size_t));
+
+			std::string sFileName(nFilePathSize, ' ');
+			for (size_t j = 0; j < nFilePathSize; j++)
+				sFileName[j] = ifs.get();
+
+			sEntry e;
+			e.data = nullptr;
+			ifs.read((char*)&e.nID, sizeof(uint32_t));
+			ifs.read((char*)&e.nFileSize, sizeof(uint32_t));
+			ifs.read((char*)&e.nFileOffset, sizeof(uint32_t));
+			mapFiles[sFileName] = e;
+		}
+
+		// 2) Read Data
+		for (auto &e : mapFiles)
+		{
+			e.second.data = new uint8_t[(uint32_t)e.second.nFileSize];
+			ifs.seekg(e.second.nFileOffset);
+			ifs.read((char*)e.second.data, e.second.nFileSize);
+			e.second._config();
+		}
+
+		ifs.close();
+		return olc::OK;
+	}
+
+	olc::ResourcePack::sEntry ResourcePack::GetStreamBuffer(std::string sFile)
+	{
+		return mapFiles[sFile];
+	}
+
+	std::vector<std::string> ResourcePack::GetEntries() 
+	{
+		std::vector<std::string> result;
+		result.reserve(mapFiles.size());
+		for (auto& e: mapFiles) {
+			result.push_back(e.first);
+		}
+		return result;
+	}
+
+	olc::rcode ResourcePack::ClearPack()
+	{
+		for (auto &e : mapFiles)
+		{
+			if (e.second.data != nullptr)
+				delete[] e.second.data;
+		}
+
+		mapFiles.clear();
+		return olc::OK;
+	}
+}

src/olcPixelGameEngine.cpp → pge/src/olcPixelGameEngine.cpp

@@ -351,144 +351,6 @@ namespace olc
 
 	//==========================================================
 
-	ResourcePack::ResourcePack()
-	{
-
-	}
-
-	ResourcePack::~ResourcePack()
-	{
-		ClearPack();
-	}
-
-	olc::rcode ResourcePack::AddToPack(std::string sFile)
-	{
-		std::ifstream ifs(sFile, std::ifstream::binary);
-		if (!ifs.is_open()) return olc::FAIL;
-
-		// Get File Size
-		std::streampos p = 0;
-		p = ifs.tellg();
-		ifs.seekg(0, std::ios::end);
-		p = ifs.tellg() - p;
-		ifs.seekg(0, std::ios::beg);
-
-		// Create entry
-		sEntry e;
-		e.data = nullptr;
-		e.nFileSize = (uint32_t)p;
-
-		// Read file into memory
-		e.data = new uint8_t[(uint32_t)e.nFileSize];
-		ifs.read((char*)e.data, e.nFileSize);
-		ifs.close();
-
-		// Add To Map
-		mapFiles[sFile] = e;
-		return olc::OK;
-	}
-
-	olc::rcode ResourcePack::SavePack(std::string sFile)
-	{
-		std::ofstream ofs(sFile, std::ofstream::binary);
-		if (!ofs.is_open()) return olc::FAIL;
-
-		// 1) Write Map
-		size_t nMapSize = mapFiles.size();
-		ofs.write((char*)&nMapSize, sizeof(size_t));
-		for (auto &e : mapFiles)
-		{
-			size_t nPathSize = e.first.size();
-			ofs.write((char*)&nPathSize, sizeof(size_t));
-			ofs.write(e.first.c_str(), nPathSize);
-			ofs.write((char*)&e.second.nID, sizeof(uint32_t));
-			ofs.write((char*)&e.second.nFileSize, sizeof(uint32_t));
-			ofs.write((char*)&e.second.nFileOffset, sizeof(uint32_t));
-		}
-
-		// 2) Write Data
-		std::streampos offset = ofs.tellp();
-		for (auto &e : mapFiles)
-		{
-			e.second.nFileOffset = (uint32_t)offset;
-			ofs.write((char*)e.second.data, e.second.nFileSize);
-			offset += e.second.nFileSize;
-		}
-
-		// 3) Rewrite Map (it has been updated with offsets now)
-		ofs.seekp(std::ios::beg);
-		ofs.write((char*)&nMapSize, sizeof(size_t));
-		for (auto &e : mapFiles)
-		{
-			size_t nPathSize = e.first.size();
-			ofs.write((char*)&nPathSize, sizeof(size_t));
-			ofs.write(e.first.c_str(), nPathSize);
-			ofs.write((char*)&e.second.nID, sizeof(uint32_t));
-			ofs.write((char*)&e.second.nFileSize, sizeof(uint32_t));
-			ofs.write((char*)&e.second.nFileOffset, sizeof(uint32_t));
-		}
-		ofs.close();
-
-		return olc::OK;
-	}
-
-	olc::rcode ResourcePack::LoadPack(std::string sFile)
-	{
-		std::ifstream ifs(sFile, std::ifstream::binary);
-		if (!ifs.is_open()) return olc::FAIL;
-
-		// 1) Read Map
-		size_t nMapEntries;
-		ifs.read((char*)&nMapEntries, sizeof(size_t));
-		for (size_t i = 0; i < nMapEntries; i++)
-		{
-			size_t nFilePathSize = 0;
-			ifs.read((char*)&nFilePathSize, sizeof(size_t));
-
-			std::string sFileName(nFilePathSize, ' ');
-			for (size_t j = 0; j < nFilePathSize; j++)
-				sFileName[j] = ifs.get();
-
-			sEntry e;
-			e.data = nullptr;
-			ifs.read((char*)&e.nID, sizeof(uint32_t));
-			ifs.read((char*)&e.nFileSize, sizeof(uint32_t));
-			ifs.read((char*)&e.nFileOffset, sizeof(uint32_t));
-			mapFiles[sFileName] = e;
-		}
-
-		// 2) Read Data
-		for (auto &e : mapFiles)
-		{
-			e.second.data = new uint8_t[(uint32_t)e.second.nFileSize];
-			ifs.seekg(e.second.nFileOffset);
-			ifs.read((char*)e.second.data, e.second.nFileSize);
-			e.second._config();
-		}
-
-		ifs.close();
-		return olc::OK;
-	}
-
-	olc::ResourcePack::sEntry ResourcePack::GetStreamBuffer(std::string sFile)
-	{
-		return mapFiles[sFile];
-	}
-
-	olc::rcode ResourcePack::ClearPack()
-	{
-		for (auto &e : mapFiles)
-		{
-			if (e.second.data != nullptr)
-				delete[] e.second.data;
-		}
-
-		mapFiles.clear();
-		return olc::OK;
-	}
-
-	//==========================================================
-
 	PixelGameEngine::PixelGameEngine()
 	{
 		sAppName = "Undefined";
@@ -1175,21 +1037,23 @@ namespace olc
 		Display* d = XOpenDisplay(NULL);
 		int defaultScreen = DefaultScreen(d);
 		Screen *s = ScreenOfDisplay(d, defaultScreen);
-		int minResolution = std::min(WidthOfScreen(s), HeightOfScreen(s));
+		int minWidth = WidthOfScreen(s);
+		int minHeight = HeightOfScreen(s);
 		int screensCount = ScreenCount(d);
 		for (int i=0; i < screensCount; i++) {
 			s = ScreenOfDisplay(d, i);
-			if (WidthOfScreen(s) < minResolution) {
-				minResolution = WidthOfScreen(s);
+			if (WidthOfScreen(s) < minWidth) {
+				minWidth = WidthOfScreen(s);
 			}
-			if (HeightOfScreen(s) < minResolution) {
-				minResolution = HeightOfScreen(s);
+			if (HeightOfScreen(s) < minHeight) {
+				minHeight = HeightOfScreen(s);
 			}
 		}
 
-		uint32_t maxScreenSize = std::max(width, height);
+		uint32_t pixelWidth = minWidth / width;
+		uint32_t pixelHeight = minHeight / height;
 
-		return minResolution / maxScreenSize;		
+		return std::min(pixelWidth, pixelHeight);		
 #endif
 	}