diff --git a/SpaceCadetPinball/TBall.h b/SpaceCadetPinball/TBall.h
index b060b4d..a9046aa 100644
--- a/SpaceCadetPinball/TBall.h
+++ b/SpaceCadetPinball/TBall.h
@@ -23,8 +23,8 @@ public :
 	float RayMaxDistance;
 	float TimeDelta;
 	float TimeNow;
-	vector_type InvAcceleration{};
-	vector_type RampFieldForce{};	
+	vector2 InvAcceleration{};
+	vector2 RampFieldForce{};	
 	TCollisionComponent* CollisionComp;
 	int FieldFlag;
 	TEdgeSegment* Collisions[5]{};
diff --git a/SpaceCadetPinball/TBumper.cpp b/SpaceCadetPinball/TBumper.cpp
index 6942192..b55dd75 100644
--- a/SpaceCadetPinball/TBumper.cpp
+++ b/SpaceCadetPinball/TBumper.cpp
@@ -100,7 +100,7 @@ int TBumper::Message(int code, float value)
 	return 0;
 }
 
-void TBumper::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TBumper::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	if (DefaultCollision(ball, nextPosition, direction))
 	{
diff --git a/SpaceCadetPinball/TBumper.h b/SpaceCadetPinball/TBumper.h
index 24705f9..cee5e15 100644
--- a/SpaceCadetPinball/TBumper.h
+++ b/SpaceCadetPinball/TBumper.h
@@ -14,7 +14,7 @@ public:
 	TBumper(TPinballTable* table, int groupIndex);
 	~TBumper() override = default;
 	int Message(int code, float value) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 		TEdgeSegment* edge) override;
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
diff --git a/SpaceCadetPinball/TCircle.cpp b/SpaceCadetPinball/TCircle.cpp
index c537fe8..4cf9d79 100644
--- a/SpaceCadetPinball/TCircle.cpp
+++ b/SpaceCadetPinball/TCircle.cpp
@@ -5,7 +5,7 @@
 #include "TCollisionComponent.h"
 #include "TTableLayer.h"
 
-TCircle::TCircle(TCollisionComponent* collComp, char* activeFlag, unsigned collisionGroup, vector_type* center,
+TCircle::TCircle(TCollisionComponent* collComp, char* activeFlag, unsigned collisionGroup, vector2* center,
                  float radius): TEdgeSegment(collComp, activeFlag, collisionGroup)
 {
 	Circle.RadiusSq = radius * radius;
@@ -19,7 +19,7 @@ float TCircle::FindCollisionDistance(ray_type* ray)
 
 void TCircle::EdgeCollision(TBall* ball, float coef)
 {
-	vector_type direction{}, nextPosition{};
+	vector2 direction{}, nextPosition{};
 
 	nextPosition.X = coef * ball->Acceleration.X + ball->Position.X;
 	nextPosition.Y = coef * ball->Acceleration.Y + ball->Position.Y;
diff --git a/SpaceCadetPinball/TCircle.h b/SpaceCadetPinball/TCircle.h
index 8e1cdee..24b8aea 100644
--- a/SpaceCadetPinball/TCircle.h
+++ b/SpaceCadetPinball/TCircle.h
@@ -8,7 +8,7 @@ class TCircle :
 public:
 	circle_type Circle{};
 
-	TCircle(TCollisionComponent* collComp, char* activeFlag, unsigned int collisionGroup, vector_type* center,
+	TCircle(TCollisionComponent* collComp, char* activeFlag, unsigned int collisionGroup, vector2* center,
 	        float radius);
 	float FindCollisionDistance(ray_type* ray) override;
 	void EdgeCollision(TBall* ball, float coef) override;
diff --git a/SpaceCadetPinball/TCollisionComponent.cpp b/SpaceCadetPinball/TCollisionComponent.cpp
index 493aad1..f0b958e 100644
--- a/SpaceCadetPinball/TCollisionComponent.cpp
+++ b/SpaceCadetPinball/TCollisionComponent.cpp
@@ -51,7 +51,7 @@ void TCollisionComponent::port_draw()
 		edge->port_draw();
 }
 
-int TCollisionComponent::DefaultCollision(TBall* ball, vector_type* nextPosition, vector_type* direction)
+int TCollisionComponent::DefaultCollision(TBall* ball, vector2* nextPosition, vector2* direction)
 {
 	if (PinballTable->TiltLockFlag)
 	{
@@ -73,7 +73,7 @@ int TCollisionComponent::DefaultCollision(TBall* ball, vector_type* nextPosition
 	return 1;
 }
 
-void TCollisionComponent::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction,
+void TCollisionComponent::Collision(TBall* ball, vector2* nextPosition, vector2* direction,
                                     float coef, TEdgeSegment* edge)
 {
 	int soundIndex;
@@ -105,7 +105,7 @@ void TCollisionComponent::Collision(TBall* ball, vector_type* nextPosition, vect
 		loader::play_sound(soundIndex);
 }
 
-int TCollisionComponent::FieldEffect(TBall* ball, vector_type* vecDst)
+int TCollisionComponent::FieldEffect(TBall* ball, vector2* vecDst)
 {
 	return 0;
 }
diff --git a/SpaceCadetPinball/TCollisionComponent.h b/SpaceCadetPinball/TCollisionComponent.h
index e10232c..f8b77ae 100644
--- a/SpaceCadetPinball/TCollisionComponent.h
+++ b/SpaceCadetPinball/TCollisionComponent.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "TPinballComponent.h"
 
-struct vector_type;
+struct vector2;
 class TEdgeSegment;
 class TBall;
 
@@ -19,8 +19,8 @@ public:
 	TCollisionComponent(TPinballTable* table, int groupIndex, bool createWall);
 	~TCollisionComponent() override;
 	void port_draw() override;
-	virtual void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	virtual void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	                       TEdgeSegment* edge);
-	virtual int FieldEffect(TBall* ball, vector_type* vecDst);
-	int DefaultCollision(TBall* ball, vector_type* nextPosition, vector_type* direction);
+	virtual int FieldEffect(TBall* ball, vector2* vecDst);
+	int DefaultCollision(TBall* ball, vector2* nextPosition, vector2* direction);
 };
diff --git a/SpaceCadetPinball/TDemo.cpp b/SpaceCadetPinball/TDemo.cpp
index 37f6656..b39a957 100644
--- a/SpaceCadetPinball/TDemo.cpp
+++ b/SpaceCadetPinball/TDemo.cpp
@@ -93,7 +93,7 @@ int TDemo::Message(int code, float value)
 	return 0;
 }
 
-void TDemo::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TDemo::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	ball->not_again(edge);
 	ball->Position.X = nextPosition->X;
diff --git a/SpaceCadetPinball/TDemo.h b/SpaceCadetPinball/TDemo.h
index b289a5d..8ebea88 100644
--- a/SpaceCadetPinball/TDemo.h
+++ b/SpaceCadetPinball/TDemo.h
@@ -7,7 +7,7 @@ class TDemo :
 public:
 	TDemo(TPinballTable* table, int groupIndex);
 	int Message(int code, float value) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
 
 	static void PlungerRelease(int timerId, void* caller);
diff --git a/SpaceCadetPinball/TDrain.cpp b/SpaceCadetPinball/TDrain.cpp
index d78d961..9579bcc 100644
--- a/SpaceCadetPinball/TDrain.cpp
+++ b/SpaceCadetPinball/TDrain.cpp
@@ -28,7 +28,7 @@ int TDrain::Message(int code, float value)
 	return 0;
 }
 
-void TDrain::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TDrain::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	ball->Message(1024, 0.0);
 	PinballTable->BallInSink = 1;
diff --git a/SpaceCadetPinball/TDrain.h b/SpaceCadetPinball/TDrain.h
index cbfdf31..7b1d907 100644
--- a/SpaceCadetPinball/TDrain.h
+++ b/SpaceCadetPinball/TDrain.h
@@ -7,7 +7,7 @@ class TDrain :
 public:
 	TDrain(TPinballTable* table, int groupIndex);
 	int Message(int code, float value) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
 
 	static void TimerCallback(int timerId, void* caller);
diff --git a/SpaceCadetPinball/TEdgeManager.cpp b/SpaceCadetPinball/TEdgeManager.cpp
index 634bb31..0fba12e 100644
--- a/SpaceCadetPinball/TEdgeManager.cpp
+++ b/SpaceCadetPinball/TEdgeManager.cpp
@@ -87,9 +87,9 @@ int TEdgeManager::TestGridBox(int x, int y, float* distPtr, TEdgeSegment** edgeD
 	return edgeIndex;
 }
 
-void TEdgeManager::FieldEffects(TBall* ball, vector_type* dstVec)
+void TEdgeManager::FieldEffects(TBall* ball, vector2* dstVec)
 {
-	vector_type vec{};
+	vector2 vec{};
 	TEdgeBox* edgeBox = &BoxArray[box_x(ball->Position.X) + box_y(ball->Position.Y) *
 		MaxBoxX];
 
diff --git a/SpaceCadetPinball/TEdgeManager.h b/SpaceCadetPinball/TEdgeManager.h
index 5e1b482..a5d284b 100644
--- a/SpaceCadetPinball/TEdgeManager.h
+++ b/SpaceCadetPinball/TEdgeManager.h
@@ -16,7 +16,7 @@ class TEdgeManager
 public:
 	TEdgeManager(float posX, float posY, float width, float height);
 	~TEdgeManager();
-	void FieldEffects(TBall* ball, struct vector_type* dstVec);
+	void FieldEffects(TBall* ball, struct vector2* dstVec);
 	int box_x(float x);
 	int box_y(float y);
 	int increment_box_x(int x);
diff --git a/SpaceCadetPinball/TEdgeSegment.cpp b/SpaceCadetPinball/TEdgeSegment.cpp
index 43545c3..6aa0c74 100644
--- a/SpaceCadetPinball/TEdgeSegment.cpp
+++ b/SpaceCadetPinball/TEdgeSegment.cpp
@@ -20,7 +20,7 @@ void TEdgeSegment::port_draw()
 TEdgeSegment* TEdgeSegment::install_wall(float* floatArr, TCollisionComponent* collComp, char* activeFlagPtr,
                                          unsigned int collisionGroup, float offset, size_t wallValue)
 {
-	vector_type center{}, start{}, end{}, prevCenter{};
+	vector2 center{}, start{}, end{}, prevCenter{};
 	vector3 vec1{}, vec2{}, dstVec{};
 	TEdgeSegment* edge = nullptr;
 
diff --git a/SpaceCadetPinball/TFlagSpinner.cpp b/SpaceCadetPinball/TFlagSpinner.cpp
index 7286c1c..ea2e77c 100644
--- a/SpaceCadetPinball/TFlagSpinner.cpp
+++ b/SpaceCadetPinball/TFlagSpinner.cpp
@@ -13,7 +13,7 @@
 TFlagSpinner::TFlagSpinner(TPinballTable* table, int groupIndex) : TCollisionComponent(table, groupIndex, false)
 {
 	visualStruct visual{};
-	vector_type end{}, start{};
+	vector2 end{}, start{};
 
 	Timer = 0;
 	loader::query_visual(groupIndex, 0, &visual);
@@ -72,7 +72,7 @@ int TFlagSpinner::Message(int code, float value)
 	return 0;
 }
 
-void TFlagSpinner::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+void TFlagSpinner::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
                              TEdgeSegment* edge)
 {
 	ball->Position.X = nextPosition->X;
diff --git a/SpaceCadetPinball/TFlagSpinner.h b/SpaceCadetPinball/TFlagSpinner.h
index dbf5e52..c0f835d 100644
--- a/SpaceCadetPinball/TFlagSpinner.h
+++ b/SpaceCadetPinball/TFlagSpinner.h
@@ -7,7 +7,7 @@ class TFlagSpinner :
 public:
 	TFlagSpinner(TPinballTable* table, int groupIndex);
 	int Message(int code, float value) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 		TEdgeSegment* edge) override;
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
diff --git a/SpaceCadetPinball/TFlipper.cpp b/SpaceCadetPinball/TFlipper.cpp
index 55dc126..09621c9 100644
--- a/SpaceCadetPinball/TFlipper.cpp
+++ b/SpaceCadetPinball/TFlipper.cpp
@@ -128,7 +128,7 @@ void TFlipper::port_draw()
 	FlipperEdge->port_draw();
 }
 
-void TFlipper::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TFlipper::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 }
 
diff --git a/SpaceCadetPinball/TFlipper.h b/SpaceCadetPinball/TFlipper.h
index 423a46d..3e2ef05 100644
--- a/SpaceCadetPinball/TFlipper.h
+++ b/SpaceCadetPinball/TFlipper.h
@@ -11,7 +11,7 @@ public:
 	~TFlipper() override;
 	int Message(int code, float value) override;
 	void port_draw() override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 		TEdgeSegment* edge) override;
 
 	static void TimerExpired(int timerId, void* caller);
diff --git a/SpaceCadetPinball/TFlipperEdge.cpp b/SpaceCadetPinball/TFlipperEdge.cpp
index 780eba1..b6637fd 100644
--- a/SpaceCadetPinball/TFlipperEdge.cpp
+++ b/SpaceCadetPinball/TFlipperEdge.cpp
@@ -7,7 +7,7 @@
 #include "TTableLayer.h"
 
 float TFlipperEdge::flipper_sin_angle, TFlipperEdge::flipper_cos_angle;
-vector_type TFlipperEdge::A1, TFlipperEdge::A2, TFlipperEdge::B1, TFlipperEdge::B2, TFlipperEdge::T1;
+vector2 TFlipperEdge::A1, TFlipperEdge::A2, TFlipperEdge::B1, TFlipperEdge::B2, TFlipperEdge::T1;
 line_type TFlipperEdge::lineA, TFlipperEdge::lineB;
 circle_type TFlipperEdge::circlebase, TFlipperEdge::circleT1;
 
@@ -200,7 +200,7 @@ float TFlipperEdge::FindCollisionDistance(ray_type* ray)
 			auto ballInside = is_ball_inside(posX, posY);
 			if (ballInside != 0)
 			{
-				vector_type* linePtr;
+				vector2* linePtr;
 				if (FlipperFlag == 1 && ballInside != 5)
 				{
 					linePtr = &lineA.PerpendicularL;
@@ -271,7 +271,7 @@ float TFlipperEdge::FindCollisionDistance(ray_type* ray)
 				NextBallPosition = dstRay.Origin;
 				NextBallPosition.X -= srcRay.Direction.X * 1e-05f;
 				NextBallPosition.Y -= srcRay.Direction.Y * 1e-05f;
-				vector_type* linePtr;
+				vector2* linePtr;
 				if (FlipperFlag == 2)
 				{
 					linePtr = &lineB.PerpendicularL;
@@ -435,7 +435,7 @@ float TFlipperEdge::flipper_angle(float timeNow)
 
 int TFlipperEdge::is_ball_inside(float x, float y)
 {
-	vector_type testPoint{};
+	vector2 testPoint{};
 	float dx = RotOrigin.X - x;
 	float dy = RotOrigin.Y - y;
 	if (((A2.X - A1.X) * (y - A1.Y) - (A2.Y - A1.Y) * (x - A1.X) >= 0.0f &&
diff --git a/SpaceCadetPinball/TFlipperEdge.h b/SpaceCadetPinball/TFlipperEdge.h
index a440697..c82c6ec 100644
--- a/SpaceCadetPinball/TFlipperEdge.h
+++ b/SpaceCadetPinball/TFlipperEdge.h
@@ -23,7 +23,7 @@ public:
 	int FlipperFlag;
 	float Elasticity;
 	float Smoothness;
-	vector_type RotOrigin{};
+	vector2 RotOrigin{};
 	float CirclebaseRadius;
 	float CircleT1Radius;
 	float CirclebaseRadiusSq;
@@ -35,27 +35,27 @@ public:
 	float Angle1;
 	int CollisionFlag1;
 	int CollisionFlag2{};
-	vector_type CollisionLinePerp{};
-	vector_type A1Src{};
-	vector_type A2Src{};
-	vector_type B1Src{};
-	vector_type B2Src{};
+	vector2 CollisionLinePerp{};
+	vector2 A1Src{};
+	vector2 A2Src{};
+	vector2 B1Src{};
+	vector2 B2Src{};
 	float CollisionMult;
-	vector_type T1Src{};
-	vector_type T2Src{};
+	vector2 T1Src{};
+	vector2 T2Src{};
 	float DistanceDivSq;
 	float CollisionTimeAdvance;
-	vector_type CollisionDirection{};
+	vector2 CollisionDirection{};
 	int EdgeCollisionFlag;
 	float InputTime;
 	float AngleStopTime;
 	float AngleMult;
 	float ExtendTime;
 	float RetractTime;
-	vector_type NextBallPosition{};
+	vector2 NextBallPosition{};
 
 	static float flipper_sin_angle, flipper_cos_angle;
-	static vector_type A1, A2, B1, B2, T1;
+	static vector2 A1, A2, B1, B2, T1;
 	static line_type lineA, lineB;
 	static circle_type circlebase, circleT1;
 };
diff --git a/SpaceCadetPinball/THole.cpp b/SpaceCadetPinball/THole.cpp
index b93b3a7..428852f 100644
--- a/SpaceCadetPinball/THole.cpp
+++ b/SpaceCadetPinball/THole.cpp
@@ -69,7 +69,7 @@ int THole::Message(int code, float value)
 	return 0;
 }
 
-void THole::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void THole::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	if (!BallCapturedFlag)
 	{
@@ -93,10 +93,10 @@ void THole::Collision(TBall* ball, vector_type* nextPosition, vector_type* direc
 	}
 }
 
-int THole::FieldEffect(TBall* ball, vector_type* vecDst)
+int THole::FieldEffect(TBall* ball, vector2* vecDst)
 {
 	int result;
-	vector_type direction{};
+	vector2 direction{};
 
 	if (BallCapturedFlag)
 	{
diff --git a/SpaceCadetPinball/THole.h b/SpaceCadetPinball/THole.h
index 3d3937c..187a4b0 100644
--- a/SpaceCadetPinball/THole.h
+++ b/SpaceCadetPinball/THole.h
@@ -9,9 +9,9 @@ class THole :
 public:
 	THole(TPinballTable* table, int groupIndex);
 	int Message(int code, float value) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
-	int FieldEffect(TBall* ball, vector_type* vecDst) override;
+	int FieldEffect(TBall* ball, vector2* vecDst) override;
 
 	static void TimerExpired(int timerId, void* caller);
 
diff --git a/SpaceCadetPinball/TKickback.cpp b/SpaceCadetPinball/TKickback.cpp
index e082ad0..8abb403 100644
--- a/SpaceCadetPinball/TKickback.cpp
+++ b/SpaceCadetPinball/TKickback.cpp
@@ -33,7 +33,7 @@ int TKickback::Message(int code, float value)
 	return 0;
 }
 
-void TKickback::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+void TKickback::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
                           TEdgeSegment* edge)
 {
 	if (PinballTable->TiltLockFlag)
diff --git a/SpaceCadetPinball/TKickback.h b/SpaceCadetPinball/TKickback.h
index a688c12..ebdd14b 100644
--- a/SpaceCadetPinball/TKickback.h
+++ b/SpaceCadetPinball/TKickback.h
@@ -7,7 +7,7 @@ class TKickback :
 public:
 	TKickback(TPinballTable* table, int groupIndex);
 	int Message(int code, float value) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 		TEdgeSegment* edge) override;
 
 	static void TimerExpired(int timerId, void* caller);
diff --git a/SpaceCadetPinball/TKickout.cpp b/SpaceCadetPinball/TKickout.cpp
index 400bb21..156184c 100644
--- a/SpaceCadetPinball/TKickout.cpp
+++ b/SpaceCadetPinball/TKickout.cpp
@@ -104,7 +104,7 @@ int TKickout::get_scoring(int index)
 	return index < 5 ? Scores[index] : 0;
 }
 
-void TKickout::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TKickout::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	if (!KickFlag1)
 	{
@@ -128,9 +128,9 @@ void TKickout::Collision(TBall* ball, vector_type* nextPosition, vector_type* di
 	}
 }
 
-int TKickout::FieldEffect(TBall* ball, vector_type* dstVec)
+int TKickout::FieldEffect(TBall* ball, vector2* dstVec)
 {
-	vector_type direction{};
+	vector2 direction{};
 
 	if (KickFlag1)
 		return 0;
diff --git a/SpaceCadetPinball/TKickout.h b/SpaceCadetPinball/TKickout.h
index 5dfcc89..05623cb 100644
--- a/SpaceCadetPinball/TKickout.h
+++ b/SpaceCadetPinball/TKickout.h
@@ -11,9 +11,9 @@ public:
 	int Message(int code, float value) override;
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
-	int FieldEffect(TBall* ball, vector_type* vecDst) override;
+	int FieldEffect(TBall* ball, vector2* vecDst) override;
 
 	static void TimerExpired(int timerId, void* caller);
 	static void ResetTimerExpired(int timerId, void* caller);
diff --git a/SpaceCadetPinball/TLightRollover.cpp b/SpaceCadetPinball/TLightRollover.cpp
index 5ec855d..e139db0 100644
--- a/SpaceCadetPinball/TLightRollover.cpp
+++ b/SpaceCadetPinball/TLightRollover.cpp
@@ -34,7 +34,7 @@ int TLightRollover::Message(int code, float value)
 	return 0;
 }
 
-void TLightRollover::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+void TLightRollover::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
                                TEdgeSegment* edge)
 {
 	ball->Position.X = nextPosition->X;
diff --git a/SpaceCadetPinball/TLightRollover.h b/SpaceCadetPinball/TLightRollover.h
index 52a8d5b..9100e1b 100644
--- a/SpaceCadetPinball/TLightRollover.h
+++ b/SpaceCadetPinball/TLightRollover.h
@@ -8,7 +8,7 @@ public:
 	TLightRollover(TPinballTable* table, int groupIndex);
 	~TLightRollover() override = default;
 	int Message(int code, float value) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 		TEdgeSegment* edge) override;
 
 	static void delay_expired(int timerId, void* caller);
diff --git a/SpaceCadetPinball/TLine.cpp b/SpaceCadetPinball/TLine.cpp
index eee336b..fd1d1e2 100644
--- a/SpaceCadetPinball/TLine.cpp
+++ b/SpaceCadetPinball/TLine.cpp
@@ -14,8 +14,8 @@ TLine::TLine(TCollisionComponent* collCmp, char* activeFlag, unsigned int collis
 	maths::line_init(&Line, x0, y0, x1, y1);
 }
 
-TLine::TLine(TCollisionComponent* collCmp, char* activeFlag, unsigned int collisionGroup, struct vector_type* start,
-             struct vector_type* end) : TEdgeSegment(collCmp, activeFlag, collisionGroup)
+TLine::TLine(TCollisionComponent* collCmp, char* activeFlag, unsigned int collisionGroup, struct vector2* start,
+             struct vector2* end) : TEdgeSegment(collCmp, activeFlag, collisionGroup)
 {
 	X0 = start->X;
 	Y0 = start->Y;
diff --git a/SpaceCadetPinball/TLine.h b/SpaceCadetPinball/TLine.h
index cd1082c..f494f4f 100644
--- a/SpaceCadetPinball/TLine.h
+++ b/SpaceCadetPinball/TLine.h
@@ -9,7 +9,7 @@ public:
 	line_type Line{};
 	float X0, Y0, X1, Y1;
 	TLine(TCollisionComponent* collCmp, char* activeFlag, unsigned int collisionGroup, float x0, float y0, float x1, float y1);
-	TLine(TCollisionComponent* collCmp, char* activeFlag, unsigned int collisionGroup, vector_type* start, vector_type* end);
+	TLine(TCollisionComponent* collCmp, char* activeFlag, unsigned int collisionGroup, vector2* start, vector2* end);
 	void Offset(float offset);
 	float FindCollisionDistance(ray_type* ray) override;
 	void EdgeCollision(TBall* ball, float coef) override;
diff --git a/SpaceCadetPinball/TOneway.cpp b/SpaceCadetPinball/TOneway.cpp
index ca97678..d16d536 100644
--- a/SpaceCadetPinball/TOneway.cpp
+++ b/SpaceCadetPinball/TOneway.cpp
@@ -11,7 +11,7 @@
 TOneway::TOneway(TPinballTable* table, int groupIndex) : TCollisionComponent(table, groupIndex, false)
 {
 	visualStruct visual{};
-	vector_type linePt1{}, linePt2{};
+	vector2 linePt1{}, linePt2{};
 
 	loader::query_visual(groupIndex, 0, &visual);
 	if (visual.FloatArrCount == 2)
@@ -40,7 +40,7 @@ TOneway::TOneway(TPinballTable* table, int groupIndex) : TCollisionComponent(tab
 	}
 }
 
-void TOneway::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TOneway::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	if (edge == Line)
 	{
diff --git a/SpaceCadetPinball/TOneway.h b/SpaceCadetPinball/TOneway.h
index 8501e0a..01fc02b 100644
--- a/SpaceCadetPinball/TOneway.h
+++ b/SpaceCadetPinball/TOneway.h
@@ -8,7 +8,7 @@ class TOneway : public TCollisionComponent
 public:
 	TOneway(TPinballTable* table, int groupIndex);
 	~TOneway() override = default;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
diff --git a/SpaceCadetPinball/TPinballTable.cpp b/SpaceCadetPinball/TPinballTable.cpp
index 46d2f20..86e55ea 100644
--- a/SpaceCadetPinball/TPinballTable.cpp
+++ b/SpaceCadetPinball/TPinballTable.cpp
@@ -617,7 +617,7 @@ void TPinballTable::replay_timer_callback(int timerId, void* caller)
 void TPinballTable::tilt_timeout(int timerId, void* caller)
 {
 	auto table = static_cast<TPinballTable*>(caller);
-	vector_type vec{};
+	vector2 vec{};
 
 	table->TiltTimeoutTimer = 0;
 	if (table->TiltLockFlag)
diff --git a/SpaceCadetPinball/TPlunger.cpp b/SpaceCadetPinball/TPlunger.cpp
index 488cd9c..7fda598 100644
--- a/SpaceCadetPinball/TPlunger.cpp
+++ b/SpaceCadetPinball/TPlunger.cpp
@@ -33,7 +33,7 @@ TPlunger::TPlunger(TPinballTable* table, int groupIndex) : TCollisionComponent(t
 	table->PlungerPositionY = floatArr[1];
 }
 
-void TPlunger::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TPlunger::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	if (PinballTable->TiltLockFlag)
 		Message(1017, 0.0);
diff --git a/SpaceCadetPinball/TPlunger.h b/SpaceCadetPinball/TPlunger.h
index 9419239..2fe44bf 100644
--- a/SpaceCadetPinball/TPlunger.h
+++ b/SpaceCadetPinball/TPlunger.h
@@ -7,7 +7,7 @@ class TPlunger :
 public:
 	TPlunger(TPinballTable* table, int groupIndex);
 	~TPlunger() override = default;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
 	int Message(int code, float value) override;
 
diff --git a/SpaceCadetPinball/TPopupTarget.cpp b/SpaceCadetPinball/TPopupTarget.cpp
index 7a72786..af29c1c 100644
--- a/SpaceCadetPinball/TPopupTarget.cpp
+++ b/SpaceCadetPinball/TPopupTarget.cpp
@@ -62,7 +62,7 @@ int TPopupTarget::get_scoring(int index)
 	return index < 3 ? Scores[index] : 0;
 }
 
-void TPopupTarget::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+void TPopupTarget::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
                              TEdgeSegment* edge)
 {
 	if (this->PinballTable->TiltLockFlag)
diff --git a/SpaceCadetPinball/TPopupTarget.h b/SpaceCadetPinball/TPopupTarget.h
index 7d8950b..ebae2f2 100644
--- a/SpaceCadetPinball/TPopupTarget.h
+++ b/SpaceCadetPinball/TPopupTarget.h
@@ -9,7 +9,7 @@ public:
 	int Message(int code, float value) override;
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 		TEdgeSegment* edge) override;	
 
 	static void TimerExpired(int timerId, void* caller);
diff --git a/SpaceCadetPinball/TRamp.cpp b/SpaceCadetPinball/TRamp.cpp
index 4c930dc..7a29af1 100644
--- a/SpaceCadetPinball/TRamp.cpp
+++ b/SpaceCadetPinball/TRamp.cpp
@@ -14,7 +14,7 @@
 TRamp::TRamp(TPinballTable* table, int groupIndex) : TCollisionComponent(table, groupIndex, false)
 {
 	visualStruct visual{};
-	vector_type end{}, start{}, *end2, *start2, *start3, *end3;
+	vector2 end{}, start{}, *end2, *start2, *start3, *end3;
 
 	MessageField = 0;
 	UnusedBaseFlag = 1;
@@ -94,7 +94,7 @@ TRamp::TRamp(TPinballTable* table, int groupIndex) : TCollisionComponent(table,
 		xMax = std::max(std::max(std::max(plane->V3.X, plane->V1.X), plane->V2.X), xMin);
 		yMax = std::max(std::max(std::max(plane->V3.Y, plane->V1.Y), plane->V2.Y), xMin);
 
-		vector_type* pointOrder[4] = {pVec1, pVec2, pVec3, pVec1};
+		vector2* pointOrder[4] = {pVec1, pVec2, pVec3, pVec1};
 		for (auto pt = 0; pt < 3; pt++)
 		{
 			auto point1 = pointOrder[pt], point2 = pointOrder[pt + 1];
@@ -154,7 +154,7 @@ int TRamp::get_scoring(int index)
 	return index < 4 ? Scores[index] : 0;
 }
 
-void TRamp::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TRamp::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	ball->not_again(edge);
 	ball->Position.X = nextPosition->X;
@@ -204,7 +204,7 @@ void TRamp::Collision(TBall* ball, vector_type* nextPosition, vector_type* direc
 	}
 }
 
-int TRamp::FieldEffect(TBall* ball, vector_type* vecDst)
+int TRamp::FieldEffect(TBall* ball, vector2* vecDst)
 {
 	vecDst->X = ball->RampFieldForce.X - ball->Acceleration.X * ball->Speed * BallFieldMult;
 	vecDst->Y = ball->RampFieldForce.Y - ball->Acceleration.Y * ball->Speed * BallFieldMult;
diff --git a/SpaceCadetPinball/TRamp.h b/SpaceCadetPinball/TRamp.h
index 345ce5b..b402c6e 100644
--- a/SpaceCadetPinball/TRamp.h
+++ b/SpaceCadetPinball/TRamp.h
@@ -12,9 +12,9 @@ public:
 	TRamp(TPinballTable* table, int groupIndex);
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
-	int FieldEffect(TBall* ball, vector_type* vecDst) override;
+	int FieldEffect(TBall* ball, vector2* vecDst) override;
 	void port_draw() override;
 
 	int Scores[4]{};
diff --git a/SpaceCadetPinball/TRollover.cpp b/SpaceCadetPinball/TRollover.cpp
index d11ad79..d091aed 100644
--- a/SpaceCadetPinball/TRollover.cpp
+++ b/SpaceCadetPinball/TRollover.cpp
@@ -37,7 +37,7 @@ int TRollover::Message(int code, float value)
 	return 0;
 }
 
-void TRollover::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+void TRollover::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
                           TEdgeSegment* edge)
 {
 	ball->Position.X = nextPosition->X;
diff --git a/SpaceCadetPinball/TRollover.h b/SpaceCadetPinball/TRollover.h
index 30b0118..421e88d 100644
--- a/SpaceCadetPinball/TRollover.h
+++ b/SpaceCadetPinball/TRollover.h
@@ -10,7 +10,7 @@ public:
 	TRollover(TPinballTable* table, int groupIndex);
 	~TRollover() override = default;
 	int Message(int code, float value) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 		TEdgeSegment* edge) override;
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
diff --git a/SpaceCadetPinball/TSink.cpp b/SpaceCadetPinball/TSink.cpp
index 21323f6..0aaabb1 100644
--- a/SpaceCadetPinball/TSink.cpp
+++ b/SpaceCadetPinball/TSink.cpp
@@ -75,7 +75,7 @@ int TSink::get_scoring(int index)
 	return index < 3 ? Scores[index] : 0;
 }
 
-void TSink::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TSink::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	Timer = 0;
 	if (PinballTable->TiltLockFlag)
diff --git a/SpaceCadetPinball/TSink.h b/SpaceCadetPinball/TSink.h
index db426e2..f1a4bd1 100644
--- a/SpaceCadetPinball/TSink.h
+++ b/SpaceCadetPinball/TSink.h
@@ -10,14 +10,14 @@ public:
 	int Message(int code, float value) override;
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
 
 	static void TimerExpired(int timerId, void* caller);
 
 	int Timer;
 	float TimerTime;
-	vector_type BallPosition{};
+	vector2 BallPosition{};
 	vector3 BallAcceleration{};
 	float ThrowAngleMult;
 	float ThrowSpeedMult1;
diff --git a/SpaceCadetPinball/TSoloTarget.cpp b/SpaceCadetPinball/TSoloTarget.cpp
index 8ac9e28..f55f213 100644
--- a/SpaceCadetPinball/TSoloTarget.cpp
+++ b/SpaceCadetPinball/TSoloTarget.cpp
@@ -64,7 +64,7 @@ int TSoloTarget::get_scoring(int index)
 	return index < 1 ? Scores[index] : 0;
 }
 
-void TSoloTarget::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+void TSoloTarget::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
                             TEdgeSegment* edge)
 {
 	if (DefaultCollision(ball, nextPosition, direction))
diff --git a/SpaceCadetPinball/TSoloTarget.h b/SpaceCadetPinball/TSoloTarget.h
index 78ec01c..cbcf2c7 100644
--- a/SpaceCadetPinball/TSoloTarget.h
+++ b/SpaceCadetPinball/TSoloTarget.h
@@ -9,7 +9,7 @@ public:
 	int Message(int code, float value) override;
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
 
 	static void TimerExpired(int timerId, void* caller);
diff --git a/SpaceCadetPinball/TTableLayer.cpp b/SpaceCadetPinball/TTableLayer.cpp
index f804bb9..710a019 100644
--- a/SpaceCadetPinball/TTableLayer.cpp
+++ b/SpaceCadetPinball/TTableLayer.cpp
@@ -111,7 +111,7 @@ TTableLayer::~TTableLayer()
 		delete edge_manager;
 }
 
-int TTableLayer::FieldEffect(TBall* ball, vector_type* vecDst)
+int TTableLayer::FieldEffect(TBall* ball, vector2* vecDst)
 {
 	vecDst->X = GraityDirX - (0.5f - RandFloat() + ball->Acceleration.X) *
 		ball->Speed * GraityMult;
@@ -161,7 +161,7 @@ void TTableLayer::edges_insert_square(float y0, float x0, float y1, float x1, TE
 void TTableLayer::edges_insert_circle(circle_type* circle, TEdgeSegment* edge, field_effect_type* field)
 {
 	ray_type ray{};
-	vector_type vec1{};
+	vector2 vec1{};
 
 	auto radiusM = sqrt(circle->RadiusSq) + edge_manager->AdvanceX * 0.001f;
 	auto radiusMSq = radiusM * radiusM;
diff --git a/SpaceCadetPinball/TTableLayer.h b/SpaceCadetPinball/TTableLayer.h
index f847b32..d5ee6b6 100644
--- a/SpaceCadetPinball/TTableLayer.h
+++ b/SpaceCadetPinball/TTableLayer.h
@@ -14,7 +14,7 @@ class TTableLayer :
 public:
 	TTableLayer(TPinballTable* table);
 	~TTableLayer() override;
-	int FieldEffect(TBall* ball, vector_type* vecDst) override;
+	int FieldEffect(TBall* ball, vector2* vecDst) override;
 
 	static void edges_insert_square(float y0, float x0, float y1, float x1, TEdgeSegment* edge,
 	                                field_effect_type* field);
diff --git a/SpaceCadetPinball/TTripwire.cpp b/SpaceCadetPinball/TTripwire.cpp
index bc34094..cd36e3a 100644
--- a/SpaceCadetPinball/TTripwire.cpp
+++ b/SpaceCadetPinball/TTripwire.cpp
@@ -10,7 +10,7 @@ TTripwire::TTripwire(TPinballTable* table, int groupIndex) : TRollover(table, gr
 {
 }
 
-void TTripwire::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+void TTripwire::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
                           TEdgeSegment* edge)
 {
 	ball->Position.X = nextPosition->X;
diff --git a/SpaceCadetPinball/TTripwire.h b/SpaceCadetPinball/TTripwire.h
index d886ec8..178caa3 100644
--- a/SpaceCadetPinball/TTripwire.h
+++ b/SpaceCadetPinball/TTripwire.h
@@ -7,6 +7,6 @@ class TTripwire :
 public:
 	TTripwire(TPinballTable* table, int groupIndex);
 	~TTripwire() override = default;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
 };
diff --git a/SpaceCadetPinball/TWall.cpp b/SpaceCadetPinball/TWall.cpp
index ef464f8..3130566 100644
--- a/SpaceCadetPinball/TWall.cpp
+++ b/SpaceCadetPinball/TWall.cpp
@@ -24,7 +24,7 @@ int TWall::Message(int code, float value)
 	return 0;
 }
 
-void TWall::Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef, TEdgeSegment* edge)
+void TWall::Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef, TEdgeSegment* edge)
 {
 	if (DefaultCollision(ball, nextPosition, direction))
 	{
diff --git a/SpaceCadetPinball/TWall.h b/SpaceCadetPinball/TWall.h
index c55c5c7..988b74c 100644
--- a/SpaceCadetPinball/TWall.h
+++ b/SpaceCadetPinball/TWall.h
@@ -10,7 +10,7 @@ class TWall :
 public:
 	TWall(TPinballTable* table, int groupIndex);
 	int Message(int code, float value) override;
-	void Collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float coef,
+	void Collision(TBall* ball, vector2* nextPosition, vector2* direction, float coef,
 	               TEdgeSegment* edge) override;
 	void put_scoring(int index, int score) override;
 	int get_scoring(int index) override;
diff --git a/SpaceCadetPinball/maths.cpp b/SpaceCadetPinball/maths.cpp
index f392680..b9ab866 100644
--- a/SpaceCadetPinball/maths.cpp
+++ b/SpaceCadetPinball/maths.cpp
@@ -155,7 +155,7 @@ float maths::ray_intersect_circle(ray_type* ray, circle_type* circle)
 }
 
 
-float maths::normalize_2d(vector_type* vec)
+float maths::normalize_2d(vector2* vec)
 {
 	float mag = sqrt(vec->X * vec->X + vec->Y * vec->Y);
 	if (mag != 0.0f)
@@ -263,13 +263,13 @@ float maths::magnitude(vector3* vec)
 	return result;
 }
 
-void maths::vector_add(vector_type* vec1Dst, vector_type* vec2)
+void maths::vector_add(vector2* vec1Dst, vector2* vec2)
 {
 	vec1Dst->X += vec2->X;
 	vec1Dst->Y += vec2->Y;
 }
 
-float maths::basic_collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float elasticity, float smoothness,
+float maths::basic_collision(TBall* ball, vector2* nextPosition, vector2* direction, float elasticity, float smoothness,
                              float threshold, float boost)
 {
 	ball->Position.X = nextPosition->X;
@@ -299,24 +299,24 @@ float maths::basic_collision(TBall* ball, vector_type* nextPosition, vector_type
 	return projSpeed;
 }
 
-float maths::Distance_Squared(vector_type& vec1, vector_type& vec2)
+float maths::Distance_Squared(vector2& vec1, vector2& vec2)
 {
 	return (vec1.Y - vec2.Y) * (vec1.Y - vec2.Y) + (vec1.X - vec2.X) * (vec1.X - vec2.X);
 }
 
-float maths::DotProduct(vector_type* vec1, vector_type* vec2)
+float maths::DotProduct(vector2* vec1, vector2* vec2)
 {
 	return vec1->Y * vec2->Y + vec1->X * vec2->X;
 }
 
-void maths::vswap(vector_type* vec1, vector_type* vec2)
+void maths::vswap(vector2* vec1, vector2* vec2)
 {
-	vector_type tmp = *vec1;
+	vector2 tmp = *vec1;
 	*vec1 = *vec2;
 	*vec2 = tmp;
 }
 
-float maths::Distance(vector_type* vec1, vector_type* vec2)
+float maths::Distance(vector2* vec1, vector2* vec2)
 {
 	auto dx = vec1->X - vec2->X;
 	auto dy = vec1->Y - vec2->Y;
@@ -329,7 +329,7 @@ void maths::SinCos(float angle, float* sinOut, float* cosOut)
 	*cosOut = cos(angle);
 }
 
-void maths::RotatePt(vector_type* point, float sin, float cos, vector_type* origin)
+void maths::RotatePt(vector2* point, float sin, float cos, vector2* origin)
 {
 	auto dirX = point->X - origin->X;
 	auto dirY = point->Y - origin->Y;
@@ -370,7 +370,7 @@ float maths::distance_to_flipper(ray_type* ray1, ray_type* ray2)
 
 	if (distanceType != -1)
 	{
-		vector_type* nextOrigin;
+		vector2* nextOrigin;
 		if (distanceType)
 		{
 			if (distanceType != 1)
@@ -406,7 +406,7 @@ float maths::distance_to_flipper(ray_type* ray1, ray_type* ray2)
 	return 1000000000.0;
 }
 
-void maths::RotateVector(vector_type* vec, float angle)
+void maths::RotateVector(vector2* vec, float angle)
 {
 	float s = sin(angle), c = cos(angle);
 	vec->X = c * vec->X - s * vec->Y;
@@ -418,10 +418,10 @@ void maths::RotateVector(vector_type* vec, float angle)
 	 */
 }
 
-void maths::find_closest_edge(ramp_plane_type* plane, int planeCount, wall_point_type* wall, vector_type** lineEnd,
-                              vector_type** lineStart)
+void maths::find_closest_edge(ramp_plane_type* plane, int planeCount, wall_point_type* wall, vector2** lineEnd,
+                              vector2** lineStart)
 {
-	vector_type wallEnd{}, wallStart{};
+	vector2 wallEnd{}, wallStart{};
 
 	wallStart.X = wall->X0;
 	wallStart.Y = wall->Y0;
diff --git a/SpaceCadetPinball/maths.h b/SpaceCadetPinball/maths.h
index 29e87ed..87ed98a 100644
--- a/SpaceCadetPinball/maths.h
+++ b/SpaceCadetPinball/maths.h
@@ -2,17 +2,13 @@
 
 class TBall;
 
-struct vector_type
+struct vector2
 {
 	float X;
 	float Y;
 };
 
-struct vector_type2 :vector_type
-{
-};
-
-struct vector3 :vector_type
+struct vector3 :vector2
 {	
 	float Z;
 };
@@ -27,14 +23,14 @@ struct rectangle_type
 
 struct circle_type
 {
-	vector_type Center;
+	vector2 Center;
 	float RadiusSq;
 };
 
 struct ray_type
 {
-	vector_type Origin;
-	vector_type Direction;
+	vector2 Origin;
+	vector2 Direction;
 	float MaxDistance;
 	float MinDistance;
 	float TimeNow;
@@ -44,12 +40,12 @@ struct ray_type
 
 struct line_type
 {
-	vector_type PerpendicularL;
-	vector_type Direction;
+	vector2 PerpendicularL;
+	vector2 Direction;
 	float PreComp1;
 	float OriginX;
 	float OriginY;
-	vector_type RayIntersect;
+	vector2 RayIntersect;
 };
 
 struct wall_point_type
@@ -63,12 +59,12 @@ struct wall_point_type
 struct ramp_plane_type
 {
 	vector3 BallCollisionOffset;
-	vector_type2 V1;
-	vector_type2 V2;
-	vector_type2 V3;
+	vector2 V1;
+	vector2 V2;
+	vector2 V3;
 	float GravityAngle1;
 	float GravityAngle2;
-	vector_type2 FieldForce;
+	vector2 FieldForce;
 };
 
 
@@ -79,23 +75,23 @@ public:
 	static int rectangle_clip(rectangle_type* rect1, rectangle_type* rect2, rectangle_type* dstRect);
 	static int overlapping_box(rectangle_type* rect1, rectangle_type* rect2, rectangle_type* dstRect);
 	static float ray_intersect_circle(ray_type* ray, circle_type* circle);
-	static float normalize_2d(vector_type* vec);
+	static float normalize_2d(vector2* vec);
 	static void line_init(line_type* line, float x0, float y0, float x1, float y1);
 	static float ray_intersect_line(ray_type* ray, line_type* line);
 	static void cross(vector3* vec1, vector3* vec2, vector3* dstVec);
 	static float magnitude(vector3* vec);
-	static void vector_add(vector_type* vec1Dst, vector_type* vec2);
-	static float basic_collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float elasticity,
+	static void vector_add(vector2* vec1Dst, vector2* vec2);
+	static float basic_collision(TBall* ball, vector2* nextPosition, vector2* direction, float elasticity,
 	                             float smoothness,
 	                             float threshold, float boost);
-	static float Distance_Squared(vector_type& vec1, vector_type& vec2);
-	static float DotProduct(vector_type* vec1, vector_type* vec2);
-	static void vswap(vector_type* vec1, vector_type* vec2);
-	static float Distance(vector_type* vec1, vector_type* vec2);
+	static float Distance_Squared(vector2& vec1, vector2& vec2);
+	static float DotProduct(vector2* vec1, vector2* vec2);
+	static void vswap(vector2* vec1, vector2* vec2);
+	static float Distance(vector2* vec1, vector2* vec2);
 	static void SinCos(float angle, float* sinOut, float* cosOut);
-	static void RotatePt(vector_type* point, float sin, float cos, vector_type* origin);
+	static void RotatePt(vector2* point, float sin, float cos, vector2* origin);
 	static float distance_to_flipper(ray_type* ray1, ray_type* ray2);
-	static void RotateVector(vector_type* vec, float angle);
-	static void find_closest_edge(ramp_plane_type* plane, int planeCount, wall_point_type* wall, vector_type** lineEnd,
-	                              vector_type** lineStart);
+	static void RotateVector(vector2* vec, float angle);
+	static void find_closest_edge(ramp_plane_type* plane, int planeCount, wall_point_type* wall, vector2** lineEnd,
+	                              vector2** lineStart);
 };
diff --git a/SpaceCadetPinball/nudge.cpp b/SpaceCadetPinball/nudge.cpp
index 3609b8a..7a69eed 100644
--- a/SpaceCadetPinball/nudge.cpp
+++ b/SpaceCadetPinball/nudge.cpp
@@ -64,7 +64,7 @@ void nudge::nudge_up()
 
 void nudge::_nudge(float xDiff, float yDiff)
 {
-	vector_type accelMod;
+	vector2 accelMod;
 	float invAccelX, invAccelY;
 
 	accelMod.X = xDiff * 0.5f;
diff --git a/SpaceCadetPinball/pb.cpp b/SpaceCadetPinball/pb.cpp
index 0df8d6f..e5a73ac 100644
--- a/SpaceCadetPinball/pb.cpp
+++ b/SpaceCadetPinball/pb.cpp
@@ -290,7 +290,7 @@ void pb::frame(float dtMilliSec)
 
 void pb::timed_frame(float timeNow, float timeDelta, bool drawBalls)
 {
-	vector_type vec1{}, vec2{};
+	vector2 vec1{}, vec2{};
 
 	for (auto ball : MainTable->BallList)
 	{
@@ -594,7 +594,7 @@ bool pb::chk_highscore()
 float pb::collide(float timeNow, float timeDelta, TBall* ball)
 {
 	ray_type ray{};
-	vector_type positionMod{};
+	vector2 positionMod{};
 
 	if (ball->ActiveFlag && !ball->CollisionComp)
 	{