Added Flatbuffers, experimented, and made some project changes

- I decided to add Flatbuffers in its entirety to Galavant. I feel confident that it will work for all of my data serialization needs. Here's to hoping this doesn't bite me in the ass later.
- Wrote an awful experiment involving flatbuffers to get a feel for how to use the library
- Updated the readme with links and information about Jam
- Jamfiles now reference eachother and all use Jamrules for compilation variables. Building from the root galavant/ now deposits libs and bins to root galavant/lib and galavant/bin, which is much more organized. So far, only experiments are built to bin (as Galavant is supposed to be a lib only)

.gitignore

@@ -30,6 +30,7 @@
 # Codeblocks folder ignores
 bin/
 obj/
+lib/
 
 # Codeblocks file ignores
 *.layout

Jamfile

@@ -0,0 +1,2 @@
+SubDir . ;
+SubInclude . src ;

Jamrules

@@ -0,0 +1,6 @@
+CC = gcc ;
+C++ = g++ ;
+LINK = g++ ;
+C++FLAGS = -std=c++11 -fPIC ; 	# fPIC = position independent code. This is so the lib can be linked in other libs/executables
+OBJECTC++FLAGS = -std=c++11 ;
+HDRS = thirdParty/flatbuffers/include ;

README.md

@@ -15,10 +15,18 @@ There is a lot to the design of Galavant that does not fit in this readme. If yo
 
 License
 --------
-The code is MIT licensed. I intend on keeping all data (images, sprites, gameplay/design data) private, following the Doom/Quake model. 
+The code is MIT licensed. I intend on keeping all data (images, sprites, gameplay/design data) private, following the Doom/Quake model, but for now, consider those to be MIT Licensed.
 
 Technical
 ----------
 I am writing Galavant in C++ (C++11, to be specific). I rely on SFML2 for sound, graphics, input, and networking. SFML is wrapped in my personal game library, [Base2.0](https://github.com/makuto/base2.0) (also MIT licensed), which also has other useful game-agnostic code. 
 
-Horizon used a makefile for its build process (which I hand wrote). I have decided to abandon this method because I think it wasted a lot of my time updating it. I plan on using Codeblocks with GCC to make this process more automatic. It should also make compiling on Windows much simpler.
+Jam is used as the build system for Galavant. I used to use makefiles in the Horizon iteration of this project, and I hated them. Jam is much easier to use and takes much less work to get a project set up. If people actually become interested in this project, I can invest some time in cmake-ifying it for more standard building. If you're willing to try building using jam, you may have to edit Jamrules to set your preferred compiler.
+
+Dependencies
+--------------
+Galavant uses features of C++11.
+
+The following libraries are required by Galavant and included in /thirdParty:
+- [OpenSimplexNoise](https://gist.github.com/tombsar/716134ec71d1b8c1b530), created by Arthur Tombs (public domain)
+- [Flatbuffers](https://github.com/google/flatbuffers), created by Google/Fun Propulsion Labs (Apache License, v2.0)

src/GalavantMain.hpp

@@ -8,6 +8,7 @@ class GalavantMain
 {
 public:
 	// All updating of Galavant happens here
+	// This is not a great idea
 	void Update(float frameTime);
 };
 }

src/Jamfile

@@ -1,9 +1,12 @@
-CC = gcc ;
-C++ = g++ ;
-LINK = g++ ;
-C++FLAGS = -std=c++11 -fPIC ; 	# fPIC = position independent code. This is so the lib can be linked in other libs/executables
-OBJECTC++FLAGS = -std=c++11 ;
+SubDir . src ;
+
+Library libGalavant : GalavantMain.cpp ;
+
+LinkLibraries libGalavant : libGalaThirdPartyWrapper ;
 
 MakeLocate libGalavant.a : lib ;
 
-Library libGalavant : GalavantMain.cpp ;
+SubInclude . src thirdPartyWrapper ;
+
+# Experiments (feel free to remove this if desired)
+SubInclude . src experiments ;

src/experiments/Jamfile

@@ -0,0 +1,5 @@
+SubDir . src experiments ;
+
+SubInclude . src experiments flatbuffers ;
+SubInclude . src experiments noise ;
+SubInclude . src experiments threading ;

src/experiments/flatbuffers/Jamfile

@@ -0,0 +1,5 @@
+SubDir . src experiments flatbuffers ;
+
+Main testFlatbuffers : testFlatbuffers.cpp ;
+
+MakeLocate testFlatbuffers : bin ;

src/experiments/flatbuffers/anotherBogusSchema.flb

@@ -0,0 +1,8 @@
+namespace Galavant.Test;
+
+table HelloReply
+{
+	message:string;
+}
+
+root_type HelloReply;

src/experiments/flatbuffers/anotherBogusSchema_generated.h

@@ -0,0 +1,85 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+#ifndef FLATBUFFERS_GENERATED_ANOTHERBOGUSSCHEMA_GALAVANT_TEST_H_
+#define FLATBUFFERS_GENERATED_ANOTHERBOGUSSCHEMA_GALAVANT_TEST_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace Galavant
+{
+namespace Test
+{
+struct HelloReply;
+
+struct HelloReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
+{
+	enum
+	{
+		VT_MESSAGE = 4
+	};
+	const flatbuffers::String *message() const
+	{
+		return GetPointer<const flatbuffers::String *>(VT_MESSAGE);
+	}
+	bool Verify(flatbuffers::Verifier &verifier) const
+	{
+		return VerifyTableStart(verifier) &&
+			   VerifyField<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
+			   verifier.Verify(message()) && verifier.EndTable();
+	}
+};
+
+struct HelloReplyBuilder
+{
+	flatbuffers::FlatBufferBuilder &fbb_;
+	flatbuffers::uoffset_t start_;
+	void add_message(flatbuffers::Offset<flatbuffers::String> message)
+	{
+		fbb_.AddOffset(HelloReply::VT_MESSAGE, message);
+	}
+	HelloReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
+	{
+		start_ = fbb_.StartTable();
+	}
+	HelloReplyBuilder &operator=(const HelloReplyBuilder &);
+	flatbuffers::Offset<HelloReply> Finish()
+	{
+		auto o = flatbuffers::Offset<HelloReply>(fbb_.EndTable(start_, 1));
+		return o;
+	}
+};
+
+inline flatbuffers::Offset<HelloReply> CreateHelloReply(
+	flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> message = 0)
+{
+	HelloReplyBuilder builder_(_fbb);
+	builder_.add_message(message);
+	return builder_.Finish();
+}
+
+inline flatbuffers::Offset<HelloReply> CreateHelloReplyDirect(flatbuffers::FlatBufferBuilder &_fbb,
+															  const char *message = nullptr)
+{
+	return CreateHelloReply(_fbb, message ? _fbb.CreateString(message) : 0);
+}
+
+inline const Galavant::Test::HelloReply *GetHelloReply(const void *buf)
+{
+	return flatbuffers::GetRoot<Galavant::Test::HelloReply>(buf);
+}
+
+inline bool VerifyHelloReplyBuffer(flatbuffers::Verifier &verifier)
+{
+	return verifier.VerifyBuffer<Galavant::Test::HelloReply>(nullptr);
+}
+
+inline void FinishHelloReplyBuffer(flatbuffers::FlatBufferBuilder &fbb,
+								   flatbuffers::Offset<Galavant::Test::HelloReply> root)
+{
+	fbb.Finish(root);
+}
+
+}  // namespace Test
+}  // namespace Galavant
+
+#endif  // FLATBUFFERS_GENERATED_ANOTHERBOGUSSCHEMA_GALAVANT_TEST_H_

src/experiments/flatbuffers/bogusSchema.flb

@@ -0,0 +1,14 @@
+include "anotherBogusSchema.flb";
+
+namespace Galavant.Test;
+
+enum FuckYou:byte { FuckYou = 0, FuckYouToo  }
+
+table Hello
+{
+	status:FuckYou = FuckYou;
+	value:int = 1232;
+	message:HelloReply;
+}
+
+root_type Hello;

src/experiments/flatbuffers/bogusSchema_generated.h

@@ -0,0 +1,122 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+#ifndef FLATBUFFERS_GENERATED_BOGUSSCHEMA_GALAVANT_TEST_H_
+#define FLATBUFFERS_GENERATED_BOGUSSCHEMA_GALAVANT_TEST_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "anotherBogusSchema_generated.h"
+
+namespace Galavant
+{
+namespace Test
+{
+struct Hello;
+
+enum FuckYou
+{
+	FuckYou_FuckYou = 0,
+	FuckYou_FuckYouToo = 1,
+	FuckYou_MIN = FuckYou_FuckYou,
+	FuckYou_MAX = FuckYou_FuckYouToo
+};
+
+inline const char **EnumNamesFuckYou()
+{
+	static const char *names[] = {"FuckYou", "FuckYouToo", nullptr};
+	return names;
+}
+
+inline const char *EnumNameFuckYou(FuckYou e)
+{
+	return EnumNamesFuckYou()[static_cast<int>(e)];
+}
+
+struct Hello FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
+{
+	enum
+	{
+		VT_STATUS = 4,
+		VT_VALUE = 6,
+		VT_MESSAGE = 8
+	};
+	FuckYou status() const
+	{
+		return static_cast<FuckYou>(GetField<int8_t>(VT_STATUS, 0));
+	}
+	int32_t value() const
+	{
+		return GetField<int32_t>(VT_VALUE, 1232);
+	}
+	const Galavant::Test::HelloReply *message() const
+	{
+		return GetPointer<const Galavant::Test::HelloReply *>(VT_MESSAGE);
+	}
+	bool Verify(flatbuffers::Verifier &verifier) const
+	{
+		return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_STATUS) &&
+				 VerifyField<int32_t>(verifier, VT_VALUE) &&
+				 VerifyField<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
+				 verifier.VerifyTable(message()) && verifier.EndTable();
+	}
+};
+
+struct HelloBuilder
+{
+	flatbuffers::FlatBufferBuilder &fbb_;
+	flatbuffers::uoffset_t start_;
+	void add_status(FuckYou status)
+	{
+		fbb_.AddElement<int8_t>(Hello::VT_STATUS, static_cast<int8_t>(status), 0);
+	}
+	void add_value(int32_t value)
+	{
+		fbb_.AddElement<int32_t>(Hello::VT_VALUE, value, 1232);
+	}
+	void add_message(flatbuffers::Offset<Galavant::Test::HelloReply> message)
+	{
+		fbb_.AddOffset(Hello::VT_MESSAGE, message);
+	}
+	HelloBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
+	{
+		start_ = fbb_.StartTable();
+	}
+	HelloBuilder &operator=(const HelloBuilder &);
+	flatbuffers::Offset<Hello> Finish()
+	{
+		auto o = flatbuffers::Offset<Hello>(fbb_.EndTable(start_, 3));
+		return o;
+	}
+};
+
+inline flatbuffers::Offset<Hello> CreateHello(
+	flatbuffers::FlatBufferBuilder &_fbb, FuckYou status = FuckYou_FuckYou, int32_t value = 1232,
+	flatbuffers::Offset<Galavant::Test::HelloReply> message = 0)
+{
+	HelloBuilder builder_(_fbb);
+	builder_.add_message(message);
+	builder_.add_value(value);
+	builder_.add_status(status);
+	return builder_.Finish();
+}
+
+inline const Galavant::Test::Hello *GetHello(const void *buf)
+{
+	return flatbuffers::GetRoot<Galavant::Test::Hello>(buf);
+}
+
+inline bool VerifyHelloBuffer(flatbuffers::Verifier &verifier)
+{
+	return verifier.VerifyBuffer<Galavant::Test::Hello>(nullptr);
+}
+
+inline void FinishHelloBuffer(flatbuffers::FlatBufferBuilder &fbb,
+								flatbuffers::Offset<Galavant::Test::Hello> root)
+{
+	fbb.Finish(root);
+}
+
+}  // namespace Test
+}  // namespace Galavant
+
+#endif  // FLATBUFFERS_GENERATED_BOGUSSCHEMA_GALAVANT_TEST_H_

src/experiments/flatbuffers/lastBogusSchema.flb

@@ -0,0 +1,10 @@
+include "bogusSchema.flb";
+
+namespace Galavant.Test;
+
+table HelloDict
+{
+	helloArray:[Hello];
+}
+
+root_type HelloDict;

src/experiments/flatbuffers/lastBogusSchema_generated.h

@@ -0,0 +1,98 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+#ifndef FLATBUFFERS_GENERATED_LASTBOGUSSCHEMA_GALAVANT_TEST_H_
+#define FLATBUFFERS_GENERATED_LASTBOGUSSCHEMA_GALAVANT_TEST_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "anotherBogusSchema_generated.h"
+#include "bogusSchema_generated.h"
+
+namespace Galavant
+{
+namespace Test
+{
+struct HelloDict;
+
+struct HelloDict FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
+{
+	enum
+	{
+		VT_HELLOARRAY = 4
+	};
+	const flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello> > *helloArray() const
+	{
+		return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello> > *>(
+			VT_HELLOARRAY);
+	}
+	bool Verify(flatbuffers::Verifier &verifier) const
+	{
+		return VerifyTableStart(verifier) &&
+			   VerifyField<flatbuffers::uoffset_t>(verifier, VT_HELLOARRAY) &&
+			   verifier.Verify(helloArray()) && verifier.VerifyVectorOfTables(helloArray()) &&
+			   verifier.EndTable();
+	}
+};
+
+struct HelloDictBuilder
+{
+	flatbuffers::FlatBufferBuilder &fbb_;
+	flatbuffers::uoffset_t start_;
+	void add_helloArray(
+		flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello> > >
+			helloArray)
+	{
+		fbb_.AddOffset(HelloDict::VT_HELLOARRAY, helloArray);
+	}
+	HelloDictBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
+	{
+		start_ = fbb_.StartTable();
+	}
+	HelloDictBuilder &operator=(const HelloDictBuilder &);
+	flatbuffers::Offset<HelloDict> Finish()
+	{
+		auto o = flatbuffers::Offset<HelloDict>(fbb_.EndTable(start_, 1));
+		return o;
+	}
+};
+
+inline flatbuffers::Offset<HelloDict> CreateHelloDict(
+	flatbuffers::FlatBufferBuilder &_fbb,
+	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello> > >
+		helloArray = 0)
+{
+	HelloDictBuilder builder_(_fbb);
+	builder_.add_helloArray(helloArray);
+	return builder_.Finish();
+}
+
+inline flatbuffers::Offset<HelloDict> CreateHelloDictDirect(
+	flatbuffers::FlatBufferBuilder &_fbb,
+	const std::vector<flatbuffers::Offset<Galavant::Test::Hello> > *helloArray = nullptr)
+{
+	return CreateHelloDict(
+		_fbb, helloArray ?
+				  _fbb.CreateVector<flatbuffers::Offset<Galavant::Test::Hello> >(*helloArray) :
+				  0);
+}
+
+inline const Galavant::Test::HelloDict *GetHelloDict(const void *buf)
+{
+	return flatbuffers::GetRoot<Galavant::Test::HelloDict>(buf);
+}
+
+inline bool VerifyHelloDictBuffer(flatbuffers::Verifier &verifier)
+{
+	return verifier.VerifyBuffer<Galavant::Test::HelloDict>(nullptr);
+}
+
+inline void FinishHelloDictBuffer(flatbuffers::FlatBufferBuilder &fbb,
+								  flatbuffers::Offset<Galavant::Test::HelloDict> root)
+{
+	fbb.Finish(root);
+}
+
+}  // namespace Test
+}  // namespace Galavant
+
+#endif  // FLATBUFFERS_GENERATED_LASTBOGUSSCHEMA_GALAVANT_TEST_H_

src/experiments/flatbuffers/testFlatbuffers.cpp

@@ -0,0 +1,162 @@
+#include <vector>
+#include <iostream>
+#include <fstream>
+
+#include "bogusSchema_generated.h"
+#include "lastBogusSchema_generated.h"
+
+// This is awful code written only to test flatbuffers. It should be burned in hell.
+
+void printHello(const Galavant::Test::Hello *hello)
+{
+	if (hello)
+	{
+		std::string message = hello->message() ? hello->message()->message()->str() : "";
+		std::cout << "From buffer:\n\tstatus: " << Galavant::Test::EnumNameFuckYou(hello->status())
+				  << " value: " << hello->value() << " message: \"" << message << "\"\n";
+	}
+}
+
+void writeBuffer(flatbuffers::FlatBufferBuilder &builder)
+{
+	std::ofstream outputFile;
+
+	std::cout << "Writing out SavedHello.bin...\n";
+
+	outputFile.open("SavedHello.bin", std::ios::binary);
+	if (outputFile.is_open())
+	{
+		// outputFile.seekg(0, std::ios::beg);
+		outputFile.write((char *)builder.GetBufferPointer(), builder.GetSize());
+		outputFile.close();
+
+		std::cout << "Done writing to SavedHello.bin\n\t(" << builder.GetSize() << " bytes)\n";
+	}
+	else
+		std::cout << "Failed to write out to SavedHello.bin\n";
+}
+
+char *readBuffer()
+{
+	std::ifstream inputFile;
+
+	std::cout << "Reading in SavedHello.bin...\n";
+
+	// open with std::ios::ate so buffer pointer starts at end. tellg() tells us the size,
+	//  then we move the pointer back to the start and read in the entire file
+	// This sucks and I should be ashamed to have written it
+	inputFile.open("SavedHello.bin", std::ios::binary | std::ios::ate);
+	if (inputFile.is_open())
+	{
+		std::streampos size = inputFile.tellg();
+		char *memblock = new char[size];
+		inputFile.seekg(0, std::ios::beg);
+		inputFile.read(memblock, size);
+		inputFile.close();
+
+		std::cout << "Successfully read in SavedHello.bin\n\t(" << size << " bytes)\n";
+		return memblock;
+	}
+	else
+		std::cout << "Failed to read in SavedHello.bin\n";
+
+	return nullptr;
+}
+
+void createPlaceholderHelloArray(std::vector<flatbuffers::Offset<Galavant::Test::Hello> > &array,
+								 flatbuffers::FlatBufferBuilder &builder, int count)
+{
+	for (int i = 0; i < count; i++)
+	{
+		flatbuffers::Offset<flatbuffers::String> messageString =
+			builder.CreateString("This is the message!!!1 hello codegomad, mckenna and 123ran");
+
+		flatbuffers::Offset<Galavant::Test::HelloReply> message =
+			Galavant::Test::CreateHelloReply(builder, messageString);
+
+		flatbuffers::Offset<Galavant::Test::Hello> testHello = Galavant::Test::CreateHello(
+			builder, Galavant::Test::FuckYou::FuckYou_FuckYouToo, i, message);
+
+		array.push_back(testHello);
+	}
+}
+
+void testHellos()
+{
+	flatbuffers::FlatBufferBuilder builder;
+
+	flatbuffers::Offset<flatbuffers::String> messageString =
+		builder.CreateString("This is the message!!!1 hello codegomad and 123ran");
+
+	flatbuffers::Offset<Galavant::Test::HelloReply> message =
+		Galavant::Test::CreateHelloReply(builder, messageString);
+
+	flatbuffers::Offset<Galavant::Test::Hello> testHello = Galavant::Test::CreateHello(
+		builder, Galavant::Test::FuckYou::FuckYou_FuckYouToo, 58008, message);
+
+	builder.Finish(testHello);
+
+	const Galavant::Test::Hello *actualHello = Galavant::Test::GetHello(builder.GetBufferPointer());
+
+	printHello(actualHello);
+
+	writeBuffer(builder);
+
+	char *memblock = readBuffer();
+	if (memblock)
+	{
+		const Galavant::Test::Hello *readInHello = Galavant::Test::GetHello(memblock);
+		printHello(readInHello);
+		delete memblock;
+	}
+}
+
+void testHelloDict()
+{
+	flatbuffers::FlatBufferBuilder builder;
+	std::vector<flatbuffers::Offset<Galavant::Test::Hello> > helloArray;
+
+	createPlaceholderHelloArray(helloArray, builder, 10000);
+
+	flatbuffers::Offset<Galavant::Test::HelloDict> helloDict =
+		Galavant::Test::CreateHelloDictDirect(builder, &helloArray);
+
+	builder.Finish(helloDict);
+
+	writeBuffer(builder);
+
+	char *memblock = readBuffer();
+	if (memblock)
+	{
+		const Galavant::Test::HelloDict *readInHelloDict = Galavant::Test::GetHelloDict(memblock);
+
+		if (readInHelloDict)
+		{
+			const flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello> > *helloArray =
+				readInHelloDict->helloArray();
+
+			if (helloArray)
+			{
+				for (int i = 0; i < helloArray->Length(); i++)
+				{
+					const Galavant::Test::Hello *readInHello = helloArray->Get(i);
+
+					if (readInHello)
+						printHello(readInHello);
+				}
+			}
+		}
+
+		delete memblock;
+	}
+}
+
+int main()
+{
+	std::cout << "Test Flatbuffers\n";
+
+	testHellos();
+	testHelloDict();
+
+	return 1;
+}

src/experiments/noise/Jamfile

@@ -1,7 +1,7 @@
-CC = gcc ;
-C++ = g++ ;
-LINK = g++ ;
-C++FLAGS = -std=c++11 ;
-OBJECTC++FLAGS = -std=c++11 ;
+SubDir . src experiments noise ;
+
 Main simple2dNoiseTest : simple2dNoiseTest.cpp ;
-LinkLibraries simple2dNoiseTest : ../../thirdPartyWrapper/lib/libGalaThirdPartyWrapper.a ;
+
+LinkLibraries simple2dNoiseTest : libGalaThirdPartyWrapper ;
+
+MakeLocate simple2dNoiseTest : bin ;

src/experiments/threading/Jamfile

@@ -1,6 +1,5 @@
-CC = gcc ;
-C++ = g++ ;
-LINK = g++ ;
-C++FLAGS = -std=c++11 ;
-OBJECTC++FLAGS = -std=c++11 ;
-Main multithreading : multithreading.cpp ;
+SubDir . src experiments threading ;
+
+Main multithreading : multithreading.cpp ;
+
+MakeLocate multithreading : bin ;

src/project/galavantSublime/galavant.sublime-project

@@ -2,8 +2,8 @@
     "folders":
     [
         {
-            "path": "../../../src",
-            "name": "Source",
+            "path": "../../../../galavant",
+            "name": "Galavant",
             "folder_exclude_patterns": ["project"],
             "file_include_patterns": ["*.c", "*.cpp", "*.h", "*.hpp", "*.txt", "Jam*"]
         },

src/thirdPartyWrapper/Jamfile

@@ -1,9 +1,5 @@
-CC = gcc ;
-C++ = g++ ;
-LINK = g++ ;
-C++FLAGS = -std=c++11 -fPIC ; 	# fPIC = position independent code. This is so the thirdPartyWrapper can be linked in other libs/executables
-OBJECTC++FLAGS = -std=c++11 ;
+SubDir . src thirdPartyWrapper ;
 
-MakeLocate libGalaThirdPartyWrapper.a : lib ;
+Library libGalaThirdPartyWrapper : noise/noise.cpp ;
 
-Library libGalaThirdPartyWrapper : noise/noise.cpp ;
+MakeLocate libGalaThirdPartyWrapper.a : lib/thirdPartyWrapper ;

thirdParty/flatbuffers

@@ -0,0 +1 @@
+Subproject commit d05d1145238d301ed714573183514f95b1b4f89b