1

/* $Id$ */

     2

     3

/** @file group_cmd.cpp Handling of the engine groups */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "player.h"

     9

#include "table/strings.h"

    10

#include "command.h"

    11

#include "vehicle.h"

    12

#include "saveload.h"

    13

#include "debug.h"

    14

#include "group.h"

    15

#include "train.h"

    16

#include "aircraft.h"

    17

#include "string.h"

    18

#include "window.h"

    19

#include "vehicle_gui.h"

    20

    21

/**

    22

 * Update the num engines of a groupID. Decrease the old one and increase the new one

    23

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    24

 * @param i     EngineID we have to update

    25

 * @param old_g index of the old group

    26

 * @param new_g index of the new group

    27

 */

    28

static inline void UpdateNumEngineGroup(EngineID i, GroupID old_g, GroupID new_g)

    29

{

    30

	if (old_g != new_g) {

    31

		/* Decrease the num engines of EngineID i of the old group if it's not the default one */

    32

		if (!IsDefaultGroupID(old_g) && IsValidGroupID(old_g)) GetGroup(old_g)->num_engines[i]--;

    33

    34

		/* Increase the num engines of EngineID i of the new group if it's not the new one */

    35

		if (!IsDefaultGroupID(new_g) && IsValidGroupID(new_g)) GetGroup(new_g)->num_engines[i]++;

    36

	}

    37

}

    38

    39

    40

/**

    41

 * Called if a new block is added to the group-pool

    42

 */

    43

static void GroupPoolNewBlock(uint start_item)

    44

{

    45

	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.

    46

	 * TODO - This is just a temporary stage, this will be removed. */

    47

	for (Group *g = GetGroup(start_item); g != NULL; g = (g->index + 1U < GetGroupPoolSize()) ? GetGroup(g->index + 1) : NULL) g->index = start_item++;

    48

}

    49

    50

DEFINE_OLD_POOL(Group, Group, GroupPoolNewBlock, NULL)

    51

    52

static Group *AllocateGroup(void)

    53

{

    54

	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.

    55

	 * TODO - This is just a temporary stage, this will be removed. */

    56

	for (Group *g = GetGroup(0); g != NULL; g = (g->index + 1U < GetGroupPoolSize()) ? GetGroup(g->index + 1) : NULL) {

    57

		if (!IsValidGroup(g)) {

    58

			const GroupID index = g->index;

    59

    60

			memset(g, 0, sizeof(*g));

    61

			g->index = index;

    62

    63

			return g;

    64

		}

    65

	}

    66

    67

	/* Check if we can add a block to the pool */

    68

	return (AddBlockToPool(&_Group_pool)) ? AllocateGroup() : NULL;

    69

}

    70

    71

void InitializeGroup(void)

    72

{

    73

	CleanPool(&_Group_pool);

    74

	AddBlockToPool(&_Group_pool);

    75

}

    76

    77

    78

static WindowClass GetWCForVT(VehicleType vt)

    79

{

    80

	switch (vt) {

    81

		default:

    82

		case VEH_TRAIN:    return WC_TRAINS_LIST;

    83

		case VEH_ROAD:     return WC_ROADVEH_LIST;

    84

		case VEH_SHIP:     return WC_SHIPS_LIST;

    85

		case VEH_AIRCRAFT: return WC_AIRCRAFT_LIST;

    86

	}

    87

}

    88

    89

    90

/**

    91

 * Add a vehicle to a group

    92

 * @param tile unused

    93

 * @param p1   vehicle type

    94

 * @param p2   unused

    95

 */

    96

int32 CmdCreateGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

    97

{

    98

	VehicleType vt = (VehicleType)p1;

    99

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

   100

   101

	Group *g = AllocateGroup();

   102

	if (g == NULL) return CMD_ERROR;

   103

   104

	if (flags & DC_EXEC) {

   105

		g->owner = _current_player;

   106

		g->string_id = STR_SV_GROUP_NAME;

   107

		g->replace_protection = false;

   108

		g->vehicle_type = vt;

   109

   110

		InvalidateWindowData(GetWCForVT(vt), (vt << 11) | VLW_GROUP_LIST | _current_player);

   111

	}

   112

   113

	return 0;

   114

}

   115

   116

   117

/**

   118

 * Add a vehicle to a group

   119

 * @param tile unused

   120

 * @param p1   index of array group

   121

 *      - p1 bit 0-15 : GroupID

   122

 * @param p2   unused

   123

 */

   124

int32 CmdDeleteGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   125

{

   126

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   127

   128

	Group *g = GetGroup(p1);

   129

	if (g->owner != _current_player) return CMD_ERROR;

   130

   131

	if (flags & DC_EXEC) {

   132

		Vehicle *v;

   133

   134

		/* Add all vehicles belong to the group to the default group */

   135

		FOR_ALL_VEHICLES(v) {

   136

			if (v->group_id == g->index && v->type == g->vehicle_type) v->group_id = DEFAULT_GROUP;

   137

		}

   138

   139

		/* If we set an autoreplace for the group we delete, remove it. */

   140

		if (_current_player < MAX_PLAYERS) {

   141

			Player *p;

   142

			EngineRenew *er;

   143

   144

			p = GetPlayer(_current_player);

   145

			FOR_ALL_ENGINE_RENEWS(er) {

   146

				if (er->group_id == g->index) RemoveEngineReplacementForPlayer(p, er->from, g->index, flags);

   147

			}

   148

		}

   149

   150

		VehicleType vt = g->vehicle_type;

   151

   152

		/* Delete the Replace Vehicle Windows */

   153

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   154

		DeleteGroup(g);

   155

   156

		InvalidateWindowData(GetWCForVT(vt), (vt << 11) | VLW_GROUP_LIST | _current_player);

   157

	}

   158

   159

	return 0;

   160

}

   161

   162

   163

/**

   164

 * Rename a group

   165

 * @param tile unused

   166

 * @param p1   index of array group

   167

 *   - p1 bit 0-15 : GroupID

   168

 * @param p2   unused

   169

 */

   170

int32 CmdRenameGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   171

{

   172

	if (!IsValidGroupID(p1) || StrEmpty(_cmd_text)) return CMD_ERROR;

   173

   174

	Group *g = GetGroup(p1);

   175

	if (g->owner != _current_player) return CMD_ERROR;

   176

   177

	/* Create the name */

   178

	StringID str = AllocateName(_cmd_text, 0);

   179

	if (str == STR_NULL) return CMD_ERROR;

   180

   181

	if (flags & DC_EXEC) {

   182

		/* Delete the old name */

   183

		DeleteName(g->string_id);

   184

		/* Assign the new one */

   185

		g->string_id = str;

   186

   187

		InvalidateWindowData(GetWCForVT(g->vehicle_type), (g->vehicle_type << 11) | VLW_GROUP_LIST | _current_player);

   188

	}

   189

   190

	return 0;

   191

}

   192

   193

   194

/**

   195

 * Add a vehicle to a group

   196

 * @param tile unused

   197

 * @param p1   index of array group

   198

 *   - p1 bit 0-15 : GroupID

   199

 * @param p2   vehicle to add to a group

   200

 *   - p2 bit 0-15 : VehicleID

   201

 */

   202

int32 CmdAddVehicleGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   203

{

   204

	GroupID new_g = p1;

   205

   206

	if (!IsValidVehicleID(p2) || (!IsValidGroupID(new_g) && !IsDefaultGroupID(new_g))) return CMD_ERROR;

   207

   208

	if (IsValidGroupID(new_g)) {

   209

		Group *g = GetGroup(new_g);

   210

		if (g->owner != _current_player) return CMD_ERROR;

   211

	}

   212

   213

	Vehicle *v = GetVehicle(p2);

   214

	if (v->owner != _current_player || (v->type == VEH_TRAIN && !IsFrontEngine(v))) return CMD_ERROR;

   215

   216

	if (flags & DC_EXEC) {

   217

		DecreaseGroupNumVehicle(v->group_id);

   218

		IncreaseGroupNumVehicle(new_g);

   219

   220

		switch (v->type) {

   221

			default: NOT_REACHED();

   222

			case VEH_TRAIN:

   223

				SetTrainGroupID(v, new_g);

   224

				break;

   225

			case VEH_ROAD:

   226

			case VEH_SHIP:

   227

			case VEH_AIRCRAFT:

   228

				if (IsEngineCountable(v)) UpdateNumEngineGroup(v->engine_type, v->group_id, new_g);

   229

				v->group_id = new_g;

   230

				break;

   231

		}

   232

   233

		/* Update the Replace Vehicle Windows */

   234

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   235

		InvalidateWindowData(GetWCForVT(v->type), (v->type << 11) | VLW_GROUP_LIST | _current_player);

   236

	}

   237

   238

	return 0;

   239

}

   240

   241

/**

   242

 * Add all shared vehicles of all vehicles from a group

   243

 * @param tile unused

   244

 * @param p1   index of group array

   245

 *  - p1 bit 0-15 : GroupID

   246

 * @param p2   type of vehicles

   247

 */

   248

int32 CmdAddSharedVehicleGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   249

{

   250

	VehicleType type = (VehicleType)p2;

   251

	if (!IsValidGroupID(p1) || !IsPlayerBuildableVehicleType(type)) return CMD_ERROR;

   252

   253

	if (flags & DC_EXEC) {

   254

		Vehicle *v;

   255

		VehicleType type = (VehicleType)p2;

   256

		GroupID id_g = p1;

   257

		uint subtype = (type == VEH_AIRCRAFT) ? AIR_AIRCRAFT : 0;

   258

   259

		/* Find the first front engine which belong to the group id_g

   260

		 * then add all shared vehicles of this front engine to the group id_g */

   261

		FOR_ALL_VEHICLES(v) {

   262

			if ((v->type == type) && (

   263

					(type == VEH_TRAIN && IsFrontEngine(v)) ||

   264

					(type != VEH_TRAIN && v->subtype <= subtype))) {

   265

				if (v->group_id != id_g) continue;

   266

   267

				/* For each shared vehicles add it to the group */

   268

				for (Vehicle *v2 = GetFirstVehicleFromSharedList(v); v2 != NULL; v2 = v2->next_shared) {

   269

					if (v2->group_id != id_g) CmdAddVehicleGroup(tile, flags, id_g, v2->index);

   270

				}

   271

			}

   272

		}

   273

   274

		InvalidateWindowData(GetWCForVT(type), (type << 11) | VLW_GROUP_LIST | _current_player);

   275

	}

   276

   277

	return 0;

   278

}

   279

   280

   281

/**

   282

 * Remove all vehicles from a group

   283

 * @param tile unused

   284

 * @param p1   index of group array

   285

 * - p1 bit 0-15 : GroupID

   286

 * @param p2   type of vehicles

   287

 */

   288

int32 CmdRemoveAllVehiclesGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   289

{

   290

	VehicleType type = (VehicleType)p2;

   291

	if (!IsValidGroupID(p1) || !IsPlayerBuildableVehicleType(type)) return CMD_ERROR;

   292

   293

	Group *g = GetGroup(p1);

   294

	if (g->owner != _current_player) return CMD_ERROR;

   295

   296

	if (flags & DC_EXEC) {

   297

		GroupID old_g = p1;

   298

		uint subtype = (type == VEH_AIRCRAFT) ? AIR_AIRCRAFT : 0;

   299

		Vehicle *v;

   300

   301

		/* Find each Vehicle that belongs to the group old_g and add it to the default group */

   302

		FOR_ALL_VEHICLES(v) {

   303

			if ((v->type == type) && (

   304

					(type == VEH_TRAIN && IsFrontEngine(v)) ||

   305

					(type != VEH_TRAIN && v->subtype <= subtype))) {

   306

				if (v->group_id != old_g) continue;

   307

   308

				/* Add The Vehicle to the default group */

   309

				CmdAddVehicleGroup(tile, flags, DEFAULT_GROUP, v->index);

   310

			}

   311

		}

   312

   313

		InvalidateWindowData(GetWCForVT(type), (type << 11) | VLW_GROUP_LIST | _current_player);

   314

	}

   315

   316

	return 0;

   317

}

   318

   319

   320

/**

   321

 * (Un)set global replace protection from a group

   322

 * @param tile unused

   323

 * @param p1   index of group array

   324

 * - p1 bit 0-15 : GroupID

   325

 * @param p2

   326

 * - p2 bit 0    : 1 to set or 0 to clear protection.

   327

 */

   328

int32 CmdSetGroupReplaceProtection(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   329

{

   330

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   331

   332

	Group *g = GetGroup(p1);

   333

	if (g->owner != _current_player) return CMD_ERROR;

   334

   335

	if (flags & DC_EXEC) {

   336

		g->replace_protection = HASBIT(p2, 0);

   337

   338

		InvalidateWindowData(GetWCForVT(g->vehicle_type), (g->vehicle_type << 11) | VLW_GROUP_LIST | _current_player);

   339

	}

   340

   341

	return 0;

   342

}

   343

   344

/**

   345

 * Decrease the num_vehicle variable before delete an front engine from a group

   346

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   347

 * @param v     FrontEngine of the train we want to remove.

   348

 */

   349

void RemoveVehicleFromGroup(const Vehicle *v)

   350

{

   351

	if (!IsValidVehicle(v) || v->type != VEH_TRAIN || !IsFrontEngine(v)) return;

   352

   353

	if (!IsDefaultGroupID(v->group_id)) DecreaseGroupNumVehicle(v->group_id);

   354

}

   355

   356

   357

/**

   358

 * Affect the groupID of a train to new_g.

   359

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   360

 * @param v     First vehicle of the chain.

   361

 * @param new_g index of array group

   362

 */

   363

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   364

{

   365

	if (!IsValidGroupID(new_g) && !IsDefaultGroupID(new_g)) return;

   366

   367

	assert(IsValidVehicle(v) && v->type == VEH_TRAIN && IsFrontEngine(v));

   368

   369

	for (Vehicle *u = v; u != NULL; u = u->next) {

   370

		if (IsEngineCountable(u)) UpdateNumEngineGroup(u->engine_type, u->group_id, new_g);

   371

   372

		u->group_id = new_g;

   373

	}

   374

   375

	/* Update the Replace Vehicle Windows */

   376

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   377

}

   378

   379

   380

/**

   381

 * Recalculates the groupID of a train. Should be called each time a vehicle is added

   382

 * to/removed from the chain,.

   383

 * @note this needs to be called too for 'wagon chains' (in the depot, without an engine)

   384

 * @note Called in CmdBuildRailVehicle, CmdBuildRailWagon, CmdMoveRailVehicle, CmdSellRailWagon

   385

 * @param v First vehicle of the chain.

   386

 */

   387

void UpdateTrainGroupID(Vehicle *v)

   388

{

   389

	assert(IsValidVehicle(v) && v->type == VEH_TRAIN && (IsFrontEngine(v) || IsFreeWagon(v)));

   390

   391

	GroupID new_g = IsFrontEngine(v) ? v->group_id : (GroupID)DEFAULT_GROUP;

   392

	for (Vehicle *u = v; u != NULL; u = u->next) {

   393

		if (IsEngineCountable(u)) UpdateNumEngineGroup(u->engine_type, u->group_id, new_g);

   394

   395

		u->group_id = new_g;

   396

	}

   397

   398

	/* Update the Replace Vehicle Windows */

   399

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   400

}

   401

   402

   403

void RemoveAllGroupsForPlayer(const Player *p)

   404

{

   405

	Group *g;

   406

   407

	FOR_ALL_GROUPS(g) {

   408

		if (p->index == g->owner) DeleteGroup(g);

   409

	}

   410

}

   411

   412

   413

static const SaveLoad _group_desc[] = {

   414

  SLE_VAR(Group, string_id,          SLE_UINT16),

   415

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   416

  SLE_VAR(Group, owner,              SLE_UINT8),

   417

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   418

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   419

  SLE_END()

   420

};

   421

   422

   423

static void Save_GROUP(void)

   424

{

   425

	Group *g;

   426

   427

	FOR_ALL_GROUPS(g) {

   428

		SlSetArrayIndex(g->index);

   429

		SlObject(g, _group_desc);

   430

	}

   431

}

   432

   433

   434

static void Load_GROUP(void)

   435

{

   436

	int index;

   437

   438

	while ((index = SlIterateArray()) != -1) {

   439

		if (!AddBlockIfNeeded(&_Group_pool, index)) {

   440

			error("Groups: failed loading savegame: too many groups");

   441

		}

   442

   443

		Group *g = GetGroup(index);

   444

		SlObject(g, _group_desc);

   445

	}

   446

}

   447

   448

extern const ChunkHandler _group_chunk_handlers[] = {

   449

	{ 'GRPS', Save_GROUP, Load_GROUP, CH_ARRAY | CH_LAST},

   450

};