SunRed/SpaceCadetPinball
1
0
Fork 0
mirror of https://github.com/k4zmu2a/SpaceCadetPinball.git synced 2024-11-17 15:20:17 +01:00
Code Issues Releases Activity

Cleaning up maths: part 2.

Browse source 
Renamed vector2.
This commit is contained in:
Muzychenko Andrey 2022-05-11 16:47:13 +03:00
parent d23444b983
commit 2d0da712e3
55 changed files with 127 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
SpaceCadetPinball/TBall.h
View file

@ -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]{};

2
SpaceCadetPinball/TBumper.cpp
View file

@ -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))
{

2
SpaceCadetPinball/TBumper.h
View file

@ -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;

4
SpaceCadetPinball/TCircle.cpp
View file

@ -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;

2
SpaceCadetPinball/TCircle.h
View file

@ -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;

6
SpaceCadetPinball/TCollisionComponent.cpp
View file

@ -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;
}

8
SpaceCadetPinball/TCollisionComponent.h
View file

@ -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);
};

2
SpaceCadetPinball/TDemo.cpp
View file

@ -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;

2
SpaceCadetPinball/TDemo.h
View file

@ -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);

2
SpaceCadetPinball/TDrain.cpp
View file

@ -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;

2
SpaceCadetPinball/TDrain.h
View file

@ -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);

4
SpaceCadetPinball/TEdgeManager.cpp
View file

@ -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];

2
SpaceCadetPinball/TEdgeManager.h
View file

@ -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);

2
SpaceCadetPinball/TEdgeSegment.cpp
View file

@ -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;

4
SpaceCadetPinball/TFlagSpinner.cpp
View file

@ -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;

2
SpaceCadetPinball/TFlagSpinner.h
View file

@ -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;

2
SpaceCadetPinball/TFlipper.cpp
View file

@ -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)
{
}

2
SpaceCadetPinball/TFlipper.h
View file

@ -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);

8
SpaceCadetPinball/TFlipperEdge.cpp
View file

@ -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 &&

22
SpaceCadetPinball/TFlipperEdge.h
View file

@ -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;
};

6
SpaceCadetPinball/THole.cpp
View file

@ -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)
{

4
SpaceCadetPinball/THole.h
View file

@ -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);

2
SpaceCadetPinball/TKickback.cpp
View file

@ -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)

2
SpaceCadetPinball/TKickback.h
View file

@ -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);

6
SpaceCadetPinball/TKickout.cpp
View file

@ -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;

4
SpaceCadetPinball/TKickout.h
View file

@ -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);

2
SpaceCadetPinball/TLightRollover.cpp
View file

@ -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;

2
SpaceCadetPinball/TLightRollover.h
View file

@ -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);

4
SpaceCadetPinball/TLine.cpp
View file

@ -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;

2
SpaceCadetPinball/TLine.h
View file

@ -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;

4
SpaceCadetPinball/TOneway.cpp
View file

@ -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)
{

2
SpaceCadetPinball/TOneway.h
View file

@ -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;

2
SpaceCadetPinball/TPinballTable.cpp
View file

@ -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)

2
SpaceCadetPinball/TPlunger.cpp
View file

@ -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);

2
SpaceCadetPinball/TPlunger.h
View file

@ -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;

2
SpaceCadetPinball/TPopupTarget.cpp
View file

@ -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)

2
SpaceCadetPinball/TPopupTarget.h
View file

@ -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);

8
SpaceCadetPinball/TRamp.cpp
View file

@ -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;

4
SpaceCadetPinball/TRamp.h
View file

@ -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]{};

2
SpaceCadetPinball/TRollover.cpp
View file

@ -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;

2
SpaceCadetPinball/TRollover.h
View file

@ -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;

2
SpaceCadetPinball/TSink.cpp
View file

@ -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)

4
SpaceCadetPinball/TSink.h
View file

@ -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;

2
SpaceCadetPinball/TSoloTarget.cpp
View file

@ -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))

2
SpaceCadetPinball/TSoloTarget.h
View file

@ -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);

4
SpaceCadetPinball/TTableLayer.cpp
View file

@ -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;

2
SpaceCadetPinball/TTableLayer.h
View file

@ -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);

2
SpaceCadetPinball/TTripwire.cpp
View file

@ -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;

2
SpaceCadetPinball/TTripwire.h
View file

@ -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;
};

2
SpaceCadetPinball/TWall.cpp
View file

@ -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))
{

2
SpaceCadetPinball/TWall.h
View file

@ -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;

28
SpaceCadetPinball/maths.cpp
View file

@ -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;

50
SpaceCadetPinball/maths.h
View file

@ -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);
};

2
SpaceCadetPinball/nudge.cpp
View file

@ -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;

4
SpaceCadetPinball/pb.cpp
View file

@ -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)
{