1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "vehicle.h"

     5

#include "command.h"

     6

#include "station.h"

     7

#include "player.h"

     8

#include "news.h"

     9

    10

/* p1 & 0xFFFF = vehicle

    11

 * p1 >> 16 = index in order list

    12

 * p2 = order command to insert

    13

 */

    14

int32 CmdInsertOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)

    15

{

    16

	Vehicle *v = &_vehicles[p1 & 0xFFFF];

    17

	int sel = p1 >> 16;

    19

    20

	if (sel > v->num_orders) return_cmd_error(STR_EMPTY);

    21

	if (_ptr_to_next_order == endof(_order_array)) return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

    22

	if (v->num_orders >= 40) return_cmd_error(STR_8832_TOO_MANY_ORDERS);

    23

    24

	// for ships, make sure that the station is not too far away from the previous destination.

    25

	if (v->type == VEH_Ship && IS_HUMAN_PLAYER(v->owner) &&

    27

    32

		if (dist >= 130)

    33

			return_cmd_error(STR_0210_TOO_FAR_FROM_PREVIOUS_DESTINATIO);

    34

	}

    35

    36

	if (flags & DC_EXEC) {

    39

		Vehicle *u;

    40

    41

		s1 = &v->schedule_ptr[sel];

    42

		s2 = _ptr_to_next_order++;

    43

		do s2[1] = s2[0]; while (--s2 >= s1);

    45

    46

		s1 = v->schedule_ptr;

    47

    48

		FOR_ALL_VEHICLES(u) {

    49

			if (u->type != 0 && u->schedule_ptr != NULL) {

    50

				if (s1 < u->schedule_ptr) {

    51

					u->schedule_ptr++;

    52

				} else if (s1 == u->schedule_ptr) { // handle shared orders

    53

					u->num_orders++;

    54

    55

					if ((byte)sel <= u->cur_order_index) {

    56

						sel++;

    57

						if ((byte)sel < u->num_orders)

    58

							u->cur_order_index = sel;

    59

					}

    60

					InvalidateWindow(WC_VEHICLE_VIEW, u->index);

    61

					InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

    62

				}

    63

			}

    64

		}

    65

	}

    66

    67

	return 0;

    68

}

    69

    70

static int32 DecloneOrder(Vehicle *dst, uint32 flags)

    71

{

    72

	if (_ptr_to_next_order == endof(_order_array))

    73

		return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

    74

    75

	if (flags & DC_EXEC) {

    76

		DeleteVehicleSchedule(dst);

    77

    78

		dst->num_orders = 0;

    82

    83

		InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);

    84

	}

    85

	return 0;

    86

}

    87

    88

/* p1 = vehicle

    89

 * p2 = sel

    90

 */

    91

int32 CmdDeleteOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)

    92

{

    93

	Vehicle *v = &_vehicles[p1], *u;

    94

	uint sel = (uint)p2;

    95

    96

	_error_message = STR_EMPTY;

    97

	if (sel >= v->num_orders)

    98

		return DecloneOrder(v, flags);

    99

   100

	if (flags & DC_EXEC) {

   102

   103

		// copy all orders to get rid of the hole

   104

		do s1[0] = s1[1]; while (++s1 != _ptr_to_next_order);

   105

		_ptr_to_next_order--;

   106

   107

		s1 = v->schedule_ptr;

   108

   109

		FOR_ALL_VEHICLES(u) {

   110

			if (u->type != 0 && u->schedule_ptr != NULL) {

   111

				if (s1 < u->schedule_ptr) {

   112

					u->schedule_ptr--;

   113

				} else if (s1 == u->schedule_ptr) {// handle shared orders

   114

					u->num_orders--;

   115

					if ((byte)sel < u->cur_order_index)

   116

						u->cur_order_index--;

   117

   123

   124

					InvalidateWindow(WC_VEHICLE_VIEW, u->index);

   125

					InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

   126

				}

   127

			}

   128

		}

   129

	}

   130

   131

	return 0;

   132

}

   133

   134

/* p1 = vehicle */

   135

int32 CmdSkipOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   136

{

   137

	if (flags & DC_EXEC) {

   138

		Vehicle *v = &_vehicles[p1];

   139

   140

		{

   141

			byte b = v->cur_order_index + 1;

   142

			if (b >= v->num_orders) b = 0;

   143

			v->cur_order_index = b;

   144

   145

			if (v->type == VEH_Train)

   146

				v->u.rail.days_since_order_progr = 0;

   147

		}

   148

   153

   154

		InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   155

	}

   156

	return 0;

   157

}

   158

   159

/* p1 = vehicle

   160

 * p2&0xFF = sel

   161

 * p2>>8 = mode

   162

 */

   163

int32 CmdModifyOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   164

{

   165

	Vehicle *v = &_vehicles[p1];

   166

	byte sel = (byte)p2;

   168

   169

	if (sel >= v->num_orders)

   170

		return CMD_ERROR;

   171

   172

	sched = &v->schedule_ptr[sel];

   175

		return CMD_ERROR;

   176

   177

	if (flags & DC_EXEC) {

   179

		case 0: // full load

   182

			break;

   183

		case 1: // unload

   186

			break;

   187

		case 2: // non stop

   189

			break;

   190

		}

   191

		sched = v->schedule_ptr;

   192

   193

		FOR_ALL_VEHICLES(v) {

   194

			if (v->schedule_ptr == sched)

   195

				InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   196

		}

   197

   198

	}

   199

   200

	return 0;

   201

}

   202

   203

// Clone an order

   204

// p1 & 0xFFFF is destination vehicle

   205

// p1 >> 16 is source vehicle

   206

   207

// p2 is

   208

//   0 - clone

   209

//   1 - copy

   210

//   2 - unclone

   211

   212

   213

int32 CmdCloneOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   214

{

   215

	Vehicle *dst = &_vehicles[p1 & 0xFFFF];

   216

   217

	if (!(dst->type && dst->owner == _current_player))

   218

		return CMD_ERROR;

   219

   220

	switch(p2) {

   221

   222

	// share vehicle orders?

   223

	case 0: {

   224

		Vehicle *src = &_vehicles[p1 >> 16];

   225

   226

		// sanity checks

   227

		if (!(src->owner == _current_player && dst->type == src->type && dst != src))

   228

			return CMD_ERROR;

   229

   230

		// let's see what happens with road vehicles

   231

		if (src->type == VEH_Road) {

   232

			if (src->cargo_type != dst->cargo_type && (src->cargo_type == CT_PASSENGERS || dst->cargo_type == CT_PASSENGERS))

   233

				return CMD_ERROR;

   234

		}

   235

   236

		if (flags & DC_EXEC) {

   237

			DeleteVehicleSchedule(dst);

   238

			dst->schedule_ptr = src->schedule_ptr;

   239

			dst->num_orders = src->num_orders;

   240

   241

			InvalidateWindow(WC_VEHICLE_ORDERS, src->index);

   242

			InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);

   243

		}

   244

		break;

   245

	}

   246

   247

	// copy vehicle orders?

   248

	case 1: {

   249

		Vehicle *src = &_vehicles[p1 >> 16];

   250

		int delta;

   251

   252

		// sanity checks

   253

		if (!(src->owner == _current_player && dst->type == src->type && dst != src))

   254

			return CMD_ERROR;

   255

   256

		// let's see what happens with road vehicles

   257

		if (src->type == VEH_Road) {

   259

			TileIndex required_dst;

   260

   264

					required_dst = (dst->cargo_type == CT_PASSENGERS) ? st->bus_tile : st->lorry_tile;

   265

					if ( !required_dst )

   266

						return CMD_ERROR;

   267

				}

   268

			}

   269

		}

   270

   271

		// make sure there's orders available

   272

		delta = IsScheduleShared(dst) ? src->num_orders + 1 : src->num_orders - dst->num_orders;

   273

		if (delta > endof(_order_array) - _ptr_to_next_order)

   274

			return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

   275

   276

		if (flags & DC_EXEC) {

   277

			DeleteVehicleSchedule(dst);

   278

			dst->schedule_ptr = _ptr_to_next_order;

   279

			dst->num_orders = src->num_orders;

   280

			_ptr_to_next_order += src->num_orders + 1;

   281

			memcpy(dst->schedule_ptr, src->schedule_ptr, (src->num_orders + 1) * sizeof(uint16));

   282

   283

			InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);

   284

		}

   285

		break;

   286

	}

   287

   288

	// declone vehicle orders?

   289

	case 2: return DecloneOrder(dst, flags);

   290

	}

   291

   292

	return 0;

   293

}

   294

   295

void BackupVehicleOrders(Vehicle *v, BackuppedOrders *bak)

   296

{

   297

	Vehicle *u = IsScheduleShared(v);

   298

   299

	bak->orderindex = v->cur_order_index;

   300

	bak->service_interval = v->service_interval;

   301

   302

	if ((v->string_id & 0xF800) != 0x7800) {

   303

		bak->name[0] = 0;

   304

	} else {

   305

		GetName(v->string_id & 0x7FF, bak->name);

   306

	}

   307

   308

	// stored shared orders in this special way?

   320

	}

   321

}

   322

   323

void RestoreVehicleOrders(Vehicle *v, BackuppedOrders *bak)

   324

{

   326

   327

	if (bak->name[0]) {

   328

		strcpy((char*)_decode_parameters, bak->name);

   329

		DoCommandP(0, v->index, 0, NULL, CMD_NAME_VEHICLE);

   330

	}

   331

   332

	DoCommandP(0, v->index, bak->orderindex|(bak->service_interval<<16) , NULL, CMD_RESTORE_ORDER_INDEX);

   333

   336

		return;

   337

	}

   338

   339

	// CMD_NO_TEST_IF_IN_NETWORK is used here, because CMD_INSERT_ORDER checks if the

   340

	//  order number is one more then the current amount of orders, and because

   341

	//  in network the commands are queued before send, the second insert always

   342

	//  fails in test mode. By bypassing the test-mode, that no longer is a problem.

   345

			break;

   346

}

   347

   348

/*	p1 = vehicle

   349

 *	upper 16 bits p2 = service_interval

   350

 *	lower 16 bits p2 = cur_order_index

   351

 */

   352

int32 CmdRestoreOrderIndex(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   353

{

   354

	// nonsense to update the windows, since, train rebought will have its window deleted

   355

	if (flags & DC_EXEC) {

   356

		Vehicle *v = &_vehicles[p1];

   357

		v->service_interval = (uint16)(p2>>16);

   358

		v->cur_order_index = (byte)(p2&0xFFFF);

   359

	}

   360

	return 0;

   361

}

   362

   363

int CheckOrders(Vehicle *v)

   364

{

   365

	if (!_patches.order_review_system)	//User doesn't want things to be checked

   366

		return 0;

   367

   368

	if ( (_patches.order_review_system == 1) && (v->vehstatus & VS_STOPPED) )

   369

		return 0;

   370

   371

	/* only check every 20 days, so that we don't flood the message log */

   372

	if ( ( ( v->day_counter % 20) == 0 ) && (v->owner == _local_player) ) {

   375

		int i, n_st, problem_type = -1;

   376

		Station *st;

   377

		int message=0;

   378

		TileIndex required_tile=-1;

   379

   380

		/* check the order list */

   381

		order = v->schedule_ptr[0];

   382

		n_st = 0;

   383

   387

			order = v->schedule_ptr[i];

   391

				problem_type = 2;

   392

				break;

   393

			}

   395

				problem_type = 1;

   396

				break;

   397

			}

   399

				//I uncommented this in order not to get two error messages

   400

				//when two identical entries are in the list

   401

				n_st++;

   403

				required_tile = GetStationTileForVehicle(v,st);

   404

				if (!required_tile) problem_type = 3;

   405

			}

   406

			old_order = order; //store the old order

   407

		}

   408

   409

		//Now, check the last and the first order

   410

		//as the last order is the end of order marker, jump back 2

   415

			problem_type = 2;

   416

   417

		if ( (n_st < 2) && (problem_type == -1) ) problem_type = 0;

   418

   419

		SetDParam(0, v->unitnumber);

   420

   421

		message = (STR_TRAIN_HAS_TOO_FEW_ORDERS) + (((v->type) - VEH_Train) << 2) + problem_type;

   422

   423

		if (problem_type < 0) return 0;

   424

   425

		AddNewsItem(

   426

			message,

   427

			NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0),

   428

			v->index,

   429

			0);

   430

	}

   431

	// End of order check

   432

   433

	return 1;

   434

}