TPinballTable v2.

.gitignore

@@ -259,3 +259,4 @@ paket-files/
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
 *.pyc
+/Ida

SpaceCadetPinball/Sound.cpp

@@ -39,3 +39,17 @@ int Sound::AddFactor(int a1, int a2)
 {
 	return a1 + a2;
 }
+
+void Sound::PlaySoundA(int a1, int a2, int a3, unsigned short a4, short a5)
+{
+}
+
+CHAR* Sound::LoadWaveFile(LPCSTR lpName)
+{
+	return nullptr;
+}
+
+LPCVOID Sound::FreeSound(LPCVOID pMem)
+{
+	return nullptr;
+}

SpaceCadetPinball/Sound.h

@@ -11,4 +11,7 @@ public:
 	static void Close();
 	static int SubFactor(int a1, int a2);
 	static int AddFactor(int a1, int a2);
+	static void PlaySound(int a1, int a2, int a3, unsigned __int16 a4, __int16 a5);
+	static CHAR* LoadWaveFile(LPCSTR lpName);
+	static LPCVOID FreeSound(LPCVOID pMem);
 };

SpaceCadetPinball/TDemo.cpp

@@ -1,2 +1,10 @@
 #include "pch.h"
 #include "TDemo.h"
+
+#include "TPinballTable.h"
+
+TDemo::TDemo(TPinballTable* table, int groupIndex)
+	: TCollisionComponent(table, groupIndex, false)
+{
+	table->Demo = this;
+}

SpaceCadetPinball/TDemo.h

@@ -5,7 +5,5 @@ class TDemo :
 	public TCollisionComponent
 {
 public:
-	TDemo(TPinballTable* table, int groupIndex) : TCollisionComponent(table, groupIndex, false)
+	TDemo(TPinballTable* table, int groupIndex);
-	{
-	}
 };

SpaceCadetPinball/TPinballComponent.h

@@ -1,10 +1,13 @@
 #pragma once
 
-#include "control.h"
+struct render_sprite_type_struct;
-#include "render.h"
+struct component_control;
-#include "TZmapList.h"
-
 class TPinballTable;
+class TZmapList;
+
+enum class message_code
+{
+};
 
 class TPinballComponent
 {
@@ -16,7 +19,6 @@ public:
 	virtual void put_scoring(int scoreId, int value);
 	virtual int get_scoring(int score1);
 
-	int VfTable;
 	__int8 UnknownBaseFlag1;
 	__int8 UnknownBaseFlag2;
 	int MessageField;

SpaceCadetPinball/TPinballTable.cpp

@@ -5,7 +5,10 @@
 #include "control.h"
 #include "loader.h"
 #include "memory.h"
+#include "pb.h"
 #include "pinball.h"
+#include "render.h"
+#include "Sound.h"
 #include "TBall.h"
 #include "TBlocker.h"
 #include "TBumper.h"
@@ -14,6 +17,7 @@
 #include "TFlagSpinner.h"
 #include "TGate.h"
 #include "THole.h"
+#include "timer.h"
 #include "TKickback.h"
 #include "TKickout.h"
 #include "TLight.h"
@@ -32,48 +36,50 @@
 #include "TTimer.h"
 #include "TTripwire.h"
 #include "TWall.h"
+#include "TPlunger.h"
+#include "TFlipper.h"
+#include "TDrain.h"
+
+int TPinballTable::score_multipliers[5] = {1, 2, 3, 5, 10};
+
 
 TPinballTable::TPinballTable(): TPinballComponent(nullptr, -1, false)
 {
 	int shortArrLength;
 
-	//this->VfTable = (int)&TPinballTable::`vftable';
 	ListP1 = new objlist_class(32, 16);
 	ListP2 = new objlist_class(3, 1);
-	this->Score1 = nullptr;
+	CurScoreStruct = nullptr;
-	this->ScoreBallcount = nullptr;
+	ScoreBallcount = nullptr;
-	this->ScorePlayerNumber1 = nullptr;
+	ScorePlayerNumber1 = nullptr;
-	this->UnknownP10 = 0;
+	UnknownP10 = 0;
-	this->UnknownBaseFlag2 = 1;
+	UnknownBaseFlag2 = 1;
-	this->UnknownP83 = 0;
+	TiltLockFlag = 0;
-	this->UnknownP14 = 0;
+	EndGameTimeoutTimer = 0;
-	this->UnknownP13 = 0;
+	LightShowTimer = 0;
-	this->UnknownP80 = 0;
+	ReplayTimer = 0;
-	this->UnknownP15 = 0;
+	TiltTimeoutTimer = 0;
-	this->UnknownP77 = 0;
+	MultiballFlag = 0;
 
-	TBall* ballObj = new TBall(this);
+	auto ballObj = new TBall(this);
 	ListP2->Add(ballObj);
 	if (ballObj)
 		ballObj->UnknownBaseFlag2 = 0;
 	new TTableLayer(this);
-	this->LightGroup = new TLightGroup(this, 0);
+	LightGroup = new TLightGroup(this, 0);
 
 	auto score1 = score::create("score1", render::background_bitmap);
-	this->Score1 = score1;
+	CurScoreStruct = score1;
-	this->Score2 = score1;
+	PlayerScores[0].ScoreStruct = score1;
-	int scoreIndex = 1;
+	for (int scoreIndex = 1; scoreIndex < 4; scoreIndex++)
-	auto scorePtr = &this->Score3_x3_at7;
-	do
 	{
-		*scorePtr = score::dup(this->Score1, scoreIndex++);
+		PlayerScores[scoreIndex].ScoreStruct = score::dup(CurScoreStruct, scoreIndex);
-		scorePtr += 7;
 	}
-	while (scoreIndex < 4);
+
-	this->CurrentPlayer = 0;
+	CurrentPlayer = 0;
-	this->UnknownP73 = 3;
+	MaxBallCount = 3;
-	this->ScoreBallcount = (int*)score::create("ballcount1", render::background_bitmap);
+	ScoreBallcount = score::create("ballcount1", render::background_bitmap);
-	this->ScorePlayerNumber1 = (int*)score::create("player_number1", render::background_bitmap);
+	ScorePlayerNumber1 = score::create("player_number1", render::background_bitmap);
 	int groupIndexObjects = loader::query_handle("table_objects");
 
 	short* shortArr = loader::query_iattribute(groupIndexObjects, 1025, &shortArrLength);
@@ -92,17 +98,17 @@ TPinballTable::TPinballTable(): TPinballComponent(nullptr, -1, false)
 				new TWall(this, groupIndex);
 				break;
 			case 1001:
-				this->Plunger = new TPlunger(this, groupIndex);
+				Plunger = new TPlunger(this, groupIndex);
 				break;
 			case 1002:
 				new TLight(this, groupIndex);
-				//((objlist_class*)(this->LightGroup + 42))->Add(light);
+				//((objlist_class*)(LightGroup + 42))->Add(light);
 				break;
 			case 1003:
-				this->FlipperL = new TFlipper(this, groupIndex);
+				FlipperL = new TFlipper(this, groupIndex);
 				break;
 			case 1004:
-				this->FlipperR = new TFlipper(this, groupIndex);
+				FlipperR = new TFlipper(this, groupIndex);
 				break;
 			case 1005:
 				new TBumper(this, groupIndex);
@@ -111,7 +117,7 @@ TPinballTable::TPinballTable(): TPinballComponent(nullptr, -1, false)
 				new TPopupTarget(this, groupIndex);
 				break;
 			case 1007:
-				this->Drain = new TDrain(this, groupIndex);
+				Drain = new TDrain(this, groupIndex);
 				break;
 			case 1011:
 				new TBlocker(this, groupIndex);
@@ -191,19 +197,10 @@ TPinballTable::TPinballTable(): TPinballComponent(nullptr, -1, false)
 
 TPinballTable::~TPinballTable()
 {
-	scoreStruct** scorePtr = &Score2;
+	for (int scoreIndex = 0; scoreIndex < 4; scoreIndex++)
-	int index = 4;
-	do
 	{
-		if (*scorePtr)
+		memory::free(PlayerScores[scoreIndex].ScoreStruct);
-		{
-			memory::free(*scorePtr);
-			*scorePtr = nullptr;
-		}
-		scorePtr += 7;
-		--index;
 	}
-	while (index);
 	if (ScorePlayerNumber1)
 	{
 		memory::free(ScorePlayerNumber1);
@@ -260,6 +257,66 @@ TPinballComponent* TPinballTable::find_component(int groupIndex)
 	return nullptr;
 }
 
+int TPinballTable::AddScore(int score)
+{
+	if (this->ScoreSpecial3Flag)
+	{
+		this->ScoreSpecial3 += score;
+		if (this->ScoreSpecial3 > 5000000)
+			this->ScoreSpecial3 = 5000000;
+	}
+	if (this->ScoreSpecial2Flag)
+	{
+		this->ScoreSpecial2 += score;
+		if (this->ScoreSpecial2 > 5000000)
+			this->ScoreSpecial2 = 5000000;
+	}
+	int addedScore = this->ScoreAdded + score * score_multipliers[this->ScoreMultiplier];
+	this->CurScore += addedScore;
+	if (this->CurScore > 1000000000)
+	{
+		++this->CurScoreE9;
+		this->CurScore = this->CurScore - 1000000000;
+	}
+	score::set(this->CurScoreStruct, this->CurScore);
+	return addedScore;
+}
+
+void TPinballTable::ChangeBallCount(int count)
+{
+	BallCount = count;
+	if (count <= 0)
+	{
+		score::erase(ScoreBallcount, 1);
+	}
+	else
+	{
+		score::set(ScoreBallcount, MaxBallCount - count + 1);
+		score::update(ScoreBallcount);
+	}
+}
+
+void TPinballTable::tilt(float time)
+{
+	TPinballTable* this2 = this;
+	if (!this->TiltLockFlag && !this->UnknownP10)
+	{
+		pinball::InfoTextBox->Clear();
+		pinball::MissTextBox->Clear();
+		pinball::InfoTextBox->Display(pinball::get_rc_string(35, 0), -1.0);
+		loader::play_sound(this2->SoundIndex3);
+		this2->TiltTimeoutTimer = timer::set(30.0, this2, TPinballTable::tilt_timeout);
+
+		for (int i = 0; i < ListP1->Count(); i++)
+		{
+			static_cast<TPinballComponent*>(ListP1->Get(i))->Message(1011, time);
+		}
+		this2->LightGroup->Message(8, 0);
+		this2->TiltLockFlag = 1;
+		control::table_control_handler(1011);
+	}
+}
+
 
 void TPinballTable::port_draw()
 {
@@ -268,3 +325,341 @@ void TPinballTable::port_draw()
 		static_cast<TPinballComponent*>(ListP1->Get(index))->port_draw();
 	}
 }
+
+int TPinballTable::Message(int code, float value)
+{
+	LPSTR rc_text;
+	switch (code)
+	{
+	case 1000:
+		if (!TiltLockFlag)
+		{
+			FlipperL->Message(1, value);
+		}
+		break;
+	case 1001:
+		if (!TiltLockFlag)
+		{
+			FlipperL->Message(2, value);
+		}
+		break;
+	case 1002:
+		if (!TiltLockFlag)
+		{
+			FlipperR->Message(1, value);
+		}
+		break;
+	case 1003:
+		if (!TiltLockFlag)
+		{
+			FlipperR->Message(2, value);
+		}
+		break;
+	case 1004:
+	case 1005:
+		Plunger->Message(code, value);
+		break;
+	case 1008:
+	case 1009:
+	case 1010:
+		for (int i = 0; i < ListP1->Count(); i++)
+		{
+			static_cast<TPinballComponent*>(ListP1->Get(i))->Message(code, value);
+		}
+		break;
+	case 1012:
+		LightGroup->Message(14, 0.0);
+		if (TiltLockFlag)
+		{
+			TiltLockFlag = 0;
+			if (TiltTimeoutTimer)
+				timer::kill(TiltTimeoutTimer);
+			TiltTimeoutTimer = 0;
+		}
+		break;
+	case 1013:
+		LightGroup->Message(34, 0.0);
+		LightGroup->Message(20, 0.0);
+		Plunger->Message(1016, 0.0);
+		if (Demo->UnknownBaseFlag2)
+			rc_text = pinball::get_rc_string(30, 0);
+		else
+			rc_text = pinball::get_rc_string(26, 0);
+		pinball::InfoTextBox->Display(rc_text, -1.0);
+		if (Demo)
+			Demo->Message(1014, 0.0);
+		break;
+	case 1014:
+		if (EndGameTimeoutTimer)
+		{
+			timer::kill(EndGameTimeoutTimer);
+			EndGame_timeout(0, this);
+			pb::mode_change(1);
+		}
+		if (LightShowTimer)
+		{
+			timer::kill(LightShowTimer);
+			LightShowTimer = 0;
+			Message(1013, 0.0);
+		}
+		else
+		{
+			UnknownP6 = 0;
+			Message(1024, 0.0);
+			/*v8 = (char*)this2->ListP2.ListPtr->Array[0];
+			*(float*)(v8 + 46) = 0.0;
+			*(float*)(v8 + 42) = 0.0;
+			*(_DWORD*)(v8 + 50) = -1085485875;*/
+
+			auto playerCount = static_cast<int>(floor(value));
+			PlayerCount = playerCount;
+			if (playerCount >= 1)
+			{
+				if (playerCount > 4)
+					PlayerCount = 4;
+			}
+			else
+			{
+				PlayerCount = 1;
+			}
+
+			auto plr1Score = PlayerScores[0].ScoreStruct;
+			CurrentPlayer = 0;
+			CurScoreStruct = plr1Score;
+			CurScore = 0;
+			score::set(plr1Score, 0);
+			ScoreMultiplier = 0;
+
+			for (int plrIndex = 1; plrIndex < PlayerCount; ++plrIndex)
+			{
+				auto scorePtr = &PlayerScores[plrIndex];
+				score::set(scorePtr->ScoreStruct, 0);
+				scorePtr->Score = 0;
+				scorePtr->ScoreE9Part = 0;
+				scorePtr->BallCount = MaxBallCount;
+				scorePtr->ExtraBalls = ExtraBalls;
+				scorePtr->BallLockedCounter = BallLockedCounter;
+				scorePtr->Unknown2 = ScoreSpecial3;
+			}
+
+			BallCount = MaxBallCount;
+			Sound::Idle();
+			ChangeBallCount(BallCount);
+			score::set(ScorePlayerNumber1, CurrentPlayer + 1);
+			score::update(ScorePlayerNumber1);
+			Sound::Idle();
+
+			for (auto scoreIndex = 4 - PlayerCount; scoreIndex > 0; scoreIndex--)
+			{
+				score::set(PlayerScores[scoreIndex].ScoreStruct, -1);
+			}
+
+			Sound::Idle();
+			ScoreSpecial3Flag = 0;
+			ScoreSpecial2Flag = 0;
+			UnknownP71 = 0;
+			pinball::InfoTextBox->Clear();
+			Sound::Idle();
+			pinball::MissTextBox->Clear();
+			Sound::Idle();
+			LightGroup->Message(28, 0.2f);
+			auto time = loader::play_sound(SoundIndex1);
+			LightShowTimer = timer::set(time, this, LightShow_timeout);
+		}
+		break;
+	case 1018:
+		if (ReplayTimer)
+			timer::kill(ReplayTimer);
+		ReplayTimer = timer::set(floor(value), this, replay_timer_callback);
+		ReplayActiveFlag = 1;
+		break;
+	case 1021:
+		{
+			if (PlayerCount <= 1)
+			{
+				char* textboxText;
+				if (Demo->UnknownBaseFlag2)
+					textboxText = pinball::get_rc_string(30, 0);
+				else
+					textboxText = pinball::get_rc_string(26, 0);
+				pinball::InfoTextBox->Display(textboxText, -1.0);
+				break;
+			}
+
+			auto nextPlayer = (CurrentPlayer + 1) % PlayerCount;
+			auto nextScorePtr = &PlayerScores[nextPlayer];
+			if (nextScorePtr->BallCount <= 0)
+				break;
+
+			PlayerScores[CurrentPlayer].Score = CurScore;
+			PlayerScores[CurrentPlayer].ScoreE9Part = CurScoreE9;
+			PlayerScores[CurrentPlayer].BallCount = BallCount;
+			PlayerScores[CurrentPlayer].ExtraBalls = ExtraBalls;
+			PlayerScores[CurrentPlayer].BallLockedCounter = BallLockedCounter;
+			PlayerScores[CurrentPlayer].Unknown2 = ScoreSpecial3;
+
+			CurScore = nextScorePtr->Score;
+			CurScoreE9 = nextScorePtr->ScoreE9Part;
+			BallCount = nextScorePtr->BallCount;
+			ExtraBalls = nextScorePtr->ExtraBalls;
+			BallLockedCounter = nextScorePtr->BallLockedCounter;
+			ScoreSpecial3 = nextScorePtr->Unknown2;
+
+			CurScoreStruct = nextScorePtr->ScoreStruct;
+			score::set(CurScoreStruct, CurScore);
+			CurScoreStruct->DirtyFlag = true;
+
+			ChangeBallCount(BallCount);
+			score::set(ScorePlayerNumber1, nextPlayer + 1);
+			score::update(ScorePlayerNumber1);
+
+			for (int i = 0; i < ListP1->Count(); i++)
+			{
+				static_cast<TPinballComponent*>(ListP1->Get(i))->Message(1020, static_cast<float>(nextPlayer));
+			}
+
+			char* textboxText = nullptr;
+			switch (nextPlayer)
+			{
+			case 0:
+				if (Demo->UnknownBaseFlag2)
+					textboxText = pinball::get_rc_string(30, 0);
+				else
+					textboxText = pinball::get_rc_string(26, 0);
+				break;
+			case 1:
+				if (Demo->UnknownBaseFlag2)
+					textboxText = pinball::get_rc_string(31, 0);
+				else
+					textboxText = pinball::get_rc_string(27, 0);
+				break;
+			case 2:
+				if (Demo->UnknownBaseFlag2)
+					textboxText = pinball::get_rc_string(32, 0);
+				else
+					textboxText = pinball::get_rc_string(28, 0);
+				break;
+			case 3:
+				if (Demo->UnknownBaseFlag2)
+					textboxText = pinball::get_rc_string(33, 0);
+				else
+					textboxText = pinball::get_rc_string(29, 0);
+				break;
+			default:
+				break;
+			}
+
+			if (textboxText != nullptr)
+				pinball::InfoTextBox->Display(textboxText, -1);
+			ScoreSpecial3Flag = 0;
+			ScoreSpecial2Flag = 0;
+			UnknownP71 = 0;
+			CurrentPlayer = nextPlayer;
+		}
+		break;
+	case 1022:
+		loader::play_sound(SoundIndex2);
+		pinball::MissTextBox->Clear();
+		pinball::InfoTextBox->Display(pinball::get_rc_string(34, 0), -1.0);
+		EndGameTimeoutTimer = timer::set(3.0, this, EndGame_timeout);
+		break;
+	case 1024:
+		for (int i = 0; i < ListP1->Count(); i++)
+		{
+			static_cast<TPinballComponent*>(ListP1->Get(i))->Message(1024, 0);
+		}
+		if (ReplayTimer)
+			timer::kill(ReplayTimer);
+		ReplayTimer = 0;
+		if (LightShowTimer)
+		{
+			timer::kill(LightShowTimer);
+			LightGroup->Message(34, 0.0);
+		}
+		LightShowTimer = 0;
+		ScoreMultiplier = 0;
+		ScoreAdded = 0;
+		ScoreSpecial1 = 0;
+		ScoreSpecial2 = 10000;
+		ScoreSpecial2Flag = 0;
+		ScoreSpecial3 = 20000;
+		ScoreSpecial3Flag = 0;
+		UnknownP71 = 0;
+		ExtraBalls = 0;
+		UnknownP75 = 0;
+		BallLockedCounter = 0;
+		MultiballFlag = 0;
+		UnknownP78 = 0;
+		ReplayActiveFlag = 0;
+		ReplayTimer = 0;
+		TiltLockFlag = 0;
+		break;
+
+	default: break;
+	}
+
+	control::table_control_handler(code);
+	return 0;
+}
+
+void TPinballTable::EndGame_timeout(int timerId, void* caller)
+{
+	auto table = static_cast<TPinballTable*>(caller);
+	table->EndGameTimeoutTimer = 0;
+	pb::end_game();
+
+	for (int i = 0; i < table->ListP1->Count(); i++)
+	{
+		static_cast<TPinballComponent*>(table->ListP1->Get(i))->Message(1022, 0);
+	}
+	if (table->Demo)
+		table->Demo->Message(1022, 0.0);
+	control::handler(67, pinball::MissTextBox);
+	pinball::InfoTextBox->Display(pinball::get_rc_string(24, 0), -1.0);
+}
+
+void TPinballTable::LightShow_timeout(int timerId, void* caller)
+{
+	auto table = static_cast<TPinballTable*>(caller);
+	table->LightShowTimer = 0;
+	table->Message(1013, 0.0);
+}
+
+void TPinballTable::replay_timer_callback(int timerId, void* caller)
+{
+	auto table = static_cast<TPinballTable*>(caller);
+	table->ReplayActiveFlag = 0;
+	table->ReplayTimer = 0;
+}
+
+void TPinballTable::tilt_timeout(int timerId, void* caller)
+{
+	auto table = static_cast<TPinballTable*>(caller);
+
+	objlist_struct1* v2; // eax
+	void** v3; // edi
+	int v4; // ebx
+	char v5; // [esp+14h] [ebp-Ch]
+
+	table->TiltTimeoutTimer = 0;
+	if (table->TiltLockFlag)
+	{
+		/*v2 = table->ListP2.ListPtr;
+		v3 = v2->Array;
+		if (v2->Count > 0)
+		{
+			v4 = v2->Count;
+			do
+			{
+				(*(void(__stdcall**)(void*, char*, char*, _DWORD, _DWORD))(*(_DWORD*)table->Drain + 20))(
+					*v3,
+					&v5,
+					&v5,
+					0.0,
+					0);
+				++v3;
+				--v4;
+			} while (v4);
+		}*/
+	}
+}

SpaceCadetPinball/TPinballTable.h

@@ -1,11 +1,26 @@
 #pragma once
-#include "objlist_class.h"
+
-#include "score.h"
-#include "TDrain.h"
-#include "TFlipper.h"
-#include "TLightGroup.h"
 #include "TPinballComponent.h"
-#include "TPlunger.h"
+
+struct scoreStruct;
+class TFlipper;
+class TPlunger;
+class TDrain;
+class TDemo;
+class objlist_class;
+class TLightGroup;
+
+struct score_struct_super
+{
+	scoreStruct* ScoreStruct;
+	int Score;
+	int ScoreE9Part;
+	int Unknown2;
+	int BallCount;
+	int ExtraBalls;
+	int BallLockedCounter;
+};
+
 
 class TPinballTable : public TPinballComponent
 {
@@ -14,56 +29,38 @@ public:
 	~TPinballTable();
 	TPinballComponent* find_component(LPCSTR componentName);
 	TPinballComponent* find_component(int groupIndex);
+	int AddScore(int score);
+	void ChangeBallCount(int count);
+	void tilt(float time);
 	void port_draw() override;
+	int Message(int code, float value) override;
+
+	static void EndGame_timeout(int timerId, void* caller);
+	static void LightShow_timeout(int timerId, void* caller);
+	static void replay_timer_callback(int timerId, void* caller);
+	static void tilt_timeout(int timerId, void* caller);
 
 	TFlipper* FlipperL;
 	TFlipper* FlipperR;
-	scoreStruct* Score1;
+	scoreStruct* CurScoreStruct;
-	int* ScoreBallcount;
+	scoreStruct* ScoreBallcount;
-	int* ScorePlayerNumber1;
+	scoreStruct* ScorePlayerNumber1;
 	int UnknownP6;
 	int SoundIndex1;
 	int SoundIndex2;
 	int SoundIndex3;
 	int UnknownP10;
-	int UnknownP11;
+	int CurScore;
-	int UnknownP12;
+	int CurScoreE9;
-	int UnknownP13;
+	int LightShowTimer;
-	int UnknownP14;
+	int EndGameTimeoutTimer;
-	int UnknownP15;
+	int TiltTimeoutTimer;
-	scoreStruct* Score2;
+	score_struct_super PlayerScores[4];
-	int UnknownP17;
-	int UnknownP18;
-	int UnknownP19;
-	int UnknownP20;
-	int UnknownP21;
-	int UnknownP22;
-	scoreStruct* Score3_x3_at7;
-	int UnknownP24;
-	int UnknownP25;
-	int UnknownP26;
-	int UnknownP27;
-	int UnknownP28;
-	int UnknownP29;
-	int UnknownP30;
-	int UnknownP31;
-	int UnknownP32;
-	int UnknownP33;
-	int UnknownP34;
-	int UnknownP35;
-	int UnknownP36;
-	int UnknownP37;
-	int UnknownP38;
-	int UnknownP39;
-	int UnknownP40;
-	int UnknownP41;
-	int UnknownP42;
-	int UnknownP43;
 	int PlayerCount;
 	int CurrentPlayer;
 	TPlunger* Plunger;
 	TDrain* Drain;
-	int UnknownP48;
+	TDemo* Demo;
 	int XOffset;
 	int YOffset;
 	int Width;
@@ -77,24 +74,27 @@ public:
 	float CollisionCompOffset;
 	int UnknownP62;
 	int UnknownP63;
-	int UnknownP64;
+	int ScoreMultiplier;
-	int UnknownP65;
+	int ScoreAdded;
-	int UnknownP66;
+	int ScoreSpecial1;
-	int UnknownP67;
+	int ScoreSpecial2;
-	int UnknownP68;
+	int ScoreSpecial2Flag;
-	int UnknownP69;
+	int ScoreSpecial3;
-	int UnknownP70;
+	int ScoreSpecial3Flag;
 	int UnknownP71;
-	int UnknownP72;
+	int BallCount;
-	int UnknownP73;
+	int MaxBallCount;
-	int UnknownP74;
+	int ExtraBalls;
 	int UnknownP75;
-	int UnknownP76;
+	int BallLockedCounter;
-	int UnknownP77;
+	int MultiballFlag;
 	int UnknownP78;
-	int UnknownP79;
+	int ReplayActiveFlag;
-	int UnknownP80;
+	int ReplayTimer;
 	int UnknownP81;
 	int UnknownP82;
-	int UnknownP83;
+	int TiltLockFlag;
+
+private:
+	static int score_multipliers[5];
 };

SpaceCadetPinball/TTableLayer.cpp

@@ -3,6 +3,7 @@
 
 #include "loader.h"
 #include "proj.h"
+#include "render.h"
 #include "TLine.h"
 #include "TPinballTable.h"
 

SpaceCadetPinball/TTableLayer.h

@@ -3,13 +3,15 @@
 #include "TEdgeManager.h"
 
 
-
+class TPinballTable;
+class TEdgeManager;
+struct gdrv_bitmap8;
 
 class TTableLayer :
 	public TCollisionComponent
 {
 public:
-	static TEdgeManager *edge_manager;
+	static TEdgeManager* edge_manager;
 
 	TTableLayer(TPinballTable* table);
 	~TTableLayer() override;

SpaceCadetPinball/TTextBox.cpp

@@ -1,6 +1,9 @@
 #include "pch.h"
 #include "TTextBox.h"
+
+#include "control.h"
 #include "loader.h"
+#include "render.h"
 #include "score.h"
 #include "timer.h"
 

SpaceCadetPinball/control.cpp

@@ -1,5 +1,7 @@
 #include "pch.h"
 #include "control.h"
+
+#include "objlist_class.h"
 #include "TPinballTable.h"
 
 int control_bump_scores1[] = {500, 1000, 1500, 2000};
@@ -500,6 +502,8 @@ component_tag* control::simple_components[142]
 	&control_soundwave7_tag
 };
 
+int control::table_control_flag;
+
 
 void control::make_links(TPinballTable* table)
 {
@@ -558,7 +562,8 @@ void control::handler(int code, TPinballComponent* cmp)
 			{
 				cmp->put_scoring(scoreInd, control->Scores[scoreInd]);
 				++scoreInd;
-			} while (scoreInd < control->ScoreCount);
+			}
+			while (scoreInd < control->ScoreCount);
 		}
 		control->ControlFunc(code, cmp);
 	}
@@ -796,3 +801,12 @@ void control::MultiplierTargetControl(int code, TPinballComponent* caller)
 void control::BallDrainControl(int code, TPinballComponent* caller)
 {
 }
+
+void control::table_control_handler(int code)
+{
+	if (code == 1011)
+	{
+		table_control_flag = 0;
+		control_lite77_tag.Component->Message(7, 0.0);
+	}
+}

SpaceCadetPinball/control.h

@@ -30,6 +30,7 @@ public:
 	static TPinballTable* TableG;
 	static component_info score_components[88];
 	static component_tag* simple_components[142];
+	static int table_control_flag;
 
 	static void make_links(TPinballTable* table);
 	static TPinballComponent* make_component_link(component_tag* tag);
@@ -93,4 +94,6 @@ public:
 	static void MedalTargetControl(int code, TPinballComponent* caller);
 	static void MultiplierTargetControl(int code, TPinballComponent* caller);
 	static void BallDrainControl(int code, TPinballComponent* caller);
+
+	static void table_control_handler(int code);	
 };

SpaceCadetPinball/loader.cpp

@@ -3,6 +3,7 @@
 #include "memory.h"
 #include "partman.h"
 #include "pinball.h"
+#include "Sound.h"
 #include "zdrv.h"
 
 
@@ -132,7 +133,7 @@ void loader::unload()
 		soundListStruct* soundListPtr = &sound_list[1];
 		do
 		{
-			//Sound_FreeSound(soundListPtr->WavePtr);
+			Sound::FreeSound(soundListPtr->WavePtr);
 			++index;
 			++soundListPtr;
 		}
@@ -166,7 +167,7 @@ int loader::get_sound_id(int groupIndex)
 		if (!sound_list[soundIndex].Loaded && !sound_list[soundIndex].WavePtr)
 		{
 			int soundGroupId = sound_list[soundIndex].GroupIndex;
-			sound_list[soundIndex].Volume = 0.0;
+			sound_list[soundIndex].Duration = 0.0;
 			if (soundGroupId > 0 && !pinball::quickFlag)
 			{
 				__int16* value = (__int16*)partman::field(loader_table, soundGroupId, datFieldTypes::ShortValue);
@@ -174,9 +175,9 @@ int loader::get_sound_id(int groupIndex)
 				{
 					const CHAR* fileName = partman::field(loader_table, soundGroupId, datFieldTypes::String);
 					HFILE hFile = _lopen(fileName, 0);
-					sound_list[soundIndex].Volume = (float)((double)(_llseek(hFile, 0, 2)) * 0.0000909090909090909);
+					sound_list[soundIndex].Duration = (float)((double)_llseek(hFile, 0, 2) * 0.0000909090909090909);
 					_lclose(hFile);
-					//sound_list[soundIndex4].WavePtr = Sound_LoadWaveFile(lpName);
+					sound_list[soundIndex].WavePtr = Sound::LoadWaveFile(fileName);
 				}
 			}
 		}
@@ -320,12 +321,12 @@ int loader::material(int groupIndex, visualStruct* visual)
 }
 
 
-double loader::play_sound(int soundIndex)
+float loader::play_sound(int soundIndex)
 {
 	if (soundIndex <= 0)
 		return 0.0;
-	//Sound_PlaySound(sound_list[soundIndex].WavePtr, 0, 7, 5, 0);
+	Sound::PlaySound((int)sound_list[soundIndex].WavePtr, 0, 7, 5, 0);
-	return sound_list[soundIndex].Volume;
+	return sound_list[soundIndex].Duration;
 }
 
 int loader::state_id(int groupIndex, int groupIndexOffset)

SpaceCadetPinball/loader.h

@@ -16,7 +16,7 @@ struct soundListStruct
 	char* WavePtr;
 	int GroupIndex;
 	int Loaded;
-	float Volume;
+	float Duration;
 	char* PtrToSmth;
 };
 
@@ -66,7 +66,7 @@ public:
 	static char* query_name(int groupIndex);
 	static float* query_float_attribute(int groupIndex, int groupIndexOffset, int firstValue);
 	static __int16* query_iattribute(int groupIndex, int firstValue, int* arraySize);
-	static double play_sound(int soundIndex);
+	static float play_sound(int soundIndex);
 	static datFileStruct* loader_table;
 private:
 	static errorMsg loader_errors[];	

SpaceCadetPinball/pb.cpp

@@ -13,6 +13,8 @@
 #include "timer.h"
 #include "winmain.h"
 #include "resource.h"
+#include "TLightGroup.h"
+#include "TPlunger.h"
 
 TPinballTable* pb::MainTable = nullptr;
 datFileStruct* pb::record_table = nullptr;
@@ -355,19 +357,19 @@ void pb::keydown(int key)
 		}
 		if (key == options::Options.LeftTableBumpKey)
 		{
-			if (!MainTable->UnknownP83)
+			if (!MainTable->TiltLockFlag)
 				nudge::nudge_right();
 			return;
 		}
 		if (key == options::Options.RightTableBumpKey)
 		{
-			if (!MainTable->UnknownP83)
+			if (!MainTable->TiltLockFlag)
 				nudge::nudge_left();
 			return;
 		}
 		if (key == options::Options.BottomTableBumpKey)
 		{
-			if (!MainTable->UnknownP83)
+			if (!MainTable->TiltLockFlag)
 				nudge::nudge_up();
 			return;
 		}

SpaceCadetPinball/score.cpp

@@ -3,6 +3,7 @@
 #include "loader.h"
 #include "memory.h"
 #include "partman.h"
+#include "render.h"
 #include "TDrain.h"
 #include "winmain.h"
 
@@ -15,12 +16,13 @@ int score::init()
 
 scoreStruct* score::create(LPCSTR fieldName, gdrv_bitmap8* renderBgBmp)
 {
-	scoreStruct* score = (scoreStruct*)memory::allocate(sizeof(scoreStruct));
+	auto score = reinterpret_cast<scoreStruct*>(memory::allocate(sizeof(scoreStruct)));
 	if (!score)
 		return nullptr;
 	score->Score = -9999;
 	score->BackgroundBmp = renderBgBmp;
-	__int16* shortArr = (__int16*)partman::field_labeled(loader::loader_table, fieldName, datFieldTypes::ShortArray);
+	auto shortArr = reinterpret_cast<__int16*>(partman::field_labeled(loader::loader_table, fieldName,
+	                                                                  datFieldTypes::ShortArray));
 	if (!shortArr)
 	{
 		memory::free(score);