WebSVN – Games.Carmageddon – Blame – /src/DETHRACE/common/racestrt.c

Rev	Author	Line No.	Line
1	pmbaty	1	#include "racestrt.h"
18	pmbaty	2	#include "brender.h"
1	pmbaty	3	#include "cutscene.h"
		4	#include "displays.h"
		5	#include "drmem.h"
		6	#include "errors.h"
		7	#include "flicplay.h"
		8	#include "globvars.h"
		9	#include "globvrpb.h"
		10	#include "grafdata.h"
		11	#include "graphics.h"
		12	#include "harness/config.h"
		13	#include "harness/trace.h"
		14	#include "input.h"
		15	#include "intrface.h"
		16	#include "loading.h"
		17	#include "netgame.h"
		18	#include "network.h"
		19	#include "newgame.h"
		20	#include "opponent.h"
		21	#include "pd/sys.h"
		22	#include "racestrt.h"
		23	#include "sound.h"
		24	#include "structur.h"
		25	#include "utility.h"
		26	#include "world.h"
		27	#include <stdlib.h>
		28
		29	int gGrid_number_colour[4] = { 49u, 201u, 1u, 201u };
		30	int gJust_bought_part;
		31	tU32 gLast_host_query;
		32	br_pixelmap* gDead_car;
		33	int gFade_away_parts_shop;
		34	tU32 gDare_start_time;
		35	int gRefund_rate;
		36	int gSwap_grid_2;
		37	int gSwap_grid_1;
		38	int gChange_race_net_mode;
		39	tParts_category gPart_category;
		40	tU32 gNet_synch_start;
		41	tNet_game_details* gChoose_car_net_game;
		42	int gPart_index;
18	pmbaty	43	int gChallenger_index__racestrt; // suffix added to avoid duplicate symbol
1	pmbaty	44	tGrid_draw gDraw_grid_status;
		45	tNet_sequence_type gNet_race_sequence__racestrt; // suffix added to avoid duplicate symbol
		46	br_pixelmap* gTaken_image;
		47	int gGrid_number_x_coords[31];
		48	int gGrid_transition_stage;
		49	int gGrid_y_adjust;
		50	br_pixelmap* gBullet_image;
		51	br_pixelmap* gDeceased_image;
		52	int gBest_pos_available;
		53	int gChallenger_position;
		54	int gOpponent_index;
		55	int gChallenge_time;
		56	int gOriginal_position;
		57	int gCurrent_race_index;
		58	tInterface_spec* gStart_interface_spec;
		59	int gCurrent_car_index;
		60	int gOur_starting_position;
		61
		62	// IDA: void __usercall DrawRaceList(int pOffset@<EAX>)
		63	void DrawRaceList(int pOffset) {
		64	int i;
		65	//int font_height; // Pierre-Marie Baty -- unused variable
		66	int pitch;
		67	int y;
		68	int left_most;
		69	int right_most;
		70	int rank_colour;
		71	int text_colour;
		72	//int box_bot; // Pierre-Marie Baty -- unused variable
		73	//int text_width; // Pierre-Marie Baty -- unused variable
		74	int text_x;
		75	char rank_str[256];
		76	LOG_TRACE("(%d)", pOffset);
		77
		78	left_most = (gCurrent_graf_data->choose_race_rank_right - 2 * gBig_font->width[48] + gCurrent_graf_data->choose_race_left) / 2;
		79	right_most = gCurrent_graf_data->choose_race_right - (left_most - gCurrent_graf_data->choose_race_left);
		80	BrPixelmapRectangleFill(gBack_screen,
		81	left_most,
		82	gCurrent_graf_data->choose_race_y_top,
		83	gCurrent_graf_data->choose_race_right - gCurrent_graf_data->choose_race_left - 2 * (left_most - gCurrent_graf_data->choose_race_left),
		84	gCurrent_graf_data->choose_race_y_bottom - gCurrent_graf_data->choose_race_y_top,
		85	0);
		86	pitch = gCurrent_graf_data->choose_race_y_pitch;
		87	for (i = 0; i < gNumber_of_races; i++) {
		88	y = pitch * i + gCurrent_graf_data->choose_race_curr_y - pOffset;
		89	if (gCurrent_graf_data->choose_race_y_top <= (y - (TranslationMode() ? 2 : 0)) && (y + gBig_font->glyph_y) < gCurrent_graf_data->choose_race_line_y) {
		90	if ((gProgram_state.rank > gRace_list[i].rank_required \|\| gProgram_state.rank < gRace_list[i].best_rank) && !gProgram_state.game_completed && !gChange_race_net_mode) {
		91	rank_colour = 44;
		92	text_colour = 49;
		93	} else if (gCurrent_graf_data->choose_race_curr_y == y) {
		94	rank_colour = 5;
		95	text_colour = 1;
		96	} else {
		97	rank_colour = 198;
		98	text_colour = 201;
		99	}
		100	if (!gChange_race_net_mode) {
		101	sprintf(rank_str, "%2d", gRace_list[i].rank_required);
		102	TransBrPixelmapText(gBack_screen,
		103	gCurrent_graf_data->choose_race_rank_right - BrPixelmapTextWidth(gBack_screen, gBig_font, rank_str),
		104	y,
		105	rank_colour,
		106	gBig_font,
		107	rank_str);
		108	}
		109	TransBrPixelmapText(gBack_screen,
		110	gCurrent_graf_data->choose_race_name_left,
		111	y,
		112	text_colour,
		113	gBig_font,
		114	gRace_list[i].name);
		115	if (gRace_list[i].been_there_done_that && gBullet_image != NULL) {
		116	BrPixelmapRectangleCopy(gBack_screen,
		117	gCurrent_graf_data->choose_race_bullet_left,
		118	y + (gBig_font->glyph_y - gBullet_image->height) / 2,
		119	gBullet_image,
		120	0,
		121	0,
		122	gBullet_image->width,
		123	gBullet_image->height);
		124	}
		125	}
		126	}
		127	if (gChange_race_net_mode) {
		128	strcpy(rank_str, GetMiscString(gNet_race_sequence__racestrt == 1 ? kMiscString_SUBSEQUENT_RACES_WILL_BE_RANDOM : kMiscString_RACES_WILL_CONTINUE_DOWN_THIS_LIST));
		129	TransBrPixelmapText(gBack_screen,
		130	(right_most + left_most - BrPixelmapTextWidth(gBack_screen, gBig_font, rank_str)) / 2,
		131	gCurrent_graf_data->choose_race_current_text_y,
		132	5,
		133	gBig_font,
		134	rank_str);
		135	} else {
		136	sprintf(rank_str, "%s%d", GetMiscString(kMiscString_YourCurrentRankIs), gProgram_state.rank);
		137	text_x = (gCurrent_graf_data->choose_race_left + gCurrent_graf_data->choose_race_right) / 2 - BrPixelmapTextWidth(gBack_screen, gBig_font, rank_str) / 2;
		138	TransBrPixelmapText(gBack_screen,
		139	text_x,
		140	gCurrent_graf_data->choose_race_current_text_y,
		141	3,
		142	gBig_font,
		143	GetMiscString(kMiscString_YourCurrentRankIs));
		144	sprintf(rank_str, "%d", gProgram_state.rank);
		145	TransBrPixelmapText(gBack_screen,
		146	text_x + BrPixelmapTextWidth(gBack_screen, gBig_font, GetMiscString(kMiscString_YourCurrentRankIs)),
		147	gCurrent_graf_data->choose_race_current_text_y,
		148	5,
		149	gBig_font,
		150	rank_str);
		151	}
		152	BrPixelmapLine(gBack_screen,
		153	left_most,
		154	gCurrent_graf_data->choose_race_line_y,
		155	right_most,
		156	gCurrent_graf_data->choose_race_line_y,
		157	6);
		158	DrawRectangle(gBack_screen,
		159	left_most,
		160	gCurrent_graf_data->choose_race_box_top - 1,
		161	right_most,
		162	2 * gCurrent_graf_data->choose_race_curr_y - gCurrent_graf_data->choose_race_box_top + gBig_font->glyph_y,
		163	3);
		164	PDScreenBufferSwap(0);
		165	}
		166
		167	// IDA: void __usercall MoveRaceList(int pFrom@<EAX>, int pTo@<EDX>, tS32 pTime_to_move@<EBX>)
		168	void MoveRaceList(int pFrom, int pTo, tS32 pTime_to_move) {
		169	tS32 start_time;
		170	tS32 the_time;
		171	//int move_distance; // Pierre-Marie Baty -- unused variable
		172	int pitch;
		173	LOG_TRACE("(%d, %d, %d)", pFrom, pTo, pTime_to_move);
		174
		175	pitch = gCurrent_graf_data->choose_race_y_pitch;
		176	start_time = PDGetTotalTime();
		177	while (1) {
		178	the_time = PDGetTotalTime();
		179	if (start_time + pTime_to_move <= the_time)
		180	break;
		181	DrawRaceList((the_time - start_time) * (pTo - pFrom) * pitch / pTime_to_move + pitch * pFrom);
		182	}
		183	DrawRaceList(pitch * pTo);
		184	}
		185
		186	// IDA: int __usercall UpRace@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		187	int UpRace(int* pCurrent_choice, int* pCurrent_mode) {
		188	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		189
		190	AddToFlicQueue(gStart_interface_spec->pushed_flics[2].flic_index,
		191	gStart_interface_spec->pushed_flics[2].x[gGraf_data_index],
		192	gStart_interface_spec->pushed_flics[2].y[gGraf_data_index],
		193	1);
		194	DRS3StartSound(gEffects_outlet, 3000);
		195	if (gCurrent_race_index != 0 && (gRace_list[gCurrent_race_index - 1].best_rank <= gProgram_state.rank \|\| gProgram_state.game_completed \|\| gChange_race_net_mode)) {
		196	RemoveTransientBitmaps(1);
		197	MoveRaceList(gCurrent_race_index, gCurrent_race_index - 1, 150);
		198	gCurrent_race_index--;
		199	}
		200	return 0;
		201	}
		202
		203	// IDA: int __usercall DownRace@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		204	int DownRace(int* pCurrent_choice, int* pCurrent_mode) {
		205	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		206
		207	AddToFlicQueue(gStart_interface_spec->pushed_flics[3].flic_index,
		208	gStart_interface_spec->pushed_flics[3].x[gGraf_data_index],
		209	gStart_interface_spec->pushed_flics[3].y[gGraf_data_index],
		210	1);
		211	DRS3StartSound(gEffects_outlet, 3000);
		212	if (gCurrent_race_index < gNumber_of_races - 1 && (gProgram_state.rank <= gRace_list[gCurrent_race_index + 1].rank_required \|\| gProgram_state.game_completed \|\| gChange_race_net_mode)) {
		213	RemoveTransientBitmaps(1);
		214	MoveRaceList(gCurrent_race_index, gCurrent_race_index + 1, 150);
		215	gCurrent_race_index++;
		216	}
		217	return 0;
		218	}
		219
		220	// IDA: int __usercall ClickOnRace@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		221	int ClickOnRace(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		222	int x_coord;
		223	int y_coord;
		224	int race_delta;
		225	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		226
		227	GetMousePosition(&x_coord, &y_coord);
		228	race_delta = (y_coord - (gCurrent_graf_data->choose_race_curr_y - 5 * (gCurrent_graf_data->choose_race_y_pitch / 2) + gBig_font->glyph_y / 2)) / gCurrent_graf_data->choose_race_y_pitch - 2;
		229	if (race_delta >= -2 && race_delta <= -1) {
		230	do {
		231	UpRace(pCurrent_choice, pCurrent_mode);
		232	race_delta++;
		233	} while (race_delta != 0);
		234	} else if (race_delta > 0 && race_delta < 3) {
		235	do {
		236	DownRace(pCurrent_choice, pCurrent_mode);
		237	race_delta--;
		238	} while (race_delta != 0);
		239	}
		240	return 0;
		241	}
		242
		243	// IDA: int __usercall UpClickRace@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		244	int UpClickRace(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		245	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		246
		247	UpRace(pCurrent_choice, pCurrent_mode);
		248	return 0;
		249	}
		250
		251	// IDA: int __usercall DownClickRace@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		252	int DownClickRace(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		253	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		254
		255	DownRace(pCurrent_choice, pCurrent_mode);
		256	return 0;
		257	}
		258
		259	// IDA: void __cdecl StartChangeRace()
		260	void StartChangeRace(void) {
		261	LOG_TRACE("()");
		262
		263	MoveRaceList(-3, gCurrent_race_index, 400);
		264	}
		265
		266	// IDA: int __usercall ChangeRace@<EAX>(int *pRace_index@<EAX>, int pNet_mode@<EDX>, tNet_sequence_type pNet_race_sequence@<EBX>)
		267	int ChangeRace(int* pRace_index, int pNet_mode, tNet_sequence_type pNet_race_sequence) {
		268	static tFlicette flicker_on[4] = {
		269	{ 43, { 60, 120 }, { 154, 370 } },
		270	{ 43, { 221, 442 }, { 154, 370 } },
		271	{ 221, { 30, 60 }, { 78, 187 } },
		272	{ 221, { 30, 60 }, { 78, 187 } },
		273	};
		274	static tFlicette flicker_off[4] = {
		275	{ 42, { 60, 120 }, { 154, 370 } },
		276	{ 42, { 221, 442 }, { 154, 370 } },
		277	{ 220, { 30, 60 }, { 78, 187 } },
		278	{ 220, { 30, 60 }, { 78, 187 } },
		279	};
		280	static tFlicette push[4] = {
		281	{ 154, { 60, 120 }, { 154, 370 } },
		282	{ 45, { 221, 442 }, { 154, 370 } },
		283	{ 222, { 30, 60 }, { 78, 187 } },
		284	{ 225, { 30, 60 }, { 118, 283 } },
		285	};
		286	static tMouse_area mouse_areas[5] = {
		287	{ { 60, 120 }, { 154, 370 }, { 125, 250 }, { 174, 418 }, 0, 0, 0, NULL },
		288	{ { 221, 442 }, { 154, 370 }, { 286, 572 }, { 174, 418 }, 1, 0, 0, NULL },
		289	{ { 30, 60 }, { 78, 187 }, { 45, 90 }, { 104, 250 }, -1, 0, 0, UpClickRace },
		290	{ { 30, 60 }, { 118, 283 }, { 45, 90 }, { 145, 348 }, -1, 0, 0, DownClickRace },
		291	{ { 66, 132 }, { 33, 79 }, { 278, 556 }, { 144, 346 }, -1, 0, 0, ClickOnRace },
		292	};
		293	static tInterface_spec interface_spec = {
		294	0, 230, 60, 231, 231, 231, 6,
		295	{ -1, 0 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		296	{ -1, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		297	{ -1, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { UpRace, NULL },
		298	{ -1, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { DownRace, NULL },
		299	{ 1, 1 }, { NULL, NULL }, { 1, 1 }, { NULL, NULL },
		300	NULL, NULL, 0, NULL, StartChangeRace, NULL, 0, { 0, 0 },
		301	NULL, 1, 1, COUNT_OF(flicker_on), flicker_on, flicker_off, push,
		302	COUNT_OF(mouse_areas), mouse_areas, 0, NULL
		303	};
		304	int result;
		305	LOG_TRACE("(%p, %d, %d)", pRace_index, pNet_mode, pNet_race_sequence);
		306
		307	gNet_race_sequence__racestrt = pNet_race_sequence;
		308	gChange_race_net_mode = pNet_mode;
		309	gStart_interface_spec = &interface_spec;
		310	gCurrent_race_index = *pRace_index;
		311	if (pNet_mode == 0) {
		312	gBullet_image = LoadPixelmap("BULLET.PIX");
		313	} else {
		314	gBullet_image = NULL;
		315	}
		316	result = DoInterfaceScreen(&interface_spec, pNet_mode != 0, 0);
		317	if (result == 0) {
		318	*pRace_index = gCurrent_race_index;
		319	}
		320	if (gBullet_image != NULL) {
		321	BrPixelmapFree(gBullet_image);
		322	}
		323	return result == 0;
		324	}
		325
		326	// IDA: void __cdecl DoChangeRace()
		327	void DoChangeRace(void) {
		328	LOG_TRACE("()");
		329
		330	if (ChangeRace(&gProgram_state.current_race_index, 0, eNet_sequence_sequential) != 0) {
		331	gProgram_state.current_race_index = gCurrent_race_index;
		332	}
		333	}
		334
		335	// IDA: void __usercall DrawCar(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		336	void DrawCar(int pCurrent_choice, int pCurrent_mode) {
		337	char s[64];
		338	int text_x;
		339	int text_width;
		340	LOG_TRACE("(%d, %d)", pCurrent_choice, pCurrent_mode);
		341
		342	// Added by dethrace to ignore warnings about using sprintf without a literal format string
		343	#ifndef _MSC_VER // Pierre-Marie Baty -- exclude MSVC
		344	#pragma GCC diagnostic push
		345	#pragma GCC diagnostic ignored "-Wformat-security"
		346	#endif // !_MSC_VER
		347
		348	PollCarDetails(gChoose_car_net_game);
		349	if (gChange_race_net_mode == 0) {
		350	if (gProgram_state.number_of_cars == 1) {
		351	sprintf(s, GetMiscString(kMiscString_NoOtherCarsToChooseFromYet));
		352	} else if (gProgram_state.cars_available[gCurrent_car_index] == gProgram_state.frank_or_anniness) {
		353	sprintf(s, GetMiscString(kMiscString_YourOriginalCar));
		354	} else {
		355	sprintf(s, "%s %s", GetMiscString(kMiscString_OriginalDriverWas), gOpponents[gProgram_state.cars_available[gCurrent_car_index]].name);
		356	}
		357	} else if (gCar_details[gProgram_state.cars_available[gCurrent_car_index]].ownership == eCar_owner_someone) {
		358	sprintf(s, "%s %s", GetMiscString(kMiscString_THIS_CAR_ALREADY_TAKEN_BY), gCar_details[gProgram_state.cars_available[gCurrent_car_index]].name);
		359	} else {
		360	sprintf(s, GetMiscString(kMiscString_AVAILABLE));
		361	}
		362
		363	#ifndef _MSC_VER // Pierre-Marie Baty -- exclude MSVC
		364	#pragma GCC diagnostic pop
		365	#endif // !_MSC_VER
		366
		367	text_width = BrPixelmapTextWidth(gBack_screen, gFont_7, s);
		368	text_x = (gCurrent_graf_data->change_car_line_right + gCurrent_graf_data->change_car_line_left - text_width) / 2;
		369	BrPixelmapRectangleFill(gBack_screen,
		370	gCurrent_graf_data->change_car_line_left,
		371	gCurrent_graf_data->change_car_text_y,
		372	gCurrent_graf_data->change_car_line_right - gCurrent_graf_data->change_car_line_left,
		373	gFont_7->glyph_y,
		374	0);
		375	TransBrPixelmapText(gBack_screen,
		376	text_x,
		377	gCurrent_graf_data->change_car_text_y,
		378	3,
		379	gFont_7,
		380	s);
		381	BrPixelmapLine(gBack_screen,
		382	gCurrent_graf_data->change_car_line_left,
		383	gCurrent_graf_data->change_car_line_y,
		384	gCurrent_graf_data->change_car_line_right,
		385	gCurrent_graf_data->change_car_line_y,
		386	6);
		387	if (gChange_race_net_mode && gCar_details[gProgram_state.cars_available[gCurrent_car_index]].ownership == eCar_owner_someone) {
		388	DRPixelmapRectangleMaskedCopy(
		389	gBack_screen,
		390	(gCurrent_graf_data->change_car_panel_left + gCurrent_graf_data->change_car_panel_right - gTaken_image->width) / 2,
		391	(gCurrent_graf_data->change_car_panel_bottom + gCurrent_graf_data->change_car_panel_bottom - gTaken_image->height) / 2,
		392	gTaken_image,
		393	0,
		394	0,
		395	gTaken_image->width,
		396	gTaken_image->height);
		397	}
		398	}
		399
		400	// IDA: void __cdecl SetCarFlic()
		401	void SetCarFlic(void) {
		402	LOG_TRACE("()");
		403
		404	ChangePanelFlic(0,
		405	gOpponents[gProgram_state.cars_available[gCurrent_car_index]].stolen_car_image_data,
		406	gOpponents[gProgram_state.cars_available[gCurrent_car_index]].stolen_car_image_data_length);
		407	}
		408
		409	// IDA: int __usercall UpCar@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		410	int UpCar(int* pCurrent_choice, int* pCurrent_mode) {
		411	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		412
		413	AddToFlicQueue(gStart_interface_spec->pushed_flics[2].flic_index,
		414	gStart_interface_spec->pushed_flics[2].x[gGraf_data_index],
		415	gStart_interface_spec->pushed_flics[2].y[gGraf_data_index],
		416	1);
		417	DRS3StartSound(gEffects_outlet, 3000);
		418	if (gCurrent_car_index != 0) {
		419	RemoveTransientBitmaps(1);
		420	DropOutImageThruBottom(GetPanelPixelmap(0),
		421	gCurrent_graf_data->change_car_panel_left,
		422	gCurrent_graf_data->change_car_panel_top,
		423	gCurrent_graf_data->change_car_panel_top_clip,
		424	gCurrent_graf_data->change_car_panel_bottom_clip);
		425	gCurrent_car_index--;
		426	SetCarFlic();
		427	DropInImageFromTop(GetPanelPixelmap(0),
		428	gCurrent_graf_data->change_car_panel_left,
		429	gCurrent_graf_data->change_car_panel_top,
		430	gCurrent_graf_data->change_car_panel_top_clip,
		431	gCurrent_graf_data->change_car_panel_bottom_clip);
		432	}
		433	return 0;
		434	}
		435
		436	// IDA: int __usercall DownCar@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		437	int DownCar(int* pCurrent_choice, int* pCurrent_mode) {
		438	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		439
		440	AddToFlicQueue(gStart_interface_spec->pushed_flics[3].flic_index,
		441	gStart_interface_spec->pushed_flics[3].x[gGraf_data_index],
		442	gStart_interface_spec->pushed_flics[3].y[gGraf_data_index],
		443	1);
		444	DRS3StartSound(gEffects_outlet, 3000);
		445	if (gCurrent_car_index < gProgram_state.number_of_cars - 1) {
		446	RemoveTransientBitmaps(1);
		447	DropOutImageThruTop(GetPanelPixelmap(0),
		448	gCurrent_graf_data->change_car_panel_left,
		449	gCurrent_graf_data->change_car_panel_top,
		450	gCurrent_graf_data->change_car_panel_top_clip,
		451	gCurrent_graf_data->change_car_panel_bottom_clip);
		452	gCurrent_car_index++;
		453	SetCarFlic();
		454	DropInImageFromBottom(GetPanelPixelmap(0),
		455	gCurrent_graf_data->change_car_panel_left,
		456	gCurrent_graf_data->change_car_panel_top,
		457	gCurrent_graf_data->change_car_panel_top_clip,
		458	gCurrent_graf_data->change_car_panel_bottom_clip);
		459	}
		460	return 0;
		461	}
		462
		463	// IDA: int __usercall UpClickCar@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		464	int UpClickCar(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		465	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		466
		467	UpCar(pCurrent_choice, pCurrent_mode);
		468	return 0;
		469	}
		470
		471	// IDA: int __usercall DownClickCar@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		472	int DownClickCar(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		473	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		474
		475	DownCar(pCurrent_choice, pCurrent_mode);
		476	return 0;
		477	}
		478
		479	// IDA: int __usercall ChangeCarGoAhead@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		480	int ChangeCarGoAhead(int* pCurrent_choice, int* pCurrent_mode) {
		481	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		482
		483	if (gChange_race_net_mode == 0 \|\| gCar_details[gProgram_state.cars_available[gCurrent_car_index]].ownership != eCar_owner_someone) {
		484	return 1;
		485	} else {
		486	DRS3StartSound(gEffects_outlet, 3100);
		487	return 0;
		488	}
		489	}
		490
		491	// IDA: int __usercall ChangeCar@<EAX>(int pNet_mode@<EAX>, int pCar_index@<EDX>, tNet_game_details pNet_game@<EBX>)
		492	int ChangeCar(int pNet_mode, int* pCar_index, tNet_game_details* pNet_game) {
		493	static tFlicette flicker_on[4] = {
		494	{ 43, { 60, 120 }, { 154, 370 } },
		495	{ 43, { 221, 442 }, { 154, 370 } },
		496	{ 221, { 30, 60 }, { 78, 187 } },
		497	{ 221, { 30, 60 }, { 78, 187 } },
		498	};
		499	static tFlicette flicker_off[4] = {
		500	{ 42, { 60, 120 }, { 154, 370 } },
		501	{ 42, { 221, 442 }, { 154, 370 } },
		502	{ 220, { 30, 60 }, { 78, 187 } },
		503	{ 220, { 30, 60 }, { 78, 187 } },
		504	};
		505	static tFlicette push[4] = {
		506	{ 154, { 60, 120 }, { 154, 370 } },
		507	{ 45, { 221, 442 }, { 154, 370 } },
		508	{ 222, { 30, 60 }, { 78, 187 } },
		509	{ 225, { 30, 60 }, { 118, 283 } },
		510	};
		511	static tMouse_area mouse_areas[4] = {
		512	{ { 60, 120 }, { 154, 370 }, { 125, 250 }, { 174, 418 }, 0, 0, 0, NULL },
		513	{ { 221, 442 }, { 154, 370 }, { 286, 572 }, { 174, 418 }, 1, 0, 0, NULL },
		514	{ { 30, 60 }, { 78, 187 }, { 45, 90 }, { 104, 250 }, -1, 0, 0, UpClickCar },
		515	{ { 30, 60 }, { 118, 283 }, { 45, 90 }, { 145, 348 }, -1, 0, 0, DownClickCar },
		516	};
		517	static tInterface_spec interface_spec = {
		518	0,
		519	236,
		520	62,
		521	0,
		522	0,
		523	0,
		524	-1,
		525	{ -1, 0 },
		526	{ -1, 0 },
		527	{ 0, 0 },
		528	{ 1, 0 },
		529	{ NULL, NULL },
		530	{ -1, 0 },
		531	{ 1, 0 },
		532	{ 0, 0 },
		533	{ 1, 0 },
		534	{ NULL, NULL },
		535	{ -1, 0 },
		536	{ 0, 0 },
		537	{ 0, 0 },
		538	{ 0, 0 },
		539	{ UpCar, NULL },
		540	{ -1, 0 },
		541	{ 0, 0 },
		542	{ 0, 0 },
		543	{ 0, 0 },
		544	{ DownCar, NULL },
		545	{ 1, 1 },
		546	{ ChangeCarGoAhead, NULL },
		547	{ 1, 1 },
		548	{ NULL, NULL },
		549	NULL,
		550	DrawCar,
		551	0,
		552	NULL,
		553	NULL,
		554	NULL,
		555	0,
		556	{ 0, 0 },
		557	NULL,
		558	1,
		559	1,
		560	COUNT_OF(flicker_on),
		561	flicker_on,
		562	flicker_off,
		563	push,
		564	COUNT_OF(mouse_areas),
		565	mouse_areas,
		566	0,
		567	NULL,
		568	};
		569	int i;
		570	int result;
		571	int power_up_levels[3];
		572	LOG_TRACE("(%d, %p, %p)", pNet_mode, pCar_index, pNet_game);
		573
		574	gChoose_car_net_game = pNet_game;
		575	gChange_race_net_mode = pNet_mode;
		576	gStart_interface_spec = &interface_spec;
		577	for (i = 0; i < gProgram_state.number_of_cars; i++) {
		578	if (gProgram_state.cars_available[i] == *pCar_index) {
		579	gCurrent_car_index = i;
		580	break;
		581	}
		582	}
		583	if (gProgram_state.game_completed) {
		584	gProgram_state.number_of_cars = gNumber_of_racers;
		585	for (i = 0; i < gProgram_state.number_of_cars; i++) {
		586	gProgram_state.cars_available[i] = i;
		587	}
		588	}
		589	for (i = 0; i < gProgram_state.number_of_cars; i++) {
		590	if (gOpponents[gProgram_state.cars_available[i]].stolen_car_image_data == NULL) {
		591	LoadFlicData(gOpponents[gProgram_state.cars_available[i]].stolen_car_flic_name,
		592	&gOpponents[gProgram_state.cars_available[i]].stolen_car_image_data,
		593	&gOpponents[gProgram_state.cars_available[i]].stolen_car_image_data_length);
		594	} else {
		595	MAMSLock((void**)&gOpponents[gProgram_state.cars_available[i]].stolen_car_image_data);
		596	}
		597	}
		598	InitialiseFlicPanel(0,
		599	gCurrent_graf_data->change_car_panel_left,
		600	gCurrent_graf_data->change_car_panel_top,
		601	gCurrent_graf_data->change_car_panel_right - gCurrent_graf_data->change_car_panel_left,
		602	gCurrent_graf_data->change_car_panel_bottom - gCurrent_graf_data->change_car_panel_top);
		603	SetCarFlic();
		604	if (pNet_mode) {
		605	gTaken_image = LoadPixelmap("TAKEN.PIX");
		606	}
		607	result = DoInterfaceScreen(&interface_spec, pNet_mode, 0);
		608	if (pNet_mode) {
		609	FadePaletteDown();
		610	} else {
		611	RunFlic(237);
		612	}
		613	for (i = 0; i < gProgram_state.number_of_cars; i++) {
		614	MAMSUnlock((void**)&gOpponents[gProgram_state.cars_available[i]].stolen_car_image_data);
		615	}
		616	DisposeFlicPanel(0);
		617	if (pNet_mode) {
		618	BrPixelmapFree(gTaken_image);
		619	}
		620	if (result == 0) {
		621	if (pNet_mode) {
18	pmbaty	622	*pCar_index = gProgram_state.cars_available[gCurrent_car_index];
1	pmbaty	623	} else {
		624	AboutToLoadFirstCar();
		625	SwitchToRealResolution();
		626	for (i = 0; i < COUNT_OF(power_up_levels); i++) {
		627	power_up_levels[i] = gProgram_state.current_car.power_up_levels[i];
		628	}
		629	LoadCar(gOpponents[gProgram_state.cars_available[gCurrent_car_index]].car_file_name,
		630	eDriver_local_human,
		631	&gProgram_state.current_car,
		632	gProgram_state.cars_available[gCurrent_car_index],
		633	gProgram_state.player_name[gProgram_state.frank_or_anniness],
		634	&gOur_car_storage_space);
		635	for (i = 0; i < COUNT_OF(power_up_levels); i++) {
		636	gProgram_state.current_car.power_up_levels[i] = power_up_levels[i];
		637	}
		638	SwitchToLoresMode();
		639	SetCarStorageTexturingLevel(&gOur_car_storage_space, GetCarTexturingLevel(), eCTL_full);
		640	DisposeRaceInfo(&gCurrent_race);
		641	SelectOpponents(&gCurrent_race);
		642	LoadRaceInfo(gProgram_state.current_race_index, &gCurrent_race);
		643	}
		644	return 1;
		645	} else {
		646	return 0;
		647	}
		648	}
		649
		650	// IDA: void __cdecl DoChangeCar()
		651	void DoChangeCar(void) {
		652	LOG_TRACE("()");
		653
		654	ChangeCar(0, &gProgram_state.current_car.index, NULL);
		655	}
		656
		657	// IDA: int __cdecl PartsShopRecommended()
		658	int PartsShopRecommended(void) {
		659	int running_cost;
		660	int i;
		661	int current_index;
		662	int counter;
		663	LOG_TRACE("()");
		664
		665	running_cost = 0;
		666	counter = 0;
		667	for (i = 0; i < eParts_count; i++) {
		668	current_index = gProgram_state.current_car.power_up_levels[i];
		669	if (current_index + 1 < gProgram_state.current_car.power_ups[i].number_of_parts && (gProgram_state.rank <= gProgram_state.current_car.power_ups[i].info[current_index + 1].rank_required \|\| gProgram_state.game_completed)) {
		670	running_cost += gProgram_state.current_car.power_ups[i].info[current_index + 1].prices[gProgram_state.skill_level];
		671	counter++;
		672	}
		673	}
		674	return running_cost != 0 && ((float)running_cost / counter * 1.5f <= gProgram_state.credits);
		675	}
		676
		677	// IDA: void __usercall CalcPartPrice(int pCategory@<EAX>, int pIndex@<EDX>, int pPrice@<EBX>, int pCost@<ECX>)
		678	void CalcPartPrice(int pCategory, int pIndex, int* pPrice, int* pCost) {
		679	//int current_value; // Pierre-Marie Baty -- unused variable
		680	LOG_TRACE("(%d, %d, %p, %p)", pCategory, pIndex, pPrice, pCost);
		681
		682	*pPrice = gProgram_state.current_car.power_ups[pCategory].info[pIndex].prices[gProgram_state.skill_level];
		683	if (gProgram_state.current_car.power_up_levels[pCategory] == pIndex) {
		684	*pCost = 0;
		685	} else {
		686	pCost = pPrice - 10 * (gRefund_rate * gProgram_state.current_car.power_ups[pCategory].info[gProgram_state.current_car.power_up_levels[pCategory]].prices[gProgram_state.skill_level] / 1000);
		687	}
		688	}
		689
		690	// IDA: int __usercall BuyPart@<EAX>(int pCategory@<EAX>, int pIndex@<EDX>)
		691	int BuyPart(int pCategory, int pIndex) {
		692	int price;
		693	int cost;
		694	LOG_TRACE("(%d, %d)", pCategory, pIndex);
		695
		696	CalcPartPrice(pCategory, pIndex, &price, &cost);
		697	if (cost == 0) {
		698	return 1;
		699	} else if (gProgram_state.credits < cost) {
		700	return 0;
		701	} else {
		702	gProgram_state.credits -= cost;
		703	if (gProgram_state.credits > 999999) {
		704	gProgram_state.credits = 999999;
		705	}
		706	gProgram_state.current_car.power_up_levels[pCategory] = pIndex;
		707	return 1;
		708	}
		709	}
		710
		711	// IDA: void __cdecl DoAutoParts()
		712	void DoAutoParts(void) {
		713	int i;
		714	int lowest_yet;
		715	int lowest_one;
		716	int price;
		717	int cost;
		718	int current_level;
		719	LOG_TRACE("()");
		720
		721	while (1) {
		722	if (!PartsShopRecommended()) {
		723	return;
		724	}
		725	lowest_yet = COUNT_OF(((tParts_spec*)NULL)->info);
		726	for (i = 0; i < eParts_count; i++) {
		727	current_level = gProgram_state.current_car.power_up_levels[i];
		728	if (current_level + 1 < gProgram_state.current_car.power_ups[i].number_of_parts && (gProgram_state.rank <= gProgram_state.current_car.power_ups[i].info[current_level + 1].rank_required \|\| gProgram_state.game_completed)) {
		729	CalcPartPrice(i, current_level + 1, &price, &cost);
		730	if (cost != 0 && cost <= gProgram_state.credits && current_level < lowest_yet) {
		731	lowest_one = i;
		732	lowest_yet = current_level + 1;
		733	}
		734	}
		735	}
		736	if (lowest_yet == COUNT_OF(((tParts_spec*)NULL)->info)) {
		737	break;
		738	}
		739	if (!BuyPart(lowest_one, lowest_yet)) {
		740	return;
		741	}
		742	}
		743	}
		744
		745	// IDA: void __cdecl DrawPartsLabel()
		746	void DrawPartsLabel(void) {
		747	LOG_TRACE("()");
		748
		749	switch (gPart_category) {
		750	case eParts_armour:
		751	RunFlicAt(262, gCurrent_graf_data->parts_label_x, gCurrent_graf_data->parts_label_y);
		752	break;
		753	case eParts_power:
		754	RunFlicAt(263, gCurrent_graf_data->parts_label_x, gCurrent_graf_data->parts_label_y);
		755	break;
		756	case eParts_offensive:
		757	RunFlicAt(264, gCurrent_graf_data->parts_label_x, gCurrent_graf_data->parts_label_y);
		758	break;
		759	default:
		760	break;
		761	}
		762	}
		763
		764	// IDA: void __usercall ErasePartsText(int pTotal_as_well@<EAX>)
		765	void ErasePartsText(int pTotal_as_well) {
		766	LOG_TRACE("(%d)", pTotal_as_well);
		767
		768	BrPixelmapRectangleFill(gBack_screen,
		769	gCurrent_graf_data->parts_cost_x,
		770	gCurrent_graf_data->parts_cost_y,
		771	gCurrent_graf_data->parts_image_width - (gCurrent_graf_data->parts_cost_x - gCurrent_graf_data->parts_image_x),
		772	gFont_7->glyph_y + gCurrent_graf_data->parts_net_y - gCurrent_graf_data->parts_cost_y,
		773	0);
		774	if (pTotal_as_well) {
		775	BrPixelmapRectangleFill(gBack_screen,
		776	gCurrent_graf_data->parts_total_x,
		777	gCurrent_graf_data->parts_total_y,
		778	gCurrent_graf_data->parts_image_width - (gCurrent_graf_data->parts_total_x - gCurrent_graf_data->parts_image_x),
		779	gFont_7->glyph_y,
		780	0);
		781	}
		782	}
		783
		784	// IDA: void __cdecl DrawPartsText()
		785	void DrawPartsText(void) {
		786	int price;
		787	int cost;
		788	LOG_TRACE("()");
		789
		790	CalcPartPrice(gPart_category, gPart_index, &price, &cost);
		791	TransBrPixelmapText(gBack_screen, gCurrent_graf_data->parts_cost_x, gCurrent_graf_data->parts_cost_y, 5, gFont_7, GetMiscString(kMiscString_RetailColon));
		792	BrPixelmapTextF(gBack_screen, gCurrent_graf_data->parts_numbers_x, gCurrent_graf_data->parts_cost_y - (TranslationMode() ? 2 : 0), 5, gFont_7, "%d", price);
		793	if (cost > 0) {
		794	TransBrPixelmapText(gBack_screen, gCurrent_graf_data->parts_net_x, gCurrent_graf_data->parts_net_y, 45, gFont_7, GetMiscString(kMiscString_YouPayColon));
		795	BrPixelmapTextF(gBack_screen, gCurrent_graf_data->parts_numbers_x, gCurrent_graf_data->parts_net_y - (TranslationMode() ? 2 : 0), 45, gFont_7, "%d", cost);
		796	} else if (cost < 0) {
		797	TransBrPixelmapText(gBack_screen, gCurrent_graf_data->parts_net_x, gCurrent_graf_data->parts_net_y, 201, gFont_7, GetMiscString(kMiscString_RefundColon));
		798	BrPixelmapTextF(gBack_screen, gCurrent_graf_data->parts_numbers_x, gCurrent_graf_data->parts_net_y - (TranslationMode() ? 2 : 0), 201, gFont_7, "%d", -cost);
		799	} else if (gJust_bought_part) {
		800	TransBrPixelmapText(gBack_screen, gCurrent_graf_data->parts_net_x, gCurrent_graf_data->parts_net_y, 134, gFont_7, GetMiscString(kMiscString_YouGotIt));
		801	} else {
		802	TransBrPixelmapText(gBack_screen, gCurrent_graf_data->parts_net_x, gCurrent_graf_data->parts_net_y, 134, gFont_7, GetMiscString(kMiscString_YoursAlready));
		803	}
		804	TransBrPixelmapText(gBack_screen, gCurrent_graf_data->parts_total_x, gCurrent_graf_data->parts_total_y, 2, gFont_7, GetMiscString(kMiscString_CreditsColon));
		805	BrPixelmapTextF(gBack_screen, gCurrent_graf_data->parts_numbers_x, gCurrent_graf_data->parts_total_y - (TranslationMode() ? 2 : 0), 2, gFont_7, "%d", gProgram_state.credits);
		806	}
		807
		808	// IDA: void __cdecl SetPartsImage()
		809	void SetPartsImage(void) {
		810	LOG_TRACE("()");
		811
		812	ChangePanelFlic(0,
		813	gProgram_state.current_car.power_ups[gPart_category].info[gPart_index].data_ptr,
		814	gProgram_state.current_car.power_ups[gPart_category].info[gPart_index].data_length);
		815	TellyInImage(GetPanelPixelmap(0), gCurrent_graf_data->parts_image_x, gCurrent_graf_data->parts_image_y);
		816	DrawPartsText();
		817	}
		818
		819	// IDA: int __cdecl GetPartsMax()
		820	int GetPartsMax(void) {
		821	int i;
		822	LOG_TRACE("()");
		823
		824	for (i = gProgram_state.current_car.power_ups[gPart_category].number_of_parts - 1; i >= 0; i--) {
		825	if (gProgram_state.rank <= gProgram_state.current_car.power_ups[gPart_category].info[i].rank_required) {
		826	return i;
		827	}
		828	if (gProgram_state.game_completed) {
		829	return i;
		830	}
		831	}
		832	return 0;
		833	}
		834
		835	// IDA: void __cdecl CalcPartsIndex()
		836	void CalcPartsIndex(void) {
		837	//int current_index; // Pierre-Marie Baty -- unused variable
		838	LOG_TRACE("()");
		839
		840	gPart_index = gProgram_state.current_car.power_up_levels[gPart_category];
		841	if (gPart_index + 1 < gProgram_state.current_car.power_ups[gPart_category].number_of_parts && (gProgram_state.rank <= gProgram_state.current_car.power_ups[gPart_category].info[gPart_index + 1].rank_required \|\| gProgram_state.game_completed)) {
		842	gPart_index += 1;
		843	}
		844	}
		845
		846	// IDA: void __cdecl DoExchangePart()
		847	void DoExchangePart(void) {
		848	int price;
		849	int cost;
		850	LOG_TRACE("()");
		851
		852	CalcPartPrice(gPart_category, gPart_index, &price, &cost);
		853	if (cost == 0 \|\| gProgram_state.credits < cost) {
		854	DRS3StartSound(gEffects_outlet, 3100);
		855	} else {
		856	gJust_bought_part = 1;
		857	DRS3StartSound(gEffects_outlet, 3101);
		858	BuyPart(gPart_category, gPart_index);
		859	ErasePartsText(1);
		860	DrawPartsText();
		861	}
		862	}
		863
		864	// IDA: int __usercall PartsShopGoAhead@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		865	int PartsShopGoAhead(int* pCurrent_choice, int* pCurrent_mode) {
		866	//int flic_index; // Pierre-Marie Baty -- unused variable
		867	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		868
		869	if (pCurrent_choice < 3 && pCurrent_mode == 0) {
		870	RemoveTransientBitmaps(1);
		871	DontLetFlicFuckWithPalettes();
		872	TurnFlicTransparencyOn();
		873	RunFlicAt(
		874	gStart_interface_spec->pushed_flics[*pCurrent_choice].flic_index,
		875	gStart_interface_spec->pushed_flics[*pCurrent_choice].x[gGraf_data_index],
		876	gStart_interface_spec->pushed_flics[*pCurrent_choice].y[gGraf_data_index]);
		877	TurnFlicTransparencyOff();
		878	LetFlicFuckWithPalettes();
		879	gJust_bought_part = 0;
		880	ErasePartsText(1);
		881	TellyOutImage(GetPanelPixelmap(0), gCurrent_graf_data->parts_image_x, gCurrent_graf_data->parts_image_y);
		882	gPart_category = *pCurrent_choice;
		883	CalcPartsIndex();
		884	RunFlic(261);
		885	AddToFlicQueue(
		886	gStart_interface_spec->flicker_on_flics[*pCurrent_choice].flic_index,
		887	gStart_interface_spec->flicker_on_flics[*pCurrent_choice].x[gGraf_data_index],
		888	gStart_interface_spec->flicker_on_flics[*pCurrent_choice].y[gGraf_data_index],
		889	1);
		890	DrawPartsLabel();
		891	SetPartsImage();
		892	ProcessFlicQueue(gFrame_period);
		893	DoMouseCursor();
		894	PDScreenBufferSwap(0);
		895	return 0;
		896	} else if (*pCurrent_mode == 1) {
		897	AddToFlicQueue(
		898	gStart_interface_spec->flicker_on_flics[4].flic_index,
		899	gStart_interface_spec->flicker_on_flics[4].x[gGraf_data_index],
		900	gStart_interface_spec->flicker_on_flics[4].y[gGraf_data_index],
		901	1);
		902	DoExchangePart();
		903	return 0;
		904	} else {
		905	return 1;
		906	}
		907	}
		908
		909	// IDA: int __usercall UpPart@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		910	int UpPart(int* pCurrent_choice, int* pCurrent_mode) {
		911	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		912
		913	gJust_bought_part = 0;
		914	AddToFlicQueue(
		915	gStart_interface_spec->pushed_flics[5].flic_index,
		916	gStart_interface_spec->pushed_flics[5].x[gGraf_data_index],
		917	gStart_interface_spec->pushed_flics[5].y[gGraf_data_index],
		918	1);
		919	DRS3StartSound(gEffects_outlet, 3000);
		920	RemoveTransientBitmaps(1);
		921	ErasePartsText(0);
		922
		923	gPart_index = (gPart_index == 0) ? GetPartsMax() : (gPart_index - 1);
		924
		925	DropOutImageThruBottom(
		926	GetPanelPixelmap(0),
		927	gCurrent_graf_data->parts_image_x,
		928	gCurrent_graf_data->parts_image_y,
		929	gCurrent_graf_data->parts_top_clip,
		930	gCurrent_graf_data->parts_bottom_clip);
		931	ChangePanelFlic(0,
		932	gProgram_state.current_car.power_ups[gPart_category].info[gPart_index].data_ptr,
		933	gProgram_state.current_car.power_ups[gPart_category].info[gPart_index].data_length);
		934	DropInImageFromTop(
		935	GetPanelPixelmap(0),
		936	gCurrent_graf_data->parts_image_x,
		937	gCurrent_graf_data->parts_image_y,
		938	gCurrent_graf_data->parts_top_clip,
		939	gCurrent_graf_data->parts_bottom_clip);
		940	DrawPartsText();
		941	return 0;
		942	}
		943
		944	// IDA: int __usercall DownPart@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		945	int DownPart(int* pCurrent_choice, int* pCurrent_mode) {
		946	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		947
		948	gJust_bought_part = 0;
		949	AddToFlicQueue(
		950	gStart_interface_spec->pushed_flics[6].flic_index,
		951	gStart_interface_spec->pushed_flics[6].x[gGraf_data_index],
		952	gStart_interface_spec->pushed_flics[6].y[gGraf_data_index],
		953	1);
		954	DRS3StartSound(gEffects_outlet, 3000);
		955	RemoveTransientBitmaps(1);
		956	ErasePartsText(0);
		957
		958	gPart_index = (gPart_index == GetPartsMax()) ? 0 : (gPart_index + 1);
		959
		960	DropOutImageThruTop(
		961	GetPanelPixelmap(0),
		962	gCurrent_graf_data->parts_image_x,
		963	gCurrent_graf_data->parts_image_y,
		964	gCurrent_graf_data->parts_top_clip,
		965	gCurrent_graf_data->parts_bottom_clip);
		966	ChangePanelFlic(0,
		967	gProgram_state.current_car.power_ups[gPart_category].info[gPart_index].data_ptr,
		968	gProgram_state.current_car.power_ups[gPart_category].info[gPart_index].data_length);
		969	DropInImageFromBottom(
		970	GetPanelPixelmap(0),
		971	gCurrent_graf_data->parts_image_x,
		972	gCurrent_graf_data->parts_image_y,
		973	gCurrent_graf_data->parts_top_clip,
		974	gCurrent_graf_data->parts_bottom_clip);
		975	DrawPartsText();
		976	return 0;
		977	}
		978
		979	// IDA: int __usercall UpClickPart@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		980	int UpClickPart(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		981	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		982
		983	UpPart(pCurrent_choice, pCurrent_mode);
		984	return 0;
		985	}
		986
		987	// IDA: int __usercall DownClickPart@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		988	int DownClickPart(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		989	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		990
		991	DownPart(pCurrent_choice, pCurrent_mode);
		992	return 0;
		993	}
		994
		995	// IDA: int __usercall PartsArrowsOn@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		996	int PartsArrowsOn(int* pCurrent_choice, int* pCurrent_mode) {
		997	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		998
		999	AddToFlicQueue(
		1000	gStart_interface_spec->flicker_on_flics[5].flic_index,
		1001	gStart_interface_spec->flicker_on_flics[5].x[gGraf_data_index],
		1002	gStart_interface_spec->flicker_on_flics[5].y[gGraf_data_index],
		1003	1);
		1004	AddToFlicQueue(gStart_interface_spec->flicker_on_flics[6].flic_index,
		1005	gStart_interface_spec->flicker_on_flics[6].x[gGraf_data_index],
		1006	gStart_interface_spec->flicker_on_flics[6].y[gGraf_data_index],
		1007	1);
		1008	return 0;
		1009	}
		1010
		1011	// IDA: int __usercall PartsArrowsOff@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		1012	int PartsArrowsOff(int* pCurrent_choice, int* pCurrent_mode) {
		1013	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		1014
		1015	AddToFlicQueue(gStart_interface_spec->flicker_off_flics[5].flic_index,
		1016	gStart_interface_spec->flicker_off_flics[5].x[gGraf_data_index],
		1017	gStart_interface_spec->flicker_off_flics[5].y[gGraf_data_index],
		1018	1);
		1019	AddToFlicQueue(gStart_interface_spec->flicker_off_flics[6].flic_index,
		1020	gStart_interface_spec->flicker_off_flics[6].x[gGraf_data_index],
		1021	gStart_interface_spec->flicker_off_flics[6].y[gGraf_data_index],
		1022	1);
		1023	return 0;
		1024	}
		1025
		1026	// IDA: void __cdecl StartPartsShop()
		1027	void StartPartsShop(void) {
		1028	LOG_TRACE("()");
		1029
		1030	DrawPartsLabel();
		1031	SetPartsImage();
		1032	}
		1033
		1034	// IDA: int __usercall DonePartsShop@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pGo_ahead@<EBX>, int pEscaped@<ECX>, int pTimed_out)
		1035	int DonePartsShop(int pCurrent_choice, int pCurrent_mode, int pGo_ahead, int pEscaped, int pTimed_out) {
		1036	LOG_TRACE("(%d, %d, %d, %d, %d)", pCurrent_choice, pCurrent_mode, pGo_ahead, pEscaped, pTimed_out);
		1037
		1038	if (gFade_away_parts_shop) {
		1039	FadePaletteDown();
		1040	} else {
		1041	RunFlic(251);
		1042	}
		1043	return pGo_ahead;
		1044	}
		1045
		1046	// IDA: void __usercall DrawPartsShop(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		1047	void DrawPartsShop(int pCurrent_choice, int pCurrent_mode) {
		1048	LOG_TRACE("(%d, %d)", pCurrent_choice, pCurrent_mode);
		1049
		1050	DrawPartsText();
		1051	}
		1052
		1053	// IDA: void __usercall DoPartsShop(int pFade_away@<EAX>)
		1054	void DoPartsShop(int pFade_away) {
		1055	static tFlicette flicker_on[7] = {
		1056	{ 43, { 225, 450 }, { 30, 72 } },
		1057	{ 43, { 225, 450 }, { 60, 144 } },
		1058	{ 43, { 225, 450 }, { 89, 214 } },
		1059	{ 43, { 225, 450 }, { 152, 365 } },
		1060	{ 43, { 85, 170 }, { 152, 365 } },
		1061	{ 221, { 30, 60 }, { 79, 190 } },
		1062	{ 221, { 30, 60 }, { 79, 190 } },
		1063	};
		1064	static tFlicette flicker_off[7] = {
		1065	{ 42, { 225, 450 }, { 30, 72 } },
		1066	{ 42, { 225, 450 }, { 60, 144 } },
		1067	{ 42, { 225, 450 }, { 89, 214 } },
		1068	{ 42, { 225, 450 }, { 152, 365 } },
		1069	{ 42, { 85, 170 }, { 152, 365 } },
		1070	{ 220, { 30, 60 }, { 79, 190 } },
		1071	{ 220, { 30, 60 }, { 79, 190 } },
		1072	};
		1073	static tFlicette push[7] = {
		1074	{ 254, { 225, 450 }, { 30, 72 } },
		1075	{ 255, { 225, 450 }, { 60, 144 } },
		1076	{ 256, { 225, 450 }, { 89, 214 } },
		1077	{ 154, { 225, 450 }, { 152, 365 } },
		1078	{ 260, { 85, 170 }, { 152, 365 } },
		1079	{ 222, { 30, 60 }, { 79, 190 } },
		1080	{ 225, { 30, 60 }, { 120, 288 } },
		1081	};
		1082	static tMouse_area mouse_areas[7] = {
		1083	{ { 225, 450 }, { 30, 72 }, { 288, 576 }, { 50, 120 }, 0, 0, 0, NULL },
		1084	{ { 225, 450 }, { 60, 144 }, { 288, 576 }, { 80, 192 }, 1, 0, 0, NULL },
		1085	{ { 225, 450 }, { 89, 214 }, { 288, 576 }, { 109, 262 }, 2, 0, 0, NULL },
		1086	{ { 225, 450 }, { 152, 365 }, { 288, 576 }, { 172, 413 }, 3, 0, 0, NULL },
		1087	{ { 85, 170 }, { 152, 365 }, { 148, 296 }, { 172, 413 }, 4, 1, 0, NULL },
		1088	{ { 30, 60 }, { 79, 190 }, { 45, 90 }, { 106, 254 }, -1, 1, 0, UpClickPart },
		1089	{ { 30, 60 }, { 120, 288 }, { 45, 90 }, { 147, 353 }, -1, 1, 0, DownClickPart },
		1090	};
		1091	static tInterface_spec interface_spec = {
		1092	0, 250, 190, 0, 0, 0, 6,
		1093	{ 1, 0 }, { 4, -1 }, { 4, 0 }, { 4, 3 }, { PartsArrowsOn, PartsArrowsOff },
		1094	{ 1, 0 }, { 4, -1 }, { 4, 0 }, { 4, 3 }, { PartsArrowsOn, PartsArrowsOff },
		1095	{ -1, -1 }, { -1, 0 }, { 0, 4 }, { 3, 4 }, { NULL, UpPart },
		1096	{ -1, -1 }, { 1, 0 }, { 0, 4 }, { 3, 4 }, { NULL, DownPart },
		1097	{ 1, 1 }, { PartsShopGoAhead, PartsShopGoAhead },
		1098	{ 1, 1 }, { NULL, NULL },
		1099	NULL, DrawPartsShop, 0, NULL, StartPartsShop, DonePartsShop,
		1100	0, { 0, 0 }, NULL, 3, 1,
		1101	COUNT_OF(flicker_on),
		1102	flicker_on,
		1103	flicker_off,
		1104	push,
		1105	COUNT_OF(mouse_areas),
		1106	mouse_areas,
		1107	0,
		1108	NULL
		1109	};
		1110	//int result; // Pierre-Marie Baty -- unused variable
		1111	LOG_TRACE("(%d)", pFade_away);
		1112
		1113	LoadParts();
		1114	gFade_away_parts_shop = pFade_away;
		1115	InitialiseFlicPanel(0,
		1116	gCurrent_graf_data->parts_image_x,
		1117	gCurrent_graf_data->parts_image_y,
		1118	gCurrent_graf_data->parts_image_width,
		1119	gCurrent_graf_data->parts_image_height);
		1120	gStart_interface_spec = &interface_spec;
		1121	gPart_category = eParts_armour;
		1122	gJust_bought_part = 0;
		1123	gRefund_rate = 75;
		1124	CalcPartsIndex();
		1125	DoInterfaceScreen(&interface_spec, gFaded_palette, 3);
		1126	DisposeFlicPanel(0);
		1127	UnlockParts();
		1128	gProgram_state.parts_shop_visited = 1;
		1129	}
		1130
		1131	// IDA: int __usercall AutoPartsDone@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pGo_ahead@<EBX>, int pEscaped@<ECX>, int pTimed_out)
		1132	int AutoPartsDone(int pCurrent_choice, int pCurrent_mode, int pGo_ahead, int pEscaped, int pTimed_out) {
		1133	LOG_TRACE("(%d, %d, %d, %d, %d)", pCurrent_choice, pCurrent_mode, pGo_ahead, pEscaped, pTimed_out);
		1134
		1135	if (pEscaped) {
		1136	pCurrent_choice = -1;
		1137	}
		1138	return pCurrent_choice;
		1139	}
		1140
		1141	// IDA: tSO_result __cdecl DoAutoPartsShop()
		1142	tSO_result DoAutoPartsShop(void) {
		1143	static tFlicette flicker_on[3] = {
		1144	{ 43, { 84, 168 }, { 67, 161 } },
		1145	{ 43, { 84, 168 }, { 95, 228 } },
		1146	{ 43, { 84, 168 }, { 124, 298 } },
		1147	};
		1148	static tFlicette flicker_off[3] = {
		1149	{ 42, { 84, 168 }, { 67, 161 } },
		1150	{ 42, { 84, 168 }, { 95, 228 } },
		1151	{ 42, { 84, 168 }, { 124, 298 } },
		1152	};
		1153	static tFlicette push[3] = {
		1154	{ 284, { 84, 168 }, { 67, 161 } },
		1155	{ 284, { 84, 168 }, { 95, 228 } },
		1156	{ 284, { 84, 168 }, { 124, 298 } },
		1157	};
		1158	static tMouse_area mouse_areas[3] = {
		1159	{ { 84, 168 }, { 32, 77 }, { 147, 294 }, { 87, 209 }, 0, 0, 0, NULL },
		1160	{ { 84, 168 }, { 95, 228 }, { 147, 294 }, { 115, 276 }, 1, 0, 0, NULL },
		1161	{ { 84, 168 }, { 124, 298 }, { 147, 294 }, { 144, 346 }, 2, 0, 0, NULL },
		1162	};
		1163	static tInterface_spec interface_spec = {
		1164	0, 280, 0, 0, 0, 0, 6,
		1165	{ -1, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { NULL, NULL },
		1166	{ -1, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { NULL, NULL },
		1167	{ -1, -1 }, { -1, 0 }, { 0, 0 }, { 2, 0 }, { NULL, NULL },
		1168	{ -1, -1 }, { 1, 0 }, { 0, 0 }, { 2, 0 }, { NULL, NULL },
		1169	{ 1, 1 }, { NULL, NULL },
		1170	{ 1, 1 }, { NULL, NULL },
		1171	NULL, NULL, 0, NULL, NULL, AutoPartsDone, 0,
		1172	{ 0, 0 }, NULL, -1, 1,
		1173	COUNT_OF(flicker_on), flicker_on, flicker_off, push,
		1174	COUNT_OF(mouse_areas), mouse_areas,
		1175	0, NULL
		1176	};
		1177	int result;
		1178	LOG_TRACE("()");
		1179
		1180	gProgram_state.dont_load = 1;
		1181	result = DoInterfaceScreen(&interface_spec, 0, gProgram_state.auto_parts_reply);
		1182	gProgram_state.dont_load = 0;
		1183	if (result < 0) {
		1184	RunFlic(281);
		1185	return eSO_main_menu_invoked;
		1186	} else {
		1187	gProgram_state.auto_parts_reply = result;
		1188	switch (result) {
		1189	case eAP_auto:
		1190	DoAutoParts();
		1191	break;
		1192	case eAP_manual:
		1193	RunFlic(281);
		1194	DoPartsShop(1);
		1195	break;
		1196	}
		1197	FadePaletteDown();
		1198	return eSO_continue;
		1199	}
		1200	}
		1201
		1202	// IDA: void __cdecl SetOpponentFlic()
		1203	void SetOpponentFlic(void) {
		1204	LOG_TRACE("()");
		1205	ChangePanelFlic(0,
		1206	gOpponents[gCurrent_race.opponent_list[gOpponent_index].index].mug_shot_image_data,
		1207	gOpponents[gCurrent_race.opponent_list[gOpponent_index].index].mug_shot_image_data_length);
		1208	}
		1209
		1210	// IDA: void __cdecl DrawSceneyMappyInfoVieweyThing()
		1211	void DrawSceneyMappyInfoVieweyThing(void) {
		1212	LOG_TRACE("()");
		1213
		1214	RemoveTransientBitmaps(1);
		1215	if (gProgram_state.view_type) {
		1216	if (gProgram_state.view_type == eVT_Info) {
		1217	ChangePanelFlic(0, gCurrent_race.info_image_data, gCurrent_race.info_image_data_length);
		1218	} else if (gProgram_state.view_type == eVT_Opponents) {
		1219	SetOpponentFlic();
		1220	}
		1221	} else {
		1222	ChangePanelFlic(0, gCurrent_race.scene_image_data, gCurrent_race.scene_image_data_length);
		1223	}
		1224	TellyInImage(GetPanelPixelmap(0), gCurrent_graf_data->start_race_panel_left, gCurrent_graf_data->start_race_panel_top);
		1225	}
		1226
		1227	// IDA: void __cdecl DismissSceneyMappyInfoVieweyThing()
		1228	void DismissSceneyMappyInfoVieweyThing(void) {
		1229	LOG_TRACE("()");
		1230
		1231	RemoveTransientBitmaps(1);
		1232	TellyOutImage(GetPanelPixelmap(0), gCurrent_graf_data->start_race_panel_left, gCurrent_graf_data->start_race_panel_top);
		1233	}
		1234
		1235	// IDA: int __usercall SelectRaceDone@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pGo_ahead@<EBX>, int pEscaped@<ECX>, int pTimed_out)
		1236	int SelectRaceDone(int pCurrent_choice, int pCurrent_mode, int pGo_ahead, int pEscaped, int pTimed_out) {
		1237	LOG_TRACE("(%d, %d, %d, %d, %d)", pCurrent_choice, pCurrent_mode, pGo_ahead, pEscaped, pTimed_out);
		1238
		1239	DismissSceneyMappyInfoVieweyThing();
		1240	if (pEscaped) {
		1241	return -1;
		1242	}
		1243	return pCurrent_choice;
		1244	}
		1245
		1246	// IDA: int __usercall StartRaceGoAhead@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		1247	int StartRaceGoAhead(int* pCurrent_choice, int* pCurrent_mode) {
		1248	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		1249
		1250	if (pCurrent_choice != 1 \|\| pCurrent_mode) {
		1251	return 1;
		1252	}
		1253	RemoveTransientBitmaps(1);
		1254	DismissSceneyMappyInfoVieweyThing();
		1255	gProgram_state.view_type++;
		1256	if (gProgram_state.view_type > eVT_Opponents) {
		1257	gProgram_state.view_type = eVT_Scene;
		1258	}
		1259	if (gProgram_state.view_type) {
		1260	if (gProgram_state.view_type == eVT_Info) {
		1261	RunFlic(210);
		1262	} else if (gProgram_state.view_type == eVT_Opponents) {
		1263	RunFlic(212);
		1264	}
		1265	} else {
		1266	RunFlic(213);
		1267	}
		1268	DrawSceneyMappyInfoVieweyThing();
		1269	return 0;
		1270	}
		1271
		1272	// IDA: int __usercall TryToMoveToArrows@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		1273	int TryToMoveToArrows(int* pCurrent_choice, int* pCurrent_mode) {
		1274	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		1275
		1276	if (gProgram_state.view_type != eVT_Opponents) {
		1277	return 0;
		1278	}
		1279	*pCurrent_choice = 5;
		1280	*pCurrent_mode = 1;
		1281	DRS3StartSound(gEffects_outlet, 3000);
		1282	return 1;
		1283	}
		1284
		1285	// IDA: int __usercall UpOpponent@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		1286	int UpOpponent(int* pCurrent_choice, int* pCurrent_mode) {
		1287	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		1288
		1289	#if defined(DETHRACE_FIX_BUGS)
		1290	// fixes bug where racers could be scrolled in other race menu modes
		1291	if (gProgram_state.view_type != eVT_Opponents) {
		1292	return 0;
		1293	}
		1294	#endif
		1295	AddToFlicQueue(gStart_interface_spec->pushed_flics[5].flic_index,
		1296	gStart_interface_spec->pushed_flics[5].x[gGraf_data_index],
		1297	gStart_interface_spec->pushed_flics[5].y[gGraf_data_index],
		1298	1);
		1299	DRS3StartSound(gEffects_outlet, 3000);
		1300	RemoveTransientBitmaps(1);
		1301	DropOutImageThruBottom(GetPanelPixelmap(0),
		1302	gCurrent_graf_data->start_race_panel_left,
		1303	gCurrent_graf_data->start_race_panel_top,
		1304	gCurrent_graf_data->start_race_panel_top_clip,
		1305	gCurrent_graf_data->start_race_panel_bottom_clip);
		1306	if (gOpponent_index == 0) {
		1307	gOpponent_index = gCurrent_race.number_of_racers;
		1308	}
		1309	gOpponent_index--;
		1310	SetOpponentFlic();
		1311	DropInImageFromTop(GetPanelPixelmap(0),
		1312	gCurrent_graf_data->start_race_panel_left,
		1313	gCurrent_graf_data->start_race_panel_top,
		1314	gCurrent_graf_data->start_race_panel_top_clip,
		1315	gCurrent_graf_data->start_race_panel_bottom_clip);
		1316	return 0;
		1317	}
		1318
		1319	// IDA: int __usercall DownOpponent@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		1320	int DownOpponent(int* pCurrent_choice, int* pCurrent_mode) {
		1321	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		1322
		1323	#if defined(DETHRACE_FIX_BUGS)
		1324	// fixes bug where racers could be scrolled in other race menu modes
		1325	if (gProgram_state.view_type != eVT_Opponents) {
		1326	return 0;
		1327	}
		1328	#endif
		1329	AddToFlicQueue(gStart_interface_spec->pushed_flics[6].flic_index,
		1330	gStart_interface_spec->pushed_flics[6].x[gGraf_data_index],
		1331	gStart_interface_spec->pushed_flics[6].y[gGraf_data_index],
		1332	1);
		1333	DRS3StartSound(gEffects_outlet, 3000);
		1334	RemoveTransientBitmaps(1);
		1335	DropOutImageThruTop(GetPanelPixelmap(0),
		1336	gCurrent_graf_data->start_race_panel_left,
		1337	gCurrent_graf_data->start_race_panel_top,
		1338	gCurrent_graf_data->start_race_panel_top_clip,
		1339	gCurrent_graf_data->start_race_panel_bottom_clip);
		1340	gOpponent_index++;
		1341	if (gOpponent_index == gCurrent_race.number_of_racers) {
		1342	gOpponent_index = 0;
		1343	}
		1344	SetOpponentFlic();
		1345	DropInImageFromBottom(GetPanelPixelmap(0),
		1346	gCurrent_graf_data->start_race_panel_left,
		1347	gCurrent_graf_data->start_race_panel_top,
		1348	gCurrent_graf_data->start_race_panel_top_clip,
		1349	gCurrent_graf_data->start_race_panel_bottom_clip);
		1350	return 0;
		1351	}
		1352
		1353	// IDA: int __usercall UpClickOpp@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		1354	int UpClickOpp(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		1355	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		1356
		1357	UpOpponent(pCurrent_choice, pCurrent_mode);
		1358	return 0;
		1359	}
		1360
		1361	// IDA: int __usercall DownClickOpp@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		1362	int DownClickOpp(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		1363	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		1364
		1365	DownOpponent(pCurrent_choice, pCurrent_mode);
		1366	return 0;
		1367	}
		1368
		1369	// IDA: void __cdecl SelectRaceStart()
		1370	void SelectRaceStart(void) {
		1371	LOG_TRACE("()");
		1372
		1373	DrawSceneyMappyInfoVieweyThing();
		1374	PrintMemoryDump(0, "INSIDE START RACE");
		1375	}
		1376
		1377	// IDA: int __cdecl SuggestRace()
		1378	int SuggestRace(void) {
		1379	int i;
		1380	int least_done;
		1381	int suggested_so_far;
		1382	int suggested_race;
		1383	int new_suggestion;
		1384	int number_of_visits;
		1385	LOG_TRACE("()");
		1386
		1387	suggested_so_far = 32767;
		1388	suggested_race = 0;
		1389	if (gProgram_state.game_completed) {
		1390	return IRandomBetween(0, gNumber_of_races - 1);
		1391	}
		1392	if (gProgram_state.redo_race_index >= 0) {
		1393	return gProgram_state.redo_race_index;
		1394	}
		1395	for (i = 0; i < gNumber_of_races; i++) {
		1396	if (gRace_list[i].suggested_rank <= suggested_so_far && gRace_list[i].suggested_rank >= gProgram_state.rank) {
		1397	suggested_so_far = gRace_list[i].suggested_rank;
		1398	suggested_race = i;
		1399	}
		1400	}
		1401	number_of_visits = gRace_list[suggested_race].been_there_done_that;
		1402	new_suggestion = suggested_race;
		1403
		1404	if (number_of_visits) {
		1405	// Jeff: if we have already completed the suggested race, look backwards for a race that we haven't completed as many times
		1406	for (i = suggested_race - 1; i >= 0 && i >= suggested_race - 5; i--) {
		1407	if (gRace_list[i].rank_required < gProgram_state.rank \|\| gRace_list[i].best_rank > gProgram_state.rank) {
		1408	continue;
		1409	}
		1410	least_done = gRace_list[i].been_there_done_that < number_of_visits;
		1411	if (!gRace_list[i].been_there_done_that
		1412	\|\| (least_done && suggested_race - 3 <= i)) {
		1413	new_suggestion = i;
		1414	number_of_visits = gRace_list[i].been_there_done_that;
		1415	}
		1416	}
		1417	// Jeff: look forwards for a race that we haven't completed as many times as the previous suggestion
		1418	for (i = suggested_race + 1; i < gNumber_of_races; i++) {
		1419	least_done = gRace_list[i].been_there_done_that < number_of_visits;
		1420	if (!least_done) {
		1421	continue;
		1422	}
		1423
		1424	if ((gRace_list[i].rank_required >= gProgram_state.rank && gRace_list[i].best_rank <= gProgram_state.rank)
		1425	\|\| gProgram_state.game_completed) {
		1426	new_suggestion = i;
		1427	number_of_visits = gRace_list[i].been_there_done_that;
		1428	}
		1429	}
		1430	}
		1431	return new_suggestion;
		1432	}
		1433
		1434	// IDA: void __usercall SelectRaceDraw(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		1435	void SelectRaceDraw(int pCurrent_choice, int pCurrent_mode) {
		1436	tOpponent* the_opponent;
		1437	tText_chunk* the_chunk;
		1438	int j;
		1439	int k;
		1440	int y_coord;
		1441	//char s[256]; // Pierre-Marie Baty -- unused variable
		1442	//char temp_str[256]; // Pierre-Marie Baty -- unused variable
		1443	//char* sub_pt; // Pierre-Marie Baty -- unused variable
		1444	//char sub_str[16]; // Pierre-Marie Baty -- unused variable
		1445	tU32* test;
		1446	static tU32 test2;
		1447	LOG_TRACE8("(%d, %d)", pCurrent_choice, pCurrent_mode);
		1448
		1449	if (gProgram_state.view_type == eVT_Opponents) {
		1450	the_opponent = &gOpponents[gCurrent_race.opponent_list[gOpponent_index].index];
		1451	for (j = 0; j < the_opponent->text_chunk_count; j++) {
		1452	the_chunk = &the_opponent->text_chunks[j];
		1453	if (GetPanelFlicFrameIndex(0) >= the_chunk->frame_cue && GetPanelFlicFrameIndex(0) < the_chunk->frame_end) {
		1454	y_coord = the_chunk->y_coord * gGraf_specs[gGraf_spec_index].total_height / 200
		1455	+ gCurrent_graf_data->start_race_panel_top;
		1456	for (k = 0; k < the_chunk->line_count; k++) {
		1457	TransBrPixelmapText(
		1458	gBack_screen,
		1459	the_chunk->x_coord * gGraf_specs[gGraf_spec_index].total_width / 320
		1460	+ gCurrent_graf_data->start_race_panel_left,
		1461	y_coord,
		1462	201,
		1463	gFont_7,
		1464	the_chunk->text[k]);
		1465	y_coord += gFont_7->glyph_y + gFont_7->glyph_y / 2;
		1466	}
		1467	}
		1468	}
		1469	} else if (gProgram_state.view_type == eVT_Info) {
		1470	for (j = 0; j < gCurrent_race.text_chunk_count; j++) {
		1471	the_chunk = &gCurrent_race.text_chunks[j];
		1472	if (GetPanelFlicFrameIndex(0) >= the_chunk->frame_cue && GetPanelFlicFrameIndex(0) < the_chunk->frame_end) {
		1473	y_coord = the_chunk->y_coord * gGraf_specs[gGraf_spec_index].total_height / 200
		1474	+ gCurrent_graf_data->start_race_panel_top;
		1475	for (k = 0; k < the_chunk->line_count; k++) {
		1476	TransBrPixelmapText(
		1477	gBack_screen,
		1478	the_chunk->x_coord * gGraf_specs[gGraf_spec_index].total_width / 320
		1479	+ gCurrent_graf_data->start_race_panel_left,
		1480	y_coord,
		1481	201,
		1482	gFont_7,
		1483	the_chunk->text[k]);
		1484	y_coord += gFont_7->glyph_y + gFont_7->glyph_y / 2;
		1485	}
		1486	}
		1487	}
		1488	}
		1489	test = KevKeyService();
		1490	if (*test) {
		1491	test2 = *test;
		1492	}
		1493	if (test[0] == 0x27645433 && test[1] == 0x758f0015) {
		1494	// cheat code: "KEVWOZEAR"
		1495	gProgram_state.game_completed = 1;
		1496	DRS3StartSound(gEffects_outlet, 3202);
		1497	DRS3StartSound(gEffects_outlet, 3202);
		1498	}
		1499	if (test[0] == 0x33f75455 && test[1] == 0xC10AAAF2) {
		1500	// cheat code: "IWANTTOFIDDLE"
		1501
		1502	char s[128];
		1503	FILE* f;
		1504	size_t i; // Pierre-Marie Baty -- fixed type
		1505
		1506	// Jeff
		1507	assert(strlen(gApplication_path) < 120);
		1508
		1509	PathCat(s, gApplication_path, "ACTORS");
		1510	PathCat(s, s, "PROG.ACT");
		1511	PDFileUnlock(s);
		1512	f = fopen(s, "wb");
		1513	if (f != NULL) {
		1514	DRS3StartSound(gEffects_outlet, 9000);
		1515	if (gDecode_thing) {
		1516	for (i = 0; i < strlen(gDecode_string); i++) {
		1517	gDecode_string[i] -= 50;
		1518	}
		1519	fputs(gDecode_string, f);
		1520	for (i = 0; i < strlen(gDecode_string); i++) {
		1521	gDecode_string[i] += 50;
		1522	}
		1523	} else {
		1524	for (i = 0; i < 20; i++) {
		1525	fputs("*************", f);
		1526	}
		1527	}
		1528	gDecode_thing ^= 0x40u;
		1529	fclose(f);
		1530	EncodeAllFilesInDirectory("");
		1531	EncodeAllFilesInDirectory("CARS");
		1532	EncodeAllFilesInDirectory("NONCARS");
		1533	EncodeAllFilesInDirectory("RACES");
		1534	EncodeAllFilesInDirectory("32X20X8");
		1535	EncodeAllFilesInDirectory("64X48X8");
		1536	PathCat(s, "32X20X8", "CARS");
		1537	EncodeAllFilesInDirectory(s);
		1538	PathCat(s, "64X48X8", "CARS");
		1539	EncodeAllFilesInDirectory(s);
		1540	PathCat(s, "32X20X8", "FONTS");
		1541	EncodeAllFilesInDirectory(s);
		1542	PathCat(s, "64X48X8", "FONTS");
		1543	EncodeAllFilesInDirectory(s);
		1544	}
		1545	DRS3StartSound(gEffects_outlet, 9000);
		1546	}
		1547	}
		1548
		1549	// IDA: tSO_result __usercall DoSelectRace@<EAX>(int *pSecond_time_around@<EAX>)
		1550	tSO_result DoSelectRace(int* pSecond_time_around) {
		1551	static tFlicette flicker_on[7] = {
		1552	{ 43, { 224, 448 }, { 28, 67 } },
		1553	{ 43, { 224, 448 }, { 56, 134 } },
		1554	{ 43, { 224, 448 }, { 85, 204 } },
		1555	{ 43, { 224, 448 }, { 113, 271 } },
		1556	{ 43, { 224, 448 }, { 147, 353 } },
		1557	{ 221, { 30, 60 }, { 79, 190 } },
		1558	{ 221, { 30, 60 }, { 79, 190 } }
		1559	};
		1560
		1561	static tFlicette flicker_off[7] = {
		1562	{ 42, { 224, 448 }, { 28, 67 } },
		1563	{ 42, { 224, 448 }, { 56, 134 } },
		1564	{ 42, { 224, 448 }, { 85, 204 } },
		1565	{ 42, { 224, 448 }, { 113, 271 } },
		1566	{ 42, { 224, 448 }, { 147, 353 } },
		1567	{ 220, { 30, 60 }, { 79, 190 } },
		1568	{ 220, { 30, 60 }, { 79, 190 } }
		1569	};
		1570
		1571	static tFlicette push[7] = {
		1572	{ 195, { 224, 448 }, { 28, 67 } },
		1573	{ -1, { 224, 448 }, { 56, 134 } },
		1574	{ 200, { 224, 448 }, { 85, 204 } },
		1575	{ 202, { 224, 448 }, { 113, 271 } },
		1576	{ 201, { 224, 448 }, { 147, 353 } },
		1577	{ 222, { 30, 60 }, { 79, 190 } },
		1578	{ 225, { 30, 60 }, { 119, 286 } }
		1579	};
		1580
		1581	static tMouse_area mouse_areas[7] = {
		1582	{ { 224, 448 }, { 28, 67 }, { 287, 574 }, { 48, 115 }, 0, 0, 0, NULL },
		1583	{ { 224, 448 }, { 56, 134 }, { 287, 574 }, { 76, 182 }, 1, 0, 0, NULL },
		1584	{ { 224, 448 }, { 85, 204 }, { 287, 574 }, { 105, 252 }, 2, 0, 0, NULL },
		1585	{ { 224, 448 }, { 113, 271 }, { 287, 574 }, { 133, 319 }, 3, 0, 0, NULL },
		1586	{ { 224, 448 }, { 147, 353 }, { 287, 574 }, { 167, 401 }, 4, 0, 0, NULL },
		1587	{ { 30, 60 },
		1588	{ 79, 190 },
		1589	{ 45, 90 },
		1590	{ 106, 254 },
		1591	-1,
		1592	0,
		1593	0,
		1594	&UpClickOpp },
		1595	{ { 30, 60 },
		1596	{ 119, 286 },
		1597	{ 45, 90 },
		1598	{ 146, 350 },
		1599	-1,
		1600	0,
		1601	0,
		1602	&DownClickOpp }
		1603	};
		1604
		1605	static tInterface_spec interface_spec = {
		1606	0, // initial_imode
		1607	191, // first_opening_flic
		1608	190, // second_opening_flic
		1609	0, // end_flic_go_ahead
		1610	0, // end_flic_escaped
		1611	0, // end_flic_otherwise
		1612	6, // flic_bunch_to_load
		1613	{ -1, 0 }, // move_left_new_mode
		1614	{ 0, -4 }, // move_left_delta
		1615	{ 0, 1 }, // move_left_min
		1616	{ 0, 1 }, // move_left_max
		1617	{ &TryToMoveToArrows, NULL }, // move_left_proc
		1618	{ -1, 0 }, // move_right_new_mode
		1619	{ 0, -4 }, // move_right_delta
		1620	{ 0, 1 }, // move_right_min
		1621	{ 0, 1 }, // move_right_max
		1622	{ &TryToMoveToArrows, NULL }, // move_right_proc
		1623	{ -1, -1 }, // move_up_new_mode
		1624	{ -1, 0 }, // move_up_delta
		1625	{ 0, 5 }, // move_up_min
		1626	{ 4, 5 }, // move_up_max
		1627	{ NULL, &UpOpponent }, // move_up_proc
		1628	{ -1, -1 }, // move_down_new_mode
		1629	{ 1, 0 }, // move_down_delta
		1630	{ 0, 5 }, // move_down_min
		1631	{ 4, 5 }, // move_down_max
		1632	{ NULL, &DownOpponent }, // move_down_proc
		1633	{ 1, 1 }, // go_ahead_allowed
		1634	{ &StartRaceGoAhead, NULL }, // go_ahead_proc
		1635	{ 1, 1 }, // escape_allowed
		1636	{ NULL, NULL }, // escape_proc
		1637	NULL, // exit_proc
		1638	&SelectRaceDraw, // draw_proc
		1639	0u, // time_out
		1640	NULL, // start_proc1
		1641	&SelectRaceStart, // start_proc2
		1642	&SelectRaceDone, // done_proc
		1643	0, // font_needed
		1644	{ 0, 0 }, // typeable
		1645	NULL, // get_original_string
		1646	-1, // escape_code
		1647	1, // dont_save_or_load
		1648	7, // number_of_button_flics
		1649	flicker_on, // flicker_on_flics
		1650	flicker_off, // flicker_off_flics
		1651	push, // pushed_flics
		1652	7, // number_of_mouse_areas
		1653	mouse_areas, // mouse_areas
		1654	0, // number_of_recopy_areas
		1655	NULL // recopy_areas
		1656	};
		1657
		1658	int result;
		1659	//int default_choice; // Pierre-Marie Baty -- unused variable
		1660	int suggested;
		1661	int old_current_race;
		1662	LOG_TRACE("(%p)", pSecond_time_around);
		1663
		1664	suggested = SuggestRace();
		1665	if (!*pSecond_time_around) {
		1666	gProgram_state.current_race_index = suggested;
		1667	SelectOpponents(&gCurrent_race);
		1668	}
		1669	gProgram_state.parts_shop_visited = 0;
		1670	gProgram_state.dont_load = 1;
		1671	gDeceased_image = LoadPixelmap("DECEASED.PIX");
		1672	InitialiseFlicPanel(
		1673	0,
		1674	gCurrent_graf_data->start_race_panel_left,
		1675	gCurrent_graf_data->start_race_panel_top,
		1676	gCurrent_graf_data->start_race_panel_right - gCurrent_graf_data->start_race_panel_left,
		1677	gCurrent_graf_data->start_race_panel_bottom - gCurrent_graf_data->start_race_panel_top);
		1678	LoadRaceInfo(gProgram_state.current_race_index, &gCurrent_race);
		1679	do {
		1680	gProgram_state.view_type = 0;
		1681	gOpponent_index = 0;
		1682	gStart_interface_spec = &interface_spec;
		1683	if (gFaded_palette \|\| gCurrent_splash) {
		1684	result = DoInterfaceScreen(&interface_spec, 1, 4);
		1685	} else {
		1686	result = DoInterfaceScreen(&interface_spec, 0, 4);
		1687	}
		1688
		1689	if (result == 0 \|\| result == 2 \|\| result == 3) {
		1690	DisposeFlicPanel(0);
		1691
		1692	if (result == 2) {
		1693	if (harness_game_info.mode == eGame_carmageddon_demo \|\| harness_game_info.mode == eGame_splatpack_demo \|\| harness_game_info.mode == eGame_splatpack_xmas_demo) {
		1694	DoFeatureUnavailableInDemo();
		1695	} else {
		1696	RunFlic(192);
		1697	DoPartsShop(0);
		1698	}
		1699	} else if (result == 3) {
		1700	RunFlic(192);
		1701	DoChangeCar();
		1702	} else if (result == 0) {
		1703	RunFlic(192);
		1704	old_current_race = gProgram_state.current_race_index;
		1705	DoChangeRace();
		1706	if (gProgram_state.current_race_index != old_current_race) {
		1707	DisposeRaceInfo(&gCurrent_race);
		1708	SelectOpponents(&gCurrent_race);
		1709	LoadRaceInfo(gProgram_state.current_race_index, &gCurrent_race);
		1710	}
		1711	}
		1712	InitialiseFlicPanel(
		1713	0,
		1714	gCurrent_graf_data->start_race_panel_left,
		1715	gCurrent_graf_data->start_race_panel_top,
		1716	gCurrent_graf_data->start_race_panel_right - gCurrent_graf_data->start_race_panel_left,
		1717	gCurrent_graf_data->start_race_panel_bottom - gCurrent_graf_data->start_race_panel_top);
		1718	}
		1719	} while (result >= 0 && result != 4);
		1720	BrPixelmapFree(gDeceased_image);
		1721	FillInRaceInfo(&gCurrent_race);
		1722	DisposeRaceInfo(&gCurrent_race);
		1723	DisposeFlicPanel(0);
		1724	*pSecond_time_around = 1;
		1725	gProgram_state.dont_load = 0;
		1726	if (result >= 0) {
		1727	*pSecond_time_around = 1;
		1728	if (gProgram_state.parts_shop_visited \|\| !PartsShopRecommended()) {
		1729	FadePaletteDown();
		1730	return eSO_continue;
		1731	} else {
		1732	RunFlic(192);
		1733	return DoAutoPartsShop();
		1734	}
		1735	} else {
		1736	RunFlic(192);
		1737	gDisallow_abandon_race = 1;
		1738	return eSO_main_menu_invoked;
		1739	}
		1740	}
		1741
		1742	// IDA: void __usercall DrawGridCar(int pX@<EAX>, int pY@<EDX>, br_pixelmap *pImage@<EBX>)
		1743	void DrawGridCar(int pX, int pY, br_pixelmap* pImage) {
		1744	LOG_TRACE("(%d, %d, %p)", pX, pY, pImage);
		1745
		1746	if (gCurrent_graf_data->grid_left_clip <= pX && pX + pImage->width < gCurrent_graf_data->grid_right_clip) {
		1747	DRPixelmapRectangleMaskedCopy(gBack_screen, pX, pY, pImage, 0, 0, pImage->width, pImage->height);
		1748	}
		1749	}
		1750
		1751	// IDA: void __usercall DrawGrid(int pOffset@<EAX>, int pDraw_it@<EDX>)
		1752	void DrawGrid(int pOffset, int pDraw_it) {
		1753	int i;
		1754	int j;
		1755	int y;
		1756	int x;
		1757	int str_x;
		1758	//int width_job; // Pierre-Marie Baty -- unused variable
		1759	int done_highest;
		1760	int str_index;
		1761	int swap_1_x = 0;
		1762	int swap_1_y = 0;
		1763	int swap_2_x = 0;
		1764	int swap_2_y = 0;
		1765	br_pixelmap* the_image = NULL;
		1766	br_pixelmap* swap_1_image = NULL;
		1767	br_pixelmap* swap_2_image = NULL;
		1768	char numbers_str[4][100];
		1769	char total_str[256];
		1770	tU32 the_time;
		1771	LOG_TRACE("(%d, %d)", pOffset, pDraw_it);
		1772
		1773	done_highest = 0;
		1774	str_index = 0;
		1775
		1776	memset(numbers_str, 0, sizeof(numbers_str));
		1777	memset(total_str, 0, sizeof(total_str));
		1778
		1779	the_time = PDGetTotalTime();
		1780	BrPixelmapRectangleFill(
		1781	gBack_screen,
		1782	gCurrent_graf_data->grid_left_clip,
		1783	gCurrent_graf_data->grid_top_clip,
		1784	gCurrent_graf_data->grid_right_clip - gCurrent_graf_data->grid_left_clip,
		1785	gCurrent_graf_data->grid_bottom_clip - gCurrent_graf_data->grid_top_clip,
		1786	0);
		1787	for (i = 0; i < gCurrent_race.number_of_racers; i++) {
		1788	if (gCurrent_race.opponent_list[i].index == -1) {
		1789	the_image = gProgram_state.current_car.grid_icon_image;
		1790	} else {
		1791	the_image = gCurrent_race.opponent_list[i].car_spec->grid_icon_image;
		1792	}
		1793	y = gCurrent_graf_data->grid_top_y
		1794	+ i % 2 * gCurrent_graf_data->grid_y_pitch
		1795	- the_image->height / 2
		1796	- gGrid_y_adjust;
		1797	x = gCurrent_graf_data->grid_left_x
		1798	+ i % 2 * gCurrent_graf_data->grid_x_stagger
		1799	+ i / 2 * gCurrent_graf_data->grid_x_pitch
		1800	- pOffset;
		1801	if (i == gSwap_grid_1) {
		1802	swap_1_x = x;
		1803	swap_1_y = y;
		1804	swap_1_image = the_image;
		1805	} else if (i == gSwap_grid_2) {
		1806	swap_2_x = x;
		1807	swap_2_y = y;
		1808	swap_2_image = the_image;
		1809	} else if (gCurrent_race.opponent_list[i].index != -1 \|\| the_time % 900 / 300) {
		1810	DrawGridCar(x, y, the_image);
		1811	}
		1812	if (!done_highest && gCurrent_race.opponent_list[i].ranking >= gProgram_state.rank) {
		1813	done_highest = 1;
		1814	if (x - gCurrent_graf_data->grid_marker_margin >= gCurrent_graf_data->grid_left_clip
		1815	&& x + the_image->width < gCurrent_graf_data->grid_right_clip) {
		1816	BrPixelmapLine(
		1817	gBack_screen,
		1818	x - gCurrent_graf_data->grid_marker_margin,
		1819	y - gCurrent_graf_data->grid_marker_margin,
		1820	x - gCurrent_graf_data->grid_marker_margin,
		1821	y + gCurrent_graf_data->grid_marker_margin + the_image->height,
		1822	45);
		1823	BrPixelmapLine(
		1824	gBack_screen,
		1825	x - gCurrent_graf_data->grid_marker_margin,
		1826	y - gCurrent_graf_data->grid_marker_margin,
		1827	x + gCurrent_graf_data->grid_marker_x_len,
		1828	y - gCurrent_graf_data->grid_marker_margin,
		1829	45);
		1830	BrPixelmapLine(
		1831	gBack_screen,
		1832	x - gCurrent_graf_data->grid_marker_margin,
		1833	y + gCurrent_graf_data->grid_marker_margin + the_image->height,
		1834	x + gCurrent_graf_data->grid_marker_x_len,
		1835	y + gCurrent_graf_data->grid_marker_margin + the_image->height,
		1836	45);
		1837	}
		1838	}
		1839	if (gCurrent_race.opponent_list[i].index < 0) {
		1840	str_index = 2;
		1841	} else if (gProgram_state.rank <= gCurrent_race.opponent_list[i].ranking) {
		1842	if (str_index >= 2) {
		1843	str_index = 3;
		1844	} else {
		1845	str_index = 1;
		1846	}
		1847	}
		1848	if (gCurrent_race.opponent_list[i].index >= 0) {
		1849	if (gOpponents[gCurrent_race.opponent_list[i].index].car_number <= 0
		1850	\|\| gOpponents[gCurrent_race.opponent_list[i].index].car_number >= 100) {
		1851	if (gOpponents[gCurrent_race.opponent_list[i].index].car_number < 0) {
		1852	sprintf(&numbers_str[str_index][strlen(numbers_str[str_index])], "%c ", ':');
		1853	}
		1854	} else {
		1855	sprintf(
		1856	&numbers_str[str_index][strlen(numbers_str[str_index])],
		1857	"%d ",
		1858	gOpponents[gCurrent_race.opponent_list[i].index].car_number);
		1859	}
		1860	} else {
		1861	if (gProgram_state.frank_or_anniness == eAnnie) {
		1862	sprintf(&numbers_str[str_index][strlen(numbers_str[str_index])], "%c ", '<');
		1863	} else {
		1864	sprintf(&numbers_str[str_index][strlen(numbers_str[str_index])], "%c ", ';');
		1865	}
		1866	}
		1867	}
		1868	if (gSwap_grid_1 >= 0) {
		1869	DrawGridCar(
		1870	gGrid_transition_stage * (swap_2_x - swap_1_x) / 100 + swap_1_x,
		1871	gGrid_transition_stage * (swap_2_y - swap_1_y) / 100 + swap_1_y,
		1872	swap_1_image);
		1873	DrawGridCar(
		1874	gGrid_transition_stage * (swap_1_x - swap_2_x) / 100 + swap_2_x,
		1875	gGrid_transition_stage * (swap_1_y - swap_2_y) / 100 + swap_2_y,
		1876	swap_2_image);
		1877	}
		1878	if (gDraw_grid_status == eGrid_draw_all) {
		1879	if (strlen(numbers_str[3])) {
		1880	numbers_str[3][strlen(numbers_str[3]) - 1] = '\0';
		1881	} else {
		1882	numbers_str[2][strlen(numbers_str[2]) - 1] = '\0';
		1883	}
		1884	strcpy(total_str, numbers_str[0]);
		1885	for (i = 1; i < COUNT_OF(numbers_str); i++) {
		1886	strcat(total_str, numbers_str[i]);
		1887	}
		1888	str_x = (gCurrent_graf_data->grid_numbers_left + gCurrent_graf_data->grid_numbers_right) / 2
		1889	- (BrPixelmapTextWidth(gBack_screen, gBig_font, total_str) / 2);
		1890	BrPixelmapRectangleFill(
		1891	gBack_screen,
		1892	gCurrent_graf_data->grid_numbers_left,
		1893	gCurrent_graf_data->grid_numbers_top,
		1894	gCurrent_graf_data->grid_numbers_right - gCurrent_graf_data->grid_numbers_left,
		1895	gBig_font->glyph_y,
		1896	0);
		1897	gGrid_number_x_coords[0] = str_x - 3 - gCurrent_graf_data->grid_numbers_left;
		1898	for (i = 0; i < 4; ++i) {
		1899	if (i != 2 \|\| the_time % 900 / 300) {
		1900	TransBrPixelmapText(
		1901	gBack_screen,
		1902	str_x,
		1903	gCurrent_graf_data->grid_numbers_top,
		1904	gGrid_number_colour[i],
		1905	gBig_font,
		1906	numbers_str[i]);
		1907	}
		1908	str_x += BrPixelmapTextWidth(gBack_screen, gBig_font, numbers_str[i]);
		1909	}
		1910	for (i = gCurrent_race.number_of_racers - 1; i > 0; i--) {
		1911	for (j = strlen(total_str) - 2; j >= 0; j--) {
		1912	if (total_str[j] == ' ') {
		1913	total_str[j + 1] = '\0';
		1914	break;
		1915	}
		1916	}
		1917	gGrid_number_x_coords[i] = gGrid_number_x_coords[0] + BrPixelmapTextWidth(gBack_screen, gBig_font, total_str);
		1918	}
		1919	}
		1920	if (pDraw_it) {
		1921	PDScreenBufferSwap(0);
		1922	}
		1923	}
		1924
		1925	// IDA: void __usercall MoveGrid(int pFrom@<EAX>, int pTo@<EDX>, tS32 pTime_to_move@<EBX>)
		1926	void MoveGrid(int pFrom, int pTo, tS32 pTime_to_move) {
		1927	tS32 start_time;
		1928	tS32 the_time;
		1929	//int move_distance; // Pierre-Marie Baty -- unused variable
		1930	int pitch;
		1931	LOG_TRACE("(%d, %d, %d)", pFrom, pTo, pTime_to_move);
		1932
		1933	pitch = gCurrent_graf_data->grid_x_pitch;
		1934	start_time = PDGetTotalTime();
		1935	while (1) {
		1936	the_time = PDGetTotalTime();
		1937	if (start_time + pTime_to_move <= the_time) {
		1938	break;
		1939	}
		1940	DrawGrid(pitch * pFrom + pitch * (pTo - pFrom) * (the_time - start_time) / pTime_to_move, 1);
		1941	}
		1942	DrawGrid(pitch * pTo, 1);
		1943	}
		1944
		1945	// IDA: int __usercall CalcGridOffset@<EAX>(int pPosition@<EAX>)
		1946	int CalcGridOffset(int pPosition) {
		1947	LOG_TRACE("(%d)", pPosition);
		1948
		1949	return pPosition / 2 - 1;
		1950	}
		1951
		1952	// IDA: void __usercall GridDraw(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		1953	void GridDraw(int pCurrent_choice, int pCurrent_mode) {
		1954	LOG_TRACE8("(%d, %d)", pCurrent_choice, pCurrent_mode);
		1955
		1956	if (gDraw_grid_status > eGrid_draw_none) {
		1957	DrawGrid(gCurrent_graf_data->grid_x_pitch * CalcGridOffset(gOur_starting_position), 0);
		1958	}
		1959	}
		1960
		1961	// IDA: void __usercall ActuallySwapOrder(int pFirst_index@<EAX>, int pSecond_index@<EDX>)
		1962	void ActuallySwapOrder(int pFirst_index, int pSecond_index) {
		1963	tOpp_spec temp_opp;
		1964	LOG_TRACE("(%d, %d)", pFirst_index, pSecond_index);
		1965
		1966	temp_opp = gCurrent_race.opponent_list[pFirst_index];
		1967	gCurrent_race.opponent_list[pFirst_index] = gCurrent_race.opponent_list[pSecond_index];
		1968	gCurrent_race.opponent_list[pSecond_index] = temp_opp;
		1969	gOur_starting_position = pSecond_index;
		1970
		1971	// LOG_DEBUG("first %d, second %d", gCurrent_race.opponent_list[pFirst_index].index, gCurrent_race.opponent_list[pSecond_index].index);
		1972	}
		1973
		1974	// IDA: void __usercall DoGridTransition(int pFirst_index@<EAX>, int pSecond_index@<EDX>)
		1975	void DoGridTransition(int pFirst_index, int pSecond_index) {
		1976	tU32 start_time;
		1977	tU32 the_time;
		1978	LOG_TRACE("(%d, %d)", pFirst_index, pSecond_index);
		1979
		1980	if (pFirst_index != pSecond_index) {
		1981	start_time = PDGetTotalTime();
		1982	gSwap_grid_1 = pFirst_index;
		1983	gSwap_grid_2 = pSecond_index;
		1984	while (1) {
		1985	the_time = PDGetTotalTime();
		1986	if (start_time + 150 <= the_time) {
		1987	break;
		1988	}
		1989	RemoveTransientBitmaps(1);
		1990	gGrid_transition_stage = 100 * (the_time - start_time) / 150;
		1991	DrawGrid(gCurrent_graf_data->grid_x_pitch * CalcGridOffset(gOur_starting_position), 0);
		1992	ProcessFlicQueue(gFrame_period);
		1993	DoMouseCursor();
		1994	PDScreenBufferSwap(0);
		1995	}
		1996	gSwap_grid_1 = -1;
		1997	gSwap_grid_2 = -1;
		1998	ActuallySwapOrder(pFirst_index, pSecond_index);
		1999	MoveGrid(CalcGridOffset(pFirst_index), CalcGridOffset(pSecond_index), 150);
		2000	}
		2001	}
		2002
		2003	// IDA: void __cdecl ChallengeStart()
		2004	void ChallengeStart(void) {
		2005	br_pixelmap* the_map;
		2006	int i;
		2007	int j;
		2008	int line_count;
		2009	int dare_index;
		2010	FILE* f;
		2011	tPath_name the_path;
		2012	char s[256];
		2013	LOG_TRACE("()");
		2014
		2015	InitialiseFlicPanel(
		2016	0,
		2017	gCurrent_graf_data->start_race_panel_left,
		2018	gCurrent_graf_data->start_race_panel_top,
		2019	gCurrent_graf_data->start_race_panel_right - gCurrent_graf_data->start_race_panel_left,
		2020	gCurrent_graf_data->start_race_panel_bottom - gCurrent_graf_data->start_race_panel_top);
		2021	ChangePanelFlic(
		2022	0,
		2023	gOpponents[gChallenger_index__racestrt].mug_shot_image_data,
		2024	gOpponents[gChallenger_index__racestrt].mug_shot_image_data_length);
		2025	if (gScreen->row_bytes < 0) {
		2026	BrFatal("C:\\Msdev\\Projects\\DethRace\\Racestrt.c", 2610, "Bruce bug at line %d, file C:\\Msdev\\Projects\\DethRace\\Racestrt.c", 50);
		2027	}
		2028	the_map = DRPixelmapAllocate(
		2029	gScreen->type,
		2030	gCurrent_graf_data->dare_mugshot_width,
		2031	gCurrent_graf_data->dare_mugshot_height,
		2032	0,
		2033	0);
		2034
		2035	BrPixelmapRectangleCopy(the_map, 0, 0, GetPanelPixelmap(0), gCurrent_graf_data->dare_mug_left_margin, gCurrent_graf_data->dare_mug_top_margin, gCurrent_graf_data->dare_mugshot_width, gCurrent_graf_data->dare_mugshot_height);
		2036	DisposeFlicPanel(0);
		2037	TellyInImage(the_map, gCurrent_graf_data->dare_mugshot_left, gCurrent_graf_data->dare_mugshot_top);
		2038	BrPixelmapFree(the_map);
		2039	the_map = DRPixelmapAllocate(gScreen->type, gCurrent_graf_data->dare_text_width, gCurrent_graf_data->dare_mugshot_height, 0, 0);
		2040	BrPixelmapFill(the_map, 0);
		2041	TransBrPixelmapText(the_map, 0, 0, 1u, gBig_font, gOpponents[gChallenger_index__racestrt].abbrev_name);
		2042	PathCat(the_path, gApplication_path, "DARES.TXT");
		2043	f = DRfopen(the_path, "rt");
		2044	if (f == NULL) {
		2045	FatalError(kFatalError_OpenDareTxt);
		2046	}
		2047
		2048	dare_index = IRandomBetween(0, GetAnInt(f) - 1);
		2049	for (i = 0; i < dare_index; i++) {
		2050	line_count = GetAnInt(f);
		2051	for (j = 0; j < line_count; j++) {
		2052	GetALineAndDontArgue(f, s);
		2053	}
		2054	}
		2055	line_count = GetAnInt(f);
		2056	for (i = 0; i < line_count; i++) {
		2057	GetALineAndDontArgue(f, s);
		2058	TransBrPixelmapText(the_map, 0, 2 * (i + 1) * gBig_font->glyph_y, 0x86u, gBig_font, s);
		2059	}
		2060	fclose(f);
		2061	BrPixelmapLine(the_map, 0, gBig_font->glyph_y + 2, the_map->width, gBig_font->glyph_y + 2, 45);
		2062	TellyInImage(the_map, gCurrent_graf_data->dare_text_left, gCurrent_graf_data->dare_mugshot_top);
		2063	BrPixelmapFree(the_map);
		2064	UnlockOpponentMugshot(gChallenger_index__racestrt);
		2065	gDare_start_time = PDGetTotalTime();
		2066	}
		2067
		2068	// IDA: int __usercall CheckNextStage@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		2069	int CheckNextStage(int* pCurrent_choice, int* pCurrent_mode) {
		2070	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		2071
		2072	if (gDare_start_time && (unsigned int)(PDGetTotalTime() - gDare_start_time) >= 7500) {
		2073	BrPixelmapRectangleFill(
		2074	gBack_screen,
		2075	gCurrent_graf_data->grid_left_clip,
		2076	gCurrent_graf_data->dare_mugshot_top,
		2077	gCurrent_graf_data->grid_right_clip - gCurrent_graf_data->grid_left_clip,
		2078	gCurrent_graf_data->dare_mugshot_height,
		2079	0);
		2080	DoGridTransition(gOur_starting_position, gChallenger_position);
		2081	gDraw_grid_status = eGrid_draw_icons_only;
		2082	gDare_start_time = 0;
		2083	}
		2084	return 0;
		2085	}
		2086
		2087	// IDA: int __usercall ChallengeDone@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pGo_ahead@<EBX>, int pEscaped@<ECX>, int pTimed_out)
		2088	int ChallengeDone(int pCurrent_choice, int pCurrent_mode, int pGo_ahead, int pEscaped, int pTimed_out) {
		2089	LOG_TRACE("(%d, %d, %d, %d, %d)", pCurrent_choice, pCurrent_mode, pGo_ahead, pEscaped, pTimed_out);
		2090
		2091	if (!pEscaped \|\| gDare_start_time) {
		2092	if (!pEscaped && gDare_start_time) {
		2093	ActuallySwapOrder(gOur_starting_position, gChallenger_position);
		2094	ChallengeOccurred(gChallenger_index__racestrt, 1);
		2095	}
		2096	} else {
		2097	DoGridTransition(gOur_starting_position, gOriginal_position);
		2098	ActuallySwapOrder(gOur_starting_position, gOriginal_position);
		2099	ChallengeOccurred(gChallenger_index__racestrt, 0);
		2100	}
		2101	ChallengeOccurred(gChallenger_index__racestrt, pEscaped == 0);
		2102	if (pTimed_out) {
		2103	return 0;
		2104	} else {
		2105	return pCurrent_choice;
		2106	}
		2107	}
		2108
		2109	// IDA: void __cdecl DoChallengeScreen()
		2110	void DoChallengeScreen(void) {
		2111	static tFlicette flicker_on[2] = { { 43, { 54, 108 }, { 157, 377 } }, { 43, { 218, 436 }, { 157, 377 } } };
		2112	static tFlicette flicker_off[2] = { { 42, { 54, 108 }, { 157, 377 } }, { 42, { 218, 436 }, { 157, 377 } } };
		2113	static tFlicette push[2] = { { 304, { 54, 108 }, { 157, 377 } }, { 305, { 218, 436 }, { 157, 377 } } };
		2114	static tMouse_area mouse_areas[2] = {
		2115	{ { 54, 108 }, { 157, 377 }, { 117, 234 }, { 178, 427 }, 0, 0, 0, NULL },
		2116	{ { 218, 436 }, { 157, 377 }, { 281, 562 }, { 178, 427 }, 1, 0, 0, NULL }
		2117	};
		2118	static tInterface_spec interface_spec = {
		2119	0, // initial_imode
		2120	301, // first_opening_flic
		2121	0, // second_opening_flic
		2122	-1, // end_flic_go_ahead
		2123	-1, // end_flic_escaped
		2124	-1, // end_flic_otherwise
		2125	0, // flic_bunch_to_load
		2126	{ -1, 0 }, // move_left_new_mode
		2127	{ -1, 0 }, // move_left_delta
		2128	{ 0, 0 }, // move_left_min
		2129	{ 1, 0 }, // move_left_max
		2130	{ NULL, NULL }, // move_left_proc
		2131	{ -1, 0 }, // move_right_new_mode
		2132	{ 1, 0 }, // move_right_delta
		2133	{ 0, 0 }, // move_right_min
		2134	{ 1, 0 }, // move_right_max
		2135	{ NULL, NULL }, // move_right_proc
		2136	{ -1, 0 }, // move_up_new_mode
		2137	{ 0, 0 }, // move_up_delta
		2138	{ 0, 0 }, // move_up_min
		2139	{ 0, 0 }, // move_up_max
		2140	{ NULL, NULL }, // move_up_proc
		2141	{ -1, 0 }, // move_down_new_mode
		2142	{ 0, 0 }, // move_down_delta
		2143	{ 0, 0 }, // move_down_min
		2144	{ 0, 0 }, // move_down_max
		2145	{ NULL, NULL }, // move_down_proc
		2146	{ 1, 1 }, // go_ahead_allowed
		2147	{ NULL, NULL }, // go_ahead_proc
		2148	{ 1, 1 }, // escape_allowed
		2149	{ NULL, NULL }, // escape_proc
		2150	&CheckNextStage, // exit_proc
		2151	&GridDraw, // draw_proc
		2152	0u, // time_out
		2153	NULL, // start_proc1
		2154	&ChallengeStart, // start_proc2
		2155	&ChallengeDone, // done_proc
		2156	0, // font_needed
		2157	{ 0, 0 }, // typeable
		2158	NULL, // get_original_string
		2159	1, // escape_code
		2160	1, // dont_save_or_load
		2161	2, // number_of_button_flics
		2162	flicker_on, // flicker_on_flics
		2163	flicker_off, // flicker_off_flics
		2164	push, // pushed_flics
		2165	2, // number_of_mouse_areas
		2166	mouse_areas, // mouse_areas
		2167	0, // number_of_recopy_areas
		2168	NULL // recopy_areas
		2169	};
		2170
		2171	//int result; // Pierre-Marie Baty -- unused variable
		2172	LOG_TRACE("()");
		2173
		2174	gOriginal_position = gOur_starting_position;
		2175	gChallenger_position = IRandomBetween(0, 1);
		2176	if (gOpponents[gCurrent_race.opponent_list[gChallenger_position].index].car_number < 0) {
		2177	gChallenger_position ^= 1u;
		2178	}
		2179	gChallenger_index__racestrt = gCurrent_race.opponent_list[gChallenger_position].index;
		2180	LoadOpponentMugShot(gChallenger_index__racestrt);
		2181	gDraw_grid_status = eGrid_draw_none;
		2182	gGrid_y_adjust = gCurrent_graf_data->dare_y_adjust;
		2183	DoInterfaceScreen(&interface_spec, 0, 0);
		2184	}
		2185
		2186	// IDA: int __usercall GridDone@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pGo_ahead@<EBX>, int pEscaped@<ECX>, int pTimed_out)
		2187	int GridDone(int pCurrent_choice, int pCurrent_mode, int pGo_ahead, int pEscaped, int pTimed_out) {
		2188	LOG_TRACE("(%d, %d, %d, %d, %d)", pCurrent_choice, pCurrent_mode, pGo_ahead, pEscaped, pTimed_out);
		2189
		2190	if (pTimed_out) {
		2191	return 0;
		2192	}
		2193	if (pEscaped) {
		2194	return -1;
		2195	}
		2196	return pCurrent_choice;
		2197	}
		2198
		2199	// IDA: void __cdecl GridStart()
		2200	void GridStart(void) {
		2201	LOG_TRACE("()");
		2202
		2203	MoveGrid(-2, CalcGridOffset(gOur_starting_position), 400);
		2204	PrintMemoryDump(0, "IN GRID SCREEN");
		2205	}
		2206
		2207	// IDA: int __usercall GridMoveLeft@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		2208	int GridMoveLeft(int* pCurrent_choice, int* pCurrent_mode) {
		2209	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		2210
		2211	if (gOur_starting_position
		2212	&& gCurrent_race.opponent_list[gOur_starting_position - 1].ranking >= gProgram_state.rank) {
		2213	AddToFlicQueue(
		2214	gStart_interface_spec->pushed_flics[1].flic_index,
		2215	gStart_interface_spec->pushed_flics[1].x[gGraf_data_index],
		2216	gStart_interface_spec->pushed_flics[1].y[gGraf_data_index],
		2217	1);
		2218	DRS3StartSound(gEffects_outlet, 3000);
		2219	DoGridTransition(gOur_starting_position, gOur_starting_position - 1);
		2220	}
		2221	return 0;
		2222	}
		2223
		2224	// IDA: int __usercall GridMoveRight@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		2225	int GridMoveRight(int* pCurrent_choice, int* pCurrent_mode) {
		2226	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		2227
		2228	if (gOur_starting_position < gCurrent_race.number_of_racers - 1) {
		2229	AddToFlicQueue(
		2230	gStart_interface_spec->pushed_flics[2].flic_index,
		2231	gStart_interface_spec->pushed_flics[2].x[gGraf_data_index],
		2232	gStart_interface_spec->pushed_flics[2].y[gGraf_data_index],
		2233	1);
		2234	DRS3StartSound(gEffects_outlet, 3000);
		2235	DoGridTransition(gOur_starting_position, gOur_starting_position + 1);
		2236	}
		2237	return 0;
		2238	}
		2239
		2240	// IDA: int __usercall GridClickCar@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		2241	int GridClickCar(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		2242	int rel_pos;
		2243	int new_pos;
		2244	//int base_pos; // Pierre-Marie Baty -- unused variable
		2245	int x_coord;
		2246	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		2247
		2248	rel_pos = ((gCurrent_graf_data->grid_bottom_clip - gCurrent_graf_data->grid_top_clip) / 2) < pY_offset;
		2249	if (rel_pos) {
		2250	pX_offset -= gCurrent_graf_data->grid_x_stagger;
		2251	}
		2252	x_coord = pX_offset / gCurrent_graf_data->grid_x_pitch;
		2253	if (x_coord > 2) {
		2254	x_coord = 2;
		2255	}
		2256	new_pos = 2 * x_coord + rel_pos + (gOur_starting_position & ~1) - 2;
		2257	if (new_pos >= 0 && new_pos < gCurrent_race.number_of_racers && gProgram_state.rank < gCurrent_race.opponent_list[new_pos].ranking) {
		2258	DRS3StartSound(gEffects_outlet, 3000);
		2259	DoGridTransition(gOur_starting_position, new_pos);
		2260	}
		2261	return 0;
		2262	}
		2263
		2264	// IDA: int __usercall GridClickNumbers@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		2265	int GridClickNumbers(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		2266	int new_pos;
		2267	int i;
		2268	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		2269
		2270	new_pos = -1;
		2271	for (i = 0; i < gCurrent_race.number_of_racers; i++) {
		2272	if (gGrid_number_x_coords[i] <= pX_offset && (gCurrent_race.number_of_racers - 1 == i \|\| pX_offset < gGrid_number_x_coords[i + 1])) {
		2273	new_pos = i;
		2274	break;
		2275	}
		2276	}
		2277	if (new_pos >= 0 && new_pos < gCurrent_race.number_of_racers && gProgram_state.rank <= gCurrent_race.opponent_list[new_pos].ranking) {
		2278	DRS3StartSound(gEffects_outlet, 3000);
		2279	DoGridTransition(gOur_starting_position, new_pos);
		2280	}
		2281	return 0;
		2282	}
		2283
		2284	// IDA: int __usercall GridClickLeft@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		2285	int GridClickLeft(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		2286	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		2287
		2288	GridMoveLeft(pCurrent_choice, pCurrent_mode);
		2289	return 0;
		2290	}
		2291
		2292	// IDA: int __usercall GridClickRight@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pX_offset@<EBX>, int pY_offset@<ECX>)
		2293	int GridClickRight(int* pCurrent_choice, int* pCurrent_mode, int pX_offset, int pY_offset) {
		2294	LOG_TRACE("(%p, %p, %d, %d)", pCurrent_choice, pCurrent_mode, pX_offset, pY_offset);
		2295
		2296	GridMoveRight(pCurrent_choice, pCurrent_mode);
		2297	return 0;
		2298	}
		2299
		2300	// IDA: int __usercall CheckChallenge@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		2301	int CheckChallenge(int* pCurrent_choice, int* pCurrent_mode) {
		2302	LOG_TRACE8("(%p, %p)", pCurrent_choice, pCurrent_mode);
		2303
		2304	if (!gChallenge_time \|\| PDGetTotalTime() < gChallenge_time) {
		2305	return 0;
		2306	}
		2307	*pCurrent_choice = -2;
		2308	return 1;
		2309	}
		2310
		2311	// IDA: int __usercall FindBestPos@<EAX>(int pOur_rank@<EAX>)
		2312	int FindBestPos(int pOur_rank) {
		2313	int i;
		2314	LOG_TRACE("(%d)", pOur_rank);
		2315
		2316	for (i = gCurrent_race.number_of_racers - 1; i >= 0; i--) {
		2317	if (gCurrent_race.opponent_list[i].ranking < pOur_rank) {
		2318	return i + 1;
		2319	}
		2320	}
		2321	return 0;
		2322	}
		2323
		2324	// IDA: int __usercall SortGridFunction@<EAX>(void pFirst_one@<EAX>, void pSecond_one@<EDX>)
		2325	int SortGridFunction(const void* pFirst_one, const void* pSecond_one) {
		2326	LOG_TRACE("(%p, %p)", pFirst_one, pSecond_one);
		2327
		2328	return ((tOpp_spec)pFirst_one)->ranking - ((tOpp_spec)pSecond_one)->ranking;
		2329	}
		2330
		2331	// IDA: void __cdecl SortOpponents()
		2332	void SortOpponents(void) {
		2333	int i;
		2334	LOG_TRACE("()");
		2335
		2336	for (i = 0; gCurrent_race.number_of_racers > i; ++i) {
		2337	if (gCurrent_race.opponent_list[i].index < 0) {
		2338	return;
		2339	}
		2340	}
		2341	qsort(gCurrent_race.opponent_list, gCurrent_race.number_of_racers, sizeof(tOpp_spec), SortGridFunction);
		2342	gBest_pos_available = FindBestPos(gProgram_state.rank);
		2343	gOur_starting_position = gCurrent_race.number_of_racers - 70 * (gCurrent_race.number_of_racers - gBest_pos_available) / 100;
		2344	for (i = gCurrent_race.number_of_racers; i > gOur_starting_position; i--) {
		2345	gCurrent_race.opponent_list[i] = gCurrent_race.opponent_list[i - 1];
		2346	}
		2347	gCurrent_race.opponent_list[gOur_starting_position].index = -1;
		2348	gCurrent_race.opponent_list[gOur_starting_position].ranking = gProgram_state.rank;
		2349	gCurrent_race.opponent_list[gOur_starting_position].car_spec = &gProgram_state.current_car;
		2350	gCurrent_race.number_of_racers++;
		2351	}
		2352
		2353	// IDA: tSO_result __cdecl DoGridPosition()
		2354	tSO_result DoGridPosition(void) {
		2355	static tFlicette flicker_on[3] = {
		2356	{ 43, { 240, 480 }, { 158, 379 } },
		2357	{ 293, { 56, 112 }, { 151, 362 } },
		2358	{ 296, { 136, 272 }, { 151, 362 } }
		2359	};
		2360
		2361	static tFlicette flicker_off[3] = {
		2362	{ 42, { 240, 480 }, { 158, 379 } },
		2363	{ 292, { 56, 112 }, { 151, 362 } },
		2364	{ 295, { 136, 272 }, { 151, 362 } }
		2365	};
		2366
		2367	static tFlicette push[3] = {
		2368	{ 154, { 240, 480 }, { 158, 379 } },
		2369	{ 294, { 56, 112 }, { 151, 362 } },
		2370	{ 297, { 136, 272 }, { 151, 362 } }
		2371	};
		2372	static tMouse_area mouse_areas[5] = {
		2373	{ { 240, 480 }, { 158, 379 }, { 305, 610 }, { 178, 427 }, 0, 0, 0, NULL },
		2374	{ { 56, 112 },
		2375	{ 151, 362 },
		2376	{ 91, 182 },
		2377	{ 158, 379 },
		2378	-1,
		2379	0,
		2380	0,
		2381	GridClickLeft },
		2382	{ { 136, 272 },
		2383	{ 151, 362 },
		2384	{ 171, 342 },
		2385	{ 158, 379 },
		2386	-1,
		2387	0,
		2388	0,
		2389	GridClickRight },
		2390	{ { 52, 104 },
		2391	{ 56, 134 },
		2392	{ 269, 538 },
		2393	{ 141, 338 },
		2394	-1,
		2395	0,
		2396	0,
		2397	GridClickCar },
		2398	{ { 60, 120 },
		2399	{ 163, 391 },
		2400	{ 235, 470 },
		2401	{ 176, 422 },
		2402	-1,
		2403	0,
		2404	0,
		2405	GridClickNumbers }
		2406	};
		2407
		2408	static tInterface_spec interface_spec = {
		2409	0, // initial_imode
		2410	290, // first_opening_flic
		2411	0, // second_opening_flic
		2412	0, // end_flic_go_ahead
		2413	0, // end_flic_escaped
		2414	0, // end_flic_otherwise
		2415	8, // flic_bunch_to_load
		2416	{ -1, 0 }, // move_left_new_mode
		2417	{ 0, 0 }, // move_left_delta
		2418	{ 0, 0 }, // move_left_min
		2419	{ 0, 0 }, // move_left_max
		2420	{ GridMoveLeft, NULL }, // move_left_proc
		2421	{ -1, 0 }, // move_right_new_mode
		2422	{ 0, 0 }, // move_right_delta
		2423	{ 0, 0 }, // move_right_min
		2424	{ 0, 0 }, // move_right_max
		2425	{ GridMoveRight, NULL }, // move_right_proc
		2426	{ -1, 0 }, // move_up_new_mode
		2427	{ 0, 0 }, // move_up_delta
		2428	{ 0, 0 }, // move_up_min
		2429	{ 0, 0 }, // move_up_max
		2430	{ GridMoveLeft, NULL }, // move_up_proc
		2431	{ -1, 0 }, // move_down_new_mode
		2432	{ 0, 0 }, // move_down_delta
		2433	{ 0, 0 }, // move_down_min
		2434	{ 0, 0 }, // move_down_max
		2435	{ GridMoveRight, NULL }, // move_down_proc
		2436	{ 1, 1 }, // go_ahead_allowed
		2437	{ NULL, NULL }, // go_ahead_proc
		2438	{ 1, 1 }, // escape_allowed
		2439	{ NULL, NULL }, // escape_proc
		2440	CheckChallenge, // exit_proc
		2441	GridDraw, // draw_proc
		2442	0u, // time_out
		2443	NULL, // start_proc1
		2444	GridStart, // start_proc2
		2445	GridDone, // done_proc
		2446	0, // font_needed
		2447	{ 0, 0 }, // typeable
		2448	NULL, // get_original_string
		2449	-1, // escape_code
		2450	1, // dont_save_or_load
		2451	3, // number_of_button_flics
		2452	flicker_on, // flicker_on_flics
		2453	flicker_off, // flicker_off_flics
		2454	push, // pushed_flics
		2455	5, // number_of_mouse_areas
		2456	mouse_areas, // mouse_areas
		2457	0, // number_of_recopy_areas
		2458	NULL // recopy_areas
		2459	};
		2460
		2461	int result;
		2462	LOG_TRACE("()");
		2463
		2464	gStart_interface_spec = &interface_spec;
		2465	if (!gAusterity_mode) {
		2466	LoadGridIcons(&gCurrent_race);
		2467	}
		2468	gSwap_grid_1 = -1;
		2469	gSwap_grid_2 = -1;
		2470	gDraw_grid_status = eGrid_draw_all;
		2471	gGrid_y_adjust = 0;
		2472	SortOpponents();
		2473	if (!gAusterity_mode) {
		2474	if (gBest_pos_available > 1
		2475	&& (gOpponents[gCurrent_race.opponent_list[0].index].car_number >= 0
		2476	\|\| gOpponents[gCurrent_race.opponent_list[1].index].car_number >= 0)
		2477	&& PercentageChance(10)) {
		2478	gChallenge_time = PDGetTotalTime() + IRandomBetween(1000, 10000);
		2479	} else {
		2480	gChallenge_time = 0;
		2481	}
		2482	result = DoInterfaceScreen(&interface_spec, 0, 0);
		2483	if (result >= 0) {
		2484	FadePaletteDown();
		2485	} else {
		2486	RunFlic(291);
		2487	}
		2488	if (result == -1) {
		2489	return eSO_main_menu_invoked;
		2490	}
		2491	if (result == -2) {
		2492	DoChallengeScreen();
		2493	}
		2494	DisposeGridIcons(&gCurrent_race);
		2495	}
		2496	return eSO_continue;
		2497	}
		2498
		2499	// IDA: void __cdecl CheckPlayersAreResponding()
		2500	void CheckPlayersAreResponding(void) {
		2501	int i;
		2502	tU32 time;
		2503	tNet_message* message;
		2504	LOG_TRACE("()");
		2505
		2506	time = PDGetTotalTime();
		2507	for (i = 0; i < gNumber_of_net_players; i++) {
		2508	if (i != gThis_net_player_index && time - gNet_players[i].last_heard_from_him > 20000) {
		2509	gNet_players[i].player_status = ePlayer_status_not_responding;
		2510	}
		2511	}
		2512	if (gNet_mode == eNet_mode_client && gLast_host_query == 0) {
		2513	message = NetBuildMessage(NETMSGID_HOSTQUERY, 0);
		2514	NetGuaranteedSendMessageToHost(gCurrent_net_game, message, NULL);
		2515	gLast_host_query = time;
		2516	}
		2517	}
		2518
		2519	// IDA: void __cdecl NetSynchStartStart()
		2520	void NetSynchStartStart(void) {
		2521	LOG_TRACE("()");
		2522
		2523	CheckPlayersAreResponding();
		2524	}
		2525
		2526	// IDA: void __usercall DrawAnItem(int pX@<EAX>, int pY_index@<EDX>, int pFont_index@<EBX>, char *pText@<ECX>)
		2527	// Suffix added to avoid duplicate symbol
		2528	void DrawAnItem__racestrt(int pX, int pY_index, int pFont_index, char* pText) {
		2529	LOG_TRACE("(%d, %d, %d, \"%s\")", pX, pY_index, pFont_index, pText);
		2530
		2531	TransBrPixelmapText(gBack_screen,
		2532	pX,
		2533	gCurrent_graf_data->start_synch_top + gCurrent_graf_data->start_synch_y_pitch * pY_index,
		2534	pFont_index,
		2535	gFont_7,
		2536	pText);
		2537	}
		2538
		2539	// IDA: void __usercall NetSynchStartDraw(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		2540	void NetSynchStartDraw(int pCurrent_choice, int pCurrent_mode) {
		2541	int i;
		2542	int number_ready;
		2543	char s[256];
		2544	LOG_TRACE("(%d, %d)", pCurrent_choice, pCurrent_mode);
		2545
		2546	number_ready = 0;
		2547	CheckPlayersAreResponding();
		2548	NetPlayerStatusChanged(ePlayer_status_ready);
		2549	for (i = 0; i < COUNT_OF(gNet_players); i++) {
		2550	BrPixelmapRectangleFill(gBack_screen,
		2551	gCurrent_graf_data->start_synch_x_0,
		2552	gCurrent_graf_data->start_synch_y_pitch * i + gCurrent_graf_data->start_synch_top,
		2553	gCurrent_graf_data->start_synch_x_r - gCurrent_graf_data->start_synch_x_1,
		2554	gFont_7->glyph_y,
		2555	0);
		2556	}
		2557	for (i = 0; i < gNumber_of_net_players; i++) {
		2558	strcpy(s, gNet_players[i].player_name);
		2559	if (gNet_players[i].host) {
		2560	strcat(s, " -");
		2561	strcat(s, GetMiscString(kMiscString_HOST));
		2562	strcat(s, "-");
		2563	}
		2564	TurnOffPaletteConversion();
		2565	DRPixelmapRectangleMaskedCopy(gBack_screen,
		2566	gCurrent_graf_data->start_synch_x_0,
		2567	gCurrent_graf_data->start_synch_top + 1 + gCurrent_graf_data->start_synch_y_pitch * i,
		2568	gIcons_pix_low_res, /* DOS version uses low res, Windows version uses normal res */
		2569	0,
		2570	gNet_players[i].car_index * gCurrent_graf_data->net_head_icon_height,
		2571	gIcons_pix_low_res->width, /* DOS version uses low res, Windows version uses normal res */
		2572	gCurrent_graf_data->net_head_icon_height);
		2573	TurnOnPaletteConversion();
		2574	DrawAnItem__racestrt(
		2575	gCurrent_graf_data->start_synch_x_1,
		2576	i,
		2577	(gNet_players[i].player_status == ePlayer_status_ready) ? 66 : 4,
		2578	s);
		2579	DrawAnItem__racestrt(gCurrent_graf_data->start_synch_x_2,
		2580	i,
		2581	(gNet_players[i].player_status == ePlayer_status_ready) ? 83 : ((gNet_players[i].player_status == ePlayer_status_not_responding) ? 247 : 4),
		2582	GetMiscString(kMiscString_NetworkPlayerStatus_START + gNet_players[i].player_status));
		2583	if (gNet_players[i].player_status == ePlayer_status_ready) {
		2584	number_ready++;
		2585	}
		2586	}
		2587	if (gNet_mode == eNet_mode_host && gNumber_of_net_players == number_ready && gNumber_of_net_players > 1 && (!gNo_races_yet \|\| gNumber_of_net_players == 6)) {
		2588	SignalToStartRace();
		2589	gSynch_race_start = 1;
		2590	}
		2591	}
		2592
		2593	// IDA: int __usercall NetSynchStartDone@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>, int pGo_ahead@<EBX>, int pEscaped@<ECX>, int pTimed_out)
		2594	int NetSynchStartDone(int pCurrent_choice, int pCurrent_mode, int pGo_ahead, int pEscaped, int pTimed_out) {
		2595	LOG_TRACE("(%d, %d, %d, %d, %d)", pCurrent_choice, pCurrent_mode, pGo_ahead, pEscaped, pTimed_out);
		2596
		2597	if (pEscaped) {
		2598	pCurrent_choice = -1;
		2599	} else if (pCurrent_choice == 0) {
		2600	gProgram_state.prog_status = eProg_idling;
		2601	}
		2602	return pCurrent_choice;
		2603	}
		2604
		2605	// IDA: int __usercall NetSynchStartGoAhead@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		2606	int NetSynchStartGoAhead(int* pCurrent_choice, int* pCurrent_mode) {
		2607	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		2608
		2609	if (pCurrent_choice == 0 \|\| (gNet_mode == eNet_mode_host && pCurrent_choice >= 0)) {
		2610	if (*pCurrent_choice == 0) {
		2611	gProgram_state.prog_status = eProg_idling;
		2612	return 1;
		2613	} else if (gNet_mode == eNet_mode_host && *pCurrent_choice == 1) {
		2614	if (gNumber_of_net_players <= 1) {
		2615	DRS3StartSound(gEffects_outlet, 3100);
		2616	return 0;
		2617	} else {
		2618	SignalToStartRace();
		2619	gSynch_race_start = 1;
		2620	gNo_races_yet = 0;
		2621	return 1;
		2622	}
		2623	} else {
		2624	return 1;
		2625	}
		2626	} else {
		2627	DRS3StartSound(gEffects_outlet, 3100);
		2628	return 0;
		2629	}
		2630	}
		2631
		2632	// IDA: int __usercall ExitWhenReady@<EAX>(int pCurrent_choice@<EAX>, int pCurrent_mode@<EDX>)
		2633	int ExitWhenReady(int* pCurrent_choice, int* pCurrent_mode) {
		2634	LOG_TRACE("(%p, %p)", pCurrent_choice, pCurrent_mode);
		2635
		2636	if (!gSynch_race_start && gProgram_state.prog_status != eProg_game_starting) {
		2637	if (gProgram_state.prog_status == eProg_idling) {
		2638	*pCurrent_choice = 0;
		2639	return 1;
		2640	} else {
		2641	return 0;
		2642	}
		2643	} else {
		2644	*pCurrent_choice = 1;
		2645	return 1;
		2646	}
		2647	}
		2648
		2649	// IDA: tSO_result __usercall NetSynchRaceStart2@<EAX>(tNet_synch_mode pMode@<EAX>)
		2650	tSO_result NetSynchRaceStart2(tNet_synch_mode pMode) {
		2651	static tFlicette flicker_on_hf[2] = {
		2652	{ 321, { 219, 112 }, { 172, 362 } },
		2653	{ 321, { 39, 480 }, { 172, 379 } },
		2654	};
		2655	static tFlicette flicker_off_hf[2] = {
		2656	{ 322, { 219, 112 }, { 172, 362 } },
		2657	{ 322, { 39, 480 }, { 172, 379 } },
		2658	};
		2659	static tFlicette push_hf[2] = {
		2660	{ 206, { 219, 112 }, { 172, 362 } },
		2661	{ 205, { 39, 480 }, { 172, 379 } },
		2662	};
		2663	static tMouse_area mouse_areas_hf[2] = {
		2664	{ { 219, 480 }, { 172, 379 }, { 282, 182 }, { 192, 427 }, 0, 0, 0, NULL },
		2665	{ { 39, 112 }, { 172, 362 }, { 102, 182 }, { 192, 379 }, 1, 0, 0, NULL },
		2666	};
		2667	static tInterface_spec interface_spec_hf = {
		2668	0,
		2669	203,
		2670	0,
		2671	0,
		2672	0,
		2673	0,
		2674	8,
		2675	{ -1, 0 },
		2676	{ 1, 0 },
		2677	{ 0, 0 },
		2678	{ 1, 0 },
		2679	{ NULL, NULL },
		2680	{ -1, 0 },
		2681	{ 1, 0 },
		2682	{ 0, 0 },
		2683	{ 1, 0 },
		2684	{ NULL, NULL },
		2685	{ -1, 0 },
		2686	{ 1, 0 },
		2687	{ 0, 0 },
		2688	{ 1, 0 },
		2689	{ NULL, NULL },
		2690	{ -1, 0 },
		2691	{ 1, 0 },
		2692	{ 0, 0 },
		2693	{ 1, 0 },
		2694	{ NULL, NULL },
		2695	{ 1, 1 },
		2696	{ NetSynchStartGoAhead, NetSynchStartGoAhead },
		2697	{ 1, 1 },
		2698	{ NULL, NULL },
		2699	ExitWhenReady,
		2700	NetSynchStartDraw,
		2701	0,
		2702	NULL,
		2703	NetSynchStartStart,
		2704	NetSynchStartDone,
		2705	0,
		2706	{ 0, 0 },
		2707	NULL,
		2708	-1,
		2709	1,
		2710	COUNT_OF(flicker_on_hf),
		2711	flicker_on_hf,
		2712	flicker_off_hf,
		2713	push_hf,
		2714	COUNT_OF(mouse_areas_hf),
		2715	mouse_areas_hf,
		2716	0,
		2717	NULL,
		2718	};
		2719	static tFlicette flicker_on_hs[1] = {
		2720	{ 321, { 219, 112 }, { 172, 362 } },
		2721	};
		2722	static tFlicette flicker_off_hs[1] = {
		2723	{ 322, { 219, 112 }, { 172, 362 } },
		2724	};
		2725	static tFlicette push_hs[1] = {
		2726	{ 206, { 219, 112 }, { 172, 362 } },
		2727	};
		2728	static tMouse_area mouse_areas_hs[1] = {
		2729	{ { 219, 480 }, { 172, 379 }, { 282, 182 }, { 192, 427 }, 0, 0, 0, NULL },
		2730	};
		2731	static tInterface_spec interface_spec_hs = {
		2732	0, 209, 0, 0, 0, 0, 8,
		2733	{ -1, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		2734	{ -1, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		2735	{ -1, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		2736	{ -1, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		2737	{ 1, 1 }, { NetSynchStartGoAhead, NetSynchStartGoAhead }, { 1, 1 }, { NULL, NULL },
		2738	ExitWhenReady, NetSynchStartDraw, 0, NULL, NetSynchStartStart, NetSynchStartDone, 0, { 0, 0 },
		2739	NULL, -1, 1,
		2740	COUNT_OF(flicker_on_hs), flicker_on_hs, flicker_off_hs, push_hs,
		2741	COUNT_OF(mouse_areas_hs), mouse_areas_hs, 0, NULL
		2742	};
		2743	static tFlicette flicker_on_c[1] = {
		2744	{ 321, { 219, 112 }, { 172, 362 } },
		2745	};
		2746	static tFlicette flicker_off_c[1] = {
		2747	{ 322, { 219, 112 }, { 172, 362 } },
		2748	};
		2749	static tFlicette push_c[1] = {
		2750	{ 207, { 219, 112 }, { 172, 362 } },
		2751	};
		2752	static tMouse_area mouse_areas_c[1] = {
		2753	{ { 219, 112 }, { 172, 362 }, { 282, 182 }, { 192, 379 }, 0, 0, 0, NULL },
		2754	};
		2755	static tInterface_spec interface_spec_c = {
		2756	0, 204, 0, 0, 0, 0, 8,
		2757	{ -1, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		2758	{ -1, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		2759	{ -1, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		2760	{ -1, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { NULL, NULL },
		2761	{ 1, 1 }, { NetSynchStartGoAhead, NetSynchStartGoAhead }, { 1, 1 }, { NULL, NULL },
		2762	ExitWhenReady, NetSynchStartDraw, 0, NULL, NetSynchStartStart, NetSynchStartDone, 0, { 0, 0 },
		2763	NULL, -1, 1,
		2764	COUNT_OF(flicker_on_c), flicker_on_c, flicker_off_c, push_c,
		2765	COUNT_OF(mouse_areas_c), mouse_areas_c, 0, NULL
		2766	};
		2767	int result;
		2768	LOG_TRACE("(%d)", pMode);
		2769
		2770	if (pMode != eNet_synch_client) {
		2771	if (gCurrent_net_game->status.stage == eNet_game_starting) {
		2772	gCurrent_net_game->status.stage = eNet_game_ready;
		2773	}
		2774	SetUpNetCarPositions();
		2775	// gNet_synch_start = PDGetTotalTime();
		2776	}
		2777	TurnOnPaletteConversion();
		2778	switch (pMode) {
		2779	case eNet_synch_host_first:
		2780	result = DoInterfaceScreen(&interface_spec_hf, 0, 1);
		2781	break;
		2782	case eNet_synch_host_subsequent:
		2783	result = DoInterfaceScreen(&interface_spec_hs, 0, -1);
		2784	break;
		2785	case eNet_synch_client:
		2786	result = DoInterfaceScreen(&interface_spec_c, 0, -1);
		2787	break;
		2788	default:
		2789	break;
		2790	}
		2791	TurnOffPaletteConversion();
		2792	FadePaletteDown();
		2793	if (result > -2 && result < 1) {
		2794	NetLeaveGame(gCurrent_net_game);
		2795	}
		2796	return eSO_continue;
		2797	}
		2798
		2799	// IDA: tSO_result __cdecl NetSynchRaceStart()
		2800	tSO_result NetSynchRaceStart(void) {
		2801	LOG_TRACE("()");
		2802
		2803	SuspendPendingFlic();
		2804	if (gNet_mode == eNet_mode_host) {
		2805	if (gNo_races_yet) {
		2806	return NetSynchRaceStart2(eNet_synch_host_first);
		2807	} else {
		2808	return NetSynchRaceStart2(eNet_synch_host_subsequent);
		2809	}
		2810	} else {
		2811	return NetSynchRaceStart2(eNet_synch_client);
		2812	}
		2813	}

Subversion Repositories Games.Carmageddon

Games.Carmageddon/src/DETHRACE/common/racestrt.c – Rev 18