Updated this project to the new standard, see details.

After a significant modification to the Codebase library, I imported a lot
of the Codebase updates back to this porject. Some files that exist in
Codebase still carry the zlib license header; these files are still under
the zlib license.

Following a significant struggle with SDL_net, I've decided to ditch that
library and write my own version. It currently only supports TCP
networking, and only works on windows platforms,  but it is sufficient at
this time.

client/vector2.hpp

@@ -1,3 +1,24 @@
+/* Copyright: (c) Kayne Ruse 2013
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+*/
 #ifndef VECTOR2_HPP_
 #define VECTOR2_HPP_
 
@@ -6,68 +27,50 @@
 
 class Vector2 {
 public:
-	/* Public access members */
 	double x, y;
-
-	inline Vector2():
-	x(0), y(0)
-	{
+	Vector2() {
+		x = y = 0;
 	}
-
-	inline Vector2(double d):
-	x(d), y(d)
-	{
+	Vector2(double i, double j) {
+		x = i; y = j;
 	}
-
-	inline Vector2(double _x, double _y):
-	x(_x), y(_y)
-	{
-	}
-
-	inline double Length() {
+	double Length() const {
 		return sqrt(x*x+y*y);
 	}
-
-	inline double SquaredLength()  {
+	double SquaredLength() const {
 		return x*x+y*y;
 	}
-
-	inline double operator[](size_t i) {
+	double operator[](size_t i) {
 		if (i >= 2)
-			throw(std::domain_error("Out of range"));
-
+			throw(std::runtime_error("Out of range"));
 		return *(&x+i);
 	}
+	//Arithmetic operators
+	Vector2 operator+(Vector2 v) const { return Vector2(x + v.x, y + v.y); }
+	Vector2 operator-(Vector2 v) const { return Vector2(x - v.x, y - v.y); }
+	Vector2 operator*(Vector2 v) const { return Vector2(x * v.x, y * v.y); }
+	Vector2 operator*(double d) const { return Vector2(x * d, y * d); }
 
-	/* Arithmetic operators */
-	inline Vector2 operator+(Vector2 v) { return Vector2(x + v.x, y + v.y); }
-	inline Vector2 operator-(Vector2 v) { return Vector2(x - v.x, y - v.y); }
-	inline Vector2 operator*(Vector2 v) { return Vector2(x * v.x, y * v.y); }
-	inline Vector2 operator*(double d) { return Vector2(x * d, y * d); }
-
-	inline Vector2 operator/(Vector2 v) {
+	Vector2 operator/(Vector2 v) {
 		if (!v.x || !v.y)
-			throw(std::domain_error("Divide by zero"));
-
+			throw(std::runtime_error("Divide by zero"));
 		return Vector2(x / v.x, y / v.y);
 	}
-
-	inline Vector2 operator/(double d) {
+	Vector2 operator/(double d) {
 		if (!d)
-			throw(std::domain_error("Divide by zero"));
-
+			throw(std::runtime_error("Divide by zero"));
 		return Vector2(x / d, y / d);
 	}
 
-	template<typename T> inline Vector2 operator+=(T t) { return *this = *this + t; }
-	template<typename T> inline Vector2 operator-=(T t) { return *this = *this - t; }
-	template<typename T> inline Vector2 operator*=(T t) { return *this = *this * t; }
-	template<typename T> inline Vector2 operator/=(T t) { return *this = *this / t; }
+	bool operator==(Vector2 v) { return (x == v.x && y == v.y); }
+	bool operator!=(Vector2 v) { return (x != v.x || y != v.y); }
 
-	inline bool operator==(Vector2 v) { return (x == v.x && y == v.y); }
-	inline bool operator!=(Vector2 v) { return (x != v.x || y != v.y); }
-	template<typename T> inline bool operator==(T t) { return (x == t && y == t); }
-	template<typename T> inline bool operator!=(T t) { return (x != t || y != t); }
+	template<typename T> Vector2 operator+=(T t) { return *this = *this + t; }
+	template<typename T> Vector2 operator-=(T t) { return *this = *this - t; }
+	template<typename T> Vector2 operator*=(T t) { return *this = *this * t; }
+	template<typename T> Vector2 operator/=(T t) { return *this = *this / t; }
+	template<typename T> bool operator==(T t) { return (x == t && y == t); }
+	template<typename T> bool operator!=(T t) { return (x != t || y != t); }
 };
 
 #endif