tibia-rme/source/position.h

//////////////////////////////////////////////////////////////////////
// This file is part of Remere's Map Editor
//////////////////////////////////////////////////////////////////////
// Remere's Map Editor is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Remere's Map Editor is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//////////////////////////////////////////////////////////////////////

#ifndef __POSITION_HPP__
#define __POSITION_HPP__

#include <ostream>
#include <cstdint>
#include <vector>
#include <list>

class Position {
public:
	// We use int since it's the native machine type and can be several times faster than
	// the other integer types in most cases, also, the position may be negative in some
	// cases
	int x, y, z;

	Position() :
		x(0), y(0), z(0) { }
	Position(int x, int y, int z) :
		x(x), y(y), z(z) { }

	bool operator<(const Position &other) const noexcept {
		if (z < other.z) {
			return true;
		}
		if (z > other.z) {
			return false;
		}

		if (y < other.y) {
			return true;
		}
		if (y > other.y) {
			return false;
		}

		if (x < other.x) {
			return true;
		}
		// if(x > p.x)
		//	return false;

		return false;
	}

	bool operator>(const Position &other) const noexcept {
		return !(*this < other);
	}

	Position operator-(const Position &other) const noexcept {
		return Position(x - other.x, y - other.y, z - other.z);
	}

	Position operator+(const Position &other) const noexcept {
		return Position(x + other.x, y + other.y, z + other.z);
	}

	Position &operator+=(const Position &other) {
		*this = *this + other;
		return *this;
	}

	bool operator==(const Position &other) const noexcept {
		return other.z == z && other.x == x && other.y == y;
	}

	bool operator!=(const Position &other) const noexcept {
		return !(*this == other);
	}

	bool isValid() const noexcept {
		if (x == 0 && y == 0 && z == 0) {
			return false;
		}
		return (z >= rme::MapMinLayer && z <= rme::MapMaxLayer)
			&& (x >= 0 && x <= rme::MapMaxWidth)
			&& (y >= 0 && y <= rme::MapMaxHeight);
	}
};

inline std::ostream &operator<<(std::ostream &os, const Position &pos) {
	os << pos.x << ':' << pos.y << ':' << pos.z;
	return os;
}

inline std::istream &operator>>(std::istream &is, Position &pos) {
	char a, b;
	int x, y, z;
	is >> x;
	if (!is) {
		return is;
	}
	is >> a;
	if (!is || a != ':') {
		return is;
	}
	is >> y;
	if (!is) {
		return is;
	}
	is >> b;
	if (!is || b != ':') {
		return is;
	}
	is >> z;
	if (!is) {
		return is;
	}

	pos.x = x;
	pos.y = y;
	pos.z = z;

	return is;
}

inline Position abs(const Position &position) {
	return Position(
		std::abs(position.x),
		std::abs(position.y),
		std::abs(position.z)
	);
}

typedef std::vector<Position> PositionVector;
typedef std::list<Position> PositionList;

#endif