1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "window.h"

     6

#include "gui.h"

     7

#include "viewport.h"

     8

#include "gfx.h"

     9

#include "sound.h"

    10

#include "command.h"

    11

#include "vehicle.h"

    12

#include "station.h"

    13

    14

static uint _cur_railtype;

    15

static bool _remove_button_clicked;

    16

static byte _build_depot_direction;

    17

static byte _waypoint_count=1;

    18

static byte _cur_waypoint_type;

    19

    20

struct {

    21

	byte orientation;

    22

	byte numtracks;

    23

	byte platlength;

    24

	bool dragdrop;

    25

} _railstation;

    26

    27

    28

static void HandleStationPlacement(uint start, uint end);

    29

static void ShowBuildTrainDepotPicker();

    30

static void ShowBuildWaypointPicker();

    31

static void ShowStationBuilder();

    32

    33

typedef void OnButtonClick(Window *w);

    34

    35

void CcPlaySound1E(bool success, uint tile, uint32 p1, uint32 p2)

    36

{

    37

	if (success) SndPlayTileFx(SND_20_SPLAT_2, tile);

    38

}

    39

    40

static void GenericPlaceRail(uint tile, int cmd)

    41

{

    42

	DoCommandP(tile, _cur_railtype, cmd, CcPlaySound1E,

    43

		_remove_button_clicked ?

    44

		CMD_REMOVE_SINGLE_RAIL | CMD_MSG(STR_1012_CAN_T_REMOVE_RAILROAD_TRACK) | CMD_AUTO | CMD_NO_WATER :

    45

		CMD_BUILD_SINGLE_RAIL | CMD_MSG(STR_1011_CAN_T_BUILD_RAILROAD_TRACK) | CMD_AUTO | CMD_NO_WATER

    46

		);

    47

}

    48

    49

static void PlaceRail_N(uint tile)

    50

{

    51

	int cmd = _tile_fract_coords.x > _tile_fract_coords.y ? 4 : 5;

    52

	GenericPlaceRail(tile, cmd);

    53

}

    54

    55

static void PlaceRail_NE(uint tile)

    56

{

    57

	VpStartPlaceSizing(tile, VPM_FIX_Y);

    58

}

    59

    60

static void PlaceRail_E(uint tile)

    61

{

    62

	int cmd = _tile_fract_coords.x + _tile_fract_coords.y <= 15 ? 2 : 3;

    63

	GenericPlaceRail(tile, cmd);

    64

}

    65

    66

static void PlaceRail_NW(uint tile)

    67

{

    68

	VpStartPlaceSizing(tile, VPM_FIX_X);

    69

}

    70

    71

static void PlaceRail_AutoRail(uint tile)

    72

{

    73

	VpStartPlaceSizing(tile, VPM_RAILDIRS);

    74

}

    75

    76

static int16 _place_depot_offs_xy[4] = { -1,	0x100,	1,	-0x100};

    77

    78

static void PlaceExtraDepotRail(uint tile, uint16 extra)

    79

{

    80

	byte b = _map5[tile];

    81

    82

	if (b & 0xC0 || !(b & (extra >> 8)))

    83

		return;

    84

    85

	DoCommandP(tile, _cur_railtype, extra & 0xFF, NULL, CMD_BUILD_SINGLE_RAIL | CMD_AUTO | CMD_NO_WATER);

    86

}

    87

    88

static const uint16 _place_depot_extra[12] = {

    89

	0x604,		0x2102,		0x1202,		0x505,

    90

	0x2400,		0x2801,		0x1800,		0x1401,

    91

	0x2203,		0x904,		0x0A05,		0x1103,

    92

};

    93

    94

    95

void CcRailDepot(bool success, uint tile, uint32 p1, uint32 p2)

    96

{

    97

	if (success) {

    98

		int dir = p2;

    99

   100

		SndPlayTileFx(SND_20_SPLAT_2, tile);

   101

		ResetObjectToPlace();

   102

   103

		tile += _place_depot_offs_xy[dir];

   104

   105

		if (IS_TILETYPE(tile, MP_RAILWAY)) {

   106

			PlaceExtraDepotRail(tile, _place_depot_extra[dir]);

   107

			PlaceExtraDepotRail(tile, _place_depot_extra[dir + 4]);

   108

			PlaceExtraDepotRail(tile, _place_depot_extra[dir + 8]);

   109

		}

   110

	}

   111

}

   112

   113

static void PlaceRail_Depot(uint tile)

   114

{

   115

	DoCommandP(tile, _cur_railtype, _build_depot_direction, CcRailDepot,

   116

		CMD_BUILD_TRAIN_DEPOT | CMD_AUTO | CMD_NO_WATER | CMD_MSG(STR_100E_CAN_T_BUILD_TRAIN_DEPOT));

   117

}

   118

   119

static void PlaceRail_Waypoint(uint tile)

   120

{

   121

	if (!_remove_button_clicked) {

   122

		DoCommandP(tile, _waypoint_count > 0 ? (0x100 + _cur_waypoint_type) : 0, 0, CcPlaySound1E, CMD_BUILD_TRAIN_WAYPOINT | CMD_MSG(STR_CANT_BUILD_TRAIN_WAYPOINT));

   123

	} else {

   124

		DoCommandP(tile, 0, 0, CcPlaySound1E, CMD_REMOVE_TRAIN_WAYPOINT | CMD_MSG(STR_CANT_REMOVE_TRAIN_WAYPOINT));

   125

	}

   126

}

   127

   128

void CcStation(bool success, uint tile, uint32 p1, uint32 p2)

   129

{

   130

	if (success) {

   131

		SndPlayTileFx(SND_20_SPLAT_2, tile);

   132

		ResetObjectToPlace();

   133

	}

   134

}

   135

   136

static void PlaceRail_Station(uint tile)

   137

{

   138

	if(_remove_button_clicked)

   139

		DoCommandP(tile, 0, 0, CcPlaySound1E, CMD_REMOVE_FROM_RAILROAD_STATION | CMD_MSG(STR_CANT_REMOVE_PART_OF_STATION));

   140

	else if (_railstation.dragdrop) {

   141

		VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED);

   142

		VpSetPlaceSizingLimit(_patches.station_spread);

   143

	} else {

   144

		// TODO: Custom station selector GUI. Now we just try using first custom station

   145

		// (and fall back to normal stations if it isn't available).

   146

		DoCommandP(tile, _railstation.orientation | (_railstation.numtracks<<8) | (_railstation.platlength<<16),_cur_railtype|1<<4, CcStation,

   147

				CMD_BUILD_RAILROAD_STATION | CMD_NO_WATER | CMD_AUTO | CMD_MSG(STR_100F_CAN_T_BUILD_RAILROAD_STATION));

   148

	}

   149

}

   150

   151

static void GenericPlaceSignals(uint tile)

   152

{

   153

	uint trackstat;

   154

	int i;

   155

   156

	trackstat = (byte)GetTileTrackStatus(tile, TRANSPORT_RAIL);

   157

   158

	if ((trackstat & 0x30) == 0x30) {

   159

		trackstat = (_tile_fract_coords.x <= _tile_fract_coords.y) ? 0x20 : 0x10;

   160

	}

   161

   162

	if ((trackstat & 0x0C) == 0x0C) {

   163

		trackstat = (_tile_fract_coords.x + _tile_fract_coords.y <= 15) ? 4 : 8;

   164

	}

   165

   166

	// Lookup the bit index

   167

	i = 0;

   168

	if (trackstat != 0) {	while (!(trackstat & 1)) { i++; trackstat >>= 1; }}

   169

   170

	if (!_remove_button_clicked) {

   171

		DoCommandP(tile, i + (_ctrl_pressed ? 8 : 0), 0, CcPlaySound1E,

   172

			CMD_BUILD_SIGNALS | CMD_AUTO | CMD_MSG(STR_1010_CAN_T_BUILD_SIGNALS_HERE));

   173

	} else {

   174

		DoCommandP(tile, i, 0, CcPlaySound1E,

   175

			CMD_REMOVE_SIGNALS | CMD_AUTO | CMD_MSG(STR_1013_CAN_T_REMOVE_SIGNALS_FROM));

   176

	}

   177

}

   178

   179

static void PlaceRail_Bridge(uint tile)

   180

{

   181

	VpStartPlaceSizing(tile, VPM_X_OR_Y);

   182

}

   183

   184

void CcBuildRailTunnel(bool success, uint tile, uint32 p1, uint32 p2)

   185

{

   186

	if (success) {

   187

		SndPlayTileFx(SND_20_SPLAT_2, tile);

   188

		ResetObjectToPlace();

   189

	} else {

   190

		SetRedErrorSquare(_build_tunnel_endtile);

   191

	}

   192

}

   193

   194

static void PlaceRail_Tunnel(uint tile)

   195

{

   196

	DoCommandP(tile, _cur_railtype, 0, CcBuildRailTunnel,

   197

		CMD_BUILD_TUNNEL | CMD_AUTO | CMD_MSG(STR_5016_CAN_T_BUILD_TUNNEL_HERE));

   198

}

   199

   200

void PlaceProc_BuyLand(uint tile)

   201

{

   202

	DoCommandP(tile, 0, 0, CcPlaySound1E, CMD_PURCHASE_LAND_AREA | CMD_AUTO | CMD_NO_WATER | CMD_MSG(STR_5806_CAN_T_PURCHASE_THIS_LAND));

   203

}

   204

   205

static void PlaceRail_ConvertRail(uint tile)

   206

{

   207

	VpStartPlaceSizing(tile, VPM_X_AND_Y | (1<<4));

   208

}

   209

   210

static void PlaceRail_AutoSignals(uint tile)

   211

{

   212

	VpStartPlaceSizing(tile, VPM_SIGNALDIRS);

   213

}

   214

   215

static void BuildRailClick_N(Window *w)

   216

{

   217

	HandlePlacePushButton(w, 4, _cur_railtype*4 + 0x4EF, 1, PlaceRail_N);

   218

}

   219

   220

static void BuildRailClick_NE(Window *w)

   221

{

   222

	HandlePlacePushButton(w, 5, _cur_railtype*4 + 0x4F0, 1, PlaceRail_NE);

   223

}

   224

   225

static void BuildRailClick_E(Window *w)

   226

{

   227

	HandlePlacePushButton(w, 6, _cur_railtype*4 + 0x4F1, 1, PlaceRail_E);

   228

}

   229

   230

static void BuildRailClick_NW(Window *w)

   231

{

   232

	HandlePlacePushButton(w, 7, _cur_railtype*4 + 0x4F2, 1, PlaceRail_NW);

   233

}

   234

   235

static void BuildRailClick_AutoRail(Window *w)

   236

{

   237

	HandlePlacePushButton(w, 8, _cur_railtype + SPR_OPENTTD_BASE + 4, 1, PlaceRail_AutoRail);

   238

}

   239

   240

static void BuildRailClick_Demolish(Window *w)

   241

{

   242

	HandlePlacePushButton(w, 9, ANIMCURSOR_DEMOLISH, 1, PlaceProc_DemolishArea);

   243

}

   244

   245

static const SpriteID _depot_cursors[] = {

   246

	0x510,

   247

	SPR_OPENTTD_BASE + 14,

   248

	SPR_OPENTTD_BASE + 15,

   249

};

   250

   251

static void BuildRailClick_Depot(Window *w)

   252

{

   253

	if (HandlePlacePushButton(w, 10, _depot_cursors[_cur_railtype], 1, PlaceRail_Depot)) ShowBuildTrainDepotPicker();

   254

}

   255

   256

static void BuildRailClick_Waypoint(Window *w)

   257

{

   258

	_waypoint_count = GetCustomStationsCount(STAT_CLASS_WAYP);

   259

	if (HandlePlacePushButton(w, 11, SPR_OPENTTD_BASE + 7, 1, PlaceRail_Waypoint)

   260

	    && _waypoint_count > 1)

   261

		ShowBuildWaypointPicker();

   262

}

   263

   264

static void BuildRailClick_Station(Window *w)

   265

{

   266

	if (HandlePlacePushButton(w, 12, 0x514, 1, PlaceRail_Station)) ShowStationBuilder();

   267

}

   268

   269

static void BuildRailClick_AutoSignals(Window *w)

   270

{

   271

	HandlePlacePushButton(w, 13, ANIMCURSOR_BUILDSIGNALS , 1, PlaceRail_AutoSignals);

   272

}

   273

   274

static void BuildRailClick_Bridge(Window *w)

   275

{

   276

	HandlePlacePushButton(w, 14, 0xA21, 1, PlaceRail_Bridge);

   277

}

   278

   279

static void BuildRailClick_Tunnel(Window *w)

   280

{

   281

	HandlePlacePushButton(w, 15, 0x982 + _cur_railtype, 3, PlaceRail_Tunnel);

   282

}

   283

   284

static void BuildRailClick_Remove(Window *w)

   285

{

   286

	if (w->disabled_state & (1<<16))

   287

		return;

   288

	SetWindowDirty(w);

   289

	SndPlayFx(SND_15_BEEP);

   290

   291

	_thd.make_square_red = !!((w->click_state ^= (1 << 16)) & (1<<16));

   292

	MarkTileDirty(_thd.pos.x, _thd.pos.y);

   293

	_remove_button_clicked = (w->click_state & (1 << 16)) != 0;

   294

   295

	// handle station builder

   296

	if( w->click_state & (1 << 16) )

   297

	{

   298

		if(_remove_button_clicked)

   299

			SetTileSelectSize(1, 1);

   300

		else

   301

			BringWindowToFrontById(WC_BUILD_STATION, 0);

   302

	}

   303

}

   304

   305

static void BuildRailClick_Convert(Window *w)

   306

{

   307

	HandlePlacePushButton(w, 17, (SPR_OPENTTD_BASE + 26) + _cur_railtype * 2, 1, PlaceRail_ConvertRail);

   308

}

   309

   310

static void BuildRailClick_Landscaping(Window *w)

   311

{

   312

	ShowTerraformToolbar();

   313

}

   314

   315

   316

static void DoRailroadTrack(int mode)

   317

{

   318

	DoCommandP(TILE_FROM_XY(_thd.selstart.x, _thd.selstart.y), PACK_POINT(_thd.selend.x, _thd.selend.y), (mode << 4) | _cur_railtype, NULL,

   319

		_remove_button_clicked ?

   320

		CMD_REMOVE_RAILROAD_TRACK | CMD_AUTO | CMD_NO_WATER | CMD_MSG(STR_1012_CAN_T_REMOVE_RAILROAD_TRACK) :

   321

		CMD_BUILD_RAILROAD_TRACK | CMD_AUTO | CMD_NO_WATER | CMD_MSG(STR_1011_CAN_T_BUILD_RAILROAD_TRACK)

   322

	);

   323

}

   324

   325

typedef struct {

   326

	byte bit, a,b, mouse;

   327

} BestFitStruct;

   328

   329

#define M(d,m) (d << 6) | (m)

   330

static const BestFitStruct _bestfit[] = {

   331

	// both edges have rail

   332

	{2, M(0, 1+8), M(3, 2+8), 0}, // upper track

   333

	{3, M(2, 1+4), M(1, 2+4), 0}, // lower track

   334

   335

	{4, M(2, 1+32), M(3, 2+32), 1<<2}, // left track

   336

	{5, M(0, 1+16), M(1, 2+16), 1<<3}, // right track

   337

   338

	{0, M(0,1+8+16), M(2,1+4+32), 0}, // diag1 track

   339

	{1, M(3,2+8+32), M(1,2+4+16), 0}, // diag2 track

   340

   341

	// one edge with rail

   342

	{0, M(0,1), 0, 0}, // diag1 track

   343

	{0, M(2,1), 0, 0}, // diag1 track

   344

   345

	{1, M(1,2), 0, 0}, // diag2 track

   346

	{1, M(3,2), 0, 0}, // diag2 track

   347

   348

	{2, M(0,8), 0, 1<<0}, // upper track

   349

	{2, M(3,8), 0, 1<<0}, // upper track

   350

   351

	{3, M(1,4), 0, 1<<1}, // lower track

   352

	{3, M(2,4), 0, 1<<1}, // lower track

   353

   354

	{4, M(2,32), 0, 1<<2}, // left track

   355

	{4, M(3,32), 0, 1<<2}, // left track

   356

   357

	{5, M(0,16), 0, 1<<3}, // right track

   358

	{5, M(1,16), 0, 1<<3}, // right track

   359

   360

	{0xff, 0, 0, 0},

   361

};

   362

#undef M

   363

   364

static int GetBestArea(int x, int y)

   365

{

   366

	int r = 0;

   367

	if (x + y > 0x10) r += 2;

   368

	else if (x + y == 0x10) return -1;

   369

	if (y - x > 0) r += 1;

   370

	else if (y - x == 0) return -1;

   371

	return r;

   372

}

   373

   374

static int GetBestFit1x1(int x, int y)

   375

{

   376

	byte m[5];

   377

	const BestFitStruct *bfs;

   378

	byte mouse;

   379

	uint tile;

   380

	int best;

   381

	int i;

   382

   383

	// determine the mouse regions

   384

	mouse = ((x & 0xF) + (y & 0xF) < 0x10 ? 1 << 0 : 1 << 1) +

   385

					((x & 0xF) > (y & 0xF) ? 1 << 2 : 1 << 3);

   386

   387

	// get the rail in each direction

   388

	tile = TILE_FROM_XY(x,y);

   389

	for(i=0; i!=5; i++) {

   390

		static TileIndexDiff _tile_inc[5] = {

   391

			TILE_XY(-1, 0),

   392

			TILE_XY(0, 1) - TILE_XY(-1, 0),

   393

			TILE_XY(1, 0) - TILE_XY(0, 1),

   394

			TILE_XY(0, -1) - TILE_XY(1, 0),

   395

			TILE_XY(0, 0) - TILE_XY(0, -1),

   396

		};

   397

		tile += _tile_inc[i];

   398

		m[i] = 0;

   399

		if (IS_TILETYPE(tile, MP_RAILWAY) && _map5[tile] < 0x80)

   400

			m[i] = _map5[tile]&0x3F;

   401

   402

		// handle tracks under bridge

   403

		if(IS_TILETYPE(tile, MP_TUNNELBRIDGE) && (_map5[tile]&0xF8)==0xE0)

   404

			m[i] = (byte) !(_map5[tile]&0x01) + 1;

   405

   406

		if (_remove_button_clicked) m[i] ^= 0x3F;

   407

	}

   408

   409

	// check "mouse gesture"?

   410

	{

   411

		int a1,a2;

   412

		if ((a1 = GetBestArea(x & 0xF, y & 0xF)) != -1 && (a2 = GetBestArea(_tile_fract_coords.x, _tile_fract_coords.y)) != -1 && a1 != a2) {

   413

			static const byte _get_dir_by_areas[4][4] = {

   414

				{0,2,4,1},

   415

				{2,0,0,5},

   416

				{4,0,0,3},

   417

				{1,5,3,0},

   418

			};

   419

			i = _get_dir_by_areas[a2][a1];

   420

			if (!HASBIT(m[4], i))

   421

				return i;

   422

		}

   423

	}

   424

	// check each bestfit struct

   425

	for(bfs = _bestfit, best=-1; bfs->bit != 0xFF; bfs++) {

   426

		if ((bfs->a & m[bfs->a >> 6]) && (!bfs->b || bfs->b & m[bfs->b >> 6]) && !HASBIT(m[4], bfs->bit)) {

   427

			if ( (byte)(~mouse & bfs->mouse) == 0)

   428

				return bfs->bit;

   429

			if (best != -1)

   430

				return best;

   431

			best = bfs->bit;

   432

		}

   433

	}

   434

   435

	return best;

   436

}

   437

   438

static void SwapSelection()

   439

{

   440

	TileHighlightData *thd = &_thd;

   441

	Point pt = thd->selstart;

   442

	thd->selstart.x = thd->selend.x & ~0xF;

   443

	thd->selstart.y = thd->selend.y & ~0xF;

   444

	thd->selend = pt;

   445

}

   446

   447

static bool Check2x1AutoRail(int mode)

   448

{

   449

	TileHighlightData *thd = &_thd;

   450

	int fxpy = _tile_fract_coords.x + _tile_fract_coords.y;

   451

	int sxpy = (thd->selend.x & 0xF) + (thd->selend.y & 0xF);

   452

	int fxmy = _tile_fract_coords.x - _tile_fract_coords.y;

   453

	int sxmy = (thd->selend.x & 0xF) - (thd->selend.y & 0xF);

   454

   455

	switch(mode) {

   456

	case 0:

   457

		if (fxpy >= 20 && sxpy <= 12) { SwapSelection(); DoRailroadTrack(0); return true; }

   458

		if (fxmy < -3 && sxmy > 3) { DoRailroadTrack(0); return true; }

   459

		break;

   460

   461

	case 1:

   462

		if (fxmy > 3 && sxmy < -3) { SwapSelection(); DoRailroadTrack(0); return true; }

   463

		if (fxpy <= 12 && sxpy >= 20) { DoRailroadTrack(0); return true; }

   464

		break;

   465

   466

	case 2:

   467

		if (fxmy > 3 && sxmy < -3) { DoRailroadTrack(3); return true; }

   468

		if (fxpy >= 20 && sxpy <= 12) { SwapSelection(); DoRailroadTrack(0); return true; }

   469

		break;

   470

   471

	case 3:

   472

		if (fxmy < -3 && sxmy > 3) { SwapSelection(); DoRailroadTrack(3); return true; }

   473

		if (fxpy <= 12 && sxpy >= 20) { DoRailroadTrack(0); return true; }

   474

		break;

   475

	}

   476

   477

	return false;

   478

}

   479

   480

   481

static void HandleAutodirPlacement()

   482

{

   483

	TileHighlightData *thd = &_thd;

   484

	int bit;

   485

   486

	if (thd->drawstyle == HT_RECT) {

   487

		int dx = thd->selstart.x - (thd->selend.x&~0xF);

   488

		int dy = thd->selstart.y - (thd->selend.y&~0xF);

   489

   490

		if (dx == 0 && dy == 0 ) {

   491

			// 1x1 tile

   492

			bit = GetBestFit1x1(thd->selend.x, thd->selend.y);

   493

			if (bit == -1) return;

   494

			GenericPlaceRail(TILE_FROM_XY(thd->selend.x, thd->selend.y), bit);

   495

		} else if (dx == 0) {

   496

			if (dy == -16) {

   497

				if (Check2x1AutoRail(0)) return;

   498

			} else if (dy == 16) {

   499

				if (Check2x1AutoRail(1)) return;

   500

			}

   501

			// same x coordinate

   502

			DoRailroadTrack(VPM_FIX_X);

   503

		} else {

   504

			// same y coordinate

   505

			// check it's it -16 or 16, then we must check if it should be normal tiles or special tiles.

   506

			if (dx == -16) {

   507

				if (Check2x1AutoRail(2)) return;

   508

			} else if (dx == 16) {

   509

				if (Check2x1AutoRail(3)) return;

   510

			}

   511

			DoRailroadTrack(VPM_FIX_Y);

   512

		}

   513

	} else {

   514

		DoRailroadTrack(thd->drawstyle & 1 ? 0 : 3);

   515

	}

   516

}