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

    24

#include "table/strings.h"

    25

    26

/**

    27

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

    28

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    29

 * @param i     EngineID we have to update

    30

 * @param old_g index of the old group

    31

 * @param new_g index of the new group

    32

 */

    33

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

    34

{

    35

	if (old_g != new_g) {

    36

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

    37

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

    38

    39

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

    40

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

    41

	}

    42

}

    43

    44

    45

DEFINE_OLD_POOL_GENERIC(Group, Group)

    46

    47

    48

Group::Group(PlayerID owner)

    49

{

    50

	this->owner = owner;

    51

}

    52

    53

Group::~Group()

    54

{

    55

	free(this->name);

    56

	this->owner = INVALID_PLAYER;

    57

}

    58

    59

bool Group::IsValid() const

    60

{

    61

	return this->owner != INVALID_PLAYER;

    62

}

    63

    64

void InitializeGroup(void)

    65

{

    66

	_Group_pool.CleanPool();

    67

	_Group_pool.AddBlockToPool();

    68

}

    69

    70

    71

static WindowClass GetWCForVT(VehicleType vt)

    72

{

    73

	switch (vt) {

    74

		default:

    75

		case VEH_TRAIN:    return WC_TRAINS_LIST;

    76

		case VEH_ROAD:     return WC_ROADVEH_LIST;

    77

		case VEH_SHIP:     return WC_SHIPS_LIST;

    78

		case VEH_AIRCRAFT: return WC_AIRCRAFT_LIST;

    79

	}

    80

}

    81

    82

    83

/**

    84

 * Create a new vehicle group.

    85

 * @param tile unused

    86

 * @param p1   vehicle type

    87

 * @param p2   unused

    88

 */

    89

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

    90

{

    91

	VehicleType vt = (VehicleType)p1;

    92

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    93

    95

    96

	if (flags & DC_EXEC) {

    98

		g->replace_protection = false;

    99

		g->vehicle_type = vt;

   100

   101

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

   102

	}

   103

   104

	return CommandCost();

   105

}

   106

   107

   108

/**

   109

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

   110

 * @param tile unused

   111

 * @param p1   index of array group

   112

 *      - p1 bit 0-15 : GroupID

   113

 * @param p2   unused

   114

 */

   115

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

   116

{

   117

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   118

   119

	Group *g = GetGroup(p1);

   120

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

   121

   122

	if (flags & DC_EXEC) {

   123

		Vehicle *v;

   124

   125

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

   126

		FOR_ALL_VEHICLES(v) {

   127

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

   128

		}

   129

   130

		/* Update backupped orders if needed */

   131

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

   132

   133

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

   134

		if (_current_player < MAX_PLAYERS) {

   135

			Player *p;

   136

			EngineRenew *er;

   137

   138

			p = GetPlayer(_current_player);

   139

			FOR_ALL_ENGINE_RENEWS(er) {

   140

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

   141

			}

   142

		}

   143

   144

		VehicleType vt = g->vehicle_type;

   145

   146

		/* Delete the Replace Vehicle Windows */

   147

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   148

		delete g;

   149

   150

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

   151

	}

   152

   153

	return CommandCost();

   154

}

   155

   156

static bool IsUniqueGroupName(const char *name)

   157

{

   158

	const Group *g;

   159

	char buf[512];

   160

   161

	FOR_ALL_GROUPS(g) {

   162

		SetDParam(0, g->index);

   163

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

   164

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

   165

	}

   166

   167

	return true;

   168

}

   169

   170

/**

   171

 * Rename a group

   172

 * @param tile unused

   173

 * @param p1   index of array group

   174

 *   - p1 bit 0-15 : GroupID

   175

 * @param p2   unused

   176

 */

   177

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

   178

{

   179

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

   180

   181

	Group *g = GetGroup(p1);

   182

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

   183

   184

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

   185

   186

	if (flags & DC_EXEC) {

   187

		/* Delete the old name */

   188

		free(g->name);

   189

		/* Assign the new one */

   190

		g->name = strdup(_cmd_text);

   191

   192

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

   193

	}

   194

   195

	return CommandCost();

   196

}

   197

   198

   199

/**

   200

 * Add a vehicle to a group

   201

 * @param tile unused

   202

 * @param p1   index of array group

   203

 *   - p1 bit 0-15 : GroupID

   204

 * @param p2   vehicle to add to a group

   205

 *   - p2 bit 0-15 : VehicleID

   206

 */

   207

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

   208

{

   209

	GroupID new_g = p1;

   210

   211

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

   212

   213

	Vehicle *v = GetVehicle(p2);

   214

   215

	if (IsValidGroupID(new_g)) {

   216

		Group *g = GetGroup(new_g);

   217

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

   218

	}

   219

   220

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

   221

   222

	if (flags & DC_EXEC) {

   223

		DecreaseGroupNumVehicle(v->group_id);

   224

		IncreaseGroupNumVehicle(new_g);

   225

   226

		switch (v->type) {

   227

			default: NOT_REACHED();

   228

			case VEH_TRAIN:

   229

				SetTrainGroupID(v, new_g);

   230

				break;

   231

			case VEH_ROAD:

   232

			case VEH_SHIP:

   233

			case VEH_AIRCRAFT:

   234

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

   235

				v->group_id = new_g;

   236

				break;

   237

		}

   238

   239

		/* Update the Replace Vehicle Windows */

   240

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   241

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

   242

	}

   243

   244

	return CommandCost();

   245

}

   246

   247

/**

   248

 * Add all shared vehicles of all vehicles from a group

   249

 * @param tile unused

   250

 * @param p1   index of group array

   251

 *  - p1 bit 0-15 : GroupID

   252

 * @param p2   type of vehicles

   253

 */

   254

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

   255

{

   256

	VehicleType type = (VehicleType)p2;

   257

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

   258

   259

	if (flags & DC_EXEC) {

   260

		Vehicle *v;

   261

		VehicleType type = (VehicleType)p2;

   262

		GroupID id_g = p1;

   263

   264

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

   265

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

   266

		FOR_ALL_VEHICLES(v) {

   267

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

   268

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

   269

   270

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

   271

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

   272

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

   273

				}

   274

			}

   275

		}

   276

   277

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

   278

	}

   279

   280

	return CommandCost();

   281

}

   282

   283

   284

/**

   285

 * Remove all vehicles from a group

   286

 * @param tile unused

   287

 * @param p1   index of group array

   288

 * - p1 bit 0-15 : GroupID

   289

 * @param p2   type of vehicles

   290

 */

   291

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

   292

{

   293

	VehicleType type = (VehicleType)p2;

   294

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

   295

   296

	Group *g = GetGroup(p1);

   297

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

   298

   299

	if (flags & DC_EXEC) {

   300

		GroupID old_g = p1;

   301

		Vehicle *v;

   302

   303

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

   304

		FOR_ALL_VEHICLES(v) {

   305

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

   306

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

   307

   308

				/* Add The Vehicle to the default group */

   309

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

   310

			}

   311

		}

   312

   313

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

   314

	}

   315

   316

	return CommandCost();

   317

}

   318

   319

   320

/**

   321

 * (Un)set global replace protection from a group

   322

 * @param tile unused

   323

 * @param p1   index of group array

   324

 * - p1 bit 0-15 : GroupID

   325

 * @param p2

   326

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

   327

 */

   328

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

   329

{

   330

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   331

   332

	Group *g = GetGroup(p1);

   333

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

   334

   335

	if (flags & DC_EXEC) {

   336

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

   337

   338

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

   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(PlayerID p, GroupID id_g, EngineID id_e)

   403

{

   404

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

   405

   406

	uint num = GetPlayer(p)->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 == p) num -= g->num_engines[id_e];

   412

	}

   413

	return num;

   414

}

   415

   416

void RemoveAllGroupsForPlayer(const PlayerID p)

   417

{

   418

	Group *g;

   419

   420

	FOR_ALL_GROUPS(g) {

   421

		if (p == 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

};