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

/**

    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 default 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

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

    56

}

    57

    58

Group::~Group()

    59

{

    60

	free(this->name);

    61

	this->owner = INVALID_PLAYER;

    62

	free(this->num_engines);

    63

}

    64

    65

bool Group::IsValid() const

    66

{

    67

	return this->owner != INVALID_PLAYER;

    68

}

    69

    70

void InitializeGroup(void)

    71

{

    72

	_Group_pool.CleanPool();

    73

	_Group_pool.AddBlockToPool();

    74

}

    75

    76

    77

/**

    78

 * Create a new vehicle group.

    79

 * @param tile unused

    80

 * @param p1   vehicle type

    81

 * @param p2   unused

    82

 */

    83

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

    84

{

    85

	VehicleType vt = (VehicleType)p1;

    86

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    87

    88

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

    89

    90

	if (flags & DC_EXEC) {

    91

		Group *g = new Group(_current_player);

    92

		g->replace_protection = false;

    93

		g->vehicle_type = vt;

    94

    95

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

    96

	}

    97

    98

	return CommandCost();

    99

}

   100

   101

   102

/**

   103

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

   104

 * @param tile unused

   105

 * @param p1   index of array group

   106

 *      - p1 bit 0-15 : GroupID

   107

 * @param p2   unused

   108

 */

   109

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

   110

{

   111

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   112

   113

	Group *g = GetGroup(p1);

   114

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

   115

   116

	if (flags & DC_EXEC) {

   117

		Vehicle *v;

   118

   119

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

   120

		FOR_ALL_VEHICLES(v) {

   121

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

   122

		}

   123

   124

		/* Update backupped orders if needed */

   125

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

   126

   127

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

   128

		if (_current_player < MAX_PLAYERS) {

   129

			Player *p;

   130

			EngineRenew *er;

   131

   132

			p = GetPlayer(_current_player);

   133

			FOR_ALL_ENGINE_RENEWS(er) {

   134

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

   135

			}

   136

		}

   137

   138

		VehicleType vt = g->vehicle_type;

   139

   140

		/* Delete the Replace Vehicle Windows */

   141

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   142

		delete g;

   143

   144

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

   145

	}

   146

   147

	return CommandCost();

   148

}

   149

   150

static bool IsUniqueGroupName(const char *name)

   151

{

   152

	const Group *g;

   153

	char buf[512];

   154

   155

	FOR_ALL_GROUPS(g) {

   156

		SetDParam(0, g->index);

   157

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

   158

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

   159

	}

   160

   161

	return true;

   162

}

   163

   164

/**

   165

 * Rename a group

   166

 * @param tile unused

   167

 * @param p1   index of array group

   168

 *   - p1 bit 0-15 : GroupID

   169

 * @param p2   unused

   170

 */

   171

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

   172

{

   173

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

   174

   175

	Group *g = GetGroup(p1);

   176

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

   177

   178

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

   179

   180

	if (flags & DC_EXEC) {

   181

		/* Delete the old name */

   182

		free(g->name);

   183

		/* Assign the new one */

   184

		g->name = strdup(_cmd_text);

   185

   186

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

   187

	}

   188

   189

	return CommandCost();

   190

}

   191

   192

   193

/**

   194

 * Add a vehicle to a group

   195

 * @param tile unused

   196

 * @param p1   index of array group

   197

 *   - p1 bit 0-15 : GroupID

   198

 * @param p2   vehicle to add to a group

   199

 *   - p2 bit 0-15 : VehicleID

   200

 */

   201

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

   202

{

   203

	GroupID new_g = p1;

   204

   205

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

   206

   207

	Vehicle *v = GetVehicle(p2);

   208

   209

	if (IsValidGroupID(new_g)) {

   210

		Group *g = GetGroup(new_g);

   211

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

   212

	}

   213

   214

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

   215

   216

	if (flags & DC_EXEC) {

   217

		DecreaseGroupNumVehicle(v->group_id);

   218

		IncreaseGroupNumVehicle(new_g);

   219

   220

		switch (v->type) {

   221

			default: NOT_REACHED();

   222

			case VEH_TRAIN:

   223

				SetTrainGroupID(v, new_g);

   224

				break;

   225

			case VEH_ROAD:

   226

			case VEH_SHIP:

   227

			case VEH_AIRCRAFT:

   228

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

   229

				v->group_id = new_g;

   230

				break;

   231

		}

   232

   233

		/* Update the Replace Vehicle Windows */

   234

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   235

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

   236

	}

   237

   238

	return CommandCost();

   239

}

   240

   241

/**

   242

 * Add all shared vehicles of all vehicles from a group

   243

 * @param tile unused

   244

 * @param p1   index of group array

   245

 *  - p1 bit 0-15 : GroupID

   246

 * @param p2   type of vehicles

   247

 */

   248

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

   249

{

   250

	VehicleType type = (VehicleType)p2;

   251

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

   252

   253

	if (flags & DC_EXEC) {

   254

		Vehicle *v;

   255

		VehicleType type = (VehicleType)p2;

   256

		GroupID id_g = p1;

   257

   258

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

   259

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

   260

		FOR_ALL_VEHICLES(v) {

   261

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

   262

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

   263

   264

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

   265

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

   266

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

   267

				}

   268

			}

   269

		}

   270

   271

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

   272

	}

   273

   274

	return CommandCost();

   275

}

   276

   277

   278

/**

   279

 * Remove all vehicles from a group

   280

 * @param tile unused

   281

 * @param p1   index of group array

   282

 * - p1 bit 0-15 : GroupID

   283

 * @param p2   type of vehicles

   284

 */

   285

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

   286

{

   287

	VehicleType type = (VehicleType)p2;

   288

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

   289

   290

	Group *g = GetGroup(p1);

   291

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

   292

   293

	if (flags & DC_EXEC) {

   294

		GroupID old_g = p1;

   295

		Vehicle *v;

   296

   297

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

   298

		FOR_ALL_VEHICLES(v) {

   299

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

   300

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

   301

   302

				/* Add The Vehicle to the default group */

   303

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

   304

			}

   305

		}

   306

   307

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

   308

	}

   309

   310

	return CommandCost();

   311

}

   312

   313

   314

/**

   315

 * (Un)set global replace protection from a group

   316

 * @param tile unused

   317

 * @param p1   index of group array

   318

 * - p1 bit 0-15 : GroupID

   319

 * @param p2

   320

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

   321

 */

   322

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

   323

{

   324

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   325

   326

	Group *g = GetGroup(p1);

   327

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

   328

   329

	if (flags & DC_EXEC) {

   330

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

   331

   332

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

   333

	}

   334

   335

	return CommandCost();

   336

}

   337

   338

/**

   339

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

   340

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   341

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

   342

 */

   343

void RemoveVehicleFromGroup(const Vehicle *v)

   344

{

   345

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

   346

   347

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

   348

}

   349

   350

   351

/**

   352

 * Affect the groupID of a train to new_g.

   353

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   354

 * @param v     First vehicle of the chain.

   355

 * @param new_g index of array group

   356

 */

   357

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   358

{

   359

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

   360

   361

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

   362

   363

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

   364

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

   365

   366

		u->group_id = new_g;

   367

	}

   368

   369

	/* Update the Replace Vehicle Windows */

   370

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   371

}

   372

   373

   374

/**

   375

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

   376

 * to/removed from the chain,.

   377

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

   378

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

   379

 * @param v First vehicle of the chain.

   380

 */

   381

void UpdateTrainGroupID(Vehicle *v)

   382

{

   383

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

   384

   385

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

   386

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

   387

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

   388

   389

		u->group_id = new_g;

   390

	}

   391

   392

	/* Update the Replace Vehicle Windows */

   393

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   394

}

   395

   396

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

   397

{

   398

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

   399

   400

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

   401

	if (!IsDefaultGroupID(id_g)) return num;

   402

   403

	const Group *g;

   404

	FOR_ALL_GROUPS(g) {

   405

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

   406

	}

   407

	return num;

   408

}

   409

   410

void RemoveAllGroupsForPlayer(const PlayerID p)

   411

{

   412

	Group *g;

   413

   414

	FOR_ALL_GROUPS(g) {

   415

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

   416

	}

   417

}

   418

   419

   420

static const SaveLoad _group_desc[] = {

   421

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

   422

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

   423

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   424

  SLE_VAR(Group, owner,              SLE_UINT8),

   425

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   426

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   427

  SLE_END()

   428

};

   429

   430

   431

static void Save_GROUP(void)

   432

{

   433

	Group *g;

   434

   435

	FOR_ALL_GROUPS(g) {

   436

		SlSetArrayIndex(g->index);

   437

		SlObject(g, _group_desc);

   438

	}

   439

}

   440

   441

   442

static void Load_GROUP(void)

   443

{

   444

	int index;

   445

   446

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

   447

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

   448

		SlObject(g, _group_desc);

   449

	}

   450

}

   451

   452

extern const ChunkHandler _group_chunk_handlers[] = {

   453

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

   454

};