1

/* $Id$ */

     2

     3

/** @file group_cmd.cpp Handling of the engine groups */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "player.h"

     9

#include "table/strings.h"

    10

#include "command.h"

    11

#include "vehicle.h"

    12

#include "saveload.h"

    13

#include "debug.h"

    14

#include "group.h"

    15

#include "train.h"

    16

#include "aircraft.h"

    17

#include "string.h"

    18

#include "window.h"

    19

#include "vehicle_gui.h"

    20

    21

/**

    22

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

    23

 * @note called in SetTrainGroupID and UpdateTrainGroupID

    24

 * @param i     EngineID we have to update

    25

 * @param old_g index of the old group

    26

 * @param new_g index of the new group

    27

 */

    28

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

    29

{

    30

	if (old_g != new_g) {

    31

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

    32

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

    33

    34

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

    35

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

    36

	}

    37

}

    38

    39

    40

/**

    41

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

    42

 */

    43

static void GroupPoolNewBlock(uint start_item)

    44

{

    45

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

    46

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

    47

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

    48

}

    49

    50

DEFINE_OLD_POOL(Group, Group, GroupPoolNewBlock, NULL)

    51

    52

static Group *AllocateGroup(void)

    53

{

    54

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

    55

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

    56

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

    57

		if (!IsValidGroup(g)) {

    58

			const GroupID index = g->index;

    59

    60

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

    61

			g->index = index;

    62

    63

			return g;

    64

		}

    65

	}

    66

    67

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

    68

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

    69

}

    70

    71

void InitializeGroup(void)

    72

{

    73

	CleanPool(&_Group_pool);

    74

	AddBlockToPool(&_Group_pool);

    75

}

    76

    77

    78

static WindowClass GetWCForVT(VehicleType vt)

    79

{

    80

	switch (vt) {

    81

		default:

    82

		case VEH_TRAIN:    return WC_TRAINS_LIST;

    83

		case VEH_ROAD:     return WC_ROADVEH_LIST;

    84

		case VEH_SHIP:     return WC_SHIPS_LIST;

    85

		case VEH_AIRCRAFT: return WC_AIRCRAFT_LIST;

    86

	}

    87

}

    88

    89

    90

/**

    91

 * Add a vehicle to a group

    92

 * @param tile unused

    93

 * @param p1   vehicle type

    94

 * @param p2   unused

    95

 */

    97

{

    98

	VehicleType vt = (VehicleType)p1;

    99

	if (!IsPlayerBuildableVehicleType(vt)) return CMD_ERROR;

   100

   101

	Group *g = AllocateGroup();

   102

	if (g == NULL) return CMD_ERROR;

   103

   104

	if (flags & DC_EXEC) {

   105

		g->owner = _current_player;

   106

		g->string_id = STR_SV_GROUP_NAME;

   107

		g->replace_protection = false;

   108

		g->vehicle_type = vt;

   109

   110

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

   111

	}

   112

   113

	return 0;

   114

}

   115

   116

   117

/**

   118

 * Add a vehicle to a group

   119

 * @param tile unused

   120

 * @param p1   index of array group

   121

 *      - p1 bit 0-15 : GroupID

   122

 * @param p2   unused

   123

 */

   125

{

   126

	if (!IsValidGroupID(p1)) return CMD_ERROR;

   127

   128

	Group *g = GetGroup(p1);

   129

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

   130

   131

	if (flags & DC_EXEC) {

   132

		Vehicle *v;

   133

   134

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

   135

		FOR_ALL_VEHICLES(v) {

   136

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

   137

		}

   138

   139

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

   140

		if (_current_player < MAX_PLAYERS) {

   141

			Player *p;

   142

			EngineRenew *er;

   143

   144

			p = GetPlayer(_current_player);

   145

			FOR_ALL_ENGINE_RENEWS(er) {

   146

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

   147

			}

   148

		}

   149

   150

		VehicleType vt = g->vehicle_type;

   151

   152

		/* Delete the Replace Vehicle Windows */

   153

		DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);

   154

		DeleteGroup(g);

   155

   156

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

   157

	}

   158

   159

	return 0;

   160

}

   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

 */

   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

	/* Create the name */

   178

	StringID str = AllocateName(_cmd_text, 0);

   179

	if (str == STR_NULL) return CMD_ERROR;

   180

   181

	if (flags & DC_EXEC) {

   182

		/* Delete the old name */

   183

		DeleteName(g->string_id);

   184

		/* Assign the new one */

   185

		g->string_id = str;

   186

   187

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

   188

	}

   189

   190

	return 0;

   191

}

   192

   193

   194

/**

   195

 * Add a vehicle to a group

   196

 * @param tile unused

   197

 * @param p1   index of array group

   198

 *   - p1 bit 0-15 : GroupID

   199

 * @param p2   vehicle to add to a group

   200

 *   - p2 bit 0-15 : VehicleID

   201

 */

   203

{

   204

	GroupID new_g = p1;

   205

   206

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

   207

   208

	if (IsValidGroupID(new_g)) {

   209

		Group *g = GetGroup(new_g);

   210

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

   211

	}

   212

   213

	Vehicle *v = GetVehicle(p2);

   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(GetWCForVT(v->type), (v->type << 11) | VLW_GROUP_LIST | _current_player);

   236

	}

   237

   238

	return 0;

   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

 */

   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(GetWCForVT(type), (type << 11) | VLW_GROUP_LIST | _current_player);

   272

	}

   273

   274

	return 0;

   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

 */

   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(GetWCForVT(type), (type << 11) | VLW_GROUP_LIST | _current_player);

   308

	}

   309

   310

	return 0;

   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

 */

   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(GetWCForVT(g->vehicle_type), (g->vehicle_type << 11) | VLW_GROUP_LIST | _current_player);

   333

	}

   334

   335

	return 0;

   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 (!IsValidVehicle(v) || !(v->HasFront() && 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(IsValidVehicle(v) && 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(IsValidVehicle(v) && 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

   397

void RemoveAllGroupsForPlayer(const Player *p)

   398

{

   399

	Group *g;

   400

   401

	FOR_ALL_GROUPS(g) {

   402

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

   403

	}

   404

}

   405

   406

   407

static const SaveLoad _group_desc[] = {

   408

  SLE_VAR(Group, string_id,          SLE_UINT16),

   409

  SLE_VAR(Group, num_vehicle,        SLE_UINT16),

   410

  SLE_VAR(Group, owner,              SLE_UINT8),

   411

  SLE_VAR(Group, vehicle_type,       SLE_UINT8),

   412

  SLE_VAR(Group, replace_protection, SLE_BOOL),

   413

  SLE_END()

   414

};

   415

   416

   417

static void Save_GROUP(void)

   418

{

   419

	Group *g;

   420

   421

	FOR_ALL_GROUPS(g) {

   422

		SlSetArrayIndex(g->index);

   423

		SlObject(g, _group_desc);

   424

	}

   425

}

   426

   427

   428

static void Load_GROUP(void)

   429

{

   430

	int index;

   431

   432

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

   433

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

   434

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

   435

		}

   436

   437

		Group *g = GetGroup(index);

   438

		SlObject(g, _group_desc);

   439

	}

   440

}

   441

   442

extern const ChunkHandler _group_chunk_handlers[] = {

   443

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

   444

};