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 "company_func.h"

    23

#include "order_func.h"

    24

#include "oldpool_func.h"

    25

#include "core/alloc_func.hpp"

    26

    27

#include "table/strings.h"

    28

    29

/**

    30

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

    31

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    32

 * @param i     EngineID we have to update

    33

 * @param old_g index of the old group

    34

 * @param new_g index of the new group

    35

 */

    36

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

    37

{

    38

	if (old_g != new_g) {

    39

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

    40

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

    41

    42

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

    43

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

    44

	}

    45

}

    46

    47

    48

DEFINE_OLD_POOL_GENERIC(Group, Group)

    49

    50

    51

Group::Group(Owner owner)

    52

{

    53

	this->owner = owner;

    54

    55

	if (this->IsValid()) this->num_engines = CallocT<uint16>(GetEnginePoolSize());

    56

}

    57

    58

Group::~Group()

    59

{

    60

	free(this->name);

    61

	this->owner = INVALID_OWNER;

    62

	free(this->num_engines);

    63

}

    64

    65

bool Group::IsValid() const

    66

{

    67

	return this->owner != INVALID_OWNER;

    68

}

    69

    70

void InitializeGroup(void)

    71

{

    72

	_Group_pool.CleanPool();

    73

	_Group_pool.AddBlockToPool();

    74

}

    75

    76

    77

/**

    78

 * Create a new vehicle group.

    79

 * @param tile unused

    80

 * @param p1   vehicle type

    81

 * @param p2   unused

    82

 */

    83

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

    84

{

    85

	VehicleType vt = (VehicleType)p1;

    86

	if (!IsCompanyBuildableVehicleType(vt)) return CMD_ERROR;

    87

    88

	if (!Group::CanAllocateItem()) return CMD_ERROR;

    89

    90

	if (flags & DC_EXEC) {

    91

		Group *g = new Group(_current_company);

    92

		g->replace_protection = false;

    93

		g->vehicle_type = vt;

    94

    95

		InvalidateWindowData(GetWindowClassForVehicleType(vt), (vt << 11) | VLW_GROUP_LIST | _current_company);

    96

	}

    97

    98

	return CommandCost();

    99

}

   100

   101

   102

/**

   103

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

   104

 * @param tile unused

   105

 * @param p1   index of array group

   106

 *      - p1 bit 0-15 : GroupID

   107

 * @param p2   unused

   108

 */

   109

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

   110

{

   111

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   112

   113

	Group *g = GetGroup(p1);

   114

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

   115

   116

	if (flags & DC_EXEC) {

   117

		Vehicle *v;

   118

   119

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

   120

		FOR_ALL_VEHICLES(v) {

   121

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

   122

		}

   123

   124

		/* Update backupped orders if needed */

   125

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

   126

   127

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

   128

		if (_current_company < MAX_COMPANIES) {

   129

			Company *c;

   130

			EngineRenew *er;

   131

   132

			c = GetCompany(_current_company);

   133

			FOR_ALL_ENGINE_RENEWS(er) {

   134

				if (er->group_id == g->index) RemoveEngineReplacementForCompany(c, er->from, g->index, flags);

   135

			}

   136

		}

   137

   138

		VehicleType vt = g->vehicle_type;

   139

   140

		/* Delete the Replace Vehicle Windows */

   141

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   142

		delete g;

   143

   144

		InvalidateWindowData(GetWindowClassForVehicleType(vt), (vt << 11) | VLW_GROUP_LIST | _current_company);

   145

	}

   146

   147

	return CommandCost();

   148

}

   149

   150

static bool IsUniqueGroupName(const char *name)

   151

{

   152

	const Group *g;

   153

	char buf[512];

   154

   155

	FOR_ALL_GROUPS(g) {

   156

		SetDParam(0, g->index);

   157

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

   158

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

   159

	}

   160

   161

	return true;

   162

}

   163

   164

/**

   165

 * Rename a group

   166

 * @param tile unused

   167

 * @param p1   index of array group

   168

 *   - p1 bit 0-15 : GroupID

   169

 * @param p2   unused

   170

 */

   171

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

   172

{

   173

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   174

   175

	Group *g = GetGroup(p1);

   176

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

   177

   178

	bool reset = StrEmpty(_cmd_text);

   179

   180

	if (!reset) {

   181

		if (strlen(_cmd_text) >= MAX_LENGTH_GROUP_NAME_BYTES) return CMD_ERROR;

   182

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

   183

	}

   184

   185

	if (flags & DC_EXEC) {

   186

		/* Delete the old name */

   187

		free(g->name);

   188

		/* Assign the new one */

   189

		g->name = reset ? NULL : strdup(_cmd_text);

   190

   191

		InvalidateWindowData(GetWindowClassForVehicleType(g->vehicle_type), (g->vehicle_type << 11) | VLW_GROUP_LIST | _current_company);

   192

	}

   193

   194

	return CommandCost();

   195

}

   196

   197

   198

/**

   199

 * Add a vehicle to a group

   200

 * @param tile unused

   201

 * @param p1   index of array group

   202

 *   - p1 bit 0-15 : GroupID

   203

 * @param p2   vehicle to add to a group

   204

 *   - p2 bit 0-15 : VehicleID

   205

 */

   206

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

   207

{

   208

	GroupID new_g = p1;

   209

   210

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

   211

   212

	Vehicle *v = GetVehicle(p2);

   213

   214

	if (IsValidGroupID(new_g)) {

   215

		Group *g = GetGroup(new_g);

   216

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

   217

	}

   218

   219

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

   220

   221

	if (flags & DC_EXEC) {

   222

		DecreaseGroupNumVehicle(v->group_id);

   223

		IncreaseGroupNumVehicle(new_g);

   224

   225

		switch (v->type) {

   226

			default: NOT_REACHED();

   227

			case VEH_TRAIN:

   228

				SetTrainGroupID(v, new_g);

   229

				break;

   230

			case VEH_ROAD:

   231

			case VEH_SHIP:

   232

			case VEH_AIRCRAFT:

   233

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

   234

				v->group_id = new_g;

   235

				break;

   236

		}

   237

   238

		/* Update the Replace Vehicle Windows */

   239

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   240

		InvalidateWindowData(GetWindowClassForVehicleType(v->type), (v->type << 11) | VLW_GROUP_LIST | _current_company);

   241

	}

   242

   243

	return CommandCost();

   244

}

   245

   246

/**

   247

 * Add all shared vehicles of all vehicles from a group

   248

 * @param tile unused

   249

 * @param p1   index of group array

   250

 *  - p1 bit 0-15 : GroupID

   251

 * @param p2   type of vehicles

   252

 */

   253

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

   254

{

   255

	VehicleType type = (VehicleType)p2;

   256

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

   257

   258

	if (flags & DC_EXEC) {

   259

		Vehicle *v;

   260

		VehicleType type = (VehicleType)p2;

   261

		GroupID id_g = p1;

   262

   263

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

   264

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

   265

		FOR_ALL_VEHICLES(v) {

   266

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

   267

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

   268

   269

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

   270

				for (Vehicle *v2 = v->FirstShared(); v2 != NULL; v2 = v2->NextShared()) {

   271

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

   272

				}

   273

			}

   274

		}

   275

   276

		InvalidateWindowData(GetWindowClassForVehicleType(type), (type << 11) | VLW_GROUP_LIST | _current_company);

   277

	}

   278

   279

	return CommandCost();

   280

}

   281

   282

   283

/**

   284

 * Remove all vehicles from a group

   285

 * @param tile unused

   286

 * @param p1   index of group array

   287

 * - p1 bit 0-15 : GroupID

   288

 * @param p2   type of vehicles

   289

 */

   290

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

   291

{

   292

	VehicleType type = (VehicleType)p2;

   293

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

   294

   295

	Group *g = GetGroup(p1);

   296

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

   297

   298

	if (flags & DC_EXEC) {

   299

		GroupID old_g = p1;

   300

		Vehicle *v;

   301

   302

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

   303

		FOR_ALL_VEHICLES(v) {

   304

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

   305

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

   306

   307

				/* Add The Vehicle to the default group */

   308

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

   309

			}

   310

		}

   311

   312

		InvalidateWindowData(GetWindowClassForVehicleType(type), (type << 11) | VLW_GROUP_LIST | _current_company);

   313

	}

   314

   315

	return CommandCost();

   316

}

   317

   318

   319

/**

   320

 * (Un)set global replace protection from a group

   321

 * @param tile unused

   322

 * @param p1   index of group array

   323

 * - p1 bit 0-15 : GroupID

   324

 * @param p2

   325

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

   326

 */

   327

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

   328

{

   329

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   330

   331

	Group *g = GetGroup(p1);

   332

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

   333

   334

	if (flags & DC_EXEC) {

   335

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

   336

   337

		InvalidateWindowData(GetWindowClassForVehicleType(g->vehicle_type), (g->vehicle_type << 11) | VLW_GROUP_LIST | _current_company);

   338

		InvalidateWindowData(WC_REPLACE_VEHICLE, g->vehicle_type);

   339

	}

   340

   341

	return CommandCost();

   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 (!v->IsValid() || !v->IsPrimaryVehicle()) 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(v->IsValid() && 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(v->IsValid() && 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

uint GetGroupNumEngines(CompanyID company, GroupID id_g, EngineID id_e)

   403

{

   404

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

   405

   406

	uint num = GetCompany(company)->num_engines[id_e];

   407

	if (!IsDefaultGroupID(id_g)) return num;

   408

   409

	const Group *g;

   410

	FOR_ALL_GROUPS(g) {

   411

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

   412

	}

   413

	return num;

   414

}

   415

   416

void RemoveAllGroupsForCompany(const CompanyID company)

   417

{

   418

	Group *g;

   419

   420

	FOR_ALL_GROUPS(g) {

   421

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

   422

	}

   423

}

   424

   425

   426

static const SaveLoad _group_desc[] = {

   427

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

   428

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

   429

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   430

  SLE_VAR(Group, owner,              SLE_UINT8),

   431

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   432

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   433

  SLE_END()

   434

};

   435

   436

   437

static void Save_GROUP(void)

   438

{

   439

	Group *g;

   440

   441

	FOR_ALL_GROUPS(g) {

   442

		SlSetArrayIndex(g->index);

   443

		SlObject(g, _group_desc);

   444

	}

   445

}

   446

   447

   448

static void Load_GROUP(void)

   449

{

   450

	int index;

   451

   452

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

   453

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

   454

		SlObject(g, _group_desc);

   455

	}

   456

}

   457

   458

extern const ChunkHandler _group_chunk_handlers[] = {

   459

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

   460

};