administration/SpaceCadetPinball
1
0
Fork 0
mirror of https://github.com/k4zmu2a/SpaceCadetPinball.git synced 2023-12-30 21:52:56 +00:00
Code Issues Projects Releases Wiki Activity

midi ready, TCollision cleanup.

Browse Source
This commit is contained in:
oz 2021-01-23 13:33:30 +03:00
parent 683e823193
commit 7d15427dd9
28 changed files with 215 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Doc/FuncStats.xlsx
View File

Binary file not shown.

2
SpaceCadetPinball/TBlocker.cpp
View File

@ -17,7 +17,7 @@ TBlocker::TBlocker(TPinballTable* table, int groupIndex) : TCollisionComponent(t
SoundIndex3 = visual.SoundIndex3;
TurnOnMsgValue = 55;
TurnOffMsgValue = 5;
MaxCollisionSpeed = 1000000000.0f;
Threshold = 1000000000.0f;
Timer = 0;
MessageField = 0;
UnknownBaseFlag2 = 0;

6
SpaceCadetPinball/TBumper.cpp
View File

@ -19,7 +19,7 @@ TBumper::TBumper(TPinballTable* table, int groupIndex) : TCollisionComponent(tab
loader::query_visual(groupIndex, 0, &visual);
SoundIndex4 = visual.SoundIndex4;
SoundIndex3 = visual.SoundIndex3;
MaxCollisionSpeed2 = MaxCollisionSpeed;
OriginalThreshold = Threshold;
}
int TBumper::Message(int code, float value)
@ -133,7 +133,7 @@ void TBumper::TimerExpired(int timerId, void* caller)
zMap,
bmp->XPosition - bump->PinballTable->XOffset,
bmp->YPosition - bump->PinballTable->YOffset);
bump->MaxCollisionSpeed = bump->MaxCollisionSpeed2;
bump->Threshold = bump->OriginalThreshold;
}
void TBumper::Fire()
@ -148,5 +148,5 @@ void TBumper::Fire()
bmp->XPosition - PinballTable->XOffset,
bmp->YPosition - PinballTable->YOffset);
Timer = timer::set(TimerTime, this, TimerExpired);
MaxCollisionSpeed = 1000000000.0;
Threshold = 1000000000.0;
}

2
SpaceCadetPinball/TBumper.h
View File

@ -25,7 +25,7 @@ public:
int BmpIndex;
int Timer;
float TimerTime;
float MaxCollisionSpeed2;
float OriginalThreshold;
int SoundIndex4;
int SoundIndex3;
int Scores[4];

44
SpaceCadetPinball/TCollisionComponent.cpp
View File

@ -31,12 +31,12 @@ TCollisionComponent::TCollisionComponent(TPinballTable* table, int groupIndex, b
}
}
MaxCollisionSpeed = visual.Kicker.Unknown1F;
UnknownC4F = visual.Unknown2F;
UnknownC5F = visual.Unknown1F;
CollisionMultiplier = visual.Kicker.Unknown2F;
SoundIndex1 = visual.Kicker.SoundIndex;
SoundIndex2 = visual.SoundIndex2;
Threshold = visual.Kicker.Threshold;
Elasticity = visual.Elasticity;
Smoothness = visual.Smoothness;
Boost = visual.Kicker.Boost;
HardHitSoundId = visual.Kicker.HardHitSoundId;
SoftHitSoundId = visual.SoftHitSoundId;
GroupIndex = groupIndex;
}
@ -64,23 +64,21 @@ int TCollisionComponent::DefaultCollision(TBall* ball, vector_type* nextPosition
{
if (PinballTable->TiltLockFlag)
{
maths::basic_collision(ball, nextPosition, direction, UnknownC4F, UnknownC5F, 1000000000.0, 0.0);
maths::basic_collision(ball, nextPosition, direction, Elasticity, Smoothness, 1000000000.0, 0.0);
return 0;
}
auto projSpeed = maths::basic_collision(ball, nextPosition, direction, UnknownC4F, UnknownC5F,
MaxCollisionSpeed,
CollisionMultiplier);
if (projSpeed <= MaxCollisionSpeed)
auto projSpeed = maths::basic_collision(ball, nextPosition, direction, Elasticity, Smoothness, Threshold, Boost);
if (projSpeed <= Threshold)
{
if (projSpeed > 0.2)
{
if (SoundIndex2)
loader::play_sound(SoundIndex2);
if (SoftHitSoundId)
loader::play_sound(SoftHitSoundId);
}
return 0;
}
if (SoundIndex1)
loader::play_sound(SoundIndex1);
if (HardHitSoundId)
loader::play_sound(HardHitSoundId);
return 1;
}
@ -91,26 +89,26 @@ void TCollisionComponent::Collision(TBall* ball, vector_type* nextPosition, vect
if (PinballTable->TiltLockFlag)
{
maths::basic_collision(ball, nextPosition, direction, UnknownC4F, UnknownC5F, 1000000000.0, 0.0);
maths::basic_collision(ball, nextPosition, direction, Elasticity, Smoothness, 1000000000.0, 0.0);
return;
}
double projSpeed = maths::basic_collision(
ball,
nextPosition,
direction,
UnknownC4F,
UnknownC5F,
MaxCollisionSpeed,
CollisionMultiplier);
if (projSpeed <= MaxCollisionSpeed)
Elasticity,
Smoothness,
Threshold,
Boost);
if (projSpeed <= Threshold)
{
if (projSpeed <= 0.2)
return;
soundIndex = SoundIndex2;
soundIndex = SoftHitSoundId;
}
else
{
soundIndex = SoundIndex1;
soundIndex = HardHitSoundId;
}
if (soundIndex)
loader::play_sound(soundIndex);

14
SpaceCadetPinball/TCollisionComponent.h
View File

@ -10,14 +10,12 @@ class TCollisionComponent : public TPinballComponent
{
public:
objlist_class* EdgeList;
__int16 UnknownC2;
__int16 UnknownC3;
float UnknownC4F;
float UnknownC5F;
float CollisionMultiplier;
float MaxCollisionSpeed;
int SoundIndex2;
int SoundIndex1;
float Elasticity;
float Smoothness;
float Boost;
float Threshold;
int SoftHitSoundId;
int HardHitSoundId;
TCollisionComponent(TPinballTable* table, int groupIndex, bool createWall);
~TCollisionComponent() override;

4
SpaceCadetPinball/TFlagSpinner.cpp
View File

@ -118,8 +118,8 @@ void TFlagSpinner::NextFrame()
if (!PinballTable->TiltLockFlag)
{
control::handler(63, this);
if (SoundIndex2)
loader::play_sound(SoundIndex2);
if (SoftHitSoundId)
loader::play_sound(SoftHitSoundId);
if (!BmpIndex)
control::handler(62, this);
}

16
SpaceCadetPinball/TFlipper.cpp
View File

@ -15,11 +15,11 @@ TFlipper::TFlipper(TPinballTable* table, int groupIndex) : TCollisionComponent(t
visualStruct visual{};
loader::query_visual(groupIndex, 0, &visual);
SoundIndex1 = visual.SoundIndex4;
SoundIndex2 = visual.SoundIndex3;
UnknownC4F = visual.Unknown2F;
HardHitSoundId = visual.SoundIndex4;
SoftHitSoundId = visual.SoundIndex3;
Elasticity = visual.Elasticity;
Timer = 0;
UnknownC5F = visual.Unknown1F;
Smoothness = visual.Smoothness;
auto floatArr = loader::query_float_attribute(groupIndex, 0, 803);
auto floatArr2 = loader::query_float_attribute(groupIndex, 0, 805);
@ -41,8 +41,8 @@ TFlipper::TFlipper(TPinballTable* table, int groupIndex) : TCollisionComponent(t
bmpCoef1,
bmpCoef2,
collMult,
UnknownC4F,
UnknownC5F);
Elasticity,
Smoothness);
FlipperEdge = flipperEdge;
if (flipperEdge)
@ -69,12 +69,12 @@ int TFlipper::Message(int code, float value)
{
control::handler(1, this);
TimerTime = BmpCoef1;
soundIndex = SoundIndex1;
soundIndex = HardHitSoundId;
}
else if (code == 2)
{
TimerTime = BmpCoef2;
soundIndex = SoundIndex2;
soundIndex = SoftHitSoundId;
}
else
{

28
SpaceCadetPinball/TFlipperEdge.cpp
View File

@ -13,12 +13,12 @@ circle_type TFlipperEdge::circlebase, TFlipperEdge::circleT1;
TFlipperEdge::TFlipperEdge(TCollisionComponent* collComp, char* someFlag, unsigned int visualFlag, TPinballTable* table,
vector_type* origin, vector_type* vecT1, vector_type* vecT2, float bmpCoef1, float bmpCoef2,
float collMult, float c4F, float c5F): TEdgeSegment(collComp, someFlag, visualFlag)
float collMult, float elasticity, float smoothness): TEdgeSegment(collComp, someFlag, visualFlag)
{
vector_type crossProd{}, vecDir1{}, vecDir2{};
CollisionC4F = c4F;
CollisionC5F = c5F;
Elasticity = elasticity;
Smoothness = smoothness;
BmpCoef1 = bmpCoef1;
BmpCoef2 = bmpCoef2;
CollisionMult = collMult;
@ -304,7 +304,7 @@ void TFlipperEdge::EdgeCollision(TBall* ball, float coef)
EdgeCollisionFlag = 1;
if (!FlipperFlag || !CollisionFlag2 || CollisionFlag1)
{
float collMult = 0.0;
float boost = 0.0;
if (CollisionFlag1)
{
float dx = NextBallPosition.X - RotOrigin.X;
@ -319,31 +319,31 @@ void TFlipperEdge::EdgeCollision(TBall* ball, float coef)
v11 = dot1 * v20;
else
v11 = 0.0;
collMult = v11 * CollisionMult;
boost = v11 * CollisionMult;
}
}
float maxSpeed = collMult <= 0.0 ? 1000000000.0f : -1.0f;
float threshold = boost <= 0.0 ? 1000000000.0f : -1.0f;
maths::basic_collision(
ball,
&NextBallPosition,
&CollisionDirection,
CollisionC4F,
CollisionC5F,
maxSpeed,
collMult);
Elasticity,
Smoothness,
threshold,
boost);
return;
}
float c4F;
float elasticity;
float dx = NextBallPosition.X - RotOrigin.X;
float dy = NextBallPosition.Y - RotOrigin.Y;
float distance = dy * dy + dx * dx;
if (circlebase.RadiusSq * 1.01 < distance)
c4F = (1.0f - sqrt(distance / DistanceDivSq)) * CollisionC4F;
elasticity = (1.0f - sqrt(distance / DistanceDivSq)) * Elasticity;
else
c4F = CollisionC4F;
maths::basic_collision(ball, &NextBallPosition, &CollisionDirection, c4F, CollisionC5F, 1000000000.0, 0.0);
elasticity = Elasticity;
maths::basic_collision(ball, &NextBallPosition, &CollisionDirection, elasticity, Smoothness, 1000000000.0, 0.0);
}
void TFlipperEdge::place_in_grid()

6
SpaceCadetPinball/TFlipperEdge.h
View File

@ -9,7 +9,7 @@ class TFlipperEdge : public TEdgeSegment
public:
TFlipperEdge(TCollisionComponent* collComp, char* someFlag, unsigned int visualFlag, TPinballTable* table,
vector_type* origin, vector_type* vecT1, vector_type* vecT2, float bmpCoef1, float bmpCoef2, float collMult,
float c4F, float c5F);
float elasticity, float smoothness);
void port_draw() override;
float FindCollisionDistance(ray_type* ray) override;
void EdgeCollision(TBall* ball, float coef) override;
@ -21,8 +21,8 @@ public:
void SetMotion(int code, float value);
int FlipperFlag;
float CollisionC4F;
float CollisionC5F;
float Elasticity;
float Smoothness;
vector_type RotOrigin;
float CirclebaseRadius;
float CircleT1Radius;

6
SpaceCadetPinball/THole.cpp
View File

@ -78,7 +78,7 @@ void THole::Collision(TBall* ball, vector_type* nextPosition, vector_type* direc
if (!BallCapturedFlag)
{
BallCapturedSecondStage = 0;
MaxCollisionSpeed = 1000000000.0;
Threshold = 1000000000.0;
BallCapturedFlag = 1;
ball->CollisionComp = this;
ball->Position.X = Circle.Center.X;
@ -87,7 +87,7 @@ void THole::Collision(TBall* ball, vector_type* nextPosition, vector_type* direc
Timer = timer::set(0.5f, this, TimerExpired);
if (!PinballTable->TiltLockFlag)
{
loader::play_sound(SoundIndex1);
loader::play_sound(HardHitSoundId);
control::handler(57, this);
}
}
@ -115,7 +115,7 @@ int THole::FieldEffect(TBall* ball, vector_type* vecDst)
ball->CollisionComp = nullptr;
ball->Acceleration.X = 0.0;
ball->Speed = 0.0;
loader::play_sound(SoundIndex2);
loader::play_sound(SoftHitSoundId);
control::handler(58, this);
}
}

14
SpaceCadetPinball/TKickback.cpp
View File

@ -17,7 +17,7 @@ TKickback::TKickback(TPinballTable* table, int groupIndex): TCollisionComponent(
ActiveFlag = 0;
TimerTime = 0.69999999f;
TimerTime2 = 0.1f;
MaxCollisionSpeed = 1000000000.0f;
Threshold = 1000000000.0f;
}
int TKickback::Message(int code, float value)
@ -29,7 +29,7 @@ int TKickback::Message(int code, float value)
render::sprite_set_bitmap(RenderSprite, nullptr);
Timer = 0;
ActiveFlag = 0;
MaxCollisionSpeed = 1000000000.0;
Threshold = 1000000000.0;
}
return 0;
}
@ -39,14 +39,14 @@ void TKickback::Collision(TBall* ball, vector_type* nextPosition, vector_type* d
{
if (PinballTable->TiltLockFlag)
{
maths::basic_collision(ball, nextPosition, direction, UnknownC4F, UnknownC5F, 0.0,
CollisionMultiplier);
maths::basic_collision(ball, nextPosition, direction, Elasticity, Smoothness, 0.0,
Boost);
}
else
{
if (!ActiveFlag)
{
MaxCollisionSpeed = 1000000000.0;
Threshold = 1000000000.0;
ActiveFlag = 1;
Timer = timer::set(TimerTime, this, TimerExpired);
}
@ -61,9 +61,9 @@ void TKickback::TimerExpired(int timerId, void* caller)
if (kick->ActiveFlag)
{
kick->MaxCollisionSpeed = 0.0;
kick->Threshold = 0.0;
kick->Timer = timer::set(kick->TimerTime2, kick, TimerExpired);
loader::play_sound(kick->SoundIndex1);
loader::play_sound(kick->HardHitSoundId);
if (kick->ListBitmap)
{
auto bmp = static_cast<gdrv_bitmap8*>(kick->ListBitmap->Get(1));

20
SpaceCadetPinball/TKickout.cpp
View File

@ -27,8 +27,8 @@ TKickout::TKickout(TPinballTable* table, int groupIndex, bool someFlag): TCollis
KickFlag1 = 0;
FieldMult = *loader::query_float_attribute(groupIndex, 0, 305);
loader::query_visual(groupIndex, 0, &visual);
SoundIndex2 = visual.SoundIndex2;
SoundIndex1 = visual.Kicker.SoundIndex;
SoftHitSoundId = visual.SoftHitSoundId;
HardHitSoundId = visual.Kicker.HardHitSoundId;
Circle.Center.X = *visual.FloatArr;
Circle.Center.Y = visual.FloatArr[1];
@ -45,12 +45,10 @@ TKickout::TKickout(TPinballTable* table, int groupIndex, bool someFlag): TCollis
Circle.RadiusSq = visual.FloatArr[2] * visual.FloatArr[2];
CollisionBallSetZ = loader::query_float_attribute(groupIndex, 0, 408)[2];
ThrowSpeedMult2 = visual.Kicker.Unknown3F * 0.01f;
BallAcceleration.X = visual.Kicker.Unknown4F;
BallAcceleration.Y = visual.Kicker.Unknown5F;
BallAcceleration.Z = visual.Kicker.Unknown6F;
ThrowAngleMult = visual.Kicker.Unknown7F;
ThrowSpeedMult1 = visual.Kicker.Unknown2F;
ThrowSpeedMult2 = visual.Kicker.ThrowBallMult * 0.01f;
BallAcceleration = visual.Kicker.ThrowBallAcceleration;
ThrowAngleMult = visual.Kicker.ThrowBallAngleMult;
ThrowSpeedMult1 = visual.Kicker.Boost;
circle.RadiusSq = Circle.RadiusSq;
circle.Center.X = Circle.Center.X;
@ -111,7 +109,7 @@ void TKickout::Collision(TBall* ball, vector_type* nextPosition, vector_type* di
if (!KickFlag1)
{
Ball = ball;
MaxCollisionSpeed = 1000000000.0;
Threshold = 1000000000.0;
KickFlag1 = 1;
ball->CollisionComp = this;
ball->Position.X = Circle.Center.X;
@ -124,7 +122,7 @@ void TKickout::Collision(TBall* ball, vector_type* nextPosition, vector_type* di
}
else
{
loader::play_sound(SoundIndex2);
loader::play_sound(SoftHitSoundId);
control::handler(63, this);
}
}
@ -160,7 +158,7 @@ void TKickout::TimerExpired(int timerId, void* caller)
kick->ThrowSpeedMult2);
kick->UnknownBaseFlag2 = 0;
kick->Ball = nullptr;
loader::play_sound(kick->SoundIndex1);
loader::play_sound(kick->HardHitSoundId);
}
}
}

2
SpaceCadetPinball/TLightRollover.cpp
View File

@ -54,7 +54,7 @@ void TLightRollover::Collision(TBall* ball, vector_type* nextPosition, vector_ty
}
else
{
loader::play_sound(SoundIndex2);
loader::play_sound(SoftHitSoundId);
control::handler(63, this);
RolloverFlag = RolloverFlag == 0;
if (ListBitmap)

18
SpaceCadetPinball/TOneway.cpp
View File

@ -51,26 +51,26 @@ void TOneway::Collision(TBall* ball, vector_type* nextPosition, vector_type* dir
ball->RayMaxDistance -= coef;
if (!PinballTable->TiltLockFlag)
{
if (SoundIndex1)
loader::play_sound(SoundIndex1);
if (HardHitSoundId)
loader::play_sound(HardHitSoundId);
control::handler(63, this);
}
}
else if (PinballTable->TiltLockFlag)
{
maths::basic_collision(ball, nextPosition, direction, UnknownC4F, UnknownC5F, 1000000000.0, 0.0);
maths::basic_collision(ball, nextPosition, direction, Elasticity, Smoothness, 1000000000.0, 0.0);
}
else if (maths::basic_collision(
ball,
nextPosition,
direction,
UnknownC4F,
UnknownC5F,
MaxCollisionSpeed,
CollisionMultiplier) > 0.2)
Elasticity,
Smoothness,
Threshold,
Boost) > 0.2)
{
if (SoundIndex2)
loader::play_sound(SoundIndex2);
if (SoftHitSoundId)
loader::play_sound(SoftHitSoundId);
}
}

40
SpaceCadetPinball/TPlunger.cpp
View File

@ -17,16 +17,16 @@ TPlunger::TPlunger(TPinballTable* table, int groupIndex) : TCollisionComponent(t
visualStruct visual{};
loader::query_visual(groupIndex, 0, &visual);
CollisionMultiplier = 0.0;
Boost = 0.0;
BallFeedTimer_ = 0;
PullbackTimer_ = 0;
SoundIndexP1 = visual.SoundIndex4;
SoundIndexP2 = visual.SoundIndex3;
SoundIndex1 = visual.Kicker.SoundIndex;
MaxCollisionSpeed = 1000000000.0;
HardHitSoundId = visual.Kicker.HardHitSoundId;
Threshold = 1000000000.0;
MaxPullback = 100;
UnknownC4F = 0.5f;
UnknownC5F = 0.5f;
Elasticity = 0.5f;
Smoothness = 0.5f;
PullbackIncrement = static_cast<int>(100.0 / (ListBitmap->Count() * 8.0));
Unknown4F = 0.025f;
float* floatArr = loader::query_float_attribute(groupIndex, 0, 601);
@ -38,8 +38,8 @@ void TPlunger::Collision(TBall* ball, vector_type* nextPosition, vector_type* di
{
if (PinballTable->TiltLockFlag)
Message(1017, 0.0);
coef = static_cast<float>(rand()) * 0.00003051850947599719f * CollisionMultiplier * 0.1f + CollisionMultiplier;
maths::basic_collision(ball, nextPosition, direction, UnknownC4F, UnknownC5F, MaxCollisionSpeed, coef);
coef = static_cast<float>(rand()) * 0.00003051850947599719f * Boost * 0.1f + Boost;
maths::basic_collision(ball, nextPosition, direction, Elasticity, Smoothness, Threshold, coef);
}
int TPlunger::Message(int code, float value)
@ -49,9 +49,9 @@ int TPlunger::Message(int code, float value)
case 1004:
if (!PullbackTimer_)
{
CollisionMultiplier = 0.0;
MaxCollisionSpeed = 1000000000.0;
loader::play_sound(SoundIndex1);
Boost = 0.0;
Threshold = 1000000000.0;
loader::play_sound(HardHitSoundId);
PullbackTimer(0, this);
}
return 0;
@ -59,7 +59,7 @@ int TPlunger::Message(int code, float value)
case 1009:
case 1010:
{
MaxCollisionSpeed = 0.0;
Threshold = 0.0;
if (PullbackTimer_)
timer::kill(PullbackTimer_);
PullbackTimer_ = 0;
@ -97,8 +97,8 @@ int TPlunger::Message(int code, float value)
control::handler(code, this);
return 0;
case 1017:
MaxCollisionSpeed = 0.0;
CollisionMultiplier = static_cast<float>(MaxPullback);
Threshold = 0.0;
Boost = static_cast<float>(MaxPullback);
timer::set(0.2f, this, PlungerReleasedTimer);
break;
case 1024:
@ -106,7 +106,7 @@ int TPlunger::Message(int code, float value)
if (BallFeedTimer_)
timer::kill(BallFeedTimer_);
BallFeedTimer_ = 0;
MaxCollisionSpeed = 0.0;
Threshold = 0.0;
if (PullbackTimer_)
timer::kill(PullbackTimer_);
PullbackTimer_ = 0;
@ -140,19 +140,19 @@ void TPlunger::BallFeedTimer(int timerId, void* caller)
void TPlunger::PullbackTimer(int timerId, void* caller)
{
auto plunger = static_cast<TPlunger*>(caller);
plunger->CollisionMultiplier += static_cast<float>(plunger->PullbackIncrement);
if (plunger->CollisionMultiplier <= static_cast<float>(plunger->MaxPullback))
plunger->Boost += static_cast<float>(plunger->PullbackIncrement);
if (plunger->Boost <= static_cast<float>(plunger->MaxPullback))
{
plunger->PullbackTimer_ = timer::set(plunger->Unknown4F, plunger, PullbackTimer);
}
else
{
plunger->PullbackTimer_ = 0;
plunger->CollisionMultiplier = static_cast<float>(plunger->MaxPullback);
plunger->Boost = static_cast<float>(plunger->MaxPullback);
}
int index = static_cast<int>(floor(
static_cast<float>(plunger->ListBitmap->Count() - 1) *
(plunger->CollisionMultiplier / static_cast<float>(plunger->MaxPullback))));
(plunger->Boost / static_cast<float>(plunger->MaxPullback))));
auto bmp = static_cast<gdrv_bitmap8*>(plunger->ListBitmap->Get(index));
auto zMap = static_cast<zmap_header_type*>(plunger->ListZMap->Get(index));
render::sprite_set(
@ -166,6 +166,6 @@ void TPlunger::PullbackTimer(int timerId, void* caller)
void TPlunger::PlungerReleasedTimer(int timerId, void* caller)
{
auto plunger = static_cast<TPlunger*>(caller);
plunger->MaxCollisionSpeed = 1000000000.0;
plunger->CollisionMultiplier = 0.0;
plunger->Threshold = 1000000000.0;
plunger->Boost = 0.0;
}

18
SpaceCadetPinball/TPopupTarget.cpp
View File

@ -68,19 +68,19 @@ void TPopupTarget::Collision(TBall* ball, vector_type* nextPosition, vector_type
{
if (this->PinballTable->TiltLockFlag)
{
maths::basic_collision(ball, nextPosition, direction, this->UnknownC4F, this->UnknownC5F, 1000000000.0, 0.0);
maths::basic_collision(ball, nextPosition, direction, this->Elasticity, this->Smoothness, 1000000000.0, 0.0);
}
else if (maths::basic_collision(
ball,
nextPosition,
direction,
this->UnknownC4F,
this->UnknownC5F,
this->MaxCollisionSpeed,
this->CollisionMultiplier) > this->MaxCollisionSpeed)
this->Elasticity,
this->Smoothness,
this->Threshold,
this->Boost) > this->Threshold)
{
if (this->SoundIndex1)
loader::play_sound(this->SoundIndex1);
if (this->HardHitSoundId)
loader::play_sound(this->HardHitSoundId);
this->Message(49, 0.0);
control::handler(63, this);
}
@ -94,7 +94,7 @@ void TPopupTarget::TimerExpired(int timerId, void* caller)
render::sprite_set_bitmap(target->RenderSprite, static_cast<gdrv_bitmap8*>(target->ListBitmap->Get(0)));
if (timerId)
{
if (target->SoundIndex2)
loader::play_sound(target->SoundIndex2);
if (target->SoftHitSoundId)
loader::play_sound(target->SoftHitSoundId);
}
}

2
SpaceCadetPinball/TRamp.cpp
View File

@ -189,7 +189,7 @@ void TRamp::Collision(TBall* ball, vector_type* nextPosition, vector_type* direc
{
if (!PinballTable->TiltLockFlag)
{
loader::play_sound(SoundIndex2);
loader::play_sound(SoftHitSoundId);
control::handler(63, this);
}
}

2
SpaceCadetPinball/TRollover.cpp
View File

@ -56,7 +56,7 @@ void TRollover::Collision(TBall* ball, vector_type* nextPosition, vector_type* d
}
else
{
loader::play_sound(SoundIndex2);
loader::play_sound(SoftHitSoundId);
control::handler(63, this);
}
RolloverFlag = RolloverFlag == 0;

12
SpaceCadetPinball/TSink.cpp
View File

@ -17,12 +17,10 @@ TSink::TSink(TPinballTable* table, int groupIndex) : TCollisionComponent(table,
MessageField = 0;
Timer = 0;
loader::query_visual(groupIndex, 0, &visual);
BallAcceleration.X = visual.Kicker.Unknown4F;
BallAcceleration.Y = visual.Kicker.Unknown5F;
BallAcceleration.Z = visual.Kicker.Unknown6F;
ThrowAngleMult = visual.Kicker.Unknown7F;
ThrowSpeedMult1 = visual.Kicker.Unknown2F;
ThrowSpeedMult2 = visual.Kicker.Unknown3F * 0.01f;
BallAcceleration = visual.Kicker.ThrowBallAcceleration;
ThrowAngleMult = visual.Kicker.ThrowBallAngleMult;
ThrowSpeedMult1 = visual.Kicker.Boost;
ThrowSpeedMult2 = visual.Kicker.ThrowBallMult * 0.01f;
SoundIndex4 = visual.SoundIndex4;
SoundIndex3 = visual.SoundIndex3;
auto floatArr = loader::query_float_attribute(groupIndex, 0, 601);
@ -83,7 +81,7 @@ void TSink::Collision(TBall* ball, vector_type* nextPosition, vector_type* direc
Timer = 0;
if (PinballTable->TiltLockFlag)
{
maths::basic_collision(ball, nextPosition, direction, UnknownC4F, UnknownC5F, 1000000000.0, 0.0);
maths::basic_collision(ball, nextPosition, direction, Elasticity, Smoothness, 1000000000.0, 0.0);
}
else
{

6
SpaceCadetPinball/TTableLayer.cpp
View File

@ -33,7 +33,7 @@ TTableLayer::TTableLayer(TPinballTable* table): TCollisionComponent(table, -1, f
PinballTable->SoundIndex1 = visual.SoundIndex4;
PinballTable->SoundIndex2 = visual.SoundIndex3;
PinballTable->SoundIndex3 = visual.Kicker.SoundIndex;
PinballTable->SoundIndex3 = visual.Kicker.HardHitSoundId;
auto tableAngleArr = loader::query_float_attribute(groupIndex, 0, 305);
if (tableAngleArr)
@ -62,8 +62,8 @@ TTableLayer::TTableLayer(TPinballTable* table): TCollisionComponent(table, -1, f
table->YOffset = bmp->YPosition;
table->Width = bmp->Width;
table->Height = bmp->Height;
MaxCollisionSpeed = visual.Kicker.Unknown1F;
CollisionMultiplier = 15.0f;
Threshold = visual.Kicker.Threshold;
Boost = 15.0f;
auto visArrPtr = visual.FloatArr;
Unknown1F = min(visArrPtr[0], min(visArrPtr[2], visArrPtr[4]));

2
SpaceCadetPinball/TTripwire.cpp
View File

@ -19,7 +19,7 @@ void TTripwire::Collision(TBall* ball, vector_type* nextPosition, vector_type* d
ball->not_again(edge);
if (!PinballTable->TiltLockFlag)
{
loader::play_sound(SoundIndex2);
loader::play_sound(SoftHitSoundId);
control::handler(63, this);
}
}

35
SpaceCadetPinball/loader.cpp
View File

@ -85,12 +85,12 @@ int loader::error(int errorCode, int captionCode)
void loader::default_vsi(visualStruct* visual)
{
visual->Flag = 0;
visual->Kicker.Unknown1F = 8.9999999e10f;
visual->Kicker.SoundIndex = 0;
visual->Unknown1F = 0.94999999f;
visual->Unknown2F = 0.60000002f;
visual->Kicker.Threshold = 8.9999999e10f;
visual->Kicker.HardHitSoundId = 0;
visual->Smoothness = 0.94999999f;
visual->Elasticity = 0.60000002f;
visual->FloatArrCount = 0;
visual->SoundIndex2 = 0;
visual->SoftHitSoundId = 0;
visual->Bitmap = 0;
visual->ZMap = 0;
visual->SoundIndex3 = 0;
@ -301,13 +301,13 @@ int loader::material(int groupIndex, visualStruct* visual)
switch (static_cast<int>(floor(*floatArr)))
{
case 301:
visual->Unknown1F = *nextFloatVal;
visual->Smoothness = *nextFloatVal;
break;
case 302:
visual->Unknown2F = *nextFloatVal;
visual->Elasticity = *nextFloatVal;
break;
case 304:
visual->SoundIndex2 = get_sound_id((int)floor(*nextFloatVal));
visual->SoftHitSoundId = get_sound_id((int)floor(*nextFloatVal));
break;
default:
return error(9, 21);
@ -379,25 +379,24 @@ int loader::kicker(int groupIndex, visualKickerStruct* kicker)
switch (floorVal)
{
case 401:
kicker->Unknown1F = *floatArr;
kicker->Threshold = *floatArr;
break;
case 402:
kicker->Unknown2F = *floatArr;
kicker->Boost = *floatArr;
break;
case 403:
kicker->Unknown3F = *floatArr;
kicker->ThrowBallMult = *floatArr;
break;
case 404:
kicker->Unknown4F = *floatArr++;
kicker->Unknown5F = *floatArr++;
kicker->Unknown6F = *floatArr++;
kicker->ThrowBallAcceleration = *reinterpret_cast<vector_type*>(floatArr);
floatArr += 3;
index += 4;
break;
case 405:
kicker->Unknown7F = *floatArr;
kicker->ThrowBallAngleMult = *floatArr;
break;
case 406:
kicker->SoundIndex = get_sound_id(static_cast<int>(floor(*floatArr)));
kicker->HardHitSoundId = get_sound_id(static_cast<int>(floor(*floatArr)));
break;
default:
return error(10, 20);
@ -472,7 +471,7 @@ int loader::query_visual(int groupIndex, int groupIndexOffset, visualStruct* vi
{
if (shortVal == 406)
{
visual2->Kicker.SoundIndex = get_sound_id(*nextShortVal);
visual2->Kicker.HardHitSoundId = get_sound_id(*nextShortVal);
}
else
{
@ -492,7 +491,7 @@ int loader::query_visual(int groupIndex, int groupIndexOffset, visualStruct* vi
}
else
{
visual2->SoundIndex2 = get_sound_id(*nextShortVal);
visual2->SoftHitSoundId = get_sound_id(*nextShortVal);
}
}
else if (material(*nextShortVal, visual2))

21
SpaceCadetPinball/loader.h
View File

@ -1,5 +1,6 @@
#pragma once
#include "gdrv.h"
#include "maths.h"
#include "zdrv.h"
@ -22,24 +23,22 @@ struct soundListStruct
struct __declspec(align(4)) visualKickerStruct
{
float Unknown1F;
float Unknown2F;
float Unknown3F;
float Unknown4F;
float Unknown5F;
float Unknown6F;
float Unknown7F;
int SoundIndex;
float Threshold;
float Boost;
float ThrowBallMult;
vector_type ThrowBallAcceleration;
float ThrowBallAngleMult;
int HardHitSoundId;
};
struct __declspec(align(4)) visualStruct
{
float Unknown1F;
float Unknown2F;
float Smoothness;
float Elasticity;
int FloatArrCount;
float* FloatArr;
int SoundIndex2;
int SoftHitSoundId;
visualKickerStruct Kicker;
int Flag;
int SoundIndex4;

19
SpaceCadetPinball/maths.cpp
View File

@ -269,9 +269,8 @@ void maths::vector_add(vector_type* vec1Dst, vector_type* vec2)
vec1Dst->Y += vec2->Y;
}
float maths::basic_collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float a4, float a5,
float maxSpeed,
float multiplier)
float maths::basic_collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float elasticity, float smoothness,
float threshold, float boost)
{
ball->Position.X = nextPosition->X;
ball->Position.Y = nextPosition->Y;
@ -284,19 +283,17 @@ float maths::basic_collision(TBall* ball, vector_type* nextPosition, vector_type
{
float dx1 = proj * direction->X;
float dy1 = proj * direction->Y;
float v17 = dx1 + ball->Acceleration.X;
float v18 = dy1 + ball->Acceleration.Y;
ball->Acceleration.X = v17 * a5 + dx1 * a4;
ball->Acceleration.Y = v18 * a5 + dy1 * a4;
ball->Acceleration.X = (dx1 + ball->Acceleration.X) * smoothness + dx1 * elasticity;
ball->Acceleration.Y = (dy1 + ball->Acceleration.Y) * smoothness + dy1 * elasticity;
normalize_2d(&ball->Acceleration);
}
float projSpeed = proj * ball->Speed;
float newSpeed = ball->Speed - (1.0f - a4) * projSpeed;
float newSpeed = ball->Speed - (1.0f - elasticity) * projSpeed;
ball->Speed = newSpeed;
if (projSpeed >= maxSpeed)
if (projSpeed >= threshold)
{
ball->Acceleration.X = newSpeed * ball->Acceleration.X + direction->X * multiplier;
ball->Acceleration.Y = newSpeed * ball->Acceleration.Y + direction->Y * multiplier;
ball->Acceleration.X = newSpeed * ball->Acceleration.X + direction->X * boost;
ball->Acceleration.Y = newSpeed * ball->Acceleration.Y + direction->Y * boost;
ball->Speed = normalize_2d(&ball->Acceleration);
}
return projSpeed;

4
SpaceCadetPinball/maths.h
View File

@ -84,8 +84,8 @@ public:
static void cross(vector_type* vec1, vector_type* vec2, vector_type* dstVec);
static float magnitude(vector_type* vec);
static void vector_add(vector_type* vec1Dst, vector_type* vec2);
static float basic_collision(TBall* ball, vector_type* nextPosition, vector_type* direction, float a4, float a5,
float maxSpeed, float multiplier);
static float basic_collision(TBall* ball, vector_type* nextPosition, vector_type* 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);

49
SpaceCadetPinball/midi.cpp
View File

@ -1,27 +1,64 @@
#include "pch.h"
#include "midi.h"
#include "pinball.h"
tagMCI_OPEN_PARMSA midi::mci_open_info;
char midi::midi_device_type[28];
HWND midi::midi_notify_hwnd;
int midi::midi_seq1_open, midi::midi_seq1_playing;
MCIERROR midi::play_pb_theme(int flag)
{
return MCIERROR();
MCI_PLAY_PARMS playParams;
MCIERROR result = 0;
music_stop();
playParams.dwFrom = 0;
playParams.dwCallback = (DWORD_PTR)midi_notify_hwnd;
if (!flag && midi_seq1_open)
{
result = mciSendCommandA(mci_open_info.wDeviceID, MCI_PLAY, MCI_FROM | MCI_NOTIFY, (DWORD_PTR)&playParams);
midi_seq1_playing = result == 0;
}
return result;
}
MCIERROR midi::music_stop()
{
return MCIERROR();
MCIERROR result = 0;
if (midi_seq1_playing)
result = mciSendCommandA(mci_open_info.wDeviceID, MCI_STOP, 0, 0);
return result;
}
int midi::music_init(HWND hwnd)
{
return 1;
mci_open_info.wDeviceID = 0;
midi_notify_hwnd = hwnd;
lstrcpyA(midi_device_type, pinball::get_rc_string(156, 0));
mci_open_info.lpstrElementName = nullptr;
mci_open_info.lpstrDeviceType = midi_device_type;
auto result = mciSendCommandA(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_NOTIFY_SUPERSEDED, (DWORD_PTR)&mci_open_info);
midi_seq1_open = result == 0;
return midi_seq1_open;
}
MCIERROR midi::restart_midi_seq(int param)
{
return MCIERROR();
MCI_PLAY_PARMS playParams;
MCIERROR result = 0;
playParams.dwFrom = 0;
playParams.dwCallback = (DWORD_PTR)midi_notify_hwnd;
if (midi_seq1_playing)
result = mciSendCommandA(mci_open_info.wDeviceID, MCI_PLAY, MCI_FROM | MCI_NOTIFY, (DWORD_PTR)&playParams);
return result;
}
MCIERROR midi::music_shutdown()
void midi::music_shutdown()
{
return MCIERROR();
if (midi_seq1_open)
mciSendCommandA(mci_open_info.wDeviceID, MCI_CLOSE, 0, 0);
midi_seq1_open = 0;
}

8
SpaceCadetPinball/midi.h
View File

@ -6,5 +6,11 @@ public:
static MCIERROR music_stop();
static int music_init(HWND hwnd);
static MCIERROR restart_midi_seq(int param);
static MCIERROR music_shutdown();
static void music_shutdown();
private:
static tagMCI_OPEN_PARMSA mci_open_info;
static char midi_device_type[28];
static HWND midi_notify_hwnd;
static int midi_seq1_open, midi_seq1_playing;
};