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

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

    55

}

    56

    57

Group::~Group()

    58

{

    59

	free(this->name);

    60

	this->owner = INVALID_PLAYER;

    61

	free(this->num_engines);

    62

}

    63

    64

bool Group::IsValid() const

    65

{

    66

	return this->owner != INVALID_PLAYER;

    67

}

    68

    69

void InitializeGroup(void)

    70

{

    71

	_Group_pool.CleanPool();

    72

	_Group_pool.AddBlockToPool();

    73

}

    74

    75

    76

/**

    77

 * Create a new vehicle group.

    78

 * @param tile unused

    79

 * @param p1   vehicle type

    80

 * @param p2   unused

    81

 */

    82

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

    83

{

    84

	VehicleType vt = (VehicleType)p1;

    85

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    86

    87

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

    88

    89

	if (flags & DC_EXEC) {

    90

		Group *g = new Group(_current_player);

    91

		g->replace_protection = false;

    92

		g->vehicle_type = vt;

    93

    94

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

    95

	}

    96

    97

	return CommandCost();

    98

}

    99

   100

   101

/**

   102

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

   103

 * @param tile unused

   104

 * @param p1   index of array group

   105

 *      - p1 bit 0-15 : GroupID

   106

 * @param p2   unused

   107

 */

   108

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

   109

{

   110

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   111

   112

	Group *g = GetGroup(p1);

   113

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

   114

   115

	if (flags & DC_EXEC) {

   116

		Vehicle *v;

   117

   118

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

   119

		FOR_ALL_VEHICLES(v) {

   120

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

   121

		}

   122

   123

		/* Update backupped orders if needed */

   124

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

   125

   126

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

   127

		if (_current_player < MAX_PLAYERS) {

   128

			Player *p;

   129

			EngineRenew *er;

   130

   131

			p = GetPlayer(_current_player);

   132

			FOR_ALL_ENGINE_RENEWS(er) {

   133

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

   134

			}

   135

		}

   136

   137

		VehicleType vt = g->vehicle_type;

   138

   139

		/* Delete the Replace Vehicle Windows */

   140

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   141

		delete g;

   142

   143

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

   144

	}

   145

   146

	return CommandCost();

   147

}

   148

   149

static bool IsUniqueGroupName(const char *name)

   150

{

   151

	const Group *g;

   152

	char buf[512];

   153

   154

	FOR_ALL_GROUPS(g) {

   155

		SetDParam(0, g->index);

   156

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

   157

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

   158

	}

   159

   160

	return true;

   161

}

   162

   163

/**

   164

 * Rename a group

   165

 * @param tile unused

   166

 * @param p1   index of array group

   167

 *   - p1 bit 0-15 : GroupID

   168

 * @param p2   unused

   169

 */

   170

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

   171

{

   172

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

   173

   174

	Group *g = GetGroup(p1);

   175

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

   176

   177

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

   178

   179

	if (flags & DC_EXEC) {

   180

		/* Delete the old name */

   181

		free(g->name);

   182

		/* Assign the new one */

   183

		g->name = strdup(_cmd_text);

   184

   185

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

   186

	}

   187

   188

	return CommandCost();

   189

}

   190

   191

   192

/**

   193

 * Add a vehicle to a group

   194

 * @param tile unused

   195

 * @param p1   index of array group

   196

 *   - p1 bit 0-15 : GroupID

   197

 * @param p2   vehicle to add to a group

   198

 *   - p2 bit 0-15 : VehicleID

   199

 */

   200

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

   201

{

   202

	GroupID new_g = p1;

   203

   204

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

   205

   206

	Vehicle *v = GetVehicle(p2);

   207

   208

	if (IsValidGroupID(new_g)) {

   209

		Group *g = GetGroup(new_g);

   210

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

   211

	}

   212

   213

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

   214

   215

	if (flags & DC_EXEC) {

   216

		DecreaseGroupNumVehicle(v->group_id);

   217

		IncreaseGroupNumVehicle(new_g);

   218

   219

		switch (v->type) {

   220

			default: NOT_REACHED();

   221

			case VEH_TRAIN:

   222

				SetTrainGroupID(v, new_g);

   223

				break;

   224

			case VEH_ROAD:

   225

			case VEH_SHIP:

   226

			case VEH_AIRCRAFT:

   227

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

   228

				v->group_id = new_g;

   229

				break;

   230

		}

   231

   232

		/* Update the Replace Vehicle Windows */

   233

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   234

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

   235

	}

   236

   237

	return CommandCost();

   238

}

   239

   240

/**

   241

 * Add all shared vehicles of all vehicles from a group

   242

 * @param tile unused

   243

 * @param p1   index of group array

   244

 *  - p1 bit 0-15 : GroupID

   245

 * @param p2   type of vehicles

   246

 */

   247

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

   248

{

   249

	VehicleType type = (VehicleType)p2;

   250

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

   251

   252

	if (flags & DC_EXEC) {

   253

		Vehicle *v;

   254

		VehicleType type = (VehicleType)p2;

   255

		GroupID id_g = p1;

   256

   257

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

   258

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

   259

		FOR_ALL_VEHICLES(v) {

   260

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

   261

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

   262

   263

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

   264

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

   265

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

   266

				}

   267

			}

   268

		}

   269

   270

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

   271

	}

   272

   273

	return CommandCost();

   274

}

   275

   276

   277

/**

   278

 * Remove all vehicles from a group

   279

 * @param tile unused

   280

 * @param p1   index of group array

   281

 * - p1 bit 0-15 : GroupID

   282

 * @param p2   type of vehicles

   283

 */

   284

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

   285

{

   286

	VehicleType type = (VehicleType)p2;

   287

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

   288

   289

	Group *g = GetGroup(p1);

   290

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

   291

   292

	if (flags & DC_EXEC) {

   293

		GroupID old_g = p1;

   294

		Vehicle *v;

   295

   296

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

   297

		FOR_ALL_VEHICLES(v) {

   298

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

   299

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

   300

   301

				/* Add The Vehicle to the default group */

   302

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

   303

			}

   304

		}

   305

   306

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

   307

	}

   308

   309

	return CommandCost();

   310

}

   311

   312

   313

/**

   314

 * (Un)set global replace protection from a group

   315

 * @param tile unused

   316

 * @param p1   index of group array

   317

 * - p1 bit 0-15 : GroupID

   318

 * @param p2

   319

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

   320

 */

   321

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

   322

{

   323

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   324

   325

	Group *g = GetGroup(p1);

   326

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

   327

   328

	if (flags & DC_EXEC) {

   329

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

   330

   331

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

   332

	}

   333

   334

	return CommandCost();

   335

}

   336

   337

/**

   338

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

   339

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   340

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

   341

 */

   342

void RemoveVehicleFromGroup(const Vehicle *v)

   343

{

   344

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

   345

   346

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

   347

}

   348

   349

   350

/**

   351

 * Affect the groupID of a train to new_g.

   352

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   353

 * @param v     First vehicle of the chain.

   354

 * @param new_g index of array group

   355

 */

   356

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   357

{

   358

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

   359

   360

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

   361

   362

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

   363

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

   364

   365

		u->group_id = new_g;

   366

	}

   367

   368

	/* Update the Replace Vehicle Windows */

   369

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   370

}

   371

   372

   373

/**

   374

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

   375

 * to/removed from the chain,.

   376

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

   377

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

   378

 * @param v First vehicle of the chain.

   379

 */

   380

void UpdateTrainGroupID(Vehicle *v)

   381

{

   382

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

   383

   384

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

   385

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

   386

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

   387

   388

		u->group_id = new_g;

   389

	}

   390

   391

	/* Update the Replace Vehicle Windows */

   392

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   393

}

   394

   395

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

   396

{

   397

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

   398

   399

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

   400

	if (!IsDefaultGroupID(id_g)) return num;

   401

   402

	const Group *g;

   403

	FOR_ALL_GROUPS(g) {

   404

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

   405

	}

   406

	return num;

   407

}

   408

   409

void RemoveAllGroupsForPlayer(const PlayerID p)

   410

{

   411

	Group *g;

   412

   413

	FOR_ALL_GROUPS(g) {

   414

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

   415

	}

   416

}

   417

   418

   419

static const SaveLoad _group_desc[] = {

   420

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

   421

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

   422

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   423

  SLE_VAR(Group, owner,              SLE_UINT8),

   424

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   425

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   426

  SLE_END()

   427

};

   428

   429

   430

static void Save_GROUP(void)

   431

{

   432

	Group *g;

   433

   434

	FOR_ALL_GROUPS(g) {

   435

		SlSetArrayIndex(g->index);

   436

		SlObject(g, _group_desc);

   437

	}

   438

}

   439

   440

   441

static void Load_GROUP(void)

   442

{

   443

	int index;

   444

   445

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

   446

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

   447

		SlObject(g, _group_desc);

   448

	}

   449

}

   450

   451

extern const ChunkHandler _group_chunk_handlers[] = {

   452

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

   453

};