1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "vehicle.h"

     4

#include "command.h"

     5

#include "station.h"

     6

#include "player.h"

     7

#include "news.h"

     8

     9

/* p1 & 0xFFFF = vehicle

    10

 * p1 >> 16 = index in order list

    11

 * p2 = order command to insert

    12

 */

    13

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

    14

{

    15

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

    16

	int sel = p1 >> 16;

    17

	int t;

    18

    19

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

    20

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

    21

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

    22

    23

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

    24

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

    25

			sel != 0 && ((t=v->schedule_ptr[sel-1])&OT_MASK) == OT_GOTO_STATION) {

    26

    27

		int dist = GetTileDist(DEREF_STATION(t >> 8)->xy, DEREF_STATION(p2 >> 8)->xy);

    28

		if (dist >= 130)

    29

			return_cmd_error(STR_0210_TOO_FAR_FROM_PREVIOUS_DESTINATIO);

    30

	}

    31

    32

	if (flags & DC_EXEC) {

    33

		uint16 *s1, *s2;

    34

		Vehicle *u;

    35

    36

		s1 = &v->schedule_ptr[sel];

    37

		s2 = _ptr_to_next_order++;

    38

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

    39

		s1[0] = (uint16)p2;

    40

    41

		s1 = v->schedule_ptr;

    42

    43

		FOR_ALL_VEHICLES(u) {

    44

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

    45

				if (s1 < u->schedule_ptr) {

    46

					u->schedule_ptr++;

    47

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

    48

					u->num_orders++;

    49

    50

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

    51

						sel++;

    52

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

    53

							u->cur_order_index = sel;

    54

					}

    55

					InvalidateWindow(WC_VEHICLE_VIEW, u->index);

    56

					InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

    57

				}

    58

			}

    59

		}

    60

	}

    61

    62

	return 0;

    63

}

    64

    65

static int32 DecloneOrder(Vehicle *dst, uint32 flags)

    66

{

    67

	if (_ptr_to_next_order == endof(_order_array))

    68

		return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

    69

    70

	if (flags & DC_EXEC) {

    71

		DeleteVehicleSchedule(dst);

    72

    73

		dst->num_orders = 0;

    74

		*(dst->schedule_ptr = _ptr_to_next_order++) = 0;

    75

    76

		InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);

    77

	}

    78

	return 0;

    79

}

    80

    81

/* p1 = vehicle

    82

 * p2 = sel

    83

 */

    84

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

    85

{

    86

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

    87

	uint sel = (uint)p2;

    88

    89

	_error_message = STR_EMPTY;

    90

	if (sel >= v->num_orders)

    91

		return DecloneOrder(v, flags);

    92

    93

	if (flags & DC_EXEC) {

    94

		uint16 *s1;

    95

    96

		s1 = &v->schedule_ptr[sel];

    97

    98

		// copy all orders to get rid of the hole

    99

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

   100

		_ptr_to_next_order--;

   101

   102

		s1 = v->schedule_ptr;

   103

   104

		FOR_ALL_VEHICLES(u) {

   105

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

   106

				if (s1 < u->schedule_ptr) {

   107

					u->schedule_ptr--;

   108

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

   109

					u->num_orders--;

   110

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

   111

						u->cur_order_index--;

   112

   113

					if ((byte)sel == u->cur_order_index && (u->next_order&(OT_MASK|OF_NON_STOP)) == (OT_LOADING|OF_NON_STOP))

   114

						u->next_order = OT_LOADING;

   115

   116

					InvalidateWindow(WC_VEHICLE_VIEW, u->index);

   117

					InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

   118

				}

   119

			}

   120

		}

   121

	}

   122

   123

	return 0;

   124

}

   125

   126

/* p1 = vehicle */

   127

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

   128

{

   129

	if (flags & DC_EXEC) {

   130

		Vehicle *v = &_vehicles[p1];

   131

   132

		{

   133

			byte b = v->cur_order_index + 1;

   134

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

   135

			v->cur_order_index = b;

   136

   137

			if (v->type == VEH_Train)

   138

				v->u.rail.days_since_order_progr = 0;

   139

		}

   140

   141

		if ((v->next_order&(OT_MASK|OF_NON_STOP)) == (OT_LOADING|OF_NON_STOP))

   142

			v->next_order = OT_LOADING;

   143

   144

		InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   145

	}

   146

	return 0;

   147

}

   148

   149

/* p1 = vehicle

   150

 * p2&0xFF = sel

   151

 * p2>>8 = mode

   152

 */

   153

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

   154

{

   155

	Vehicle *v = &_vehicles[p1];

   156

	byte sel = (byte)p2;

   157

	uint16 *sched;

   158

   159

	if (sel >= v->num_orders)

   160

		return CMD_ERROR;

   161

   162

	sched = &v->schedule_ptr[sel];

   163

	if (!((*sched & OT_MASK) == OT_GOTO_STATION || 

   164

			((*sched & OT_MASK) == OT_GOTO_DEPOT &&  (p2>>8) != 1)))

   165

		return CMD_ERROR;

   166

   167

	if (flags & DC_EXEC) {

   168

		switch(p2 >> 8) {

   169

		case 0: // full load

   170

			*sched ^= OF_FULL_LOAD;

   171

			if ((*sched & OT_MASK) != OT_GOTO_DEPOT)

   172

				*sched &= ~OF_UNLOAD;

   173

			break;

   174

		case 1: // unload

   175

			*sched ^= OF_UNLOAD;

   176

			*sched &= ~OF_FULL_LOAD;

   177

			break;

   178

		case 2: // non stop

   179

			*sched ^= OF_NON_STOP;

   180

			break;

   181

		}

   182

		sched = v->schedule_ptr;

   183

   184

		FOR_ALL_VEHICLES(v) {

   185

			if (v->schedule_ptr == sched)

   186

				InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   187

		}

   188

   189

	}

   190

   191

	return 0;

   192

}

   193

   194

// Clone an order

   195

// p1 & 0xFFFF is destination vehicle

   196

// p1 >> 16 is source vehicle

   197

   198

// p2 is

   199

//   0 - clone

   200

//   1 - copy

   201

//   2 - unclone

   202

   203

   204

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

   205

{

   206

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

   207

   208

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

   209

		return CMD_ERROR;

   210

   211

	switch(p2) {

   212

   213

	// share vehicle orders?

   214

	case 0: {

   215

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

   216

   217

		// sanity checks

   218

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

   219

			return CMD_ERROR;

   226

   227

		if (flags & DC_EXEC) {

   228

			DeleteVehicleSchedule(dst);

   229

			dst->schedule_ptr = src->schedule_ptr;

   230

			dst->num_orders = src->num_orders;

   231

   232

			InvalidateWindow(WC_VEHICLE_ORDERS, src->index);

   233

			InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);

   234

		}

   235

		break;

   236

	}

   237

   238

	// copy vehicle orders?

   239

	case 1: {

   240

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

   241

		int delta;

   242

   243

		// sanity checks

   244

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

   245

			return CMD_ERROR;

   263

   264

		// make sure there's orders available

   265

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

   266

		if (delta > endof(_order_array) - _ptr_to_next_order)

   267

			return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

   268

   269

		if (flags & DC_EXEC) {

   270

			DeleteVehicleSchedule(dst);

   271

			dst->schedule_ptr = _ptr_to_next_order;

   272

			dst->num_orders = src->num_orders;

   273

			_ptr_to_next_order += src->num_orders + 1;

   274

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

   275

   276

			InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);

   277

		}

   278

		break;

   279

	}

   280

   281

	// declone vehicle orders?

   282

	case 2: return DecloneOrder(dst, flags);

   283

	}

   284

   285

	return 0;

   286

}

   287

   288

void BackupVehicleOrders(Vehicle *v, BackuppedOrders *bak)

   289

{

   290

	Vehicle *u = IsScheduleShared(v);

   291

	uint16 *sched, ord, *os;

   292

   293

	bak->orderindex = v->cur_order_index;

   294

	bak->service_interval = v->service_interval;

   295

   296

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

   297

		bak->name[0] = 0;

   298

	} else {

   299

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

   300

	}

   301

   302

	os = bak->order;

   303

	// stored shared orders in this special way?

   304

	if (u) {

   305

		os[0] = 0xFFFF;

   306

		os[1] = u->index;

   307

		return;

   308

	}

   309

   310

	sched = v->schedule_ptr;

   311

	do {

   312

		ord = *sched++;

   313

		*os++ = ord;

   314

	} while (ord != 0);

   315

}

   316

   317

void RestoreVehicleOrders(Vehicle *v, BackuppedOrders *bak)

   318

{

   319

	uint16 ord, *os;

   320

	int ind;

   321

   322

	if (bak->name[0]) {

   323

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

   324

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

   325

	}

   326

   327

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

   328

   329

	os = bak->order;

   330

	if (os[0] == 0xFFFF) {

   331

		DoCommandP(0, v->index | os[1]<<16, 0, NULL, CMD_CLONE_ORDER);

   332

		return;

   333

	}

   334

   335

	ind = 0;

   336

	while ((ord = *os++) != 0) {

   337

		if (!DoCommandP(0, v->index + (ind << 16), ord, NULL, CMD_INSERT_ORDER | CMD_ASYNC))

   338

			break;

   339

		ind++;

   340

	}

   341

}

   342

   343

/*	p1 = vehicle

   344

 *	upper 16 bits p2 = service_interval

   345

 *	lower 16 bits p2 = cur_order_index

   346

 */

   347

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

   348

{

   349

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

   350

	if (flags & DC_EXEC) {

   351

		Vehicle *v = &_vehicles[p1];

   352

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

   353

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

   354

	}

   355

	return 0;

   356

}

   357

   358

int CheckOrders(Vehicle *v)

   359

{

   360

	int i, n_st, duplicate;

   361

	uint16 order, old_orderer;

   362

	uint16 dummy;

   363

	int message=0;

   364

   365

	/* check the order list */

   366

	order = v->schedule_ptr[0];

   367

	n_st = duplicate = dummy = 0;

   368

   369

	/* only check every 20 days */

   370

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

   371

		for(old_orderer = i = 0; order!=0; i++ ) {

   372

			order = v->schedule_ptr[i];

   373

			if (order == old_orderer) duplicate = -1;

   374

			if ( (order & OT_MASK) == OT_DUMMY ) dummy = -1;

   375

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

   376

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

   377

				//when two identical entries are in the list

   378

				n_st++;

   379

			}

   380

			old_orderer = order; //store the old order

   381

		}

   382

   383

		//Now, check the last and the first order

   384

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

   385

		if ( (v->schedule_ptr[0] == v->schedule_ptr[i-2]) && ( i-2 != 0 ) ) duplicate = -1;

   386

   387

		SET_DPARAM16(0, v->unitnumber);

   388

   389

		if  (n_st < 2) {

   390

			switch (v->type) {

   391

				case VEH_Train: message = STR_TRAIN_HAS_TOO_FEW_ORDERS; break;

   392

				case VEH_Road: message = STR_ROADVEHICLE_HAS_TOO_FEW_ORDERS; break;

   393

				case VEH_Ship: message = STR_SHIP_HAS_TOO_FEW_ORDERS; break;

   394

				case VEH_Aircraft: message = STR_AIRCRAFT_HAS_TOO_FEW_ORDERS; break;

   395

			}

   396

			AddNewsItem(

   397

				message,

   398

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

   399

				v->index,

   400

				0);

   401

		} else if (duplicate) {

   402

			switch (v->type) {

   403

				case VEH_Train: message = STR_TRAIN_HAS_DUPLICATE_ENTRY; break;

   404

				case VEH_Road: message = STR_ROADVEHICLE_HAS_DUPLICATE_ENTRY; break;

   405

				case VEH_Ship: message = STR_SHIP_HAS_DUPLICATE_ENTRY; break;

   406

				case VEH_Aircraft: message = STR_AIRCRAFT_HAS_DUPLICATE_ENTRY; break;

   407

			}

   408

			AddNewsItem(

   409

				message,

   410

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

   411

				v->index,

   412

				0);

   413

		} else if (dummy) {

   414

			switch (v->type) {

   415

				case VEH_Train: message = STR_TRAIN_HAS_VOID_ORDER; break;

   416

				case VEH_Road: message = STR_ROADVEHICLE_HAS_VOID_ORDER; break;

   417

				case VEH_Ship: message = STR_SHIP_HAS_VOID_ORDER; break;

   418

				case VEH_Aircraft: message = STR_AIRCRAFT_HAS_VOID_ORDER; break;

   419

			}

   420

			AddNewsItem(

   421

				message,

   422

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

   423

				v->index,

   424

				0);

   425

		}

   426

	}

   427

	// End of order check

   428

   429

	if ( (n_st > 2) || (duplicate) || (dummy) ) 

   430

		return 1;

   431

	else

   432

		return 0;

   433

}