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

     9

#include "table/strings.h"

    10

#include "command_func.h"

    11

#include "saveload.h"

    12

#include "debug.h"

    13

#include "group.h"

    14

#include "train.h"

    15

#include "aircraft.h"

    16

#include "vehicle_gui.h"

    17

#include "misc/autoptr.hpp"

    18

#include "strings_func.h"

    19

#include "functions.h"

    20

#include "window_func.h"

    21

#include "vehicle_func.h"

    22

#include "autoreplace_base.h"

    23

#include "autoreplace_func.h"

    24

#include "string_func.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(StringID str)

    49

{

    50

	this->string_id = str;

    51

}

    52

    53

Group::~Group()

    54

{

    55

	DeleteName(this->string_id);

    56

	this->string_id = STR_NULL;

    57

}

    58

    59

bool Group::IsValid() const

    60

{

    61

	return this->string_id != STR_NULL;

    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

    94

	AutoPtrT<Group> g_auto_delete;

    95

    96

	Group *g = new Group(STR_EMPTY);

    97

	if (g == NULL) return CMD_ERROR;

    98

    99

	g_auto_delete = g;

   100

   101

	if (flags & DC_EXEC) {

   102

		g->owner = _current_player;

   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

   137

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

   138

		if (_current_player < MAX_PLAYERS) {

   139

			Player *p;

   140

			EngineRenew *er;

   141

   142

			p = GetPlayer(_current_player);

   143

			FOR_ALL_ENGINE_RENEWS(er) {

   144

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

   145

			}

   146

		}

   147

   148

		VehicleType vt = g->vehicle_type;

   149

   150

		/* Delete the Replace Vehicle Windows */

   151

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   152

		delete g;

   153

   154

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

   155

	}

   156

   157

	return CommandCost();

   158

}

   159

   160

static bool IsUniqueGroupName(const char *name)

   161

{

   162

	const Group *g;

   163

	char buf[512];

   164

   165

	FOR_ALL_GROUPS(g) {

   166

		SetDParam(0, g->index);

   167

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

   168

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

   169

	}

   170

   171

	return true;

   172

}

   173

   174

/**

   175

 * Rename a group

   176

 * @param tile unused

   177

 * @param p1   index of array group

   178

 *   - p1 bit 0-15 : GroupID

   179

 * @param p2   unused

   180

 */

   181

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

   182

{

   183

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

   184

   185

	Group *g = GetGroup(p1);

   186

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

   187

   188

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

   189

   190

	/* Create the name */

   191

	StringID str = AllocateName(_cmd_text, 0);

   192

	if (str == STR_NULL) return CMD_ERROR;

   193

   194

	if (flags & DC_EXEC) {

   195

		/* Delete the old name */

   196

		DeleteName(g->string_id);

   197

		/* Assign the new one */

   198

		g->string_id = str;

   199

   200

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

   201

	} else {

   202

		DeleteName(str);

   203

	}

   204

   205

	return CommandCost();

   206

}

   207

   208

   209

/**

   210

 * Add a vehicle to a group

   211

 * @param tile unused

   212

 * @param p1   index of array group

   213

 *   - p1 bit 0-15 : GroupID

   214

 * @param p2   vehicle to add to a group

   215

 *   - p2 bit 0-15 : VehicleID

   216

 */

   217

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

   218

{

   219

	GroupID new_g = p1;

   220

   221

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

   222

   223

	Vehicle *v = GetVehicle(p2);

   224

   225

	if (IsValidGroupID(new_g)) {

   226

		Group *g = GetGroup(new_g);

   227

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

   228

	}

   229

   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

{

   361

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

   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

   377

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

   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

{

   399

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

   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

};