2017-10-13 22:23:07 +02:00
|
|
|
/*****************************************************************************
|
2019-03-17 08:16:15 +01:00
|
|
|
* Copyright (c) 2014-2019 OpenRCT2 developers
|
2017-10-13 22:23:07 +02:00
|
|
|
*
|
2018-06-15 14:07:34 +02:00
|
|
|
* For a complete list of all authors, please refer to contributors.md
|
|
|
|
* Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
|
2017-10-13 22:23:07 +02:00
|
|
|
*
|
2018-06-15 14:07:34 +02:00
|
|
|
* OpenRCT2 is licensed under the GNU General Public License version 3.
|
2017-10-13 22:23:07 +02:00
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include "../common.h"
|
|
|
|
|
2019-01-02 12:59:37 +01:00
|
|
|
#include <algorithm>
|
|
|
|
|
2018-06-22 23:17:03 +02:00
|
|
|
#define LOCATION_NULL ((int16_t)(uint16_t)0x8000)
|
2017-10-13 22:23:07 +02:00
|
|
|
#define RCT_XY8_UNDEFINED 0xFFFF
|
|
|
|
|
|
|
|
#pragma pack(push, 1)
|
2018-06-22 23:17:03 +02:00
|
|
|
struct LocationXY8
|
|
|
|
{
|
|
|
|
union
|
|
|
|
{
|
|
|
|
struct
|
|
|
|
{
|
2018-06-20 17:28:51 +02:00
|
|
|
uint8_t x, y;
|
2017-10-13 22:23:07 +02:00
|
|
|
};
|
2018-06-20 17:28:51 +02:00
|
|
|
uint16_t xy;
|
2017-10-13 22:23:07 +02:00
|
|
|
};
|
2019-12-21 11:34:46 +01:00
|
|
|
|
|
|
|
bool isNull() const
|
|
|
|
{
|
|
|
|
return xy == RCT_XY8_UNDEFINED;
|
|
|
|
}
|
|
|
|
|
|
|
|
void setNull()
|
|
|
|
{
|
|
|
|
xy = RCT_XY8_UNDEFINED;
|
|
|
|
}
|
2018-02-14 09:42:26 +01:00
|
|
|
};
|
2017-10-13 22:23:07 +02:00
|
|
|
assert_struct_size(LocationXY8, 2);
|
|
|
|
|
2018-06-22 23:17:03 +02:00
|
|
|
struct sLocationXY8
|
|
|
|
{
|
2018-06-20 17:28:51 +02:00
|
|
|
int8_t x, y;
|
2018-03-03 11:21:42 +01:00
|
|
|
};
|
|
|
|
assert_struct_size(sLocationXY8, 2);
|
|
|
|
|
2018-06-22 23:17:03 +02:00
|
|
|
struct LocationXY16
|
|
|
|
{
|
2018-06-20 17:28:51 +02:00
|
|
|
int16_t x, y;
|
2018-02-14 09:42:26 +01:00
|
|
|
};
|
2017-10-13 22:23:07 +02:00
|
|
|
assert_struct_size(LocationXY16, 4);
|
|
|
|
|
2018-06-22 23:17:03 +02:00
|
|
|
struct LocationXYZ16
|
|
|
|
{
|
2018-06-20 17:28:51 +02:00
|
|
|
int16_t x, y, z;
|
2018-02-14 09:42:26 +01:00
|
|
|
};
|
2017-10-13 22:23:07 +02:00
|
|
|
assert_struct_size(LocationXYZ16, 6);
|
2018-02-14 09:42:26 +01:00
|
|
|
#pragma pack(pop)
|
2018-02-14 11:31:49 +01:00
|
|
|
|
2019-12-22 14:03:32 +01:00
|
|
|
constexpr int32_t COORDS_NULL = 0xFFFF8000;
|
2018-03-07 19:10:50 +01:00
|
|
|
|
2019-08-18 09:02:46 +02:00
|
|
|
struct ScreenCoordsXY
|
|
|
|
{
|
|
|
|
int32_t x = 0;
|
|
|
|
int32_t y = 0;
|
|
|
|
|
|
|
|
ScreenCoordsXY() = default;
|
|
|
|
constexpr ScreenCoordsXY(int32_t _x, int32_t _y)
|
|
|
|
: x(_x)
|
|
|
|
, y(_y)
|
|
|
|
{
|
|
|
|
}
|
2019-10-20 19:10:30 +02:00
|
|
|
|
|
|
|
const ScreenCoordsXY operator-(const ScreenCoordsXY& rhs) const
|
|
|
|
{
|
2019-10-21 04:44:26 +02:00
|
|
|
return { x - rhs.x, y - rhs.y };
|
2019-10-20 19:10:30 +02:00
|
|
|
}
|
2019-08-18 09:02:46 +02:00
|
|
|
};
|
|
|
|
|
2018-04-26 17:30:37 +02:00
|
|
|
/**
|
|
|
|
* Tile coordinates use 1 x/y increment per tile and 1 z increment per step.
|
|
|
|
* Regular ('big', 'sprite') coordinates use 32 x/y increments per tile and 8 z increments per step.
|
|
|
|
*/
|
2018-03-10 21:35:24 +01:00
|
|
|
struct CoordsXY
|
2018-02-14 11:31:49 +01:00
|
|
|
{
|
2019-01-02 12:59:37 +01:00
|
|
|
int32_t x = 0;
|
|
|
|
int32_t y = 0;
|
|
|
|
|
|
|
|
CoordsXY() = default;
|
|
|
|
constexpr CoordsXY(int32_t _x, int32_t _y)
|
|
|
|
: x(_x)
|
|
|
|
, y(_y)
|
|
|
|
{
|
|
|
|
}
|
2019-05-25 15:53:11 +02:00
|
|
|
|
|
|
|
CoordsXY& operator+=(const CoordsXY rhs)
|
|
|
|
{
|
|
|
|
x += rhs.x;
|
|
|
|
y += rhs.y;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
CoordsXY& operator-=(const CoordsXY rhs)
|
|
|
|
{
|
|
|
|
x -= rhs.x;
|
|
|
|
y -= rhs.y;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2019-08-10 09:17:47 +02:00
|
|
|
const CoordsXY operator+(const CoordsXY& rhs) const
|
|
|
|
{
|
2019-10-21 07:23:01 +02:00
|
|
|
return { x + rhs.x, y + rhs.y };
|
2019-08-10 09:17:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const CoordsXY operator-(const CoordsXY& rhs) const
|
|
|
|
{
|
2019-10-21 07:23:01 +02:00
|
|
|
return { x - rhs.x, y - rhs.y };
|
2019-08-10 09:17:47 +02:00
|
|
|
}
|
|
|
|
|
2019-08-18 09:02:46 +02:00
|
|
|
CoordsXY Rotate(int32_t direction) const
|
2019-05-25 15:53:11 +02:00
|
|
|
{
|
|
|
|
CoordsXY rotatedCoords;
|
|
|
|
switch (direction & 3)
|
|
|
|
{
|
|
|
|
default:
|
|
|
|
case 0:
|
|
|
|
rotatedCoords.x = x;
|
|
|
|
rotatedCoords.y = y;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
rotatedCoords.x = y;
|
|
|
|
rotatedCoords.y = -x;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
rotatedCoords.x = -x;
|
|
|
|
rotatedCoords.y = -y;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
rotatedCoords.x = -y;
|
|
|
|
rotatedCoords.y = x;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rotatedCoords;
|
|
|
|
}
|
2019-11-30 16:47:23 +01:00
|
|
|
|
|
|
|
CoordsXY ToTileCentre() const
|
|
|
|
{
|
|
|
|
return ToTileStart() + CoordsXY{ 16, 16 };
|
|
|
|
}
|
|
|
|
|
|
|
|
CoordsXY ToTileStart() const
|
|
|
|
{
|
|
|
|
return { floor2(x, 32), floor2(y, 32) };
|
|
|
|
}
|
2019-12-20 12:29:42 +01:00
|
|
|
|
|
|
|
bool isNull() const
|
|
|
|
{
|
|
|
|
return x == COORDS_NULL;
|
|
|
|
};
|
2019-12-27 13:33:08 +01:00
|
|
|
|
|
|
|
void setNull()
|
|
|
|
{
|
|
|
|
x = COORDS_NULL;
|
|
|
|
}
|
2018-02-14 11:31:49 +01:00
|
|
|
};
|
|
|
|
|
2019-12-28 09:44:33 +01:00
|
|
|
struct CoordsXYRangedZ : public CoordsXY
|
|
|
|
{
|
|
|
|
int32_t baseZ = 0;
|
|
|
|
int32_t clearanceZ = 0;
|
|
|
|
|
|
|
|
CoordsXYRangedZ() = default;
|
|
|
|
constexpr CoordsXYRangedZ(int32_t _x, int32_t _y, int32_t _baseZ, int32_t _clearanceZ)
|
|
|
|
: CoordsXY(_x, _y)
|
|
|
|
, baseZ(_baseZ)
|
|
|
|
, clearanceZ(_clearanceZ)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr CoordsXYRangedZ(CoordsXY _c, int32_t _baseZ, int32_t _clearanceZ)
|
|
|
|
: CoordsXY(_c)
|
|
|
|
, baseZ(_baseZ)
|
|
|
|
, clearanceZ(_clearanceZ)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-03-10 21:35:24 +01:00
|
|
|
struct TileCoordsXY
|
2018-02-14 11:31:49 +01:00
|
|
|
{
|
2019-12-20 12:29:42 +01:00
|
|
|
int32_t x = 0;
|
|
|
|
int32_t y = 0;
|
|
|
|
|
2018-03-10 21:35:24 +01:00
|
|
|
TileCoordsXY() = default;
|
2019-11-01 02:07:14 +01:00
|
|
|
constexpr TileCoordsXY(int32_t x_, int32_t y_)
|
2018-06-22 23:17:03 +02:00
|
|
|
: x(x_)
|
|
|
|
, y(y_)
|
|
|
|
{
|
|
|
|
}
|
2019-12-20 12:29:42 +01:00
|
|
|
|
2018-06-22 23:17:03 +02:00
|
|
|
explicit TileCoordsXY(CoordsXY c)
|
|
|
|
: x(c.x / 32)
|
|
|
|
, y(c.y / 32)
|
|
|
|
{
|
|
|
|
}
|
2019-12-20 12:29:42 +01:00
|
|
|
|
2019-12-23 08:35:41 +01:00
|
|
|
const TileCoordsXY operator+(const TileCoordsXY& rhs) const
|
|
|
|
{
|
|
|
|
return { x + rhs.x, y + rhs.y };
|
|
|
|
}
|
|
|
|
|
2018-04-18 20:34:34 +02:00
|
|
|
TileCoordsXY& operator+=(const TileCoordsXY rhs)
|
|
|
|
{
|
|
|
|
x += rhs.x;
|
|
|
|
y += rhs.y;
|
2018-04-18 21:10:15 +02:00
|
|
|
return *this;
|
2018-04-18 20:34:34 +02:00
|
|
|
}
|
2019-12-20 12:29:42 +01:00
|
|
|
|
2019-05-25 15:53:11 +02:00
|
|
|
TileCoordsXY& operator-=(const TileCoordsXY rhs)
|
|
|
|
{
|
|
|
|
x -= rhs.x;
|
|
|
|
y -= rhs.y;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2019-12-18 04:25:12 +01:00
|
|
|
CoordsXY ToCoordsXY() const
|
|
|
|
{
|
|
|
|
return { x * 32, y * 32 };
|
|
|
|
}
|
|
|
|
|
2019-12-18 11:21:16 +01:00
|
|
|
TileCoordsXY Rotate(int32_t direction) const
|
2019-05-25 15:53:11 +02:00
|
|
|
{
|
|
|
|
TileCoordsXY rotatedCoords;
|
|
|
|
switch (direction & 3)
|
|
|
|
{
|
|
|
|
default:
|
|
|
|
case 0:
|
|
|
|
rotatedCoords.x = x;
|
|
|
|
rotatedCoords.y = y;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
rotatedCoords.x = y;
|
|
|
|
rotatedCoords.y = -x;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
rotatedCoords.x = -x;
|
|
|
|
rotatedCoords.y = -y;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
rotatedCoords.x = -y;
|
|
|
|
rotatedCoords.y = x;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rotatedCoords;
|
|
|
|
}
|
|
|
|
|
2019-12-21 13:12:10 +01:00
|
|
|
bool operator==(const TileCoordsXY& other) const
|
|
|
|
{
|
|
|
|
return x == other.x && y == other.y;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator!=(const TileCoordsXY& other) const
|
|
|
|
{
|
|
|
|
return !(*this == other);
|
|
|
|
}
|
|
|
|
|
2019-12-20 12:29:42 +01:00
|
|
|
bool isNull() const
|
|
|
|
{
|
|
|
|
return x == COORDS_NULL;
|
|
|
|
};
|
2019-12-21 12:48:13 +01:00
|
|
|
|
|
|
|
void setNull()
|
|
|
|
{
|
|
|
|
x = COORDS_NULL;
|
|
|
|
}
|
2018-02-14 11:31:49 +01:00
|
|
|
};
|
|
|
|
|
2019-08-16 19:32:44 +02:00
|
|
|
struct CoordsXYZ : public CoordsXY
|
2018-02-14 11:31:49 +01:00
|
|
|
{
|
2019-01-02 12:59:37 +01:00
|
|
|
int32_t z = 0;
|
|
|
|
|
|
|
|
CoordsXYZ() = default;
|
|
|
|
constexpr CoordsXYZ(int32_t _x, int32_t _y, int32_t _z)
|
2019-08-16 19:32:44 +02:00
|
|
|
: CoordsXY(_x, _y)
|
2019-01-02 12:59:37 +01:00
|
|
|
, z(_z)
|
|
|
|
{
|
|
|
|
}
|
2019-08-10 09:17:47 +02:00
|
|
|
|
|
|
|
constexpr CoordsXYZ(CoordsXY c, int32_t _z)
|
2019-08-16 19:32:44 +02:00
|
|
|
: CoordsXY(c)
|
2019-08-10 09:17:47 +02:00
|
|
|
, z(_z)
|
|
|
|
{
|
|
|
|
}
|
2019-11-17 17:32:19 +01:00
|
|
|
|
2019-12-09 21:55:57 +01:00
|
|
|
const CoordsXYZ operator+(const CoordsXYZ& rhs) const
|
|
|
|
{
|
|
|
|
return { x + rhs.x, y + rhs.y, z + rhs.z };
|
|
|
|
}
|
|
|
|
|
2019-12-12 09:09:46 +01:00
|
|
|
const CoordsXYZ operator-(const CoordsXYZ& rhs) const
|
|
|
|
{
|
|
|
|
return { x - rhs.x, y - rhs.y, z - rhs.z };
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:32:19 +01:00
|
|
|
bool operator==(const CoordsXYZ& other) const
|
|
|
|
{
|
|
|
|
return x == other.x && y == other.y && z == other.z;
|
|
|
|
}
|
2019-12-18 11:23:54 +01:00
|
|
|
|
|
|
|
CoordsXYZ ToTileStart() const
|
|
|
|
{
|
|
|
|
return { floor2(x, 32), floor2(y, 32), z };
|
|
|
|
}
|
2019-12-27 15:57:40 +01:00
|
|
|
|
|
|
|
CoordsXYZ ToTileCentre() const
|
|
|
|
{
|
|
|
|
return ToTileStart() + CoordsXYZ{ 16, 16, z };
|
|
|
|
}
|
2018-02-14 11:31:49 +01:00
|
|
|
};
|
|
|
|
|
2019-12-20 12:29:42 +01:00
|
|
|
struct TileCoordsXYZ : public TileCoordsXY
|
2018-02-14 11:31:49 +01:00
|
|
|
{
|
2019-12-20 12:29:42 +01:00
|
|
|
int32_t z = 0;
|
|
|
|
|
2018-03-10 21:35:24 +01:00
|
|
|
TileCoordsXYZ() = default;
|
2019-12-20 12:29:42 +01:00
|
|
|
constexpr TileCoordsXYZ(int32_t x_, int32_t y_, int32_t z_)
|
|
|
|
: TileCoordsXY(x_, y_)
|
2018-06-22 23:17:03 +02:00
|
|
|
, z(z_)
|
|
|
|
{
|
|
|
|
}
|
2019-12-20 12:29:42 +01:00
|
|
|
|
2019-12-23 13:08:46 +01:00
|
|
|
TileCoordsXYZ(TileCoordsXY c, int32_t z_)
|
|
|
|
: TileCoordsXY(c.x, c.y)
|
|
|
|
, z(z_)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2019-12-20 12:29:42 +01:00
|
|
|
TileCoordsXYZ(CoordsXY c, int32_t z_)
|
|
|
|
: TileCoordsXY(c)
|
2018-06-22 23:17:03 +02:00
|
|
|
, z(z_)
|
|
|
|
{
|
|
|
|
}
|
2019-12-20 12:29:42 +01:00
|
|
|
|
2018-06-22 23:17:03 +02:00
|
|
|
explicit TileCoordsXYZ(CoordsXYZ c)
|
2019-12-20 12:29:42 +01:00
|
|
|
: TileCoordsXY(c)
|
2018-06-22 23:17:03 +02:00
|
|
|
, z(c.z / 8)
|
|
|
|
{
|
|
|
|
}
|
2019-12-20 12:29:42 +01:00
|
|
|
|
2018-04-18 20:56:09 +02:00
|
|
|
TileCoordsXYZ& operator+=(const TileCoordsXY rhs)
|
|
|
|
{
|
|
|
|
x += rhs.x;
|
|
|
|
y += rhs.y;
|
2018-04-18 21:10:15 +02:00
|
|
|
return *this;
|
2018-04-18 20:56:09 +02:00
|
|
|
}
|
2018-12-30 00:47:21 +01:00
|
|
|
|
2019-08-12 19:34:33 +02:00
|
|
|
TileCoordsXYZ& operator-=(const TileCoordsXY rhs)
|
|
|
|
{
|
|
|
|
x -= rhs.x;
|
|
|
|
y -= rhs.y;
|
|
|
|
return *this;
|
|
|
|
}
|
2019-12-20 12:29:42 +01:00
|
|
|
|
2018-12-30 00:47:21 +01:00
|
|
|
bool operator==(const TileCoordsXYZ& other) const
|
|
|
|
{
|
|
|
|
return x == other.x && y == other.y && z == other.z;
|
|
|
|
}
|
2019-12-20 12:29:42 +01:00
|
|
|
|
2018-12-30 00:47:21 +01:00
|
|
|
bool operator!=(const TileCoordsXYZ& other) const
|
|
|
|
{
|
|
|
|
return !(*this == other);
|
|
|
|
}
|
|
|
|
|
2019-12-18 11:21:16 +01:00
|
|
|
CoordsXYZ ToCoordsXYZ() const
|
2019-12-06 01:43:20 +01:00
|
|
|
{
|
|
|
|
return { x * 32, y * 32, z * 8 };
|
|
|
|
}
|
2018-02-14 11:31:49 +01:00
|
|
|
};
|
|
|
|
|
2019-01-05 15:28:24 +01:00
|
|
|
/**
|
|
|
|
* Cardinal directions are represented by the Direction type. It has four
|
|
|
|
* possible values:
|
|
|
|
* 0 is X-decreasing
|
|
|
|
* 1 is Y-increasing
|
|
|
|
* 2 is X-increasing
|
|
|
|
* 3 is Y-decreasing
|
|
|
|
* Direction is not used to model up/down, or diagonal directions.
|
|
|
|
*/
|
2019-01-05 14:58:32 +01:00
|
|
|
typedef uint8_t Direction;
|
|
|
|
|
2019-08-26 11:57:44 +02:00
|
|
|
const Direction INVALID_DIRECTION = 0xFF;
|
|
|
|
|
2019-08-26 19:50:37 +02:00
|
|
|
/**
|
2019-09-01 20:10:27 +02:00
|
|
|
* Array of all valid cardinal directions, to make it easy to write range-based for loops like:
|
|
|
|
* for (Direction d : ALL_DIRECTIONS)
|
2019-08-26 19:50:37 +02:00
|
|
|
*/
|
|
|
|
constexpr Direction ALL_DIRECTIONS[] = { 0, 1, 2, 3 };
|
|
|
|
|
2019-01-05 15:28:24 +01:00
|
|
|
/**
|
|
|
|
* Given a direction, return the direction that points the other way,
|
|
|
|
* on the same axis.
|
|
|
|
*/
|
2019-02-09 22:56:50 +01:00
|
|
|
[[maybe_unused]] static constexpr Direction direction_reverse(Direction dir)
|
2019-01-05 15:28:24 +01:00
|
|
|
{
|
|
|
|
return dir ^ 2;
|
|
|
|
}
|
|
|
|
|
2019-03-02 21:23:42 +01:00
|
|
|
[[maybe_unused]] static constexpr bool direction_valid(Direction dir)
|
2019-02-08 11:06:26 +01:00
|
|
|
{
|
|
|
|
return dir < 4;
|
|
|
|
}
|
|
|
|
|
2019-08-26 19:50:50 +02:00
|
|
|
/**
|
2019-09-01 20:10:27 +02:00
|
|
|
* Given a direction, return the next cardinal direction, wrapping around if necessary.
|
|
|
|
* (TODO: Figure out if this is CW or CCW)
|
2019-08-26 19:50:50 +02:00
|
|
|
*/
|
|
|
|
[[maybe_unused]] static constexpr Direction direction_next(Direction dir)
|
|
|
|
{
|
|
|
|
return (dir + 1) & 0x03;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-09-01 20:10:27 +02:00
|
|
|
* Given a direction, return the previous cardinal direction, wrapping around if necessary.
|
|
|
|
* (TODO: Figure out if this is CW or CCW)
|
2019-08-26 19:50:50 +02:00
|
|
|
*/
|
|
|
|
[[maybe_unused]] static constexpr Direction direction_prev(Direction dir)
|
|
|
|
{
|
|
|
|
return (dir - 1) & 0x03;
|
|
|
|
}
|
|
|
|
|
2019-08-16 19:32:44 +02:00
|
|
|
struct CoordsXYZD : public CoordsXYZ
|
2018-02-14 11:31:49 +01:00
|
|
|
{
|
2019-08-16 19:32:44 +02:00
|
|
|
Direction direction = 0;
|
|
|
|
|
|
|
|
CoordsXYZD() = default;
|
|
|
|
constexpr CoordsXYZD(int32_t _x, int32_t _y, int32_t _z, Direction _d)
|
|
|
|
: CoordsXYZ(_x, _y, _z)
|
|
|
|
, direction(_d)
|
|
|
|
{
|
|
|
|
}
|
2018-03-07 19:10:50 +01:00
|
|
|
|
2019-11-30 16:47:23 +01:00
|
|
|
constexpr CoordsXYZD(CoordsXY _c, int32_t _z, Direction _d)
|
|
|
|
: CoordsXYZ(_c, _z)
|
|
|
|
, direction(_d)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2019-12-11 21:33:58 +01:00
|
|
|
constexpr CoordsXYZD(CoordsXYZ _c, Direction _d)
|
|
|
|
: CoordsXYZ(_c)
|
|
|
|
, direction(_d)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2019-11-13 22:46:02 +01:00
|
|
|
bool operator==(const CoordsXYZD& other) const
|
|
|
|
{
|
|
|
|
return x == other.x && y == other.y && z == other.z && direction == other.direction;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator!=(const CoordsXYZD& other) const
|
|
|
|
{
|
|
|
|
return !(*this == other);
|
|
|
|
}
|
2018-02-14 11:31:49 +01:00
|
|
|
};
|
|
|
|
|
2019-12-20 12:29:42 +01:00
|
|
|
struct TileCoordsXYZD : public TileCoordsXYZ
|
2018-02-14 11:31:49 +01:00
|
|
|
{
|
2019-01-05 14:58:32 +01:00
|
|
|
Direction direction;
|
2018-03-07 19:10:50 +01:00
|
|
|
|
2019-12-20 12:29:42 +01:00
|
|
|
TileCoordsXYZD() = default;
|
|
|
|
constexpr TileCoordsXYZD(int32_t x_, int32_t y_, int32_t z_, Direction d_)
|
|
|
|
: TileCoordsXYZ(x_, y_, z_)
|
|
|
|
, direction(d_)
|
2018-06-22 23:17:03 +02:00
|
|
|
{
|
2019-12-20 12:29:42 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
TileCoordsXYZD(CoordsXY c_, int32_t z_, Direction d_)
|
|
|
|
: TileCoordsXYZ(c_, z_)
|
|
|
|
, direction(d_)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
TileCoordsXYZD(CoordsXYZ c_, Direction d_)
|
|
|
|
: TileCoordsXYZ(c_)
|
|
|
|
, direction(d_)
|
|
|
|
{
|
|
|
|
}
|
2019-12-19 04:11:26 +01:00
|
|
|
|
2019-12-27 15:57:40 +01:00
|
|
|
TileCoordsXYZD(CoordsXYZD c_)
|
|
|
|
: TileCoordsXYZ(c_)
|
|
|
|
, direction(c_.direction)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2019-12-19 04:11:26 +01:00
|
|
|
CoordsXYZD ToCoordsXYZD() const
|
|
|
|
{
|
|
|
|
return { x * 32, y * 32, z * 8, direction };
|
|
|
|
}
|
2018-02-14 11:31:49 +01:00
|
|
|
};
|
2019-01-02 12:59:37 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Represents a rectangular range of the map using regular coordinates (32 per tile).
|
|
|
|
*/
|
|
|
|
struct MapRange
|
|
|
|
{
|
|
|
|
CoordsXY LeftTop;
|
|
|
|
CoordsXY RightBottom;
|
|
|
|
|
|
|
|
int32_t GetLeft() const
|
|
|
|
{
|
|
|
|
return LeftTop.x;
|
|
|
|
}
|
|
|
|
int32_t GetTop() const
|
|
|
|
{
|
|
|
|
return LeftTop.y;
|
|
|
|
}
|
|
|
|
int32_t GetRight() const
|
|
|
|
{
|
|
|
|
return RightBottom.x;
|
|
|
|
}
|
|
|
|
int32_t GetBottom() const
|
|
|
|
{
|
|
|
|
return RightBottom.y;
|
|
|
|
}
|
|
|
|
|
|
|
|
MapRange()
|
|
|
|
: MapRange(0, 0, 0, 0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
MapRange(int32_t left, int32_t top, int32_t right, int32_t bottom)
|
|
|
|
: LeftTop(left, top)
|
|
|
|
, RightBottom(right, bottom)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
MapRange Normalise() const
|
|
|
|
{
|
|
|
|
auto result = MapRange(
|
|
|
|
std::min(GetLeft(), GetRight()), std::min(GetTop(), GetBottom()), std::max(GetLeft(), GetRight()),
|
|
|
|
std::max(GetTop(), GetBottom()));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
};
|