Finished a prototype of Region, needs testing

editor/region.cpp

@@ -25,6 +25,7 @@
 #include <sstream>
 
 static int snap(int base, int x) {
+	//snap to a grid
 	if (x < 0) {
 		x++;
 		return x - x % base - base;
@@ -46,8 +47,9 @@ Region::Region(int i, int j, int k, int l):
 	}
 }
 
-bool Region::NewTile(Tile const& tile) {
-	if (!InBounds(tile.x, tile.y)) {
+bool Region::NewTileR(Tile const& tile) {
+	//return 1 for overwrite, 0 for insert
+	if (!InBoundsR(tile.x, tile.y)) {
 		throw(std::runtime_error("New tile location out of bounds"));
 	}
 
@@ -56,11 +58,10 @@ bool Region::NewTile(Tile const& tile) {
 	return ret;
 }
 
-Tile Region::GetTile(int x, int y, int tw, int th, int minDepth) {
-	/* This method is used to find a tile that covers (x, y).
-	 * This method returns the first tile above minDepth.
-	 * Since Region & Tile do not save the tile's size, tw & th are the size of the tiles.
-	*/
+Tile Region::GetTileR(int tx, int ty, int tw, int th, int minDepth) {
+	//find the first tile at this location, with the specified minimum depth
+	//since neither the Region or Tile classes store the tile sizes,
+	//this function takes the sizes as arguments
 	std::set<Tile>::iterator ptr = tiles.begin();
 	while(ptr != tiles.end()) {
 		//skip the tiles that are too deep
@@ -71,7 +72,7 @@ Tile Region::GetTile(int x, int y, int tw, int th, int minDepth) {
 	}
 	while(ptr != tiles.end()) {
 		//find the first tile here
-		if ((ptr->x <= x) && (ptr->y <= y) && (ptr->x + tw > x) && (ptr->y + th > y)) {
+		if ((ptr->x <= tx) && (ptr->y <= ty) && (ptr->x + tw > tx) && (ptr->y + th > ty)) {
 			break;
 		}
 		ptr++;
@@ -79,20 +80,16 @@ Tile Region::GetTile(int x, int y, int tw, int th, int minDepth) {
 	if (ptr != tiles.end()) {
 		return *ptr;
 	}
-	return {0,0,0,-1};
+	return {0,0,0,-1}; //value = -1 is a crappy error code
 }
 
-bool Region::DeleteTile(Tile const& tile) {
-	if (!InBounds(tile.x, tile.y)) {
+bool Region::DeleteTileR(Tile const& tile) {
+	if (!InBoundsR(tile.x, tile.y)) {
 		throw(std::runtime_error("Deleted tile location out of bounds"));
 	}
 	return tiles.erase(tile);
 }
 
-bool Region::InBounds(int x, int y) {
-	return (x > this->x) && (y > this->y) && (x < this->x + this->width) && (y < this->y + this->height);
-}
-
 bool operator<(Region const& lhs, Region const& rhs) {
 	//sort by y -> x
 	if (lhs.y == rhs.y) {

editor/region.hpp

@@ -26,22 +26,57 @@
 
 #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.
+ *
+ * TODO: This class needs to be thoroughly tested.
+*/
 class Region {
 public:
 	Region() = delete;
 	Region(int x, int y, int width, int height);
 	~Region() = default;
 
-	bool NewTile(Tile const&);
+	//create and insert a new tile, overwriting an existing tile at that location
+	bool NewTileR(Tile const& tile);
+	bool NewTileA(Tile const& tile) {
+		return NewTileR({tile.x - x, tile.y - y, tile.depth, tile.value});
+	}
 
-	Tile GetTile(int x, int y, int tw, int th, int minDepth);
+	//find the first tile at this location, with the specified minimum depth
+	//since neither the Region or Tile classes store the tile sizes,
+	//this function takes the sizes as arguments
+	Tile GetTileR(int tx, int ty, int tw, int th, int minDepth);
+	Tile GetTileA(int tx, int ty, int tw, int th, int minDepth) {
+		return GetTileR(tx - x, ty - y, tw, th, minDepth);
+	}
 
-	bool DeleteTile(int x, int y, int tw, int th, int minDepth) { return DeleteTile(GetTile(x, y, tw, th, minDepth)); }
-	bool DeleteTile(Tile const&);
+	//wrap the other delete functions
+	bool DeleteTileR(int tx, int ty, int tw, int th, int minDepth) {
+		return DeleteTileR(GetTileR(tx, ty, tw, th, minDepth));
+	}
+	bool DeleteTileA(int tx, int ty, int tw, int th, int minDepth) {
+		//explicitly skip one function call by adjusting from A to R
+		return DeleteTileR(GetTileR(tx - x, ty - y, tw, th, minDepth));
+	}
 
-	bool InBounds(int x, int y);
+	//delete the specified tile
+	bool DeleteTileR(Tile const& tile);
+	bool DeleteTileA(Tile const& tile) {
+		return DeleteTileR({tile.x - x, tile.y - y, tile.depth, tile.value});
+	}
 
-	//accessors & mutators
+	//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; }
@@ -49,6 +84,7 @@ public:
 
 	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);

editor/tile.hpp

@@ -28,9 +28,7 @@ struct Tile {
 	int value;
 
 	Tile() = default;
-	Tile(int i, int j, int k, int l) : x(i), y(j), depth(k), value(l) {
-		//
-	}
+	Tile(int i, int j, int k, int l) : x(i), y(j), depth(k), value(l) {}
 
 	friend bool operator<(Tile const& lhs, Tile const& rhs);
 	friend bool operator>(Tile const& lhs, Tile const& rhs);