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

     9

#include "player.h"

    10

#include "table/strings.h"

    11

#include "command.h"

    12

#include "vehicle.h"

    13

#include "saveload.h"

    14

#include "debug.h"

    15

#include "group.h"

    16

#include "train.h"

    17

#include "aircraft.h"

    18

#include "string.h"

    19

#include "window.h"

    20

#include "vehicle_gui.h"

    21

#include "strings.h"

    22

    23

/**

    24

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

    25

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    26

 * @param i     EngineID we have to update

    27

 * @param old_g index of the old group

    28

 * @param new_g index of the new group

    29

 */

    30

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

    31

{

    32

	if (old_g != new_g) {

    33

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

    34

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

    35

    36

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

    37

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

    38

	}

    39

}

    40

    41

    42

/**

    43

 * Called if a new block is added to the group-pool

    44

 */

    45

static void GroupPoolNewBlock(uint start_item)

    46

{

    47

	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.

    48

	 * TODO - This is just a temporary stage, this will be removed. */

    49

	for (Group *g = GetGroup(start_item); g != NULL; g = (g->index + 1U < GetGroupPoolSize()) ? GetGroup(g->index + 1) : NULL) g->index = start_item++;

    50

}

    51

    52

DEFINE_OLD_POOL(Group, Group, GroupPoolNewBlock, NULL)

    53

    54

static Group *AllocateGroup(void)

    55

{

    56

	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.

    57

	 * TODO - This is just a temporary stage, this will be removed. */

    58

	for (Group *g = GetGroup(0); g != NULL; g = (g->index + 1U < GetGroupPoolSize()) ? GetGroup(g->index + 1) : NULL) {

    59

		if (!IsValidGroup(g)) {

    60

			const GroupID index = g->index;

    61

    62

			memset(g, 0, sizeof(*g));

    63

			g->index = index;

    64

    65

			return g;

    66

		}

    67

	}

    68

    69

	/* Check if we can add a block to the pool */

    70

	return (AddBlockToPool(&_Group_pool)) ? AllocateGroup() : NULL;

    71

}

    72

    73

void InitializeGroup(void)

    74

{

    75

	CleanPool(&_Group_pool);

    76

	AddBlockToPool(&_Group_pool);

    77

}

    78

    79

    80

static WindowClass GetWCForVT(VehicleType vt)

    81

{

    82

	switch (vt) {

    83

		default:

    84

		case VEH_TRAIN:    return WC_TRAINS_LIST;

    85

		case VEH_ROAD:     return WC_ROADVEH_LIST;

    86

		case VEH_SHIP:     return WC_SHIPS_LIST;

    87

		case VEH_AIRCRAFT: return WC_AIRCRAFT_LIST;

    88

	}

    89

}

    90

    91

    92

/**

    94

 * @param tile unused

    95

 * @param p1   vehicle type

    96

 * @param p2   unused

    97

 */

    98

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

    99

{

   100

	VehicleType vt = (VehicleType)p1;

   101

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

   102

   103

	Group *g = AllocateGroup();

   104

	if (g == NULL) return CMD_ERROR;

   105

   106

	if (flags & DC_EXEC) {

   107

		g->owner = _current_player;

   108

		g->string_id = STR_EMPTY;

   109

		g->replace_protection = false;

   110

		g->vehicle_type = vt;

   111

   112

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

   113

	}

   114

   115

	return CommandCost();

   116

}

   117

   118

   119

/**

   121

 * @param tile unused

   122

 * @param p1   index of array group

   123

 *      - p1 bit 0-15 : GroupID

   124

 * @param p2   unused

   125

 */

   126

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

   127

{

   128

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   129

   130

	Group *g = GetGroup(p1);

   131

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

   132

   133

	if (flags & DC_EXEC) {

   134

		Vehicle *v;

   135

   136

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

   137

		FOR_ALL_VEHICLES(v) {

   138

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

   139

		}

   140

   141

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

   142

		if (_current_player < MAX_PLAYERS) {

   143

			Player *p;

   144

			EngineRenew *er;

   145

   146

			p = GetPlayer(_current_player);

   147

			FOR_ALL_ENGINE_RENEWS(er) {

   148

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

   149

			}

   150

		}

   151

   152

		VehicleType vt = g->vehicle_type;

   153

   154

		/* Delete the Replace Vehicle Windows */

   155

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   156

		DeleteGroup(g);

   157

   158

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

   159

	}

   160

   161

	return CommandCost();

   162

}

   163

   164

static bool IsUniqueGroupName(const char *name)

   165

{

   166

	const Group *g;

   167

	char buf[512];

   168

   169

	FOR_ALL_GROUPS(g) {

   170

		SetDParam(0, g->index);

   171

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

   172

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

   173

	}

   174

   175

	return true;

   176

}

   177

   178

/**

   179

 * Rename a group

   180

 * @param tile unused

   181

 * @param p1   index of array group

   182

 *   - p1 bit 0-15 : GroupID

   183

 * @param p2   unused

   184

 */

   185

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

   186

{

   187

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

   188

   189

	Group *g = GetGroup(p1);

   190

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

   191

   192

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

   193

   194

	/* Create the name */

   195

	StringID str = AllocateName(_cmd_text, 0);

   196

	if (str == STR_NULL) return CMD_ERROR;

   197

   198

	if (flags & DC_EXEC) {

   199

		/* Delete the old name */

   200

		DeleteName(g->string_id);

   201

		/* Assign the new one */

   202

		g->string_id = str;

   203

   204

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

   205

	}

   206

   207

	return CommandCost();

   208

}

   209

   210

   211

/**

   212

 * Add a vehicle to a group

   213

 * @param tile unused

   214

 * @param p1   index of array group

   215

 *   - p1 bit 0-15 : GroupID

   216

 * @param p2   vehicle to add to a group

   217

 *   - p2 bit 0-15 : VehicleID

   218

 */

   219

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

   220

{

   221

	GroupID new_g = p1;

   222

   223

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

   224

   225

	if (IsValidGroupID(new_g)) {

   226

		Group *g = GetGroup(new_g);

   227

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

   228

	}

   229

   230

	Vehicle *v = GetVehicle(p2);

   231

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

   232

   233

	if (flags & DC_EXEC) {

   234

		DecreaseGroupNumVehicle(v->group_id);

   235

		IncreaseGroupNumVehicle(new_g);

   236

   237

		switch (v->type) {

   238

			default: NOT_REACHED();

   239

			case VEH_TRAIN:

   240

				SetTrainGroupID(v, new_g);

   241

				break;

   242

			case VEH_ROAD:

   243

			case VEH_SHIP:

   244

			case VEH_AIRCRAFT:

   245

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

   246

				v->group_id = new_g;

   247

				break;

   248

		}

   249

   250

		/* Update the Replace Vehicle Windows */

   251

		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);

   252

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

   253

	}

   254

   255

	return CommandCost();

   256

}

   257

   258

/**

   259

 * Add all shared vehicles of all vehicles from a group

   260

 * @param tile unused

   261

 * @param p1   index of group array

   262

 *  - p1 bit 0-15 : GroupID

   263

 * @param p2   type of vehicles

   264

 */

   265

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

   266

{

   267

	VehicleType type = (VehicleType)p2;

   268

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

   269

   270

	if (flags & DC_EXEC) {

   271

		Vehicle *v;

   272

		VehicleType type = (VehicleType)p2;

   273

		GroupID id_g = p1;

   274

   275

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

   276

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

   277

		FOR_ALL_VEHICLES(v) {

   278

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

   279

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

   280

   281

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

   282

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

   283

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

   284

				}

   285

			}

   286

		}

   287

   288

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

   289

	}

   290

   291

	return CommandCost();

   292

}

   293

   294

   295

/**

   296

 * Remove all vehicles from a group

   297

 * @param tile unused

   298

 * @param p1   index of group array

   299

 * - p1 bit 0-15 : GroupID

   300

 * @param p2   type of vehicles

   301

 */

   302

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

   303

{

   304

	VehicleType type = (VehicleType)p2;

   305

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

   306

   307

	Group *g = GetGroup(p1);

   308

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

   309

   310

	if (flags & DC_EXEC) {

   311

		GroupID old_g = p1;

   312

		Vehicle *v;

   313

   314

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

   315

		FOR_ALL_VEHICLES(v) {

   316

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

   317

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

   318

   319

				/* Add The Vehicle to the default group */

   320

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

   321

			}

   322

		}

   323

   324

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

   325

	}

   326

   327

	return CommandCost();

   328

}

   329

   330

   331

/**

   332

 * (Un)set global replace protection from a group

   333

 * @param tile unused

   334

 * @param p1   index of group array

   335

 * - p1 bit 0-15 : GroupID

   336

 * @param p2

   337

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

   338

 */

   339

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

   340

{

   341

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   342

   343

	Group *g = GetGroup(p1);

   344

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

   345

   346

	if (flags & DC_EXEC) {

   347

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

   348

   349

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

   350

	}

   351

   352

	return CommandCost();

   353

}

   354

   355

/**

   356

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

   357

 * @note Called in CmdSellRailWagon and DeleteLasWagon,

   358

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

   359

 */

   360

void RemoveVehicleFromGroup(const Vehicle *v)

   361

{

   362

	if (!IsValidVehicle(v) || !(v->HasFront() && v->IsPrimaryVehicle())) return;

   363

   364

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

   365

}

   366

   367

   368

/**

   369

 * Affect the groupID of a train to new_g.

   370

 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle

   371

 * @param v     First vehicle of the chain.

   372

 * @param new_g index of array group

   373

 */

   374

void SetTrainGroupID(Vehicle *v, GroupID new_g)

   375

{

   376

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

   377

   378

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

   379

   380

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

   381

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

   382

   383

		u->group_id = new_g;

   384

	}

   385

   386

	/* Update the Replace Vehicle Windows */

   387

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   388

}

   389

   390

   391

/**

   392

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

   393

 * to/removed from the chain,.

   394

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

   395

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

   396

 * @param v First vehicle of the chain.

   397

 */

   398

void UpdateTrainGroupID(Vehicle *v)

   399

{

   400

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

   401

   402

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

   403

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

   404

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

   405

   406

		u->group_id = new_g;

   407

	}

   408

   409

	/* Update the Replace Vehicle Windows */

   410

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);

   411

}

   412

   413

   414

void RemoveAllGroupsForPlayer(const Player *p)

   415

{

   416

	Group *g;

   417

   418

	FOR_ALL_GROUPS(g) {

   419

		if (p->index == g->owner) DeleteGroup(g);

   420

	}

   421

}

   422

   423

   424

static const SaveLoad _group_desc[] = {

   425

  SLE_VAR(Group, string_id,          SLE_UINT16),

   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

		if (!AddBlockIfNeeded(&_Group_pool, index)) {

   451

			error("Groups: failed loading savegame: too many groups");

   452

		}

   453

   454

		Group *g = GetGroup(index);

   455

		SlObject(g, _group_desc);

   456

	}

   457

}

   458

   459

extern const ChunkHandler _group_chunk_handlers[] = {

   460

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

   461

};