Imported revamped GUI classes, moved map classes

common/button.cpp

@@ -0,0 +1,81 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#include "button.hpp"
+
+#include <stdexcept>
+
+Button::State Button::MouseMotion(SDL_MouseMotionEvent const& motion) {
+	return CalcState(motion.x, motion.y, motion.state & SDL_BUTTON_LMASK);
+}
+
+Button::State Button::MouseButtonDown(SDL_MouseButtonEvent const& button) {
+	if (button.button == SDL_BUTTON_LEFT) {
+		return CalcState(button.x, button.y, true);
+	}
+	return state;
+}
+
+Button::State Button::MouseButtonUp(SDL_MouseButtonEvent const& button) {
+	if (button.button == SDL_BUTTON_LEFT) {
+		return CalcState(button.x, button.y, false);
+	}
+	return state;
+}
+
+void Button::DrawTo(SDL_Surface* const dest) {
+	if (!image || !font) {
+		throw(std::runtime_error("Surface not set for Button"));
+	}
+	image->SetClipY(state * image->GetClipH());
+	image->DrawTo(dest, x, y);
+	font->DrawStringTo(text, dest, textX + x, textY + y);
+}
+
+std::string Button::SetText(std::string t) {
+	if (!image || !font) {
+		throw(std::runtime_error("Surface not set for Button"));
+	}
+	//one line, cache the position
+	text = t;
+	textX = (image->GetClipW() / 2) - (font->GetCharW() * text.size() / 2);
+	textY = (image->GetClipH() / 2) - (font->GetCharH() / 2);
+	return text;
+}
+
+Button::State Button::CalcState(Sint16 i, Sint16 j, bool leftPressed) {
+	if (!image || !font) {
+		throw(std::runtime_error("Surface not set for Button"));
+	}
+	//if out of bounds
+	if (i < x || i >= (x + image->GetClipW()) ||
+		j < y || j >= (y + image->GetClipH())
+		) {
+		return state = State::NORMAL;
+	}
+
+	if (leftPressed) {
+		return state = State::PRESSED;
+	}
+	else {
+		return state = State::HOVER;
+	}
+}

common/button.hpp

@@ -0,0 +1,94 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#ifndef BUTTON_HPP_
+#define BUTTON_HPP_
+
+#include "image.hpp"
+#include "raster_font.hpp"
+
+#include <string>
+
+/* 3-phases, no toggle, centred text
+ * This class uses the size of the provided image as its bounds. Also,
+ * The provided image should be formatted correctly.
+ *
+ * The button's image should be divided into 3 sections virtucally,
+ * which act as the different button images. The clip width & height of the
+ * Image should be set manually, and the height should be 1/3 of the total
+ * graphical data.
+*/
+class Button {
+public:
+	enum State {
+		NORMAL = 0, HOVER = 1, PRESSED = 2
+	};
+
+	Button() = default;
+	~Button() = default;
+
+	//handle input
+	State MouseMotion(SDL_MouseMotionEvent const&);
+	State MouseButtonDown(SDL_MouseButtonEvent const&);
+	State MouseButtonUp(SDL_MouseButtonEvent const&);
+
+	//yet another draw function
+	void DrawTo(SDL_Surface* const);
+
+	//accessors and mutators
+	Image* SetImage(Image* const ptr) { return image = ptr; }
+	Image* GetImage() { return image; }
+	RasterFont* SetFont(RasterFont* const ptr) { return font = ptr; }
+	RasterFont* GetFont() { return font; }
+
+	Sint16 SetX(Sint16 i) { return x = i; }
+	Sint16 SetY(Sint16 i) { return y = i; }
+	Sint16 GetX() const { return x; }
+	Sint16 GetY() const { return y; }
+
+	Sint16 SetTextX(Sint16 i) { return textX = i; }
+	Sint16 SetTextY(Sint16 i) { return textY = i; }
+	Sint16 GetTextX() const { return textX; }
+	Sint16 GetTextY() const { return textY; }
+
+	State SetState(State s) { return state = s; }
+	State GetState() const { return state; }
+
+	std::string SetText(std::string);
+	std::string GetText() const { return text; }
+
+private:
+	State CalcState(Sint16 x, Sint16 y, bool leftPressed);
+
+	//point to the provided external objects
+	Image* image = nullptr;
+	RasterFont* font = nullptr;
+
+	//positions
+	Sint16 x = 0, y = 0;
+	Sint16 textX = 0, textY = 0;
+
+	//
+	State state = State::NORMAL;
+	std::string text;
+};
+
+#endif

common/menu_bar.cpp

@@ -0,0 +1,139 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#include "menu_bar.hpp"
+
+#include <stdexcept>
+#include <sstream>
+
+void MenuBar::DrawTo(SDL_Surface* const dest) {
+	for (auto& i : entries) {
+		i.DrawTo(dest);
+	}
+}
+
+void MenuBar::MouseMotion(SDL_MouseMotionEvent const& motion) {
+	for (auto& i : entries) {
+		i.MouseMotion(motion);
+	}
+}
+
+void MenuBar::MouseButtonDown(SDL_MouseButtonEvent const& button) {
+	for (auto& i : entries) {
+		i.MouseButtonDown(button);
+	}
+}
+
+void MenuBar::MouseButtonUp(SDL_MouseButtonEvent const& button, int* entry, int* butt) {
+	*entry = *butt = -1;
+	int ret = -1;
+	for (auto& i : entries) {
+		ret = i.MouseButtonUp(button);
+
+		if (ret != -1) {
+			*entry = (&i - entries.data());
+			*butt = ret;
+		}
+	}
+}
+
+void MenuBar::SetEntries(std::vector<std::vector<std::string>> info) {
+	if (!image || !font) {
+		throw(std::runtime_error("Surfaces not loaded into the menu bar"));
+	}
+
+	entries.clear();
+	for (int i = 0; i < info.size(); i++) {
+		//create the entry & the main button
+		entries.push_back(MenuBarEntry());
+		entries[i].mainButton.SetImage(image);
+		entries[i].mainButton.SetFont(font);
+		entries[i].mainButton.SetText(info[i][0]);
+		entries[i].mainButton.SetX(i * image->GetClipW());
+		entries[i].mainButton.SetY(0);
+		for (int j = 0; j < info[i].size()-1; j++) {
+			//create each drop button in this entry
+			entries[i].dropButtons.push_back(Button());
+			entries[i].dropButtons[j].SetImage(image);
+			entries[i].dropButtons[j].SetFont(font);
+			entries[i].dropButtons[j].SetText(info[i][j+1]);
+			entries[i].dropButtons[j].SetX(i * image->GetClipW());
+			entries[i].dropButtons[j].SetY((j+1) * image->GetClipH());
+		}
+	}
+}
+
+void MenuBar::MenuBarEntry::DrawTo(SDL_Surface* const dest) {
+	//only draw the dropButtons in the user has this menu open
+	mainButton.DrawTo(dest);
+
+	if (!open) {
+		return;
+	}
+
+	for (auto& i : dropButtons) {
+		i.DrawTo(dest);
+	}
+}
+
+void MenuBar::MenuBarEntry::MouseMotion(SDL_MouseMotionEvent const& motion) {
+	//open the menu
+	bool o = mainButton.MouseMotion(motion) == Button::State::PRESSED;
+
+	if (!(open |= o)) {
+		return;
+	}
+
+	for (auto& i : dropButtons) {
+		//dragging down the menu
+		o |= i.MouseMotion(motion) == Button::State::PRESSED;
+	}
+
+	open = o;
+}
+
+void MenuBar::MenuBarEntry::MouseButtonDown(SDL_MouseButtonEvent const& button) {
+	//open the menu
+	if (!(open = mainButton.MouseButtonDown(button) == Button::State::PRESSED)) {
+		return;
+	}
+
+	//update the others anyway
+	for (auto& i : dropButtons) {
+		i.MouseButtonDown(button);
+	}
+}
+
+int MenuBar::MenuBarEntry::MouseButtonUp(SDL_MouseButtonEvent const& button) {
+	int ret = -1;
+	mainButton.MouseButtonUp(button);
+
+	for (auto& i : dropButtons) {
+		//the user just released this button
+		if (i.GetState() != i.MouseButtonUp(button) && i.GetState() == Button::State::HOVER && open) {
+			//get this button's index
+			ret = (&i - dropButtons.data());
+		}
+	}
+
+	open = false;
+	return ret;
+}

common/menu_bar.hpp

@@ -0,0 +1,91 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#ifndef MENUBAR_HPP_
+#define MENUBAR_HPP_
+
+#include "image.hpp"
+#include "raster_font.hpp"
+#include "button.hpp"
+
+#include <string>
+#include <vector>
+
+/* I've redesigned this so that the contents of the menu bar can't change during run time.
+ * This is more restrictive but I'm focusing on getting this working first.
+ * The Image and Font pointers must be set before the text data is entered.
+ * 
+ * This class needs a rewrite.
+*/
+
+class MenuBar {
+public:
+	MenuBar() = default;
+	~MenuBar() = default;
+
+	//yet another draw function
+	void DrawTo(SDL_Surface* const dest);
+
+	//user inputs
+	void MouseMotion(SDL_MouseMotionEvent const&);
+	void MouseButtonDown(SDL_MouseButtonEvent const&);
+	void MouseButtonUp(SDL_MouseButtonEvent const&, int* entry, int* button);
+
+	//manage the entries & buttons
+	void SetEntries(std::vector<std::vector<std::string>> info);
+	void ClearEntries() { entries.clear(); }
+
+	//Accessors and mutators
+	Image* SetImage(Image* const ptr) { return image = ptr; }
+	Image* GetImage() { return image; }
+	RasterFont* SetFont(RasterFont* const ptr) { return font = ptr; }
+	RasterFont* GetFont() { return font; }
+
+private:
+	class MenuBarEntry;
+
+	std::vector<MenuBarEntry> entries;
+
+	Image* image = nullptr;
+	RasterFont* font = nullptr;
+};
+
+class MenuBar::MenuBarEntry {
+public:
+	MenuBarEntry() = default;
+	~MenuBarEntry() = default;
+
+	void DrawTo(SDL_Surface* const dest);
+
+	void MouseMotion(SDL_MouseMotionEvent const&);
+	void MouseButtonDown(SDL_MouseButtonEvent const&);
+	int MouseButtonUp(SDL_MouseButtonEvent const&);
+
+private:
+	Button mainButton;
+
+	std::vector<Button> dropButtons;
+	bool open = false;
+
+	friend class MenuBar;
+};
+
+#endif

common/raster_font.cpp

@@ -0,0 +1,60 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#include "raster_font.hpp"
+
+#include <stdexcept>
+
+/* It might be more efficient to render to a different surface (like an Image)
+ * rather than calling this function with all of it's '%' and '/'.
+*/
+
+void RasterFont::DrawStringTo(std::string s, SDL_Surface* const dest, Sint16 x, Sint16 y) {
+	if (!image.GetSurface()) {
+		throw(std::runtime_error("RasterFont not loaded"));
+	}
+	const Uint16 w = image.GetClipW();
+	const Uint16 h = image.GetClipH();
+	for (int i = 0; i < s.size(); i++) {
+		image.SetClipX(s[i] % 16 * w);
+		image.SetClipY(s[i] / 16 * h);
+		image.DrawTo(dest, x + i * w, y);
+	}
+}
+
+/* Note: This class can only take a raster font with 16*16 characters, and the
+ * indevidual characters must have the same dimensions. Overall this class is too
+ * restrictive; I suggest using a 3rd party library.
+*/
+
+SDL_Surface* RasterFont::LoadSurface(std::string fname) {
+	image.LoadSurface(fname);
+	image.SetClipW(image.GetSurface()->w/16);
+	image.SetClipH(image.GetSurface()->h/16);
+	return image.GetSurface();
+}
+
+SDL_Surface* RasterFont::SetSurface(SDL_Surface* p) {
+	image.SetSurface(p);
+	image.SetClipW(image.GetSurface()->w/16);
+	image.SetClipH(image.GetSurface()->h/16);
+	return image.GetSurface();
+}

common/raster_font.hpp

@@ -0,0 +1,54 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#ifndef RASTERFONT_HPP_
+#define RASTERFONT_HPP_
+
+#include "image.hpp"
+
+class RasterFont {
+public:
+	RasterFont() = default;
+	RasterFont(RasterFont const& rhs) { *this = rhs; }
+	RasterFont(RasterFont&& rhs) { *this = std::move(rhs); }
+	RasterFont(std::string fname) { LoadSurface(fname); }
+	RasterFont(SDL_Surface* p) { SetSurface(p); }
+	~RasterFont() = default;
+
+	RasterFont& operator=(RasterFont const& rhs) { image = rhs.image; }
+	RasterFont& operator=(RasterFont&& rhs) { image = std::move(rhs.image); }
+
+	void DrawStringTo(std::string, SDL_Surface* const, Sint16 x, Sint16 y);
+
+	//Accessors and Mutators
+	SDL_Surface* LoadSurface(std::string);
+	SDL_Surface* SetSurface(SDL_Surface*);
+	SDL_Surface* GetSurface() const { return image.GetSurface(); }
+	void FreeSurface() { image.FreeSurface(); }
+
+	Uint16 GetCharW() const { return image.GetClipW(); }
+	Uint16 GetCharH() const { return image.GetClipH(); }
+
+private:
+	Image image;
+};
+
+#endif

common/region.cpp

@@ -0,0 +1,123 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#include "region.hpp"
+
+#include "utility.hpp"
+
+#include <stdexcept>
+#include <sstream>
+
+Region::Region(int _x, int _y, int _w, int _h):
+	x(_x),
+	y(_y),
+	width(_w),
+	height(_h)
+{
+	//make sure that the region's position lines up
+	if (x != snapToBase(width, x) || y != snapToBase(height, y)) {
+		std::ostringstream os;
+		os << "Region is unaligned; x: " << x << ", y: " << y << ", width: " << width << ", height: " << height;
+		throw(std::runtime_error(os.str()));
+	}
+}
+
+int Region::NewTileR(Tile const& tile) {
+	//return 1 for overwrite, 0 for insert
+	if (!InBoundsR(tile.x, tile.y)) {
+		std::ostringstream os;
+		os << "New tile location out of bounds: " <<
+			"(" << x << "," << y << ")->" <<
+			"(" << tile.x << "," << tile.y << ")"
+		;
+		throw(std::runtime_error(os.str()));
+	}
+
+	int ret = tiles.erase(tile);
+	tiles.insert(tile);
+	return ret;
+}
+
+Tile Region::GetTileR(int tx, int ty, int minDepth) {
+	std::set<Tile>::iterator ptr = tiles.begin();
+
+	//skip the tiles that are too deep
+	while(ptr != tiles.end()) {
+		if (ptr->depth >= minDepth) {
+			break;
+		}
+		ptr++;
+	}
+
+	//find the first tile here
+	while(ptr != tiles.end()) {
+		//bounds
+		if ((ptr->x <= tx) && (ptr->y <= ty) && (ptr->x + ptr->width > tx) && (ptr->y + ptr->height > ty)) {
+			break;
+		}
+		ptr++;
+	}
+
+	//found it
+	if (ptr != tiles.end()) {
+		return *ptr;
+	}
+
+	//a tileIndex of -1 is an error code, the rest is for show
+	return {0,0,0,-1,-1,-1};
+}
+
+int Region::DeleteTileR(Tile const& tile) {
+	if (!InBoundsR(tile.x, tile.y)) {
+		throw(std::runtime_error("Deleted tile location out of bounds"));
+
+		std::ostringstream os;
+		os << "Deleted tile location out of bounds: " <<
+			"(" << x << "," << y << ")->" <<
+			"(" << tile.x << "," << tile.y << ")"
+		;
+		throw(std::runtime_error(os.str()));
+	}
+	//sentinel/error code
+	if (tile.tileIndex == -1) {
+		return 0;
+	}
+	return tiles.erase(tile);
+}
+
+bool operator<(Region const& lhs, Region const& rhs) {
+	//sort by y -> x
+	if (lhs.y == rhs.y) {
+		return lhs.x < rhs.x;
+	}
+	return lhs.y < rhs.y;
+}
+
+inline bool operator>(Region const& lhs, Region const& rhs) {
+	//wrap the other operator
+	return rhs < lhs;
+}
+
+inline bool operator==(Region const& lhs, Region const& rhs) {
+	//comparisons work on the location ONLY
+	//this function is redundant as far as the std::set object is concerned
+	return (lhs.x == rhs.x) && (lhs.y == rhs.y);
+}

common/region.hpp

@@ -0,0 +1,112 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#ifndef REGION_HPP_
+#define REGION_HPP_
+
+#include "tile.hpp"
+
+#include <set>
+
+/* A single section of the map.
+ * This class stores the tiles relative to it's own position, but
+ * there are functions for referencing the tiles' absolute position.
+ * These functions simply wrap the normal functions.
+*/
+class Region {
+public:
+	Region() = delete;
+	Region(int x, int y, int width, int height);
+	~Region() = default;
+
+	//create and insert a new tile, overwriting an existing tile at that location
+	int NewTileR(Tile const& tile);
+	int NewTileA(Tile const& tile) {
+		//these can change, if the Tile class is changed
+		return NewTileR({
+			tile.x - x,
+			tile.y - y,
+			tile.depth,
+			tile.width,
+			tile.height,
+			tile.tileIndex
+		});
+	}
+
+	//find the first tile at this location, with the specified minimum depth
+	Tile GetTileR(int tx, int ty, int minDepth);
+	Tile GetTileA(int tx, int ty, int minDepth) {
+		return GetTileR(tx - x, ty - y, minDepth);
+	}
+
+	//wrap the other delete functions
+	int DeleteTileR(int tx, int ty, int minDepth) {
+		return DeleteTileR(GetTileR(tx, ty, minDepth));
+	}
+	int DeleteTileA(int tx, int ty, int minDepth) {
+		//explicitly skip one function call by adjusting from A to R
+		return DeleteTileR(GetTileR(tx - x, ty - y, minDepth));
+	}
+
+	//delete the specified tile
+	int DeleteTileR(Tile const& tile);
+	int DeleteTileA(Tile const& tile) {
+		//these can change, if the Tile class is changed
+		return DeleteTileR({
+			tile.x - x,
+			tile.y - y,
+			tile.depth,
+			tile.width,
+			tile.height,
+			tile.tileIndex
+		});
+	}
+
+	//find if the specified location exists within the region's bounds
+	bool InBoundsR(int i, int j) {
+		return (i >= 0) && (j >= 0) && (i < width) && (j < height);
+	}
+	bool InBoundsA(int i, int j) {
+		return InBoundsR(i - x, j - y);
+	}
+
+	//Raw accessors & mutators
+	int GetX() const { return x; }
+	int GetY() const { return y; }
+	int GetWidth() const { return width; }
+	int GetHeight() const { return height; }
+
+	std::set<Tile>* GetTiles() { return &tiles; }
+
+	//sorting the regions by the locations
+	friend bool operator<(Region const& lhs, Region const& rhs);
+	friend bool operator>(Region const& lhs, Region const& rhs);
+	friend bool operator==(Region const& lhs, Region const& rhs);
+
+private:
+	int const x;
+	int const y;
+	int const width;
+	int const height;
+	std::set<Tile> tiles;
+};
+
+#endif

common/region_pager.cpp

@@ -0,0 +1,119 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#include "region_pager.hpp"
+
+#include <stdexcept>
+
+RegionPager::RegionPager() {
+	//
+}
+
+RegionPager::~RegionPager() {
+	if (onDelete) {
+		for (auto& i : regionList) {
+			onDelete(&i);
+		}
+	}
+}
+
+Region* RegionPager::NewRegion(int x, int y) {
+	for (auto& i : regionList) {
+		if (i.GetX() == x && i.GetY() == y) {
+			throw(std::runtime_error("Duplicate Regions detected"));
+		}
+	}
+
+	regionList.push_front({x, y, regionWidth, regionHeight});
+	if (onNew) {
+		onNew(&regionList.front());
+	}
+	return &regionList.front();
+}
+
+Region* RegionPager::GetRegion(int x, int y) {
+	for (auto& i : regionList) {
+		if (i.GetX() == x && i.GetY() == y) {
+			return &i;
+		}
+	}
+	//create, insert and return
+	regionList.push_front({x, y, regionWidth, regionHeight});
+	if (onNew) {
+		onNew(&regionList.front());
+	}
+	return &regionList.front();
+}
+
+void RegionPager::DeleteRegion(int x, int y) {
+	for (std::list<Region>::iterator i = regionList.begin(); i != regionList.end(); i++) {
+		if (i->GetX() == x && i->GetY() == y) {
+			if (onDelete) {
+				onDelete(&(*i));
+			}
+			regionList.erase(i);
+			break;
+		}
+	}
+}
+
+void RegionPager::DrawTo(SDL_Surface* const dest, std::list<TileSheet>* const sheetList, int camX, int camY) {
+	/* for each region:
+	 *     for each tile within that reagon
+	 *         if you have the correct tile sheet
+	 *             draw to the screen
+	 *         else
+	 *             error
+	*/
+
+	for (auto& regionIter : regionList) {
+		//draw the region's location
+		SDL_Rect box = {
+			Sint16(regionIter.GetX() + camX),
+			Sint16(regionIter.GetY() + camY),
+			Uint16(regionIter.GetWidth()),
+			Uint16(regionIter.GetHeight())
+		};
+		SDL_FillRect(dest, &box, SDL_MapRGB(dest->format, 10, 10, 20));
+
+		//draw each tile
+		for (auto& tileIter : *regionIter.GetTiles()) {
+			for (auto& sheetIter : *sheetList) {
+				if (sheetIter.InRange(tileIter.tileIndex)) {
+					sheetIter.DrawTo(
+						dest,
+						tileIter.x + regionIter.GetX() + camX,
+						tileIter.y + regionIter.GetY() + camY,
+						tileIter.tileIndex
+					);
+					//skip to the next tile
+					goto continueTile;
+				}
+			}
+
+			//reaching this point without rendering means that the tile is invalid
+			throw(std::runtime_error("Undrawable tile encountered"));
+
+		continueTile: ;
+			//continue with the next tile
+		}
+	}
+}

common/region_pager.hpp

@@ -0,0 +1,66 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#ifndef REGIONPAGER_HPP_
+#define REGIONPAGER_HPP_
+
+#include "region.hpp"
+#include "tile_sheet.hpp"
+
+#include <list>
+
+class RegionPager {
+public:
+	//for simplicity and consistency
+	typedef void (*regionCallback_t)(Region* const);
+
+	RegionPager();
+	~RegionPager();
+
+	//these parameters MUST be multiples of the width & height
+	Region* NewRegion(int x, int y);
+	Region* GetRegion(int x, int y);
+	void DeleteRegion(int x, int y);
+
+	//call this to draw to the screen
+	void DrawTo(SDL_Surface* const, std::list<TileSheet>* const, int camX, int camY);
+
+	//callback hooks
+	void SetOnNew(regionCallback_t f) { onNew = f; }
+	void SetOnDelete(regionCallback_t f) { onDelete = f; }
+
+	//accessors and mutators
+	int SetWidth(int i) { return regionWidth = i; }
+	int SetHeight(int i) { return regionHeight = i; }
+
+	int GetWidth() const { return regionWidth; }
+	int GetHeight() const { return regionHeight; }
+
+	std::list<Region>* GetRegions() { return &regionList; }
+private:
+	std::list<Region> regionList;
+	int regionWidth = 0, regionHeight = 0;
+
+	regionCallback_t onNew = nullptr;
+	regionCallback_t onDelete = nullptr;
+};
+
+#endif

common/tile.cpp

@@ -0,0 +1,44 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#include "tile.hpp"
+
+bool operator<(Tile const& lhs, Tile const& rhs) {
+	//sort by depth -> y -> x
+	if (lhs.depth == rhs.depth) {
+		if (lhs.y == rhs.y) {
+			return lhs.x < rhs.x;
+		}
+		return lhs.y < rhs.y;
+	}
+	return lhs.depth < rhs.depth;
+}
+
+inline bool operator>(Tile const& lhs, Tile const& rhs) {
+	//wrap the other operator
+	return rhs < lhs;
+}
+
+inline bool operator==(Tile const& lhs, Tile const& rhs) {
+	//comparisons work on the location ONLY
+	//this function is redundant as far as the std::set object is concerned
+	return (lhs.x == rhs.x) && (lhs.y == rhs.y) && (lhs.depth == rhs.depth);
+}

common/tile.hpp

@@ -0,0 +1,50 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#ifndef TILE_HPP_
+#define TILE_HPP_
+
+//explicitly a POD
+struct Tile {
+	//position relative to the Region
+	int x, y, depth;
+
+	//graphics
+	int width, height;
+	int tileIndex;
+
+	Tile() = default;
+	Tile(int _x, int _y, int _depth, int _width, int _height, int _tileIndex) {
+		//The order of the arguments should be explicit
+		x = _x;
+		y = _y;
+		depth = _depth;
+		width = _width;
+		height = _height;
+		tileIndex = _tileIndex;
+	}
+};
+
+bool operator<(Tile const& lhs, Tile const& rhs);
+bool operator>(Tile const& lhs, Tile const& rhs);
+bool operator==(Tile const& lhs, Tile const& rhs);
+
+#endif

common/tile_sheet.cpp

@@ -0,0 +1,72 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#include "tile_sheet.hpp"
+
+#include "utility.hpp"
+
+#include <stdexcept>
+
+int TileSheet::rangeEnd = 0;
+
+SDL_Surface* TileSheet::LoadSurface(std::string fname, Uint16 w, Uint16 h) {
+	//setup the image
+	image.LoadSurface(fname);
+	image.SetClipW(w);
+	image.SetClipH(h);
+
+	//get the tile counts
+	xCount = image.GetSurface()->w / w;
+	yCount = image.GetSurface()->h / h;
+	totalCount = xCount * yCount;
+
+	//cache the name
+	name = truncatePath(fname);
+
+	//set the range
+	begin = rangeEnd;
+	end = begin + totalCount;
+	rangeEnd += totalCount;
+}
+
+SDL_Surface* TileSheet::GetSurface() {
+	return image.GetSurface();
+}
+
+void TileSheet::FreeSurface() {
+	image.FreeSurface();
+	totalCount = xCount = yCount = 0;
+	begin = end = -1;
+	name.clear();
+}
+
+void TileSheet::DrawTo(SDL_Surface* const dest, int x, int y, int tileIndex) {
+	if (!InRange(tileIndex)) {
+		throw(std::runtime_error("Tile index out of range of Tile Sheet"));
+	}
+	Sint16 clipX = (tileIndex-begin) % xCount * image.GetClipW();
+	Sint16 clipY = (tileIndex-begin) / xCount * image.GetClipH();
+
+	image.SetClipX(clipX);
+	image.SetClipY(clipY);
+
+	image.DrawTo(dest, x, y);
+}

common/tile_sheet.hpp

@@ -0,0 +1,76 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
+#ifndef TILESHEET_HPP_
+#define TILESHEET_HPP_
+
+#include "image.hpp"
+
+#include <string>
+
+/* The TileSheet class is used for drawing tiles of the map to the screen.
+ * This class also tracks the range of the tile images.
+*/
+class TileSheet {
+public:
+	TileSheet() = default;
+	~TileSheet() = default;
+
+	//these load/set functions need to be followed by bookkeeping code
+	//w & h are the width & height of individual tiles
+	SDL_Surface* LoadSurface(std::string fname, Uint16 w, Uint16 h);
+	SDL_Surface* GetSurface();
+	void FreeSurface();
+
+	void DrawTo(SDL_Surface* const dest, int x, int y, int tileIndex);
+
+	bool InRange(int i) { return i >= begin && i < end; }
+
+	static int SetRangeEnd(int i) { return rangeEnd = i; }
+	static int GetRangeEnd() { return rangeEnd; }
+
+	//accessors and mutators
+	Image* GetImage() { return &image; }
+
+	std::string SetName(std::string s) { return name = s; }
+	std::string GetName() const { return name; }
+
+	int GetTotalCount() const { return totalCount; }
+	int GetXCount() const { return xCount; }
+	int GetYCount() const { return yCount; }
+
+	int SetBegin(int i) { return begin = i; }
+	int SetEnd(int i) { return end = i; }
+
+	int GetBegin() const { return begin; }
+	int GetEnd() const { return end; }
+private:
+	static int rangeEnd;
+
+	Image image;
+	std::string name;
+
+	//these are generated and used by internal processes
+	int totalCount = 0, xCount = 0, yCount = 0;
+	int begin = -1, end = -1;
+};
+
+#endif