1

/* $Id$ */

     2

     3

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

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "variables.h"

     8

#include "command_func.h"

     9

#include "saveload.h"

    10

#include "debug.h"

    11

#include "group.h"

    12

#include "train.h"

    13

#include "aircraft.h"

    14

#include "vehicle_gui.h"

    15

#include "strings_func.h"

    16

#include "functions.h"

    17

#include "window_func.h"

    18

#include "vehicle_func.h"

    19

#include "autoreplace_base.h"

    20

#include "autoreplace_func.h"

    21

#include "string_func.h"

    22

#include "player_func.h"

    23

#include "order_func.h"

    24

#include "oldpool_func.h"

    25

    26

#include "table/strings.h"

    27

    28

/**

    29

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

    30

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    31

 * @param i     EngineID we have to update

    32

 * @param old_g index of the old group

    33

 * @param new_g index of the new group

    34

 */

    35

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

    36

{

    37

	if (old_g != new_g) {

    38

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

    39

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

    40

    41

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

    42

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

    43

	}

    44

}

    45

    46

    47

DEFINE_OLD_POOL_GENERIC(Group, Group)

    48

    49

    50

Group::Group(PlayerID owner)

    51

{

    52

	this->owner = owner;

    53

}

    54

    55

Group::~Group()

    56

{

    57

	free(this->name);

    58

	this->owner = INVALID_PLAYER;

    59

}

    60

    61

bool Group::IsValid() const

    62

{

    63

	return this->owner != INVALID_PLAYER;

    64

}

    65

    66

void InitializeGroup(void)

    67

{

    68

	_Group_pool.CleanPool();

    69

	_Group_pool.AddBlockToPool();

    70

}

    71

    72

    73

static WindowClass GetWCForVT(VehicleType vt)

    74

{

    75

	switch (vt) {

    76

		default:

    77

		case VEH_TRAIN:    return WC_TRAINS_LIST;

    78

		case VEH_ROAD:     return WC_ROADVEH_LIST;

    79

		case VEH_SHIP:     return WC_SHIPS_LIST;

    80

		case VEH_AIRCRAFT: return WC_AIRCRAFT_LIST;

    81

	}

    82

}

    83

    84

    85

/**

    86

 * Create a new vehicle group.

    87

 * @param tile unused

    88

 * @param p1   vehicle type

    89

 * @param p2   unused

    90

 */

    91

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

    92

{

    93

	VehicleType vt = (VehicleType)p1;

    94

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    95

    97

    98

	if (flags & DC_EXEC) {

   100

		g->replace_protection = false;

   101

		g->vehicle_type = vt;

   102

   103

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

   104

	}

   105

   106

	return CommandCost();

   107

}

   108

   109

   110

/**

   111

 * Add all vehicles in the given group to the default group and then deletes the group.

   112

 * @param tile unused

   113

 * @param p1   index of array group

   114

 *      - p1 bit 0-15 : GroupID

   115

 * @param p2   unused

   116

 */

   117

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

   118

{

   119

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   120

   121

	Group *g = GetGroup(p1);

   122

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

   123

   124

	if (flags & DC_EXEC) {

   125

		Vehicle *v;

   126

   127

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

   128

		FOR_ALL_VEHICLES(v) {

   129

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

   130

		}

   131

   132

		/* Update backupped orders if needed */

   133

		if (_backup_orders_data.group == g->index) _backup_orders_data.group = DEFAULT_GROUP;

   134

   135

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

   136

		if (_current_player < MAX_PLAYERS) {

   137

			Player *p;

   138

			EngineRenew *er;

   139

   140

			p = GetPlayer(_current_player);

   141

			FOR_ALL_ENGINE_RENEWS(er) {

   142

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

   143

			}

   144

		}

   145

   146

		VehicleType vt = g->vehicle_type;

   147

   148

		/* Delete the Replace Vehicle Windows */

   149

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   150

		delete g;

   151

   152

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

   153

	}

   154

   155

	return CommandCost();

   156

}

   157

   158

static bool IsUniqueGroupName(const char *name)

   159

{

   160

	const Group *g;

   161

	char buf[512];

   162

   163

	FOR_ALL_GROUPS(g) {

   164

		SetDParam(0, g->index);

   165

		GetString(buf, STR_GROUP_NAME, lastof(buf));

   166

		if (strcmp(buf, name) == 0) return false;

   167

	}

   168

   169

	return true;

   170

}

   171

   172

/**

   173

 * Rename a group

   174

 * @param tile unused

   175

 * @param p1   index of array group

   176

 *   - p1 bit 0-15 : GroupID

   177

 * @param p2   unused

   178

 */

   179

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

   180

{

   181

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

   182

   183

	Group *g = GetGroup(p1);

   184

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

   185

   186

	if (!IsUniqueGroupName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE);

   187

   188

	if (flags & DC_EXEC) {

   189

		/* Delete the old name */

   190

		free(g->name);

   191

		/* Assign the new one */

   192

		g->name = strdup(_cmd_text);

   193

   194

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

   195

	}

   196

   197

	return CommandCost();

   198

}

   199

   200

   201

/**

   202

 * Add a vehicle to a group

   203

 * @param tile unused

   204

 * @param p1   index of array group

   205

 *   - p1 bit 0-15 : GroupID

   206

 * @param p2   vehicle to add to a group

   207

 *   - p2 bit 0-15 : VehicleID

   208

 */

   209

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

   210

{

   211

	GroupID new_g = p1;

   212

   213

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

   214

   215

	Vehicle *v = GetVehicle(p2);

   216

   217

	if (IsValidGroupID(new_g)) {

   218

		Group *g = GetGroup(new_g);

   219

		if (g->owner != _current_player || g->vehicle_type != v->type) return CMD_ERROR;

   220

	}

   221

   222

	if (v->owner != _current_player || !v->IsPrimaryVehicle()) return CMD_ERROR;

   223

   224

	if (flags & DC_EXEC) {

   225

		DecreaseGroupNumVehicle(v->group_id);

   226

		IncreaseGroupNumVehicle(new_g);

   227

   228

		switch (v->type) {

   229

			default: NOT_REACHED();

   230

			case VEH_TRAIN:

   231

				SetTrainGroupID(v, new_g);

   232

				break;

   233

			case VEH_ROAD:

   234

			case VEH_SHIP:

   235

			case VEH_AIRCRAFT:

   236

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

   237

				v->group_id = new_g;

   238

				break;

   239

		}

   240

   241

		/* Update the Replace Vehicle Windows */

   242

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   243

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

   244

	}

   245

   246

	return CommandCost();

   247

}

   248

   249

/**

   250

 * Add all shared vehicles of all vehicles from a group

   251

 * @param tile unused

   252

 * @param p1   index of group array

   253

 *  - p1 bit 0-15 : GroupID

   254

 * @param p2   type of vehicles

   255

 */

   256

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

   257

{

   258

	VehicleType type = (VehicleType)p2;

   259

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

   260

   261

	if (flags & DC_EXEC) {

   262

		Vehicle *v;

   263

		VehicleType type = (VehicleType)p2;

   264

		GroupID id_g = p1;

   265

   266

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

   267

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

   268

		FOR_ALL_VEHICLES(v) {

   269

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

   270

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

   271

   272

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

   273

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

   274

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

   275

				}

   276

			}

   277

		}

   278

   279

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

   280

	}

   281

   282

	return CommandCost();

   283

}

   284

   285

   286

/**

   287

 * Remove all vehicles from a group

   288

 * @param tile unused

   289

 * @param p1   index of group array

   290

 * - p1 bit 0-15 : GroupID

   291

 * @param p2   type of vehicles

   292

 */

   293

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

   294

{

   295

	VehicleType type = (VehicleType)p2;

   296

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

   297

   298

	Group *g = GetGroup(p1);

   299

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

   300

   301

	if (flags & DC_EXEC) {

   302

		GroupID old_g = p1;

   303

		Vehicle *v;

   304

   305

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

   306

		FOR_ALL_VEHICLES(v) {

   307

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

   308

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

   309

   310

				/* Add The Vehicle to the default group */

   311

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

   312

			}

   313

		}

   314

   315

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

   316

	}

   317

   318

	return CommandCost();

   319

}

   320

   321

   322

/**

   323

 * (Un)set global replace protection from a group

   324

 * @param tile unused

   325

 * @param p1   index of group array

   326

 * - p1 bit 0-15 : GroupID

   327

 * @param p2

   328

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

   329

 */

   330

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

   331

{

   332

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   333

   334

	Group *g = GetGroup(p1);

   335

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

   336

   337

	if (flags & DC_EXEC) {

   338

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

   339

   340

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

   341

	}

   342

   343

	return CommandCost();

   344

}

   345

   346

/**

   347

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

   348

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   349

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

   350

 */

   351

void RemoveVehicleFromGroup(const Vehicle *v)

   352

{

   353

	if (!v->IsValid() || !v->IsPrimaryVehicle()) return;

   354

   355

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

   356

}

   357

   358

   359

/**

   360

 * Affect the groupID of a train to new_g.

   361

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   362

 * @param v     First vehicle of the chain.

   363

 * @param new_g index of array group

   364

 */

   365

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   366

{

   367

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

   368

   369

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

   370

   371

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

   372

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

   373

   374

		u->group_id = new_g;

   375

	}

   376

   377

	/* Update the Replace Vehicle Windows */

   378

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   379

}

   380

   381

   382

/**

   383

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

   384

 * to/removed from the chain,.

   385

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

   386

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

   387

 * @param v First vehicle of the chain.

   388

 */

   389

void UpdateTrainGroupID(Vehicle *v)

   390

{

   391

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

   392

   393

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

   394

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

   395

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

   396

   397

		u->group_id = new_g;

   398

	}

   399

   400

	/* Update the Replace Vehicle Windows */

   401

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   402

}

   403

   404

uint GetGroupNumEngines(PlayerID p, GroupID id_g, EngineID id_e)

   405

{

   406

	if (IsValidGroupID(id_g)) return GetGroup(id_g)->num_engines[id_e];

   407

   408

	uint num = GetPlayer(p)->num_engines[id_e];

   409

	if (!IsDefaultGroupID(id_g)) return num;

   410

   411

	const Group *g;

   412

	FOR_ALL_GROUPS(g) {

   413

		if (g->owner == p) num -= g->num_engines[id_e];

   414

	}

   415

	return num;

   416

}

   417

   418

void RemoveAllGroupsForPlayer(const PlayerID p)

   419

{

   420

	Group *g;

   421

   422

	FOR_ALL_GROUPS(g) {

   423

		if (p == g->owner) delete g;

   424

	}

   425

}

   426

   427

   428

static const SaveLoad _group_desc[] = {

   429

  SLE_CONDVAR(Group, name,           SLE_NAME,    0, 83),

   430

  SLE_CONDSTR(Group, name,           SLE_STR, 0, 84, SL_MAX_VERSION),

   431

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   432

  SLE_VAR(Group, owner,              SLE_UINT8),

   433

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   434

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   435

  SLE_END()

   436

};

   437

   438

   439

static void Save_GROUP(void)

   440

{

   441

	Group *g;

   442

   443

	FOR_ALL_GROUPS(g) {

   444

		SlSetArrayIndex(g->index);

   445

		SlObject(g, _group_desc);

   446

	}

   447

}

   448

   449

   450

static void Load_GROUP(void)

   451

{

   452

	int index;

   453

   454

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

   455

		Group *g = new (index) Group();

   456

		SlObject(g, _group_desc);

   457

	}

   458

}

   459

   460

extern const ChunkHandler _group_chunk_handlers[] = {

   461

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

   462

};