Print errors

src/game/scripting/script_value.hpp

@@ -8,12 +8,95 @@ namespace scripting
 	class entity;
 	class array;
 	class function;
+	class value_wrap;
+
+	namespace
+	{
+		std::unordered_map<int, std::string> typenames =
+		{
+			{0, "undefined"},
+			{1, "object"},
+			{2, "string"},
+			{3, "localized string"},
+			{4, "vector"},
+			{5, "float"},
+			{6, "integer"},
+			{7, "codepos"},
+			{8, "precodepos"},
+			{9, "function"},
+			{10, "builtin function"},
+			{11, "builtin method"},
+			{12, "stack"},
+			{13, "animation"},
+			{14, "pre animation"},
+			{15, "thread"},
+			{16, "thread"},
+			{17, "thread"},
+			{18, "thread"},
+			{19, "struct"},
+			{20, "removed entity"},
+			{21, "entity"},
+			{22, "array"},
+			{23, "removed thread"},
+			{24, "count"},
+			{25, "<free>"},
+			{26, "thread list"},
+			{27, "endon list"},
+		};
+
+		std::string get_typename(const game::VariableValue& value)
+		{
+			if (value.type == game::SCRIPT_OBJECT)
+			{
+				const auto type = game::scr_VarGlob->objectVariableValue[value.u.uintValue].w.type;
+				return typenames[type];
+			}
+			else
+			{
+				return typenames[value.type];
+			}
+		}
+
+		template <typename T, typename A = array>
+		std::string get_c_typename()
+		{
+			auto& info = typeid(T);
+
+			if (info == typeid(std::string))
+			{
+				return "string";
+			}
+
+			if (info == typeid(const char*))
+			{
+				return "string";
+			}
+
+			if (info == typeid(entity))
+			{
+				return "entity";
+			}
+
+			if (info == typeid(array))
+			{
+				return "array";
+			}
+
+			if (info == typeid(vector))
+			{
+				return "vector";
+			}
+
+			return info.name();
+		}
+	}
 
 	class script_value
 	{
 	public:
 		script_value() = default;
 		script_value(const game::VariableValue& value);
+		script_value(const value_wrap& value);
 
 		script_value(void* value);
 
@@ -43,7 +126,9 @@ namespace scripting
 		{
 			if (!this->is<T>())
 			{
-				throw std::runtime_error("Invalid type");
+				const auto type = get_typename(this->get_raw());
+				const auto c_type = get_c_typename<T>();
+				throw std::runtime_error(std::string("has type '" + type + "' but should be '" + c_type + "'"));
 			}
 
 			return get<T>();
@@ -52,16 +137,12 @@ namespace scripting
 		template <typename T, typename I = int>
 		T* as_ptr()
 		{
-			if (!this->is<I>())
-			{
-				throw std::runtime_error("Invalid type");
-			}
 
-			const auto value = this->get<I>();
+			const auto value = this->as<I>();
 
 			if (!value)
 			{
-				throw std::runtime_error("Null pointer");
+				throw std::runtime_error("is null");
 			}
 
 			return reinterpret_cast<T*>(value);
@@ -74,4 +155,50 @@ namespace scripting
 		template <typename T>
 		T get() const;
 	};
+
+	class value_wrap
+	{
+	public:
+		value_wrap(const scripting::script_value& value, int argument_index);
+
+		template <typename T>
+		T as() const
+		{
+			try
+			{
+				return this->value_.as<T>();
+			}
+			catch (const std::exception& e)
+			{
+				throw std::runtime_error(utils::string::va("parameter %d %s", this->argument_index_, e.what()));
+			}
+		}
+
+		template <typename T, typename I = int>
+		T* as_ptr()
+		{
+			try
+			{
+				return this->value_.as_ptr<T>();
+			}
+			catch (const std::exception& e)
+			{
+				throw std::runtime_error(utils::string::va("parameter %d %s", this->argument_index_, e.what()));
+			}
+		}
+
+		template <typename T>
+		T is() const
+		{
+			return this->value_.is<T>();
+		}
+
+		const game::VariableValue& get_raw() const
+		{
+			return this->value_.get_raw();
+		}
+
+		int argument_index_{};
+		scripting::script_value value_;
+	};
 }