mirror of
https://github.com/k4zmu2a/SpaceCadetPinball.git
synced 2024-09-04 12:59:38 +02:00
Cleaning up maths: part 2.
Renamed vector2.
This commit is contained in:
parent
d23444b983
commit
2d0da712e3
@ -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]{};
|
||||
|
@ -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))
|
||||
{
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
}
|
||||
|
@ -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);
|
||||
};
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
@ -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];
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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 &&
|
||||
|
@ -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;
|
||||
};
|
||||
|
@ -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)
|
||||
{
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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)
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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)
|
||||
{
|
||||
|
@ -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;
|
||||
|
@ -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)
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
||||
|
@ -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)
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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]{};
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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)
|
||||
|
@ -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;
|
||||
|
@ -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))
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
};
|
||||
|
@ -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))
|
||||
{
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
};
|
||||
|
@ -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;
|
||||
|
@ -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)
|
||||
{
|
||||
|
Loading…
Reference in New Issue
Block a user