1

/* $Id$ */

     2

     3

/** @file cargopacket.cpp Implementation of the cargo packets */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "station.h"

     8

#include "cargopacket.h"

     9

#include "saveload.h"

    10

    11

/** Cache for speeding up lookups in AllocateRaw */

    12

static uint _first_free_cargo_packet_index;

    13

    14

/**

    15

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

    16

 */

    17

static void CargoPacketPoolNewBlock(uint cpart_item)

    18

{

    19

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

    20

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

    21

	for (CargoPacket *cp = GetCargoPacket(cpart_item); cp != NULL; cp = (cp->index + 1U < GetCargoPacketPoolSize()) ? GetCargoPacket(cp->index + 1U) : NULL) cp->index = cpart_item++;

    22

}

    23

    24

static void CargoPacketPoolCleanBlock(uint cpart_item, uint end_item)

    25

{

    26

	for (uint i = cpart_item; i <= end_item; i++) {

    27

		CargoPacket *cp = GetCargoPacket(i);

    28

		if (cp->IsValid()) cp->~CargoPacket();

    29

	}

    30

}

    31

    32

/* Initialize the cargopacket-pool */

    33

DEFINE_OLD_POOL(CargoPacket, CargoPacket, CargoPacketPoolNewBlock, CargoPacketPoolCleanBlock)

    34

    35

void InitializeCargoPackets()

    36

{

    37

	_first_free_cargo_packet_index = 0;

    38

	/* Clean the cargo packet pool and create 1 block in it */

    39

	CleanPool(&_CargoPacket_pool);

    40

	AddBlockToPool(&_CargoPacket_pool);

    41

    42

	/* Check whether our &cargolist == &cargolist.packets "hack" works */

    43

	CargoList::AssertOnWrongPacketOffset();

    44

}

    45

    46

CargoPacket::CargoPacket(StationID source, uint16 count)

    47

{

    48

	if (source != INVALID_STATION) assert(count != 0);

    49

    50

	this->source          = source;

    51

	this->source_xy       = (source != INVALID_STATION) ? GetStation(source)->xy : 0;

    52

	this->loaded_at_xy    = this->source_xy;

    53

    54

	this->count           = count;

    55

	this->days_in_transit = 0;

    56

	this->feeder_share    = 0;

    57

	this->paid_for        = false;

    58

}

    59

    60

CargoPacket::~CargoPacket()

    61

{

    62

	if (this->index < _first_free_cargo_packet_index) _first_free_cargo_packet_index = this->index;

    63

	this->count = 0;

    64

}

    65

    66

bool CargoPacket::SameSource(CargoPacket *cp)

    67

{

    68

	return this->source_xy == cp->source_xy && this->days_in_transit == cp->days_in_transit && this->paid_for == cp->paid_for;

    69

}

    70

    71

void *CargoPacket::operator new(size_t size)

    72

{

    73

	CargoPacket *cp = AllocateRaw();

    74

	return cp;

    75

}

    76

    77

void *CargoPacket::operator new(size_t size, CargoPacket::ID cp_idx)

    78

{

    79

	if (!AddBlockIfNeeded(&_CargoPacket_pool, cp_idx))

    80

		error("CargoPackets: failed loading savegame: too many cargo packets");

    81

    82

	CargoPacket *cp = GetCargoPacket(cp_idx);

    83

	return cp;

    84

}

    85

    86

void CargoPacket::operator delete(void *p)

    87

{

    88

}

    89

    90

void CargoPacket::operator delete(void *p, CargoPacket::ID cp_idx)

    91

{

    92

}

    93

    94

/*static*/ CargoPacket *CargoPacket::AllocateRaw()

    95

{

    96

	CargoPacket *cp = NULL;

    97

    98

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

    99

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

   100

	for (cp = GetCargoPacket(_first_free_cargo_packet_index); cp != NULL; cp = (cp->index + 1U < GetCargoPacketPoolSize()) ? GetCargoPacket(cp->index + 1U) : NULL) {

   101

		if (!cp->IsValid()) {

   102

			CargoPacket::ID index = cp->index;

   103

   104

			memset(cp, 0, sizeof(CargoPacket));

   105

			cp->index = index;

   106

			_first_free_cargo_packet_index = cp->index;

   107

			return cp;

   108

		}

   109

	}

   110

   111

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

   112

	if (AddBlockToPool(&_CargoPacket_pool)) return AllocateRaw();

   113

   114

	error("CargoPackets: too many cargo packets");

   115

}

   116

   117

static const SaveLoad _cargopacket_desc[] = {

   118

	SLE_VAR(CargoPacket, source,          SLE_UINT16),

   119

	SLE_VAR(CargoPacket, source_xy,       SLE_UINT32),

   120

	SLE_VAR(CargoPacket, loaded_at_xy,    SLE_UINT32),

   121

	SLE_VAR(CargoPacket, count,           SLE_UINT16),

   122

	SLE_VAR(CargoPacket, days_in_transit, SLE_UINT8),

   123

	SLE_VAR(CargoPacket, feeder_share,    SLE_INT64),

   124

	SLE_VAR(CargoPacket, paid_for,        SLE_BOOL),

   125

   126

	SLE_END()

   127

};

   128

   129

static void Save_CAPA()

   130

{

   131

	CargoPacket *cp;

   132

   133

	FOR_ALL_CARGOPACKETS(cp) {

   134

		SlSetArrayIndex(cp->index);

   135

		SlObject(cp, _cargopacket_desc);

   136

	}

   137

}

   138

   139

static void Load_CAPA()

   140

{

   141

	int index;

   142

   143

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

   144

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

   145

			error("CargoPackets: failed loading savegame: too many cargo packets");

   146

		}

   147

   148

		CargoPacket *cp = GetCargoPacket(index);

   149

		SlObject(cp, _cargopacket_desc);

   150

	}

   151

}

   152

   153

extern const ChunkHandler _cargopacket_chunk_handlers[] = {

   154

	{ 'CAPA', Save_CAPA, Load_CAPA, CH_ARRAY | CH_LAST},

   155

};

   156

   157

/*

   158

 *

   159

 * Cargo list implementation

   160

 *

   161

 */

   162

   163

/* static */ void CargoList::AssertOnWrongPacketOffset()

   164

{

   165

	CargoList cl;

   166

	if ((void*)&cl != (void*)cl.Packets()) NOT_REACHED();

   167

}

   168

   169

   170

CargoList::~CargoList()

   171

{

   172

	while (!packets.empty()) {

   173

		delete packets.front();

   174

		packets.pop_front();

   175

	}

   176

}

   177

   178

const CargoList::List *CargoList::Packets() const

   179

{

   180

	return &packets;

   181

}

   182

   183

void CargoList::AgeCargo()

   184

{

   185

	if (empty) return;

   186

   187

	uint dit = 0;

   188

	for (List::const_iterator it = packets.begin(); it != packets.end(); it++) {

   189

		if ((*it)->days_in_transit != 0xFF) (*it)->days_in_transit++;

   190

		dit += (*it)->days_in_transit * (*it)->count;

   191

	}

   192

	days_in_transit = dit / count;

   193

}

   194

   195

bool CargoList::Empty() const

   196

{

   197

	return empty;

   198

}

   199

   200

uint CargoList::Count() const

   201

{

   202

	return count;

   203

}

   204

   205

bool CargoList::UnpaidCargo() const

   206

{

   207

	return unpaid_cargo;

   208

}

   209

   210

Money CargoList::FeederShare() const

   211

{

   212

	return feeder_share;

   213

}

   214

   215

StationID CargoList::Source() const

   216

{

   217

	return source;

   218

}

   219

   220

uint CargoList::DaysInTransit() const

   221

{

   222

	return days_in_transit;

   223

}

   224

   225

void CargoList::Append(CargoPacket *cp)

   226

{

   227

	assert(cp != NULL);

   228

	assert(cp->IsValid());

   229

   230

	for (List::iterator it = packets.begin(); it != packets.end(); it++) {

   231

		if ((*it)->SameSource(cp) && (*it)->count + cp->count <= 65535) {

   232

			(*it)->count        += cp->count;

   233

			(*it)->feeder_share += cp->feeder_share;

   234

			delete cp;

   235

   236

			InvalidateCache();

   237

			return;

   238

		}

   239

	}

   240

   241

	/* The packet could not be merged with another one */

   242

	packets.push_back(cp);

   243

	InvalidateCache();

   244

}

   245

   246

   247

void CargoList::Truncate(uint count)

   248

{

   249

	for (List::iterator it = packets.begin(); it != packets.end(); it++) {

   250

		uint local_count = (*it)->count;

   251

		if (local_count <= count) {

   252

			count -= local_count;

   253

			continue;

   254

		}

   255

   256

		(*it)->count = count;

   257

		count = 0;

   258

	}

   259

   260

	while (!packets.empty()) {

   261

		CargoPacket *cp = packets.back();

   262

		if (cp->count != 0) break;

   263

		delete cp;

   264

		packets.pop_back();

   265

	}

   266

   267

	InvalidateCache();

   268

}

   269

   270

bool CargoList::MoveTo(CargoList *dest, uint count, CargoList::MoveToAction mta, uint data)

   271

{

   272

	assert(mta == MTA_FINAL_DELIVERY || dest != NULL);

   273

	CargoList tmp;

   274

   275

	while (!packets.empty() && count > 0) {

   276

		CargoPacket *cp = *packets.begin();

   277

		if (cp->count <= count) {

   278

			/* Can move the complete packet */

   279

			packets.remove(cp);

   280

			switch (mta) {

   281

				case MTA_FINAL_DELIVERY:

   282

					if (cp->source == data) {

   283

						tmp.Append(cp);

   284

					} else {

   285

						count -= cp->count;

   286

						delete cp;

   287

					}

   288

					break;

   289

				case MTA_CARGO_LOAD:

   290

					cp->loaded_at_xy = data;

   291

					/* When cargo is moved into another vehicle you have *always* paid for it */

   292

					cp->paid_for     = false;

   293

					/* FALL THROUGH */

   294

				case MTA_OTHER:

   295

					count -= cp->count;

   296

					dest->packets.push_back(cp);

   297

					break;

   298

			}

   299

		} else {

   300

			/* Can move only part of the packet, so split it into two pieces */

   301

			if (mta != MTA_FINAL_DELIVERY) {

   302

				CargoPacket *cp_new = new CargoPacket();

   303

				cp_new->source          = cp->source;

   304

				cp_new->source_xy       = cp->source_xy;

   305

				cp_new->loaded_at_xy    = (mta == MTA_CARGO_LOAD) ? data : cp->loaded_at_xy;

   306

   307

				cp_new->days_in_transit = cp->days_in_transit;

   308

				cp_new->feeder_share    = cp->feeder_share / count;

   309

				/* When cargo is moved into another vehicle you have *always* paid for it */

   310

				cp_new->paid_for        = (mta == MTA_CARGO_LOAD) ? false : cp->paid_for;

   311

   312

				cp_new->count = count;

   313

				dest->packets.push_back(cp_new);

   314

   315

				cp->feeder_share /= cp->count - count;

   316

			}

   317

			cp->count -= count;

   318

   319

			count = 0;

   320

		}

   321

	}

   322

   323

	bool remaining = !packets.empty();

   324

   325

	if (mta == MTA_FINAL_DELIVERY && !tmp.Empty()) {

   326

		/* There are some packets that could not be delivered at the station, put them back */

   327

		tmp.MoveTo(this, MAX_UVALUE(uint));

   328

		tmp.packets.clear();

   329

	}

   330

   331

	if (dest != NULL) dest->InvalidateCache();

   332

	InvalidateCache();

   333

   334

	return remaining;

   335

}

   336

   337

void CargoList::InvalidateCache()

   338

{

   339

	empty = packets.empty();

   340

	count = 0;

   341

	unpaid_cargo = false;

   342

	feeder_share = 0;

   343

	source = INVALID_STATION;

   344

	days_in_transit = 0;

   345

   346

	if (empty) return;

   347

   348

	uint dit = 0;

   349

	for (List::const_iterator it = packets.begin(); it != packets.end(); it++) {

   350

		count        += (*it)->count;

   351

		unpaid_cargo |= !(*it)->paid_for;

   352

		dit          += (*it)->days_in_transit * (*it)->count;

   353

		feeder_share += (*it)->feeder_share;

   354

	}

   355

	days_in_transit = dit / count;

   356

	source = (*packets.begin())->source;

   357

}