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

#include "order_func.h"

    24

#include "oldpool_func.h"

    25

#include "core/alloc_func.hpp"

    26

    27

#include "table/strings.h"

    28

    29

GroupID _new_group_id;

    30

    31

/**

    32

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

    33

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    34

 * @param i     EngineID we have to update

    35

 * @param old_g index of the old group

    36

 * @param new_g index of the new group

    37

 */

    38

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

    39

{

    40

	if (old_g != new_g) {

    41

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

    42

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

    43

    44

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

    45

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

    46

	}

    47

}

    48

    49

    50

DEFINE_OLD_POOL_GENERIC(Group, Group)

    51

    52

    53

Group::Group(PlayerID owner)

    54

{

    55

	this->owner = owner;

    56

	this->num_engines = CallocT<uint16>(GetEnginePoolSize());

    57

}

    58

    59

Group::~Group()

    60

{

    61

	free(this->name);

    62

	this->owner = INVALID_PLAYER;

    63

	free(this->num_engines);

    64

}

    65

    66

bool Group::IsValid() const

    67

{

    68

	return this->owner != INVALID_PLAYER;

    69

}

    70

    71

void InitializeGroup(void)

    72

{

    73

	_Group_pool.CleanPool();

    74

	_Group_pool.AddBlockToPool();

    75

}

    76

    77

    78

/**

    79

 * Create a new vehicle group.

    80

 * @param tile unused

    81

 * @param p1   vehicle type

    82

 * @param p2   unused

    83

 */

    84

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

    85

{

    86

	VehicleType vt = (VehicleType)p1;

    87

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    88

    89

	if (!Group::CanAllocateItem()) return CMD_ERROR;

    90

    91

	if (flags & DC_EXEC) {

    92

		Group *g = new Group(_current_player);

    93

		g->replace_protection = false;

    94

		g->vehicle_type = vt;

    95

    96

		_new_group_id = g->index;

    97

    98

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

    99

	}

   100

   101

	return CommandCost();

   102

}

   103

   104

   105

/**

   106

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

   107

 * @param tile unused

   108

 * @param p1   index of array group

   109

 *      - p1 bit 0-15 : GroupID

   110

 * @param p2   unused

   111

 */

   112

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

   113

{

   114

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   115

   116

	Group *g = GetGroup(p1);

   117

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

   118

   119

	if (flags & DC_EXEC) {

   120

		Vehicle *v;

   121

   122

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

   123

		FOR_ALL_VEHICLES(v) {

   124

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

   125

		}

   126

   127

		/* Update backupped orders if needed */

   128

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

   129

   130

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

   131

		if (_current_player < MAX_PLAYERS) {

   132

			Player *p;

   133

			EngineRenew *er;

   134

   135

			p = GetPlayer(_current_player);

   136

			FOR_ALL_ENGINE_RENEWS(er) {

   137

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

   138

			}

   139

		}

   140

   141

		VehicleType vt = g->vehicle_type;

   142

   143

		/* Delete the Replace Vehicle Windows */

   144

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   145

		delete g;

   146

   147

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

   148

	}

   149

   150

	return CommandCost();

   151

}

   152

   153

static bool IsUniqueGroupName(const char *name)

   154

{

   155

	const Group *g;

   156

	char buf[512];

   157

   158

	FOR_ALL_GROUPS(g) {

   159

		SetDParam(0, g->index);

   160

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

   161

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

   162

	}

   163

   164

	return true;

   165

}

   166

   167

/**

   168

 * Rename a group

   169

 * @param tile unused

   170

 * @param p1   index of array group

   171

 *   - p1 bit 0-15 : GroupID

   172

 * @param p2   unused

   173

 */

   174

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

   175

{

   176

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

   177

   178

	Group *g = GetGroup(p1);

   179

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

   180

   181

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

   182

   183

	if (flags & DC_EXEC) {

   184

		/* Delete the old name */

   185

		free(g->name);

   186

		/* Assign the new one */

   187

		g->name = strdup(_cmd_text);

   188

   189

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

   190

	}

   191

   192

	return CommandCost();

   193

}

   194

   195

   196

/**

   197

 * Add a vehicle to a group

   198

 * @param tile unused

   199

 * @param p1   index of array group

   200

 *   - p1 bit 0-15 : GroupID

   201

 * @param p2   vehicle to add to a group

   202

 *   - p2 bit 0-15 : VehicleID

   203

 */

   204

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

   205

{

   206

	GroupID new_g = p1;

   207

   208

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

   209

   210

	Vehicle *v = GetVehicle(p2);

   211

   212

	if (IsValidGroupID(new_g)) {

   213

		Group *g = GetGroup(new_g);

   214

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

   215

	}

   216

   217

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

   218

   219

	if (flags & DC_EXEC) {

   220

		DecreaseGroupNumVehicle(v->group_id);

   221

		IncreaseGroupNumVehicle(new_g);

   222

   223

		switch (v->type) {

   224

			default: NOT_REACHED();

   225

			case VEH_TRAIN:

   226

				SetTrainGroupID(v, new_g);

   227

				break;

   228

			case VEH_ROAD:

   229

			case VEH_SHIP:

   230

			case VEH_AIRCRAFT:

   231

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

   232

				v->group_id = new_g;

   233

				break;

   234

		}

   235

   236

		/* Update the Replace Vehicle Windows */

   237

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   238

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

   239

	}

   240

   241

	return CommandCost();

   242

}

   243

   244

/**

   245

 * Add all shared vehicles of all vehicles from a group

   246

 * @param tile unused

   247

 * @param p1   index of group array

   248

 *  - p1 bit 0-15 : GroupID

   249

 * @param p2   type of vehicles

   250

 */

   251

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

   252

{

   253

	VehicleType type = (VehicleType)p2;

   254

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

   255

   256

	if (flags & DC_EXEC) {

   257

		Vehicle *v;

   258

		VehicleType type = (VehicleType)p2;

   259

		GroupID id_g = p1;

   260

   261

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

   262

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

   263

		FOR_ALL_VEHICLES(v) {

   264

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

   265

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

   266

   267

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

   268

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

   269

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

   270

				}

   271

			}

   272

		}

   273

   274

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

   275

	}

   276

   277

	return CommandCost();

   278

}

   279

   280

   281

/**

   282

 * Remove all vehicles from a group

   283

 * @param tile unused

   284

 * @param p1   index of group array

   285

 * - p1 bit 0-15 : GroupID

   286

 * @param p2   type of vehicles

   287

 */

   288

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

   289

{

   290

	VehicleType type = (VehicleType)p2;

   291

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

   292

   293

	Group *g = GetGroup(p1);

   294

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

   295

   296

	if (flags & DC_EXEC) {

   297

		GroupID old_g = p1;

   298

		Vehicle *v;

   299

   300

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

   301

		FOR_ALL_VEHICLES(v) {

   302

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

   303

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

   304

   305

				/* Add The Vehicle to the default group */

   306

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

   307

			}

   308

		}

   309

   310

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

   311

	}

   312

   313

	return CommandCost();

   314

}

   315

   316

   317

/**

   318

 * (Un)set global replace protection from a group

   319

 * @param tile unused

   320

 * @param p1   index of group array

   321

 * - p1 bit 0-15 : GroupID

   322

 * @param p2

   323

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

   324

 */

   325

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

   326

{

   327

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   328

   329

	Group *g = GetGroup(p1);

   330

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

   331

   332

	if (flags & DC_EXEC) {

   333

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

   334

   335

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

   336

	}

   337

   338

	return CommandCost();

   339

}

   340

   341

/**

   342

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

   343

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   344

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

   345

 */

   346

void RemoveVehicleFromGroup(const Vehicle *v)

   347

{

   348

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

   349

   350

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

   351

}

   352

   353

   354

/**

   355

 * Affect the groupID of a train to new_g.

   356

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   357

 * @param v     First vehicle of the chain.

   358

 * @param new_g index of array group

   359

 */

   360

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   361

{

   362

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

   363

   364

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

   365

   366

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

   367

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

   368

   369

		u->group_id = new_g;

   370

	}

   371

   372

	/* Update the Replace Vehicle Windows */

   373

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   374

}

   375

   376

   377

/**

   378

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

   379

 * to/removed from the chain,.

   380

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

   381

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

   382

 * @param v First vehicle of the chain.

   383

 */

   384

void UpdateTrainGroupID(Vehicle *v)

   385

{

   386

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

   387

   388

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

   389

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

   390

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

   391

   392

		u->group_id = new_g;

   393

	}

   394

   395

	/* Update the Replace Vehicle Windows */

   396

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   397

}

   398

   399

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

   400

{

   401

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

   402

   403

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

   404

	if (!IsDefaultGroupID(id_g)) return num;

   405

   406

	const Group *g;

   407

	FOR_ALL_GROUPS(g) {

   408

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

   409

	}

   410

	return num;

   411

}

   412

   413

void RemoveAllGroupsForPlayer(const PlayerID p)

   414

{

   415

	Group *g;

   416

   417

	FOR_ALL_GROUPS(g) {

   418

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

   419

	}

   420

}

   421

   422

   423

static const SaveLoad _group_desc[] = {

   424

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

   425

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

   426

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   427

  SLE_VAR(Group, owner,              SLE_UINT8),

   428

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   429

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   430

  SLE_END()

   431

};

   432

   433

   434

static void Save_GROUP(void)

   435

{

   436

	Group *g;

   437

   438

	FOR_ALL_GROUPS(g) {

   439

		SlSetArrayIndex(g->index);

   440

		SlObject(g, _group_desc);

   441

	}

   442

}

   443

   444

   445

static void Load_GROUP(void)

   446

{

   447

	int index;

   448

   449

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

   450

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

   451

		SlObject(g, _group_desc);

   452

	}

   453

}

   454

   455

extern const ChunkHandler _group_chunk_handlers[] = {

   456

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

   457

};