Initial v2 water map format.

zone/CMakeLists.txt

@@ -75,6 +75,7 @@ SET(zone_sources
 	npc.cpp
 	NpcAI.cpp
 	Object.cpp
+	oriented_bounding_box.cpp
 	pathing.cpp
 	perl_client.cpp
 	perl_doors.cpp
@@ -108,7 +109,9 @@ SET(zone_sources
 	trading.cpp
 	trap.cpp
 	tribute.cpp
-	watermap.cpp
+	water_map.cpp
+	water_map_v1.cpp
+	water_map_v2.cpp
 	waypoints.cpp
 	worldserver.cpp
 	zone.cpp
@@ -174,6 +177,7 @@ SET(zone_headers
 	npc.h
 	NpcAI.h
 	object.h
+	oriented_bounding_box.h
 	pathing.h
 	perlpacket.h
 	petitions.h
@@ -193,7 +197,9 @@ SET(zone_headers
 	tasks.h
 	titles.h
 	trap.h
-	watermap.h
+	water_map.h
+	water_map_v1.h
+	water_map_v2.h
 	worldserver.h
 	zone.h
 	ZoneConfig.h

zone/MobAI.cpp

@@ -32,7 +32,7 @@
 #include "../common/rulesys.h"
 #include "../common/features.h"
 #include "QuestParserCollection.h"
-#include "watermap.h"
+#include "water_map.h"
 
 extern EntityList entity_list;
 

zone/attack.cpp

@@ -40,7 +40,7 @@
 #include "../common/StringUtil.h"
 #include "../common/rulesys.h"
 #include "QuestParserCollection.h"
-#include "watermap.h"
+#include "water_map.h"
 #include "worldserver.h"
 extern WorldServer worldserver;
 

zone/client_packet.cpp

@@ -65,7 +65,7 @@
 #include "ZoneConfig.h"
 #include "guild_mgr.h"
 #include "pathing.h"
-#include "watermap.h"
+#include "water_map.h"
 #include "merc.h"
 #include "../common/ZoneNumbers.h"
 #include "QuestParserCollection.h"

zone/command.cpp

@@ -55,7 +55,7 @@
 #include "worldserver.h"
 #include "masterentity.h"
 #include "map.h"
-#include "watermap.h"
+#include "water_map.h"
 #include "../common/features.h"
 #include "pathing.h"
 #include "client_logs.h"
@@ -8093,14 +8093,14 @@ void command_bestz(Client *c, const Seperator *sep) {
 
 		if(c->GetTarget()) {
 			z=c->GetTarget()->GetZ();
-			RegionType = zone->watermap->BSPReturnRegionType(1, c->GetTarget()->GetX(), c->GetTarget()->GetY(), z);
+			RegionType = zone->watermap->ReturnRegionType(c->GetTarget()->GetX(), c->GetTarget()->GetY(), z);
 			c->Message(0,"InWater returns %d", zone->watermap->InWater(c->GetTarget()->GetX(), c->GetTarget()->GetY(), z));
 			c->Message(0,"InLava returns %d", zone->watermap->InLava(c->GetTarget()->GetX(), c->GetTarget()->GetY(), z));
 
 		}
 		else {
 			z=c->GetZ();
-			RegionType = zone->watermap->BSPReturnRegionType(1, c->GetX(), c->GetY(),z);
+			RegionType = zone->watermap->ReturnRegionType(c->GetX(), c->GetY(), z);
 			c->Message(0,"InWater returns %d", zone->watermap->InWater(c->GetX(), c->GetY(), z));
 			c->Message(0,"InLava returns %d", zone->watermap->InLava(c->GetX(), c->GetY(), z));
 

zone/forage.cpp

@@ -28,7 +28,7 @@
 #include "entity.h"
 #include "masterentity.h"
 #include "npc.h"
-#include "watermap.h"
+#include "water_map.h"
 #include "titles.h"
 #include "StringIDs.h"
 #include "../common/MiscFunctions.h"

zone/hate_list.cpp

@@ -27,7 +27,7 @@
 #include "hate_list.h"
 #include "QuestParserCollection.h"
 #include "zone.h"
-#include "watermap.h"
+#include "water_map.h"
 
 extern Zone *zone;
 

zone/merc.cpp

@@ -12,7 +12,7 @@
 #include "../common/StringUtil.h"
 #include "../common/rulesys.h"
 #include "QuestParserCollection.h"
-#include "watermap.h"
+#include "water_map.h"
 
 extern volatile bool ZoneLoaded;
 

zone/oriented_bounding_box.cpp

@@ -0,0 +1,95 @@
+#include "oriented_bounding_box.h"
+#include <gtc/matrix_transform.hpp>
+#include <gtx/transform.hpp>
+
+glm::mat4 CreateRotateMatrix(float rx, float ry, float rz) {
+	glm::mat4 rot_x(1.0f);
+	rot_x[1][1] = cos(rx);
+	rot_x[2][1] = -sin(rx);
+	rot_x[1][2] = sin(rx);
+	rot_x[2][2] = cos(rx);
+
+	glm::mat4 rot_y(1.0f);
+	rot_y[0][0] = cos(ry);
+	rot_y[2][0] = sin(ry);
+	rot_y[0][2] = -sin(ry);
+	rot_y[2][2] = cos(ry);
+
+	glm::mat4 rot_z(1.0f);
+	rot_z[0][0] = cos(rz);
+	rot_z[1][0] = -sin(rz);
+	rot_z[0][1] = sin(rz);
+	rot_z[1][1] = cos(rz);
+
+	return rot_z * rot_y * rot_x;
+}
+
+glm::mat4 CreateTranslateMatrix(float tx, float ty, float tz) {
+	glm::mat4 trans(1.0f);
+	trans[3][0] = tx;
+	trans[3][1] = ty;
+	trans[3][2] = tz;
+
+	return trans;
+}
+
+glm::mat4 CreateScaleMatrix(float sx, float sy, float sz) {
+	glm::mat4 scale(1.0f);
+	scale[0][0] = sx;
+	scale[1][1] = sy;
+	scale[2][2] = sz;
+	return scale;
+}
+
+OrientedBoundingBox::OrientedBoundingBox(glm::vec3 pos, glm::vec3 rot, glm::vec3 scale, glm::vec3 extents) {
+	min_x = -extents.x;
+	max_x = extents.x;
+
+	if (min_x > max_x)
+	{
+		float t = min_x;
+		min_x = max_x;
+		max_x = t;
+	}
+
+	min_y = -extents.y;
+	max_y = extents.y;
+	if (min_y > max_y)
+	{
+		float t = min_y;
+		min_y = max_y;
+		max_y = t;
+	}
+
+	min_z = -extents.z;
+	max_z = extents.z;
+	if (min_z > max_z)
+	{
+		float t = min_z;
+		min_z = max_z;
+		max_z = t;
+	}
+
+	//rotate
+	transformation = CreateRotateMatrix(rot.x * 3.14159f / 180.0f, rot.y * 3.14159f / 180.0f, rot.z * 3.14159f / 180.0f);
+	
+	//scale
+	transformation = CreateScaleMatrix(scale.x, scale.y, scale.z) * transformation;
+
+	//translate
+	transformation = CreateTranslateMatrix(pos.x, pos.y, pos.z) * transformation;
+	inverted_transformation = glm::inverse(transformation);
+}
+
+bool OrientedBoundingBox::ContainsPoint(glm::vec3 p) const {
+	glm::vec4 pt(p.x, p.y, p.z, 1);
+	glm::vec4 box_space_p = inverted_transformation * pt;
+
+	if (box_space_p.x >= min_x && box_space_p.x <= max_x &&
+		box_space_p.y >= min_y && box_space_p.y <= max_y &&
+		box_space_p.z >= min_z && box_space_p.z <= max_z) {
+		return true;
+	}
+	
+	return false;
+}

zone/oriented_bounding_box.h

@@ -0,0 +1,25 @@
+#ifndef EQEMU_ORIENTED_BOUNDNG_BOX_H
+#define EQEMU_ORIENTED_BOUNDNG_BOX_H
+
+#include <glm.hpp>
+
+class OrientedBoundingBox
+{
+public:
+	OrientedBoundingBox() { }
+	OrientedBoundingBox(glm::vec3 pos, glm::vec3 rot, glm::vec3 scale, glm::vec3 extents);
+	~OrientedBoundingBox() { }
+
+	bool ContainsPoint(glm::vec3 p) const;
+	
+	glm::mat4& GetTransformation() { return transformation; }
+	glm::mat4& GetInvertedTransformation() { return inverted_transformation; }
+private:
+	float min_x, max_x;
+	float min_y, max_y;
+	float min_z, max_z;
+	glm::mat4 transformation;
+	glm::mat4 inverted_transformation;
+};
+
+#endif

zone/pathing.cpp

@@ -6,7 +6,7 @@
 #include <sstream>
 #include <fstream>
 #include "pathing.h"
-#include "watermap.h"
+#include "water_map.h"
 #include "../common/MiscFunctions.h"
 #include "doors.h"
 #include "client.h"

zone/water_map.cpp

@@ -0,0 +1,62 @@
+#include "../common/debug.h"
+#include <stdio.h>
+#include <algorithm>
+#include <functional>
+#include <cctype>
+
+#include "water_map.h"
+#include "water_map_v1.h"
+#include "water_map_v2.h"
+
+WaterMap* WaterMap::LoadWaterMapfile(std::string zone_name, std::string directory) {
+	std::transform(zone_name.begin(), zone_name.end(), zone_name.begin(), ::tolower);
+	
+	if(directory.length() == 0)
+		directory = MAP_DIR;
+		
+	std::string file_path = directory + std::string("/") + zone_name + std::string(".wtr");
+	FILE *f = fopen(file_path.c_str(), "rb");
+	if(f) {
+		char magic[10];
+		uint32 version;
+		if(fread(magic, 10, 1, f) != 1) {
+			fclose(f);
+			return nullptr;
+		}
+		
+		if(strncmp(magic, "EQEMUWATER", 10)) {
+			fclose(f);
+			return nullptr;
+		}
+		
+		if(fread(&version, sizeof(version), 1, f) != 1) {
+			fclose(f);
+			return nullptr;
+		}
+		
+		if(version == 1) {
+			WaterMapV1 *wm = new WaterMapV1();
+			if(!wm->Load(f)) {
+				delete wm;
+				wm = nullptr;
+			}
+			
+			fclose(f);
+			return wm;
+		} else if(version == 2) {
+			WaterMapV2 *wm = new WaterMapV2();
+			if(!wm->Load(f)) {
+				delete wm;
+				wm = nullptr;
+			}
+			
+			fclose(f);
+			return wm;
+		} else {
+			fclose(f);
+			return nullptr;
+		}
+	}
+	
+	return nullptr;
+}

zone/water_map.h

@@ -0,0 +1,37 @@
+#ifndef EQEMU_WATER_MAP_H
+#define EQEMU_WATER_MAP_H
+
+#include "../common/types.h"
+#include <string>
+
+enum WaterRegionType {
+	RegionTypeUnsupported = -2,
+	RegionTypeUntagged = -1,
+	RegionTypeNormal = 0,
+	RegionTypeWater = 1,
+	RegionTypeLava = 2,
+	RegionTypeZoneLine = 3,
+	RegionTypePVP = 4,
+	RegionTypeSlime = 5,
+	RegionTypeIce = 6,
+	RegionTypeVWater = 7
+};
+
+class WaterMap
+{
+public:
+	WaterMap() { }
+	~WaterMap() { }
+	
+	static WaterMap* LoadWaterMapfile(std::string zone_name, std::string directory = "");
+	virtual WaterRegionType ReturnRegionType(float y, float x, float z) const { return RegionTypeNormal; }
+	virtual bool InWater(float y, float x, float z) const { return false; }
+	virtual bool InVWater(float y, float x, float z) const { return false; }
+	virtual bool InLava(float y, float x, float z) const { return false; }
+	virtual bool InLiquid(float y, float x, float z) const { return false; }
+	
+protected:
+	virtual bool Load(FILE *fp) { return false; }
+};
+
+#endif

zone/water_map_v1.cpp

@@ -0,0 +1,82 @@
+#include "water_map_v1.h"
+
+WaterMapV1::WaterMapV1() {
+	BSP_Root = nullptr;
+}
+
+WaterMapV1::~WaterMapV1() {
+	if (BSP_Root) {
+		delete[] BSP_Root;
+	}
+}
+
+WaterRegionType WaterMapV1::ReturnRegionType(float y, float x, float z) const {
+	return BSPReturnRegionType(1, y, x, z);
+}
+
+bool WaterMapV1::InWater(float y, float x, float z) const {
+	return ReturnRegionType(y, x, z) == RegionTypeWater;
+}
+
+bool WaterMapV1::InVWater(float y, float x, float z) const {
+	return ReturnRegionType(y, x, z) == RegionTypeVWater;
+}
+
+bool WaterMapV1::InLava(float y, float x, float z) const {
+	return ReturnRegionType(y, x, z) == RegionTypeLava;
+}
+
+bool WaterMapV1::InLiquid(float y, float x, float z) const {
+	return InWater(y, x, z) || InLava(y, x, z);
+}
+
+bool WaterMapV1::Load(FILE *fp) {
+	uint32 bsp_tree_size;
+	if (fread(&bsp_tree_size, sizeof(bsp_tree_size), 1, fp) != 1) {
+		return false;
+	}
+
+	BSP_Root = new ZBSP_Node[bsp_tree_size];
+	if (!BSP_Root) {
+		return false;
+	}
+
+	if (fread(BSP_Root, sizeof(ZBSP_Node), bsp_tree_size, fp) != bsp_tree_size) {
+		return false;
+	}
+
+	return true;
+}
+
+WaterRegionType WaterMapV1::BSPReturnRegionType(int32 node_number, float y, float x, float z) const {
+	float distance;
+
+	const ZBSP_Node *current_node = &BSP_Root[node_number - 1];
+
+	if ((current_node->left == 0) &&
+		(current_node->right == 0)) {
+		return (WaterRegionType)current_node->special;
+	}
+
+	distance = (x * current_node->normal[0]) +
+		(y * current_node->normal[1]) +
+		(z * current_node->normal[2]) +
+		current_node->splitdistance;
+
+	if (distance == 0.0f) {
+		return(RegionTypeNormal);
+	}
+
+	if (distance >0.0f) {
+		if (current_node->left == 0) {
+			return(RegionTypeNormal);
+		}
+		return BSPReturnRegionType(current_node->left, y, x, z);
+	}
+
+	if (current_node->right == 0) {
+		return(RegionTypeNormal);
+	}
+
+	return BSPReturnRegionType(current_node->right, y, x, z);
+}

zone/water_map_v1.h

@@ -0,0 +1,38 @@
+#ifndef EQEMU_WATER_MAP_V1_H
+#define EQEMU_WATER_MAP_V1_H
+
+#include "water_map.h"
+
+#pragma pack(1)
+typedef struct ZBSP_Node {
+	int32 node_number;
+	float normal[3], splitdistance;
+	int32 region;
+	int32 special;
+	int32 left, right;
+} ZBSP_Node;
+#pragma pack()
+
+class WaterMapV1 : public WaterMap
+{
+public:
+	WaterMapV1();
+	~WaterMapV1();
+	
+	virtual WaterRegionType ReturnRegionType(float y, float x, float z) const;
+	virtual bool InWater(float y, float x, float z) const;
+	virtual bool InVWater(float y, float x, float z) const;
+	virtual bool InLava(float y, float x, float z) const;
+	virtual bool InLiquid(float y, float x, float z) const;
+	
+protected:
+	virtual bool Load(FILE *fp);
+
+private:
+	WaterRegionType BSPReturnRegionType(int32 node_number, float y, float x, float z) const;
+	ZBSP_Node* BSP_Root;
+
+	friend class WaterMap;
+};
+
+#endif

zone/water_map_v2.cpp

@@ -0,0 +1,114 @@
+#include "water_map_v2.h"
+
+WaterMapV2::WaterMapV2() {
+}
+
+WaterMapV2::~WaterMapV2() {
+}
+
+WaterRegionType WaterMapV2::ReturnRegionType(float y, float x, float z) const {
+	size_t sz = regions.size();
+	for(size_t i = 0; i < sz; ++i) {
+		auto const &region = regions[i];
+		if (region.second.ContainsPoint(glm::vec3(x, y, z))) {
+			return region.first;
+		}
+	}
+	return RegionTypeNormal;
+}
+
+bool WaterMapV2::InWater(float y, float x, float z) const {
+	return ReturnRegionType(y, x, z) == RegionTypeWater;
+}
+
+bool WaterMapV2::InVWater(float y, float x, float z) const {
+	return ReturnRegionType(y, x, z) == RegionTypeVWater;
+}
+
+bool WaterMapV2::InLava(float y, float x, float z) const {
+	return ReturnRegionType(y, x, z) == RegionTypeLava;
+}
+
+bool WaterMapV2::InLiquid(float y, float x, float z) const {
+	return InWater(y, x, z) || InLava(y, x, z);
+}
+
+bool WaterMapV2::Load(FILE *fp) {
+	uint32 region_count;
+	if (fread(&region_count, sizeof(region_count), 1, fp) != 1) {
+		return false;
+	}
+
+	for(uint32_t i = 0; i < region_count; ++i) {
+		uint32_t region_type;
+		float x;
+		float y;
+		float z;
+		float x_rot;
+		float y_rot;
+		float z_rot;
+		float x_scale;
+		float y_scale;
+		float z_scale;
+		float x_extent;
+		float y_extent;
+		float z_extent;
+
+		if (fread(&region_type, sizeof(region_type), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&x, sizeof(x), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&y, sizeof(y), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&z, sizeof(z), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&x_rot, sizeof(x_rot), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&y_rot, sizeof(y_rot), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&z_rot, sizeof(z_rot), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&x_scale, sizeof(x_scale), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&y_scale, sizeof(y_scale), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&z_scale, sizeof(z_scale), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&x_extent, sizeof(x_extent), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&y_extent, sizeof(y_extent), 1, fp) != 1) {
+			return false;
+		}
+
+		if (fread(&z_extent, sizeof(z_extent), 1, fp) != 1) {
+			return false;
+		}
+
+		regions.push_back(std::make_pair((WaterRegionType)region_type, 
+			OrientedBoundingBox(glm::vec3(x, y, z), glm::vec3(x_rot, y_rot, z_rot), glm::vec3(x_scale, y_scale, z_scale), glm::vec3(x_extent, y_extent, z_extent))));
+	}
+
+	return true;
+}

zone/water_map_v2.h

@@ -0,0 +1,28 @@
+#ifndef EQEMU_WATER_MAP_V2_H
+#define EQEMU_WATER_MAP_V2_H
+
+#include "water_map.h"
+#include "oriented_bounding_box.h"
+#include <vector>
+#include <utility>
+
+class WaterMapV2 : public WaterMap
+{
+public:
+	WaterMapV2();
+	~WaterMapV2();
+
+	virtual WaterRegionType ReturnRegionType(float y, float x, float z) const;
+	virtual bool InWater(float y, float x, float z) const;
+	virtual bool InVWater(float y, float x, float z) const;
+	virtual bool InLava(float y, float x, float z) const;
+	virtual bool InLiquid(float y, float x, float z) const;
+	
+protected:
+	virtual bool Load(FILE *fp);
+
+	std::vector<std::pair<WaterRegionType, OrientedBoundingBox>> regions;
+	friend class WaterMap;
+};
+
+#endif

zone/waypoints.cpp

@@ -26,7 +26,7 @@
 #include "masterentity.h"
 #include "NpcAI.h"
 #include "map.h"
-#include "watermap.h"
+#include "water_map.h"
 #include "../common/moremath.h"
 #include "StringIDs.h"
 #include "../common/MiscFunctions.h"

zone/zone.cpp

@@ -49,7 +49,7 @@
 #include "ZoneConfig.h"
 #include "../common/breakdowns.h"
 #include "map.h"
-#include "watermap.h"
+#include "water_map.h"
 #include "object.h"
 #include "petitions.h"
 #include "pathing.h"