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

{

    17

	int sel = p1 >> 16;

    18

	Order new_order = UnpackOrder(p2);

    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) &&

    26

			sel != 0 && v->schedule_ptr[sel - 1].type == OT_GOTO_STATION) {

    27

    28

		int dist = GetTileDist(

    31

		);

    32

		if (dist >= 130)

    33

			return_cmd_error(STR_0210_TOO_FAR_FROM_PREVIOUS_DESTINATIO);

    34

	}

    35

    36

	if (flags & DC_EXEC) {

    37

		Order *s1;

    38

		Order *s2;

    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);

    44

		*s1 = new_order;

    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

		RebuildVehicleLists();

    67

	}

    68

    69

	return 0;

    70

}

    71

    72

static int32 DecloneOrder(Vehicle *dst, uint32 flags)

    73

{

    74

	if (_ptr_to_next_order == endof(_order_array))

    75

		return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

    76

    77

	if (flags & DC_EXEC) {

    78

		DeleteVehicleSchedule(dst);

    79

    80

		dst->num_orders = 0;

    81

		_ptr_to_next_order->type = OT_NOTHING;

    82

		_ptr_to_next_order->flags = 0;

    83

		dst->schedule_ptr = _ptr_to_next_order++;

    84

    85

		InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);

    86

    87

		RebuildVehicleLists();

    88

	}

    89

	return 0;

    90

}

    91

    92

/* p1 = vehicle

    93

 * p2 = sel

    94

 */

    95

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

    96

{

    98

	uint sel = (uint)p2;

    99

   100

	_error_message = STR_EMPTY;

   101

	if (sel >= v->num_orders)

   102

		return DecloneOrder(v, flags);

   103

   104

	if (flags & DC_EXEC) {

   105

		Order *s1 = &v->schedule_ptr[sel];

   106

   107

		// copy all orders to get rid of the hole

   108

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

   109

		_ptr_to_next_order--;

   110

   111

		s1 = v->schedule_ptr;

   112

   113

		FOR_ALL_VEHICLES(u) {

   114

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

   115

				if (s1 < u->schedule_ptr) {

   116

					u->schedule_ptr--;

   117

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

   118

					u->num_orders--;

   119

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

   120

						u->cur_order_index--;

   121

   122

					if ((byte)sel == u->cur_order_index &&

   123

							u->current_order.type == OT_LOADING &&

   124

							u->current_order.flags & OF_NON_STOP) {

   125

						u->current_order.flags = 0;

   126

					}

   127

   128

					InvalidateWindow(WC_VEHICLE_VIEW, u->index);

   129

					InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

   130

				}

   131

			}

   132

		}

   133

   134

		RebuildVehicleLists();

   135

	}

   136

   137

	return 0;

   138

}

   139

   140

/* p1 = vehicle */

   141

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

   142

{

   143

	if (flags & DC_EXEC) {

   145

   146

		{

   147

			byte b = v->cur_order_index + 1;

   148

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

   149

			v->cur_order_index = b;

   150

   151

			if (v->type == VEH_Train)

   152

				v->u.rail.days_since_order_progr = 0;

   153

		}

   154

   155

		if (v->current_order.type == OT_LOADING &&

   156

				v->current_order.flags & OF_NON_STOP) {

   157

			v->current_order.flags = 0;

   158

		}

   159

   160

		InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   161

	}

   162

	return 0;

   163

}

   164

   165

/* p1 = vehicle

   166

 * p2&0xFF = sel

   167

 * p2>>8 = mode

   168

 */

   169

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

   170

{

   172

	byte sel = (byte)p2;

   173

	Order *sched;

   174

   175

	if (sel >= v->num_orders)

   176

		return CMD_ERROR;

   177

   178

	sched = &v->schedule_ptr[sel];

   179

	if (sched->type != OT_GOTO_STATION &&

   180

			(sched->type != OT_GOTO_DEPOT || (p2 >> 8) == 1) &&

   181

			(sched->type != OT_GOTO_WAYPOINT || (p2 >> 8) != 2))

   182

		return CMD_ERROR;

   183

   184

	if (flags & DC_EXEC) {

   185

		switch (p2 >> 8) {

   186

		case 0: // full load

   187

			sched->flags ^= OF_FULL_LOAD;

   188

			if (sched->type != OT_GOTO_DEPOT) sched->flags &= ~OF_UNLOAD;

   189

			break;

   190

		case 1: // unload

   191

			sched->flags ^= OF_UNLOAD;

   192

			sched->flags &= ~OF_FULL_LOAD;

   193

			break;

   194

		case 2: // non stop

   195

			sched->flags ^= OF_NON_STOP;

   196

			break;

   197

		}

   198

		sched = v->schedule_ptr;

   199

   200

		FOR_ALL_VEHICLES(v) {

   201

			if (v->schedule_ptr == sched)

   202

				InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   203

		}

   204

   205

	}

   206

   207

	return 0;

   208

}

   209

   210

// Clone an order

   211

// p1 & 0xFFFF is destination vehicle

   212

// p1 >> 16 is source vehicle

   213

   214

// p2 is

   215

//   0 - clone

   216

//   1 - copy

   217

//   2 - unclone

   218

   219

   220

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

   221

{

   223

   224

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

   225

		return CMD_ERROR;

   226

   227

	switch(p2) {

   228

   229

	// share vehicle orders?

   230

	case 0: {

   232

   233

		// sanity checks

   234

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

   235

			return CMD_ERROR;

   236

   237

		// let's see what happens with road vehicles

   238

		if (src->type == VEH_Road) {

   239

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

   240

				return CMD_ERROR;

   241

		}

   242

   243

		if (flags & DC_EXEC) {

   244

			DeleteVehicleSchedule(dst);

   245

			dst->schedule_ptr = src->schedule_ptr;

   246

			dst->num_orders = src->num_orders;

   247

   248

			InvalidateWindow(WC_VEHICLE_ORDERS, src->index);

   249

			InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);

   250

   251

			RebuildVehicleLists();

   252

		}

   253

		break;

   254

	}

   255

   256

	// copy vehicle orders?

   257

	case 1: {

   259

		int delta;

   260

   261

		// sanity checks

   262

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

   263

			return CMD_ERROR;

   264

   265

		// let's see what happens with road vehicles

   266

		if (src->type == VEH_Road) {

   267

			const Order *i;

   268

			TileIndex required_dst;

   269

   270

			for (i = src->schedule_ptr; i->type != OT_NOTHING; ++i) {

   271

				if (i->type == OT_GOTO_STATION) {

   273

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

   274

					if ( !required_dst )

   275

						return CMD_ERROR;

   276

				}

   277

			}

   278

		}

   279

   280

		// make sure there's orders available

   281

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

   282

		if (delta > endof(_order_array) - _ptr_to_next_order)

   283

			return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

   284

   285

		if (flags & DC_EXEC) {

   286

			DeleteVehicleSchedule(dst);

   287

			dst->schedule_ptr = _ptr_to_next_order;

   288

			dst->num_orders = src->num_orders;

   289

			_ptr_to_next_order += src->num_orders + 1;

   290

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

   291

   292

			InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);

   293

   294

			RebuildVehicleLists();

   295

		}

   296

		break;

   297

	}

   298

   299

	// declone vehicle orders?

   300

	case 2: return DecloneOrder(dst, flags);

   301

	}

   302

   303

	return 0;

   304

}

   305

   306

void BackupVehicleOrders(Vehicle *v, BackuppedOrders *bak)

   307

{

   308

	Vehicle *u = IsScheduleShared(v);

   309

   310

	bak->orderindex = v->cur_order_index;

   311

	bak->service_interval = v->service_interval;

   312

   313

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

   314

		bak->name[0] = 0;

   315

	} else {

   316

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

   317

	}

   318

   319

	// stored shared orders in this special way?

   320

	if (u != NULL) {

   321

		bak->clone = u->index;

   322

	} else {

   323

		Order *sched = v->schedule_ptr;

   324

		Order *os = bak->order;

   325

   326

		bak->clone = INVALID_VEHICLE;

   327

   328

		do {

   329

			*os++ = *sched++;

   330

		} while (sched->type != OT_NOTHING);

   331

		/* Make sure the last item is OT_NOTHING */

   332

		os->type = OT_NOTHING;

   333

	}

   334

}

   335

   336

void RestoreVehicleOrders(Vehicle *v, BackuppedOrders *bak)

   337

{

   338

	int i;

   339

   340

	if (bak->name[0]) {

   341

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

   342

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

   343

	}

   344

   345

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

   346

   347

	if (bak->clone != INVALID_VEHICLE) {

   348

		DoCommandP(0, v->index | bak->clone << 16, 0, NULL, CMD_CLONE_ORDER);

   349

		return;

   350

	}

   351

   352

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

   353

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

   354

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

   355

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

   356

	for (i = 0; bak->order[i].type != OT_NOTHING; ++i)

   357

		if (!DoCommandP(0, v->index + (i << 16), PackOrder(&bak->order[i]), NULL, CMD_INSERT_ORDER | CMD_NO_TEST_IF_IN_NETWORK))

   358

			break;

   359

}

   360

   361

/*	p1 = vehicle

   362

 *	upper 16 bits p2 = service_interval

   363

 *	lower 16 bits p2 = cur_order_index

   364

 */

   365

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

   366

{

   367

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

   368

	if (flags & DC_EXEC) {

   370

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

   371

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

   372

	}

   373

	return 0;

   374

}

   375

   376

int CheckOrders(Vehicle *v)

   377

{

   378

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

   379

		return 0;

   380

   381

	if(v->vehstatus & VS_CRASHED)

   382

		return 0;

   383

   384

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

   385

		return 0;

   386

   387

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

   388

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

   389

		Order order;

   390

		Order old_order;

   391

		int i, n_st, problem_type = -1;

   392

		Station *st;

   393

		int message=0;

   394

		TileIndex required_tile=-1;

   395

   396

		/* check the order list */

   397

		order = v->schedule_ptr[0];

   398

		n_st = 0;

   399

   400

		old_order.type = OT_NOTHING;

   401

		old_order.flags = 0;

   402

		for (i = 0; order.type != OT_NOTHING; i++) {

   403

			order = v->schedule_ptr[i];

   404

			if (order.type == old_order.type &&

   405

					order.flags == old_order.flags &&

   406

					order.station == old_order.station) {

   407

				problem_type = 2;

   408

				break;

   409

			}

   410

			if (order.type == OT_DUMMY) {

   411

				problem_type = 1;

   412

				break;

   413

			}

   414

			if (order.type == OT_GOTO_STATION /*&& (order != old_order) */) {

   415

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

   416

				//when two identical entries are in the list

   417

				n_st++;

   419

				required_tile = GetStationTileForVehicle(v,st);

   420

				if (!required_tile) problem_type = 3;

   421

			}

   422

			old_order = order; //store the old order

   423

		}

   424

   425

		//Now, check the last and the first order

   426

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

   427

		if (i > 2 &&

   428

				v->schedule_ptr[0].type == v->schedule_ptr[i - 2].type &&

   429

				v->schedule_ptr[0].flags == v->schedule_ptr[i - 2].flags &&

   430

				v->schedule_ptr[0].station == v->schedule_ptr[i - 2].station)

   431

			problem_type = 2;

   432

   433

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

   434

   435

		SetDParam(0, v->unitnumber);

   436

   437

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

   438

   439

		if (problem_type < 0) return 0;

   440

   441

		AddNewsItem(

   442

			message,

   443

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

   444

			v->index,

   445

			0);

   446

	}

   447

	// End of order check

   448

   449

	return 1;

   450

}