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 "misc/autoptr.hpp"

    16

#include "strings_func.h"

    17

#include "functions.h"

    18

#include "window_func.h"

    19

#include "vehicle_func.h"

    20

#include "autoreplace_base.h"

    21

#include "autoreplace_func.h"

    22

#include "string_func.h"

    23

#include "player_func.h"

    24

#include "order_func.h"

    25

#include "oldpool_func.h"

    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 new 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(PlayerID owner)

    52

{

    53

	this->owner = owner;

    54

}

    55

    56

Group::~Group()

    57

{

    58

	free(this->name);

    59

	this->owner = INVALID_PLAYER;

    60

}

    61

    62

bool Group::IsValid() const

    63

{

    64

	return this->owner != INVALID_PLAYER;

    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(_current_player);

   100

	if (g == NULL) return CMD_ERROR;

   101

   102

	g_auto_delete = g;

   103

   104

	if (flags & DC_EXEC) {

   105

		g->replace_protection = false;

   106

		g->vehicle_type = vt;

   107

   108

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

   109

   110

		g_auto_delete.Detach();

   111

	}

   112

   113

	return CommandCost();

   114

}

   115

   116

   117

/**

   118

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

   119

 * @param tile unused

   120

 * @param p1   index of array group

   121

 *      - p1 bit 0-15 : GroupID

   122

 * @param p2   unused

   123

 */

   124

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

   125

{

   126

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   127

   128

	Group *g = GetGroup(p1);

   129

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

   130

   131

	if (flags & DC_EXEC) {

   132

		Vehicle *v;

   133

   134

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

   135

		FOR_ALL_VEHICLES(v) {

   136

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

   137

		}

   138

   139

		/* Update backupped orders if needed */

   140

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

   141

   142

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

   143

		if (_current_player < MAX_PLAYERS) {

   144

			Player *p;

   145

			EngineRenew *er;

   146

   147

			p = GetPlayer(_current_player);

   148

			FOR_ALL_ENGINE_RENEWS(er) {

   149

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

   150

			}

   151

		}

   152

   153

		VehicleType vt = g->vehicle_type;

   154

   155

		/* Delete the Replace Vehicle Windows */

   156

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   157

		delete g;

   158

   159

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

   160

	}

   161

   162

	return CommandCost();

   163

}

   164

   165

static bool IsUniqueGroupName(const char *name)

   166

{

   167

	const Group *g;

   168

	char buf[512];

   169

   170

	FOR_ALL_GROUPS(g) {

   171

		SetDParam(0, g->index);

   172

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

   173

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

   174

	}

   175

   176

	return true;

   177

}

   178

   179

/**

   180

 * Rename a group

   181

 * @param tile unused

   182

 * @param p1   index of array group

   183

 *   - p1 bit 0-15 : GroupID

   184

 * @param p2   unused

   185

 */

   186

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

   187

{

   188

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

   189

   190

	Group *g = GetGroup(p1);

   191

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

   192

   193

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

   194

   195

	if (flags & DC_EXEC) {

   196

		/* Delete the old name */

   197

		free(g->name);

   198

		/* Assign the new one */

   199

		g->name = strdup(_cmd_text);

   200

   201

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

   202

	}

   203

   204

	return CommandCost();

   205

}

   206

   207

   208

/**

   209

 * Add a vehicle to a group

   210

 * @param tile unused

   211

 * @param p1   index of array group

   212

 *   - p1 bit 0-15 : GroupID

   213

 * @param p2   vehicle to add to a group

   214

 *   - p2 bit 0-15 : VehicleID

   215

 */

   216

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

   217

{

   218

	GroupID new_g = p1;

   219

   220

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

   221

   222

	Vehicle *v = GetVehicle(p2);

   223

   224

	if (IsValidGroupID(new_g)) {

   225

		Group *g = GetGroup(new_g);

   226

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

   227

	}

   228

   229

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

   230

   231

	if (flags & DC_EXEC) {

   232

		DecreaseGroupNumVehicle(v->group_id);

   233

		IncreaseGroupNumVehicle(new_g);

   234

   235

		switch (v->type) {

   236

			default: NOT_REACHED();

   237

			case VEH_TRAIN:

   238

				SetTrainGroupID(v, new_g);

   239

				break;

   240

			case VEH_ROAD:

   241

			case VEH_SHIP:

   242

			case VEH_AIRCRAFT:

   243

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

   244

				v->group_id = new_g;

   245

				break;

   246

		}

   247

   248

		/* Update the Replace Vehicle Windows */

   249

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   250

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

   251

	}

   252

   253

	return CommandCost();

   254

}

   255

   256

/**

   257

 * Add all shared vehicles of all vehicles from a group

   258

 * @param tile unused

   259

 * @param p1   index of group array

   260

 *  - p1 bit 0-15 : GroupID

   261

 * @param p2   type of vehicles

   262

 */

   263

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

   264

{

   265

	VehicleType type = (VehicleType)p2;

   266

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

   267

   268

	if (flags & DC_EXEC) {

   269

		Vehicle *v;

   270

		VehicleType type = (VehicleType)p2;

   271

		GroupID id_g = p1;

   272

   273

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

   274

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

   275

		FOR_ALL_VEHICLES(v) {

   276

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

   277

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

   278

   279

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

   280

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

   281

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

   282

				}

   283

			}

   284

		}

   285

   286

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

   287

	}

   288

   289

	return CommandCost();

   290

}

   291

   292

   293

/**

   294

 * Remove all vehicles from a group

   295

 * @param tile unused

   296

 * @param p1   index of group array

   297

 * - p1 bit 0-15 : GroupID

   298

 * @param p2   type of vehicles

   299

 */

   300

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

   301

{

   302

	VehicleType type = (VehicleType)p2;

   303

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

   304

   305

	Group *g = GetGroup(p1);

   306

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

   307

   308

	if (flags & DC_EXEC) {

   309

		GroupID old_g = p1;

   310

		Vehicle *v;

   311

   312

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

   313

		FOR_ALL_VEHICLES(v) {

   314

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

   315

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

   316

   317

				/* Add The Vehicle to the default group */

   318

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

   319

			}

   320

		}

   321

   322

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

   323

	}

   324

   325

	return CommandCost();

   326

}

   327

   328

   329

/**

   330

 * (Un)set global replace protection from a group

   331

 * @param tile unused

   332

 * @param p1   index of group array

   333

 * - p1 bit 0-15 : GroupID

   334

 * @param p2

   335

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

   336

 */

   337

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

   338

{

   339

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   340

   341

	Group *g = GetGroup(p1);

   342

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

   343

   344

	if (flags & DC_EXEC) {

   345

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

   346

   347

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

   348

	}

   349

   350

	return CommandCost();

   351

}

   352

   353

/**

   354

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

   355

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   356

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

   357

 */

   358

void RemoveVehicleFromGroup(const Vehicle *v)

   359

{

   360

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

   361

   362

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

   363

}

   364

   365

   366

/**

   367

 * Affect the groupID of a train to new_g.

   368

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   369

 * @param v     First vehicle of the chain.

   370

 * @param new_g index of array group

   371

 */

   372

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   373

{

   374

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

   375

   376

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

   377

   378

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

   379

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

   380

   381

		u->group_id = new_g;

   382

	}

   383

   384

	/* Update the Replace Vehicle Windows */

   385

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   386

}

   387

   388

   389

/**

   390

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

   391

 * to/removed from the chain,.

   392

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

   393

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

   394

 * @param v First vehicle of the chain.

   395

 */

   396

void UpdateTrainGroupID(Vehicle *v)

   397

{

   398

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

   399

   400

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

   401

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

   402

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

   403

   404

		u->group_id = new_g;

   405

	}

   406

   407

	/* Update the Replace Vehicle Windows */

   408

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   409

}

   410

   411

uint GetGroupNumEngines(PlayerID p, GroupID id_g, EngineID id_e)

   412

{

   413

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

   414

   415

	uint num = GetPlayer(p)->num_engines[id_e];

   416

	if (!IsDefaultGroupID(id_g)) return num;

   417

   418

	const Group *g;

   419

	FOR_ALL_GROUPS(g) {

   420

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

   421

	}

   422

	return num;

   423

}

   424

   425

void RemoveAllGroupsForPlayer(const PlayerID p)

   426

{

   427

	Group *g;

   428

   429

	FOR_ALL_GROUPS(g) {

   430

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

   431

	}

   432

}

   433

   434

   435

static const SaveLoad _group_desc[] = {

   436

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

   437

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

   438

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   439

  SLE_VAR(Group, owner,              SLE_UINT8),

   440

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   441

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   442

  SLE_END()

   443

};

   444

   445

   446

static void Save_GROUP(void)

   447

{

   448

	Group *g;

   449

   450

	FOR_ALL_GROUPS(g) {

   451

		SlSetArrayIndex(g->index);

   452

		SlObject(g, _group_desc);

   453

	}

   454

}

   455

   456

   457

static void Load_GROUP(void)

   458

{

   459

	int index;

   460

   461

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

   462

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

   463

		SlObject(g, _group_desc);

   464

	}

   465

}

   466

   467

extern const ChunkHandler _group_chunk_handlers[] = {

   468

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

   469

};