diff --git a/Angle.cpp b/Angle.cpp
index 4a039ce..3cb21e3 100644
--- a/Angle.cpp
+++ b/Angle.cpp
@@ -73,12 +73,16 @@ float Angle::SineRuleAngle(float a, float beta, float b) {
 */
 //----------------------
 
-template <> Angle2<float> Angle2<float>::pi = 3.1415927410125732421875F;
+template <> AngleOf<float> AngleOf<float>::pi = 3.1415927410125732421875F;
 
-template <> Angle2<float> Angle2<float>::Rad2Deg = 360.0f / (pi * 2);
-template <> Angle2<float> Angle2<float>::Deg2Rad = (pi * 2) / 360.0f;
+template <> AngleOf<float> AngleOf<float>::Rad2Deg = 360.0f / (pi * 2);
+template <> AngleOf<float> AngleOf<float>::Deg2Rad = (pi * 2) / 360.0f;
 
-template <> Angle2<float> Angle2<float>::Normalize(Angle2<float> angle) {
+template <> bool Passer::AngleOf<float>::operator==(AngleOf<float> a) {
+  return (float)*this == (float)a;
+}
+
+template <> AngleOf<float> AngleOf<float>::Normalize(AngleOf<float> angle) {
   float angleValue = angle;
   if (!isfinite(angleValue))
     return angleValue;
@@ -91,8 +95,8 @@ template <> Angle2<float> Angle2<float>::Normalize(Angle2<float> angle) {
 }
 
 template <>
-Angle2<float> Angle2<float>::Clamp(Angle2<float> angle, Angle2<float> min,
-                                   Angle2<float> max) {
+AngleOf<float> AngleOf<float>::Clamp(AngleOf<float> angle, AngleOf<float> min,
+                                     AngleOf<float> max) {
   float normalizedAngle = Normalize(angle);
   float r = Float::Clamp(normalizedAngle, min, max);
   return r;
@@ -105,9 +109,9 @@ Angle2<float> Angle2<float>::Clamp(Angle2<float> angle, Angle2<float> min,
 // }
 
 template <>
-Angle2<float> Angle2<float>::MoveTowards(Angle2<float> fromAngle,
-                                         Angle2<float> toAngle,
-                                         Angle2<float> maxAngle) {
+AngleOf<float> AngleOf<float>::MoveTowards(AngleOf<float> fromAngle,
+                                           AngleOf<float> toAngle,
+                                           AngleOf<float> maxAngle) {
   float d = toAngle - fromAngle;
   float sign = signbit(d) ? -1 : 1;
   d = sign * Float::Clamp(fabs(d), 0, maxAngle);
@@ -115,11 +119,11 @@ Angle2<float> Angle2<float>::MoveTowards(Angle2<float> fromAngle,
 }
 
 template <>
-Angle2<float> Angle2<float>::CosineRuleSide(float a, float b,
-                                            Angle2<float> gamma) {
+AngleOf<float> AngleOf<float>::CosineRuleSide(float a, float b,
+                                              AngleOf<float> gamma) {
   float a2 = a * a;
   float b2 = b * b;
-  float d = a2 + b2 - 2 * a * b * cos(gamma * Angle2<float>::Deg2Rad);
+  float d = a2 + b2 - 2 * a * b * cos(gamma * AngleOf<float>::Deg2Rad);
   // Catch edge cases where float inacuracies lead tot nans
   if (d < 0)
     return 0;
@@ -129,7 +133,7 @@ Angle2<float> Angle2<float>::CosineRuleSide(float a, float b,
 }
 
 template <>
-Angle2<float> Angle2<float>::CosineRuleAngle(float a, float b, float c) {
+AngleOf<float> AngleOf<float>::CosineRuleAngle(float a, float b, float c) {
   float a2 = a * a;
   float b2 = b * b;
   float c2 = c * c;
@@ -145,8 +149,8 @@ Angle2<float> Angle2<float>::CosineRuleAngle(float a, float b, float c) {
 }
 
 template <>
-Angle2<float> Angle2<float>::SineRuleAngle(float a, Angle2<float> beta,
-                                           float b) {
+AngleOf<float> AngleOf<float>::SineRuleAngle(float a, AngleOf<float> beta,
+                                             float b) {
   float alpha = asin(a * sin(beta * Angle::Deg2Rad) / b);
   return alpha;
 }
\ No newline at end of file
diff --git a/Angle.h b/Angle.h
index 6f130ff..1cb2b8e 100644
--- a/Angle.h
+++ b/Angle.h
@@ -7,36 +7,38 @@
 
 namespace Passer {
 
-template <typename T> class Angle2 {
+template <typename T> class AngleOf {
 public:
-  Angle2(){};
-  Angle2(T v) : value(v) {}
+  AngleOf(){};
+  AngleOf(T v) : value(v) {}
   operator T() { return value; }
 
-  static Angle2<T> Rad2Deg;
-  static Angle2<T> Deg2Rad;
+  static AngleOf<T> Rad2Deg;
+  static AngleOf<T> Deg2Rad;
 
-  static Angle2<T> pi;
+  static AngleOf<T> pi;
 
-  static Angle2<T> Normalize(Angle2<T> angle);
-  static Angle2<T> Clamp(Angle2<T> angle, Angle2<T> min, Angle2<T> max);
-  static Angle2<T> Difference(Angle2<T> a, Angle2<T> b) {
-    Angle2<T> r = Normalize(b - a);
+  bool AngleOf<T>::operator==(AngleOf<T> a);
+
+  static AngleOf<T> Normalize(AngleOf<T> a);
+  static AngleOf<T> Clamp(AngleOf<T> a, AngleOf<T> min, AngleOf<T> max);
+  static AngleOf<T> Difference(AngleOf<T> a, AngleOf<T> b) {
+    AngleOf<T> r = Normalize(b - a);
     return r;
   };
-  static Angle2<T> MoveTowards(Angle2<T> fromAngle, Angle2<T> toAngle,
-                               Angle2<T> maxAngle);
+  static AngleOf<T> MoveTowards(AngleOf<T> fromAngle, AngleOf<T> toAngle,
+                                AngleOf<T> maxAngle);
 
-  static Angle2<T> CosineRuleSide(float a, float b, Angle2<T> gamma);
-  static Angle2<T> CosineRuleAngle(float a, float b, float c);
+  static AngleOf<T> CosineRuleSide(float a, float b, AngleOf<T> gamma);
+  static AngleOf<T> CosineRuleAngle(float a, float b, float c);
 
-  static Angle2<T> SineRuleAngle(float a, Angle2<T> beta, float c);
+  static AngleOf<T> SineRuleAngle(float a, AngleOf<T> beta, float c);
 
 private:
   T value;
 };
 
-using Angle = Angle2<float>;
+using Angle = AngleOf<float>;
 /*
 class Angle {
 public: