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

    26

#include "table/strings.h"

    27

    28

/**

    29

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

    30

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    31

 * @param i     EngineID we have to update

    32

 * @param old_g index of the old group

    33

 * @param new_g index of the new group

    34

 */

    35

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

    36

{

    37

	if (old_g != new_g) {

    38

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

    39

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

    40

    41

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

    42

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

    43

	}

    44

}

    45

    46

    47

DEFINE_OLD_POOL_GENERIC(Group, Group)

    48

    49

    50

Group::Group(PlayerID owner)

    51

{

    52

	this->owner = owner;

    53

}

    54

    55

Group::~Group()

    56

{

    57

	free(this->name);

    58

	this->owner = INVALID_PLAYER;

    59

}

    60

    61

bool Group::IsValid() const

    62

{

    63

	return this->owner != INVALID_PLAYER;

    64

}

    65

    66

void InitializeGroup(void)

    67

{

    68

	_Group_pool.CleanPool();

    69

	_Group_pool.AddBlockToPool();

    70

}

    71

    72

    73

/**

    74

 * Create a new vehicle group.

    75

 * @param tile unused

    76

 * @param p1   vehicle type

    77

 * @param p2   unused

    78

 */

    79

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

    80

{

    81

	VehicleType vt = (VehicleType)p1;

    82

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

    83

    84

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

    85

    86

	if (flags & DC_EXEC) {

    87

		Group *g = new Group(_current_player);

    88

		g->replace_protection = false;

    89

		g->vehicle_type = vt;

    90

    92

	}

    93

    94

	return CommandCost();

    95

}

    96

    97

    98

/**

    99

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

   100

 * @param tile unused

   101

 * @param p1   index of array group

   102

 *      - p1 bit 0-15 : GroupID

   103

 * @param p2   unused

   104

 */

   105

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

   106

{

   107

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   108

   109

	Group *g = GetGroup(p1);

   110

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

   111

   112

	if (flags & DC_EXEC) {

   113

		Vehicle *v;

   114

   115

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

   116

		FOR_ALL_VEHICLES(v) {

   117

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

   118

		}

   119

   120

		/* Update backupped orders if needed */

   121

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

   122

   123

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

   124

		if (_current_player < MAX_PLAYERS) {

   125

			Player *p;

   126

			EngineRenew *er;

   127

   128

			p = GetPlayer(_current_player);

   129

			FOR_ALL_ENGINE_RENEWS(er) {

   130

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

   131

			}

   132

		}

   133

   134

		VehicleType vt = g->vehicle_type;

   135

   136

		/* Delete the Replace Vehicle Windows */

   137

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   138

		delete g;

   139

   141

	}

   142

   143

	return CommandCost();

   144

}

   145

   146

static bool IsUniqueGroupName(const char *name)

   147

{

   148

	const Group *g;

   149

	char buf[512];

   150

   151

	FOR_ALL_GROUPS(g) {

   152

		SetDParam(0, g->index);

   153

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

   154

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

   155

	}

   156

   157

	return true;

   158

}

   159

   160

/**

   161

 * Rename a group

   162

 * @param tile unused

   163

 * @param p1   index of array group

   164

 *   - p1 bit 0-15 : GroupID

   165

 * @param p2   unused

   166

 */

   167

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

   168

{

   169

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

   170

   171

	Group *g = GetGroup(p1);

   172

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

   173

   174

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

   175

   176

	if (flags & DC_EXEC) {

   177

		/* Delete the old name */

   178

		free(g->name);

   179

		/* Assign the new one */

   180

		g->name = strdup(_cmd_text);

   181

   183

	}

   184

   185

	return CommandCost();

   186

}

   187

   188

   189

/**

   190

 * Add a vehicle to a group

   191

 * @param tile unused

   192

 * @param p1   index of array group

   193

 *   - p1 bit 0-15 : GroupID

   194

 * @param p2   vehicle to add to a group

   195

 *   - p2 bit 0-15 : VehicleID

   196

 */

   197

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

   198

{

   199

	GroupID new_g = p1;

   200

   201

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

   202

   203

	Vehicle *v = GetVehicle(p2);

   204

   205

	if (IsValidGroupID(new_g)) {

   206

		Group *g = GetGroup(new_g);

   207

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

   208

	}

   209

   210

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

   211

   212

	if (flags & DC_EXEC) {

   213

		DecreaseGroupNumVehicle(v->group_id);

   214

		IncreaseGroupNumVehicle(new_g);

   215

   216

		switch (v->type) {

   217

			default: NOT_REACHED();

   218

			case VEH_TRAIN:

   219

				SetTrainGroupID(v, new_g);

   220

				break;

   221

			case VEH_ROAD:

   222

			case VEH_SHIP:

   223

			case VEH_AIRCRAFT:

   224

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

   225

				v->group_id = new_g;

   226

				break;

   227

		}

   228

   229

		/* Update the Replace Vehicle Windows */

   230

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   232

	}

   233

   234

	return CommandCost();

   235

}

   236

   237

/**

   238

 * Add all shared vehicles of all vehicles from a group

   239

 * @param tile unused

   240

 * @param p1   index of group array

   241

 *  - p1 bit 0-15 : GroupID

   242

 * @param p2   type of vehicles

   243

 */

   244

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

   245

{

   246

	VehicleType type = (VehicleType)p2;

   247

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

   248

   249

	if (flags & DC_EXEC) {

   250

		Vehicle *v;

   251

		VehicleType type = (VehicleType)p2;

   252

		GroupID id_g = p1;

   253

   254

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

   255

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

   256

		FOR_ALL_VEHICLES(v) {

   257

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

   258

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

   259

   260

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

   261

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

   262

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

   263

				}

   264

			}

   265

		}

   266

   268

	}

   269

   270

	return CommandCost();

   271

}

   272

   273

   274

/**

   275

 * Remove all vehicles from a group

   276

 * @param tile unused

   277

 * @param p1   index of group array

   278

 * - p1 bit 0-15 : GroupID

   279

 * @param p2   type of vehicles

   280

 */

   281

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

   282

{

   283

	VehicleType type = (VehicleType)p2;

   284

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

   285

   286

	Group *g = GetGroup(p1);

   287

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

   288

   289

	if (flags & DC_EXEC) {

   290

		GroupID old_g = p1;

   291

		Vehicle *v;

   292

   293

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

   294

		FOR_ALL_VEHICLES(v) {

   295

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

   296

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

   297

   298

				/* Add The Vehicle to the default group */

   299

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

   300

			}

   301

		}

   302

   304

	}

   305

   306

	return CommandCost();

   307

}

   308

   309

   310

/**

   311

 * (Un)set global replace protection from a group

   312

 * @param tile unused

   313

 * @param p1   index of group array

   314

 * - p1 bit 0-15 : GroupID

   315

 * @param p2

   316

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

   317

 */

   318

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

   319

{

   320

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   321

   322

	Group *g = GetGroup(p1);

   323

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

   324

   325

	if (flags & DC_EXEC) {

   326

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

   327

   329

	}

   330

   331

	return CommandCost();

   332

}

   333

   334

/**

   335

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

   336

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   337

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

   338

 */

   339

void RemoveVehicleFromGroup(const Vehicle *v)

   340

{

   341

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

   342

   343

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

   344

}

   345

   346

   347

/**

   348

 * Affect the groupID of a train to new_g.

   349

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   350

 * @param v     First vehicle of the chain.

   351

 * @param new_g index of array group

   352

 */

   353

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   354

{

   355

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

   356

   357

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

   358

   359

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

   360

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

   361

   362

		u->group_id = new_g;

   363

	}

   364

   365

	/* Update the Replace Vehicle Windows */

   366

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   367

}

   368

   369

   370

/**

   371

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

   372

 * to/removed from the chain,.

   373

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

   374

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

   375

 * @param v First vehicle of the chain.

   376

 */

   377

void UpdateTrainGroupID(Vehicle *v)

   378

{

   379

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

   380

   381

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

   382

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

   383

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

   384

   385

		u->group_id = new_g;

   386

	}

   387

   388

	/* Update the Replace Vehicle Windows */

   389

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   390

}

   391

   392

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

   393

{

   394

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

   395

   396

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

   397

	if (!IsDefaultGroupID(id_g)) return num;

   398

   399

	const Group *g;

   400

	FOR_ALL_GROUPS(g) {

   401

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

   402

	}

   403

	return num;

   404

}

   405

   406

void RemoveAllGroupsForPlayer(const PlayerID p)

   407

{

   408

	Group *g;

   409

   410

	FOR_ALL_GROUPS(g) {

   411

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

   412

	}

   413

}

   414

   415

   416

static const SaveLoad _group_desc[] = {

   417

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

   418

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

   419

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   420

  SLE_VAR(Group, owner,              SLE_UINT8),

   421

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   422

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   423

  SLE_END()

   424

};

   425

   426

   427

static void Save_GROUP(void)

   428

{

   429

	Group *g;

   430

   431

	FOR_ALL_GROUPS(g) {

   432

		SlSetArrayIndex(g->index);

   433

		SlObject(g, _group_desc);

   434

	}

   435

}

   436

   437

   438

static void Load_GROUP(void)

   439

{

   440

	int index;

   441

   442

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

   443

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

   444

		SlObject(g, _group_desc);

   445

	}

   446

}

   447

   448

extern const ChunkHandler _group_chunk_handlers[] = {

   449

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

   450

};