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

    20

#include "vehicle_gui.h"

    21

#include "strings.h"

    22

#include "misc/autoptr.hpp"

    23

    24

/**

    25

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

    26

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    27

 * @param i     EngineID we have to update

    28

 * @param old_g index of the old group

    29

 * @param new_g index of the new group

    30

 */

    31

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

    32

{

    33

	if (old_g != new_g) {

    34

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

    35

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

    36

    37

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

    38

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

    39

	}

    40

}

    41

    42

    43

DEFINE_OLD_POOL_GENERIC(Group, Group)

    44

    45

    46

Group::Group(StringID str)

    47

{

    48

	this->string_id = str;

    49

}

    50

    51

Group::~Group()

    52

{

    53

	DeleteName(this->string_id);

    54

	this->string_id = STR_NULL;

    55

}

    56

    57

bool Group::IsValid() const

    58

{

    59

	return this->string_id != STR_NULL;

    60

}

    61

    62

void InitializeGroup(void)

    63

{

    64

	_Group_pool.CleanPool();

    65

	_Group_pool.AddBlockToPool();

    66

}

    67

    68

    69

static WindowClass GetWCForVT(VehicleType vt)

    70

{

    71

	switch (vt) {

    72

		default:

    73

		case VEH_TRAIN:    return WC_TRAINS_LIST;

    74

		case VEH_ROAD:     return WC_ROADVEH_LIST;

    75

		case VEH_SHIP:     return WC_SHIPS_LIST;

    76

		case VEH_AIRCRAFT: return WC_AIRCRAFT_LIST;

    77

	}

    78

}

    79

    80

    81

/**

    82

 * Create a new vehicle group.

    83

 * @param tile unused

    84

 * @param p1   vehicle type

    85

 * @param p2   unused

    86

 */

    87

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

    88

{

    89

	VehicleType vt = (VehicleType)p1;

    90

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    91

    92

	AutoPtrT<Group> g_auto_delete;

    93

    94

	Group *g = new Group(STR_EMPTY);

    95

	if (g == NULL) return CMD_ERROR;

    96

    97

	g_auto_delete = g;

    98

    99

	if (flags & DC_EXEC) {

   100

		g->owner = _current_player;

   101

		g->replace_protection = false;

   102

		g->vehicle_type = vt;

   103

   104

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

   105

   106

		g_auto_delete.Detach();

   107

	}

   108

   109

	return CommandCost();

   110

}

   111

   112

   113

/**

   114

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

   115

 * @param tile unused

   116

 * @param p1   index of array group

   117

 *      - p1 bit 0-15 : GroupID

   118

 * @param p2   unused

   119

 */

   120

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

   121

{

   122

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   123

   124

	Group *g = GetGroup(p1);

   125

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

   126

   127

	if (flags & DC_EXEC) {

   128

		Vehicle *v;

   129

   130

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

   131

		FOR_ALL_VEHICLES(v) {

   132

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

   133

		}

   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

	/* Create the name */

   189

	StringID str = AllocateName(_cmd_text, 0);

   190

	if (str == STR_NULL) return CMD_ERROR;

   191

   192

	if (flags & DC_EXEC) {

   193

		/* Delete the old name */

   194

		DeleteName(g->string_id);

   195

		/* Assign the new one */

   196

		g->string_id = str;

   197

   198

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

   199

	}

   200

   201

	return CommandCost();

   202

}

   203

   204

   205

/**

   206

 * Add a vehicle to a group

   207

 * @param tile unused

   208

 * @param p1   index of array group

   209

 *   - p1 bit 0-15 : GroupID

   210

 * @param p2   vehicle to add to a group

   211

 *   - p2 bit 0-15 : VehicleID

   212

 */

   213

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

   214

{

   215

	GroupID new_g = p1;

   216

   217

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

   218

   221

	if (IsValidGroupID(new_g)) {

   222

		Group *g = GetGroup(new_g);

   224

	}

   225

   226

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

   227

   228

	if (flags & DC_EXEC) {

   229

		DecreaseGroupNumVehicle(v->group_id);

   230

		IncreaseGroupNumVehicle(new_g);

   231

   232

		switch (v->type) {

   233

			default: NOT_REACHED();

   234

			case VEH_TRAIN:

   235

				SetTrainGroupID(v, new_g);

   236

				break;

   237

			case VEH_ROAD:

   238

			case VEH_SHIP:

   239

			case VEH_AIRCRAFT:

   240

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

   241

				v->group_id = new_g;

   242

				break;

   243

		}

   244

   245

		/* Update the Replace Vehicle Windows */

   246

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   247

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

   248

	}

   249

   250

	return CommandCost();

   251

}

   252

   253

/**

   254

 * Add all shared vehicles of all vehicles from a group

   255

 * @param tile unused

   256

 * @param p1   index of group array

   257

 *  - p1 bit 0-15 : GroupID

   258

 * @param p2   type of vehicles

   259

 */

   260

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

   261

{

   262

	VehicleType type = (VehicleType)p2;

   263

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

   264

   265

	if (flags & DC_EXEC) {

   266

		Vehicle *v;

   267

		VehicleType type = (VehicleType)p2;

   268

		GroupID id_g = p1;

   269

   270

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

   271

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

   272

		FOR_ALL_VEHICLES(v) {

   273

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

   274

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

   275

   276

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

   277

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

   278

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

   279

				}

   280

			}

   281

		}

   282

   283

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

   284

	}

   285

   286

	return CommandCost();

   287

}

   288

   289

   290

/**

   291

 * Remove all vehicles from a group

   292

 * @param tile unused

   293

 * @param p1   index of group array

   294

 * - p1 bit 0-15 : GroupID

   295

 * @param p2   type of vehicles

   296

 */

   297

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

   298

{

   299

	VehicleType type = (VehicleType)p2;

   300

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

   301

   302

	Group *g = GetGroup(p1);

   303

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

   304

   305

	if (flags & DC_EXEC) {

   306

		GroupID old_g = p1;

   307

		Vehicle *v;

   308

   309

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

   310

		FOR_ALL_VEHICLES(v) {

   311

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

   312

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

   313

   314

				/* Add The Vehicle to the default group */

   315

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

   316

			}

   317

		}

   318

   319

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

   320

	}

   321

   322

	return CommandCost();

   323

}

   324

   325

   326

/**

   327

 * (Un)set global replace protection from a group

   328

 * @param tile unused

   329

 * @param p1   index of group array

   330

 * - p1 bit 0-15 : GroupID

   331

 * @param p2

   332

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

   333

 */

   334

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

   335

{

   336

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   337

   338

	Group *g = GetGroup(p1);

   339

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

   340

   341

	if (flags & DC_EXEC) {

   342

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

   343

   344

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

   345

	}

   346

   347

	return CommandCost();

   348

}

   349

   350

/**

   351

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

   352

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   353

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

   354

 */

   355

void RemoveVehicleFromGroup(const Vehicle *v)

   356

{

   357

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

   358

   359

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

   360

}

   361

   362

   363

/**

   364

 * Affect the groupID of a train to new_g.

   365

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   366

 * @param v     First vehicle of the chain.

   367

 * @param new_g index of array group

   368

 */

   369

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   370

{

   371

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

   372

   373

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

   374

   375

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

   376

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

   377

   378

		u->group_id = new_g;

   379

	}

   380

   381

	/* Update the Replace Vehicle Windows */

   382

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   383

}

   384

   385

   386

/**

   387

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

   388

 * to/removed from the chain,.

   389

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

   390

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

   391

 * @param v First vehicle of the chain.

   392

 */

   393

void UpdateTrainGroupID(Vehicle *v)

   394

{

   395

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

   396

   397

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

   398

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

   399

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

   400

   401

		u->group_id = new_g;

   402

	}

   403

   404

	/* Update the Replace Vehicle Windows */

   405

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   406

}

   407

   408

   409

void RemoveAllGroupsForPlayer(const Player *p)

   410

{

   411

	Group *g;

   412

   413

	FOR_ALL_GROUPS(g) {

   414

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

   415

	}

   416

}

   417

   418

   419

static const SaveLoad _group_desc[] = {

   420

  SLE_VAR(Group, string_id,          SLE_UINT16),

   421

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   422

  SLE_VAR(Group, owner,              SLE_UINT8),

   423

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   424

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   425

  SLE_END()

   426

};

   427

   428

   429

static void Save_GROUP(void)

   430

{

   431

	Group *g;

   432

   433

	FOR_ALL_GROUPS(g) {

   434

		SlSetArrayIndex(g->index);

   435

		SlObject(g, _group_desc);

   436

	}

   437

}

   438

   439

   440

static void Load_GROUP(void)

   441

{

   442

	int index;

   443

   444

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

   445

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

   446

		SlObject(g, _group_desc);

   447

	}

   448

}

   449

   450

extern const ChunkHandler _group_chunk_handlers[] = {

   451

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

   452

};