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

    25

#include "table/strings.h"

    26

    27

/**

    28

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

    29

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    30

 * @param i     EngineID we have to update

    31

 * @param old_g index of the old group

    32

 * @param new_g index of the new group

    33

 */

    34

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

    35

{

    36

	if (old_g != new_g) {

    37

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

    38

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

    39

    40

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

    41

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

    42

	}

    43

}

    44

    45

    46

DEFINE_OLD_POOL_GENERIC(Group, Group)

    47

    48

    49

Group::Group(PlayerID owner)

    50

{

    51

	this->owner = owner;

    52

}

    53

    54

Group::~Group()

    55

{

    56

	free(this->name);

    57

	this->owner = INVALID_PLAYER;

    58

}

    59

    60

bool Group::IsValid() const

    61

{

    62

	return this->owner != INVALID_PLAYER;

    63

}

    64

    65

void InitializeGroup(void)

    66

{

    67

	_Group_pool.CleanPool();

    68

	_Group_pool.AddBlockToPool();

    69

}

    70

    71

    72

static WindowClass GetWCForVT(VehicleType vt)

    73

{

    74

	switch (vt) {

    75

		default:

    76

		case VEH_TRAIN:    return WC_TRAINS_LIST;

    77

		case VEH_ROAD:     return WC_ROADVEH_LIST;

    78

		case VEH_SHIP:     return WC_SHIPS_LIST;

    79

		case VEH_AIRCRAFT: return WC_AIRCRAFT_LIST;

    80

	}

    81

}

    82

    83

    84

/**

    85

 * Create a new vehicle group.

    86

 * @param tile unused

    87

 * @param p1   vehicle type

    88

 * @param p2   unused

    89

 */

    90

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

    91

{

    92

	VehicleType vt = (VehicleType)p1;

    93

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    94

    95

	AutoPtrT<Group> g_auto_delete;

    96

    97

	Group *g = new Group(_current_player);

    98

	if (g == NULL) return CMD_ERROR;

    99

   100

	g_auto_delete = g;

   101

   102

	if (flags & DC_EXEC) {

   103

		g->replace_protection = false;

   104

		g->vehicle_type = vt;

   105

   106

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

   107

   108

		g_auto_delete.Detach();

   109

	}

   110

   111

	return CommandCost();

   112

}

   113

   114

   115

/**

   116

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

   117

 * @param tile unused

   118

 * @param p1   index of array group

   119

 *      - p1 bit 0-15 : GroupID

   120

 * @param p2   unused

   121

 */

   122

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

   123

{

   124

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   125

   126

	Group *g = GetGroup(p1);

   127

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

   128

   129

	if (flags & DC_EXEC) {

   130

		Vehicle *v;

   131

   132

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

   133

		FOR_ALL_VEHICLES(v) {

   134

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

   135

		}

   136

   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

	if (flags & DC_EXEC) {

   194

		/* Delete the old name */

   195

		free(g->name);

   196

		/* Assign the new one */

   197

		g->name = strdup(_cmd_text);

   198

   199

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

   200

	}

   201

   202

	return CommandCost();

   203

}

   204

   205

   206

/**

   207

 * Add a vehicle to a group

   208

 * @param tile unused

   209

 * @param p1   index of array group

   210

 *   - p1 bit 0-15 : GroupID

   211

 * @param p2   vehicle to add to a group

   212

 *   - p2 bit 0-15 : VehicleID

   213

 */

   214

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

   215

{

   216

	GroupID new_g = p1;

   217

   218

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

   219

   220

	Vehicle *v = GetVehicle(p2);

   221

   222

	if (IsValidGroupID(new_g)) {

   223

		Group *g = GetGroup(new_g);

   224

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

   225

	}

   226

   227

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

   228

   229

	if (flags & DC_EXEC) {

   230

		DecreaseGroupNumVehicle(v->group_id);

   231

		IncreaseGroupNumVehicle(new_g);

   232

   233

		switch (v->type) {

   234

			default: NOT_REACHED();

   235

			case VEH_TRAIN:

   236

				SetTrainGroupID(v, new_g);

   237

				break;

   238

			case VEH_ROAD:

   239

			case VEH_SHIP:

   240

			case VEH_AIRCRAFT:

   241

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

   242

				v->group_id = new_g;

   243

				break;

   244

		}

   245

   246

		/* Update the Replace Vehicle Windows */

   247

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   248

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

   249

	}

   250

   251

	return CommandCost();

   252

}

   253

   254

/**

   255

 * Add all shared vehicles of all vehicles from a group

   256

 * @param tile unused

   257

 * @param p1   index of group array

   258

 *  - p1 bit 0-15 : GroupID

   259

 * @param p2   type of vehicles

   260

 */

   261

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

   262

{

   263

	VehicleType type = (VehicleType)p2;

   264

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

   265

   266

	if (flags & DC_EXEC) {

   267

		Vehicle *v;

   268

		VehicleType type = (VehicleType)p2;

   269

		GroupID id_g = p1;

   270

   271

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

   272

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

   273

		FOR_ALL_VEHICLES(v) {

   274

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

   275

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

   276

   277

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

   278

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

   279

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

   280

				}

   281

			}

   282

		}

   283

   284

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

   285

	}

   286

   287

	return CommandCost();

   288

}

   289

   290

   291

/**

   292

 * Remove all vehicles from a group

   293

 * @param tile unused

   294

 * @param p1   index of group array

   295

 * - p1 bit 0-15 : GroupID

   296

 * @param p2   type of vehicles

   297

 */

   298

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

   299

{

   300

	VehicleType type = (VehicleType)p2;

   301

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

   302

   303

	Group *g = GetGroup(p1);

   304

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

   305

   306

	if (flags & DC_EXEC) {

   307

		GroupID old_g = p1;

   308

		Vehicle *v;

   309

   310

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

   311

		FOR_ALL_VEHICLES(v) {

   312

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

   313

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

   314

   315

				/* Add The Vehicle to the default group */

   316

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

   317

			}

   318

		}

   319

   320

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

   321

	}

   322

   323

	return CommandCost();

   324

}

   325

   326

   327

/**

   328

 * (Un)set global replace protection from a group

   329

 * @param tile unused

   330

 * @param p1   index of group array

   331

 * - p1 bit 0-15 : GroupID

   332

 * @param p2

   333

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

   334

 */

   335

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

   336

{

   337

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   338

   339

	Group *g = GetGroup(p1);

   340

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

   341

   342

	if (flags & DC_EXEC) {

   343

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

   344

   345

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

   346

	}

   347

   348

	return CommandCost();

   349

}

   350

   351

/**

   352

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

   353

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   354

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

   355

 */

   356

void RemoveVehicleFromGroup(const Vehicle *v)

   357

{

   358

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

   359

   360

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

   361

}

   362

   363

   364

/**

   365

 * Affect the groupID of a train to new_g.

   366

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   367

 * @param v     First vehicle of the chain.

   368

 * @param new_g index of array group

   369

 */

   370

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   371

{

   372

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

   373

   374

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

   375

   376

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

   377

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

   378

   379

		u->group_id = new_g;

   380

	}

   381

   382

	/* Update the Replace Vehicle Windows */

   383

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   384

}

   385

   386

   387

/**

   388

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

   389

 * to/removed from the chain,.

   390

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

   391

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

   392

 * @param v First vehicle of the chain.

   393

 */

   394

void UpdateTrainGroupID(Vehicle *v)

   395

{

   396

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

   397

   398

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

   399

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

   400

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

   401

   402

		u->group_id = new_g;

   403

	}

   404

   405

	/* Update the Replace Vehicle Windows */

   406

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   407

}

   408

   409

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

   410

{

   411

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

   412

   413

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

   414

	if (!IsDefaultGroupID(id_g)) return num;

   415

   416

	const Group *g;

   417

	FOR_ALL_GROUPS(g) {

   418

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

   419

	}

   420

	return num;

   421

}

   422

   423

void RemoveAllGroupsForPlayer(const PlayerID p)

   424

{

   425

	Group *g;

   426

   427

	FOR_ALL_GROUPS(g) {

   428

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

   429

	}

   430

}

   431

   432

   433

static const SaveLoad _group_desc[] = {

   434

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

   435

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

   436

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   437

  SLE_VAR(Group, owner,              SLE_UINT8),

   438

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   439

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   440

  SLE_END()

   441

};

   442

   443

   444

static void Save_GROUP(void)

   445

{

   446

	Group *g;

   447

   448

	FOR_ALL_GROUPS(g) {

   449

		SlSetArrayIndex(g->index);

   450

		SlObject(g, _group_desc);

   451

	}

   452

}

   453

   454

   455

static void Load_GROUP(void)

   456

{

   457

	int index;

   458

   459

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

   460

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

   461

		SlObject(g, _group_desc);

   462

	}

   463

}

   464

   465

extern const ChunkHandler _group_chunk_handlers[] = {

   466

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

   467

};