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

	this->QuickFree();

    54

	this->string_id = STR_NULL;

    55

}

    56

    57

void Group::QuickFree()

    58

{

    59

	DeleteName(this->string_id);

    60

}

    61

    62

bool Group::IsValid() const

    63

{

    64

	return this->string_id != STR_NULL;

    65

}

    66

    67

void InitializeGroup(void)

    68

{

    69

	_Group_pool.CleanPool();

    70

	_Group_pool.AddBlockToPool();

    71

}

    72

    73

    74

static WindowClass GetWCForVT(VehicleType vt)

    75

{

    76

	switch (vt) {

    77

		default:

    78

		case VEH_TRAIN:    return WC_TRAINS_LIST;

    79

		case VEH_ROAD:     return WC_ROADVEH_LIST;

    80

		case VEH_SHIP:     return WC_SHIPS_LIST;

    81

		case VEH_AIRCRAFT: return WC_AIRCRAFT_LIST;

    82

	}

    83

}

    84

    85

    86

/**

    87

 * Create a new vehicle group.

    88

 * @param tile unused

    89

 * @param p1   vehicle type

    90

 * @param p2   unused

    91

 */

    92

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

    93

{

    94

	VehicleType vt = (VehicleType)p1;

    95

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    96

    97

	AutoPtrT<Group> g_auto_delete;

    98

    99

	Group *g = new Group(STR_EMPTY);

   100

	if (g == NULL) return CMD_ERROR;

   101

   102

	g_auto_delete = g;

   103

   104

	if (flags & DC_EXEC) {

   105

		g->owner = _current_player;

   106

		g->replace_protection = false;

   107

		g->vehicle_type = vt;

   108

   109

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

   110

   111

		g_auto_delete.Detach();

   112

	}

   113

   114

	return CommandCost();

   115

}

   116

   117

   118

/**

   119

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

   120

 * @param tile unused

   121

 * @param p1   index of array group

   122

 *      - p1 bit 0-15 : GroupID

   123

 * @param p2   unused

   124

 */

   125

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

   126

{

   127

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   128

   129

	Group *g = GetGroup(p1);

   130

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

   131

   132

	if (flags & DC_EXEC) {

   133

		Vehicle *v;

   134

   135

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

   136

		FOR_ALL_VEHICLES(v) {

   137

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

   138

		}

   139

   140

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

   141

		if (_current_player < MAX_PLAYERS) {

   142

			Player *p;

   143

			EngineRenew *er;

   144

   145

			p = GetPlayer(_current_player);

   146

			FOR_ALL_ENGINE_RENEWS(er) {

   147

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

   148

			}

   149

		}

   150

   151

		VehicleType vt = g->vehicle_type;

   152

   153

		/* Delete the Replace Vehicle Windows */

   154

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   155

		delete g;

   156

   157

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

   158

	}

   159

   160

	return CommandCost();

   161

}

   162

   163

static bool IsUniqueGroupName(const char *name)

   164

{

   165

	const Group *g;

   166

	char buf[512];

   167

   168

	FOR_ALL_GROUPS(g) {

   169

		SetDParam(0, g->index);

   170

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

   171

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

   172

	}

   173

   174

	return true;

   175

}

   176

   177

/**

   178

 * Rename a group

   179

 * @param tile unused

   180

 * @param p1   index of array group

   181

 *   - p1 bit 0-15 : GroupID

   182

 * @param p2   unused

   183

 */

   184

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

   185

{

   186

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

   187

   188

	Group *g = GetGroup(p1);

   189

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

   190

   191

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

   192

   193

	/* Create the name */

   194

	StringID str = AllocateName(_cmd_text, 0);

   195

	if (str == STR_NULL) return CMD_ERROR;

   196

   197

	if (flags & DC_EXEC) {

   198

		/* Delete the old name */

   199

		DeleteName(g->string_id);

   200

		/* Assign the new one */

   201

		g->string_id = str;

   202

   203

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

   204

	}

   205

   206

	return CommandCost();

   207

}

   208

   209

   210

/**

   211

 * Add a vehicle to a group

   212

 * @param tile unused

   213

 * @param p1   index of array group

   214

 *   - p1 bit 0-15 : GroupID

   215

 * @param p2   vehicle to add to a group

   216

 *   - p2 bit 0-15 : VehicleID

   217

 */

   218

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

   219

{

   220

	GroupID new_g = p1;

   221

   222

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

   223

   224

	if (IsValidGroupID(new_g)) {

   225

		Group *g = GetGroup(new_g);

   226

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

   227

	}

   228

   229

	Vehicle *v = GetVehicle(p2);

   230

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

   231

   232

	if (flags & DC_EXEC) {

   233

		DecreaseGroupNumVehicle(v->group_id);

   234

		IncreaseGroupNumVehicle(new_g);

   235

   236

		switch (v->type) {

   237

			default: NOT_REACHED();

   238

			case VEH_TRAIN:

   239

				SetTrainGroupID(v, new_g);

   240

				break;

   241

			case VEH_ROAD:

   242

			case VEH_SHIP:

   243

			case VEH_AIRCRAFT:

   244

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

   245

				v->group_id = new_g;

   246

				break;

   247

		}

   248

   249

		/* Update the Replace Vehicle Windows */

   250

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   251

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

   252

	}

   253

   254

	return CommandCost();

   255

}

   256

   257

/**

   258

 * Add all shared vehicles of all vehicles from a group

   259

 * @param tile unused

   260

 * @param p1   index of group array

   261

 *  - p1 bit 0-15 : GroupID

   262

 * @param p2   type of vehicles

   263

 */

   264

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

   265

{

   266

	VehicleType type = (VehicleType)p2;

   267

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

   268

   269

	if (flags & DC_EXEC) {

   270

		Vehicle *v;

   271

		VehicleType type = (VehicleType)p2;

   272

		GroupID id_g = p1;

   273

   274

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

   275

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

   276

		FOR_ALL_VEHICLES(v) {

   277

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

   278

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

   279

   280

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

   281

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

   282

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

   283

				}

   284

			}

   285

		}

   286

   287

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

   288

	}

   289

   290

	return CommandCost();

   291

}

   292

   293

   294

/**

   295

 * Remove all vehicles from a group

   296

 * @param tile unused

   297

 * @param p1   index of group array

   298

 * - p1 bit 0-15 : GroupID

   299

 * @param p2   type of vehicles

   300

 */

   301

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

   302

{

   303

	VehicleType type = (VehicleType)p2;

   304

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

   305

   306

	Group *g = GetGroup(p1);

   307

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

   308

   309

	if (flags & DC_EXEC) {

   310

		GroupID old_g = p1;

   311

		Vehicle *v;

   312

   313

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

   314

		FOR_ALL_VEHICLES(v) {

   315

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

   316

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

   317

   318

				/* Add The Vehicle to the default group */

   319

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

   320

			}

   321

		}

   322

   323

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

   324

	}

   325

   326

	return CommandCost();

   327

}

   328

   329

   330

/**

   331

 * (Un)set global replace protection from a group

   332

 * @param tile unused

   333

 * @param p1   index of group array

   334

 * - p1 bit 0-15 : GroupID

   335

 * @param p2

   336

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

   337

 */

   338

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

   339

{

   340

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   341

   342

	Group *g = GetGroup(p1);

   343

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

   344

   345

	if (flags & DC_EXEC) {

   346

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

   347

   348

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

   349

	}

   350

   351

	return CommandCost();

   352

}

   353

   354

/**

   355

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

   356

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   357

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

   358

 */

   359

void RemoveVehicleFromGroup(const Vehicle *v)

   360

{

   362

   363

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

   364

}

   365

   366

   367

/**

   368

 * Affect the groupID of a train to new_g.

   369

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   370

 * @param v     First vehicle of the chain.

   371

 * @param new_g index of array group

   372

 */

   373

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   374

{

   375

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

   376

   378

   379

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

   380

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

   381

   382

		u->group_id = new_g;

   383

	}

   384

   385

	/* Update the Replace Vehicle Windows */

   386

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   387

}

   388

   389

   390

/**

   391

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

   392

 * to/removed from the chain,.

   393

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

   394

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

   395

 * @param v First vehicle of the chain.

   396

 */

   397

void UpdateTrainGroupID(Vehicle *v)

   398

{

   400

   401

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

   402

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

   403

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

   404

   405

		u->group_id = new_g;

   406

	}

   407

   408

	/* Update the Replace Vehicle Windows */

   409

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   410

}

   411

   412

   413

void RemoveAllGroupsForPlayer(const Player *p)

   414

{

   415

	Group *g;

   416

   417

	FOR_ALL_GROUPS(g) {

   418

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

   419

	}

   420

}

   421

   422

   423

static const SaveLoad _group_desc[] = {

   424

  SLE_VAR(Group, string_id,          SLE_UINT16),

   425

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   426

  SLE_VAR(Group, owner,              SLE_UINT8),

   427

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   428

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   429

  SLE_END()

   430

};

   431

   432

   433

static void Save_GROUP(void)

   434

{

   435

	Group *g;

   436

   437

	FOR_ALL_GROUPS(g) {

   438

		SlSetArrayIndex(g->index);

   439

		SlObject(g, _group_desc);

   440

	}

   441

}

   442

   443

   444

static void Load_GROUP(void)

   445

{

   446

	int index;

   447

   448

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

   449

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

   450

		SlObject(g, _group_desc);

   451

	}

   452

}

   453

   454

extern const ChunkHandler _group_chunk_handlers[] = {

   455

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

   456

};