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

     9

#include "player.h"

    10

#include "table/strings.h"

    11

#include "command.h"

    12

#include "vehicle.h"

    13

#include "saveload.h"

    14

#include "debug.h"

    15

#include "group.h"

    16

#include "train.h"

    17

#include "aircraft.h"

    18

#include "string.h"

    19

#include "vehicle_gui.h"

    20

#include "strings.h"

    21

#include "misc/autoptr.hpp"

    22

    23

/**

    24

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

    25

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    26

 * @param i     EngineID we have to update

    27

 * @param old_g index of the old group

    28

 * @param new_g index of the new group

    29

 */

    30

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

    31

{

    32

	if (old_g != new_g) {

    33

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

    34

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

    35

    36

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

    37

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

    38

	}

    39

}

    40

    41

    42

DEFINE_OLD_POOL_GENERIC(Group, Group)

    43

    44

    45

Group::Group(StringID str)

    46

{

    47

	this->string_id = str;

    48

}

    49

    50

Group::~Group()

    51

{

    52

	DeleteName(this->string_id);

    53

	this->string_id = STR_NULL;

    54

}

    55

    56

bool Group::IsValid() const

    57

{

    58

	return this->string_id != STR_NULL;

    59

}

    60

    61

void InitializeGroup(void)

    62

{

    63

	_Group_pool.CleanPool();

    64

	_Group_pool.AddBlockToPool();

    65

}

    66

    67

    68

static WindowClass GetWCForVT(VehicleType vt)

    69

{

    70

	switch (vt) {

    71

		default:

    72

		case VEH_TRAIN:    return WC_TRAINS_LIST;

    73

		case VEH_ROAD:     return WC_ROADVEH_LIST;

    74

		case VEH_SHIP:     return WC_SHIPS_LIST;

    75

		case VEH_AIRCRAFT: return WC_AIRCRAFT_LIST;

    76

	}

    77

}

    78

    79

    80

/**

    81

 * Create a new vehicle group.

    82

 * @param tile unused

    83

 * @param p1   vehicle type

    84

 * @param p2   unused

    85

 */

    86

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

    87

{

    88

	VehicleType vt = (VehicleType)p1;

    89

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    90

    91

	AutoPtrT<Group> g_auto_delete;

    92

    93

	Group *g = new Group(STR_EMPTY);

    94

	if (g == NULL) return CMD_ERROR;

    95

    96

	g_auto_delete = g;

    97

    98

	if (flags & DC_EXEC) {

    99

		g->owner = _current_player;

   100

		g->replace_protection = false;

   101

		g->vehicle_type = vt;

   102

   103

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

   104

   105

		g_auto_delete.Detach();

   106

	}

   107

   108

	return CommandCost();

   109

}

   110

   111

   112

/**

   113

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

   114

 * @param tile unused

   115

 * @param p1   index of array group

   116

 *      - p1 bit 0-15 : GroupID

   117

 * @param p2   unused

   118

 */

   119

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

   120

{

   121

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   122

   123

	Group *g = GetGroup(p1);

   124

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

   125

   126

	if (flags & DC_EXEC) {

   127

		Vehicle *v;

   128

   129

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

   130

		FOR_ALL_VEHICLES(v) {

   131

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

   132

		}

   133

   134

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

   135

		if (_current_player < MAX_PLAYERS) {

   136

			Player *p;

   137

			EngineRenew *er;

   138

   139

			p = GetPlayer(_current_player);

   140

			FOR_ALL_ENGINE_RENEWS(er) {

   141

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

   142

			}

   143

		}

   144

   145

		VehicleType vt = g->vehicle_type;

   146

   147

		/* Delete the Replace Vehicle Windows */

   148

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   149

		delete g;

   150

   151

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

   152

	}

   153

   154

	return CommandCost();

   155

}

   156

   157

static bool IsUniqueGroupName(const char *name)

   158

{

   159

	const Group *g;

   160

	char buf[512];

   161

   162

	FOR_ALL_GROUPS(g) {

   163

		SetDParam(0, g->index);

   164

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

   165

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

   166

	}

   167

   168

	return true;

   169

}

   170

   171

/**

   172

 * Rename a group

   173

 * @param tile unused

   174

 * @param p1   index of array group

   175

 *   - p1 bit 0-15 : GroupID

   176

 * @param p2   unused

   177

 */

   178

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

   179

{

   180

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

   181

   182

	Group *g = GetGroup(p1);

   183

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

   184

   185

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

   186

   187

	/* Create the name */

   188

	StringID str = AllocateName(_cmd_text, 0);

   189

	if (str == STR_NULL) return CMD_ERROR;

   190

   191

	if (flags & DC_EXEC) {

   192

		/* Delete the old name */

   193

		DeleteName(g->string_id);

   194

		/* Assign the new one */

   195

		g->string_id = str;

   196

   197

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

   198

	}

   199

   200

	return CommandCost();

   201

}

   202

   203

   204

/**

   205

 * Add a vehicle to a group

   206

 * @param tile unused

   207

 * @param p1   index of array group

   208

 *   - p1 bit 0-15 : GroupID

   209

 * @param p2   vehicle to add to a group

   210

 *   - p2 bit 0-15 : VehicleID

   211

 */

   212

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

   213

{

   214

	GroupID new_g = p1;

   215

   216

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

   217

   218

	Vehicle *v = GetVehicle(p2);

   219

   220

	if (IsValidGroupID(new_g)) {

   221

		Group *g = GetGroup(new_g);

   222

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

   223

	}

   224

   225

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

   226

   227

	if (flags & DC_EXEC) {

   228

		DecreaseGroupNumVehicle(v->group_id);

   229

		IncreaseGroupNumVehicle(new_g);

   230

   231

		switch (v->type) {

   232

			default: NOT_REACHED();

   233

			case VEH_TRAIN:

   234

				SetTrainGroupID(v, new_g);

   235

				break;

   236

			case VEH_ROAD:

   237

			case VEH_SHIP:

   238

			case VEH_AIRCRAFT:

   239

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

   240

				v->group_id = new_g;

   241

				break;

   242

		}

   243

   244

		/* Update the Replace Vehicle Windows */

   245

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   246

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

   247

	}

   248

   249

	return CommandCost();

   250

}

   251

   252

/**

   253

 * Add all shared vehicles of all vehicles from a group

   254

 * @param tile unused

   255

 * @param p1   index of group array

   256

 *  - p1 bit 0-15 : GroupID

   257

 * @param p2   type of vehicles

   258

 */

   259

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

   260

{

   261

	VehicleType type = (VehicleType)p2;

   262

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

   263

   264

	if (flags & DC_EXEC) {

   265

		Vehicle *v;

   266

		VehicleType type = (VehicleType)p2;

   267

		GroupID id_g = p1;

   268

   269

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

   270

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

   271

		FOR_ALL_VEHICLES(v) {

   272

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

   273

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

   274

   275

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

   276

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

   277

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

   278

				}

   279

			}

   280

		}

   281

   282

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

   283

	}

   284

   285

	return CommandCost();

   286

}

   287

   288

   289

/**

   290

 * Remove all vehicles from a group

   291

 * @param tile unused

   292

 * @param p1   index of group array

   293

 * - p1 bit 0-15 : GroupID

   294

 * @param p2   type of vehicles

   295

 */

   296

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

   297

{

   298

	VehicleType type = (VehicleType)p2;

   299

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

   300

   301

	Group *g = GetGroup(p1);

   302

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

   303

   304

	if (flags & DC_EXEC) {

   305

		GroupID old_g = p1;

   306

		Vehicle *v;

   307

   308

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

   309

		FOR_ALL_VEHICLES(v) {

   310

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

   311

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

   312

   313

				/* Add The Vehicle to the default group */

   314

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

   315

			}

   316

		}

   317

   318

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

   319

	}

   320

   321

	return CommandCost();

   322

}

   323

   324

   325

/**

   326

 * (Un)set global replace protection from a group

   327

 * @param tile unused

   328

 * @param p1   index of group array

   329

 * - p1 bit 0-15 : GroupID

   330

 * @param p2

   331

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

   332

 */

   333

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

   334

{

   335

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   336

   337

	Group *g = GetGroup(p1);

   338

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

   339

   340

	if (flags & DC_EXEC) {

   341

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

   342

   343

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

   344

	}

   345

   346

	return CommandCost();

   347

}

   348

   349

/**

   350

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

   351

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   352

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

   353

 */

   354

void RemoveVehicleFromGroup(const Vehicle *v)

   355

{

   356

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

   357

   358

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

   359

}

   360

   361

   362

/**

   363

 * Affect the groupID of a train to new_g.

   364

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   365

 * @param v     First vehicle of the chain.

   366

 * @param new_g index of array group

   367

 */

   368

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   369

{

   370

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

   371

   372

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

   373

   374

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

   375

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

   376

   377

		u->group_id = new_g;

   378

	}

   379

   380

	/* Update the Replace Vehicle Windows */

   381

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   382

}

   383

   384

   385

/**

   386

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

   387

 * to/removed from the chain,.

   388

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

   389

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

   390

 * @param v First vehicle of the chain.

   391

 */

   392

void UpdateTrainGroupID(Vehicle *v)

   393

{

   394

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

   395

   396

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

   397

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

   398

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

   399

   400

		u->group_id = new_g;

   401

	}

   402

   403

	/* Update the Replace Vehicle Windows */

   404

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   405

}

   406

   407

   408

void RemoveAllGroupsForPlayer(const Player *p)

   409

{

   410

	Group *g;

   411

   412

	FOR_ALL_GROUPS(g) {

   413

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

   414

	}

   415

}

   416

   417

   418

static const SaveLoad _group_desc[] = {

   419

  SLE_VAR(Group, string_id,          SLE_UINT16),

   420

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   421

  SLE_VAR(Group, owner,              SLE_UINT8),

   422

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   423

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   424

  SLE_END()

   425

};

   426

   427

   428

static void Save_GROUP(void)

   429

{

   430

	Group *g;

   431

   432

	FOR_ALL_GROUPS(g) {

   433

		SlSetArrayIndex(g->index);

   434

		SlObject(g, _group_desc);

   435

	}

   436

}

   437

   438

   439

static void Load_GROUP(void)

   440

{

   441

	int index;

   442

   443

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

   444

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

   445

		SlObject(g, _group_desc);

   446

	}

   447

}

   448

   449

extern const ChunkHandler _group_chunk_handlers[] = {

   450

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

   451

};