OpenTTD Source: src/cargopacket.cpp Source File

OpenTTD Source 13.1

cargopacket.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10 #include "stdafx.h"
11 #include "station_base.h"
12 #include "core/pool_func.hpp"
13 #include "core/random_func.hpp"
14 #include "economy_base.h"
15 #include "cargoaction.h"
16 #include "order_type.h"
17
18 #include "safeguards.h"
19
20 /* Initialize the cargopacket-pool */
21 CargoPacketPool _cargopacket_pool("CargoPacket");
22 INSTANTIATE_POOL_METHODS(CargoPacket)
23
24
27 CargoPacket::CargoPacket()
28 {
29 this->source_type = ST_INDUSTRY;
30 this->source_id = INVALID_SOURCE;
31 }
32
44 CargoPacket::CargoPacket(StationID source, TileIndex source_xy, uint16 count, SourceType source_type, SourceID source_id) :
45 feeder_share(0),
46 count(count),
47 days_in_transit(0),
48 source_id(source_id),
49 source(source),
50 source_xy(source_xy),
51 loaded_at_xy(0)
52 {
53 assert(count != 0);
54 this->source_type = source_type;
55 }
56
71 CargoPacket::CargoPacket(uint16 count, byte days_in_transit, StationID source, TileIndex source_xy, TileIndex loaded_at_xy, Money feeder_share, SourceType source_type, SourceID source_id) :
72 feeder_share(feeder_share),
73 count(count),
74 days_in_transit(days_in_transit),
75 source_id(source_id),
76 source(source),
77 source_xy(source_xy),
78 loaded_at_xy(loaded_at_xy.value)
79 {
80 assert(count != 0);
81 this->source_type = source_type;
82 }
83
89 CargoPacket *CargoPacket::Split(uint new_size)
90 {
91 if (!CargoPacket::CanAllocateItem()) return nullptr;
92
93 Money fs = this->FeederShare(new_size);
94 CargoPacket *cp_new = new CargoPacket(new_size, this->days_in_transit, this->source, this->source_xy, this->loaded_at_xy, fs, this->source_type, this->source_id);
95 this->feeder_share -= fs;
96 this->count -= new_size;
97 return cp_new;
98 }
99
104 void CargoPacket::Merge(CargoPacket *cp)
105 {
106 this->count += cp->count;
107 this->feeder_share += cp->feeder_share;
108 delete cp;
109 }
110
115 void CargoPacket::Reduce(uint count)
116 {
117 assert(count < this->count);
118 this->feeder_share -= this->FeederShare(count);
119 this->count -= count;
120 }
121
127 /* static */ void CargoPacket::InvalidateAllFrom(SourceType src_type, SourceID src)
128 {
129 for (CargoPacket *cp : CargoPacket::Iterate()) {
130 if (cp->source_type == src_type && cp->source_id == src) cp->source_id = INVALID_SOURCE;
131 }
132 }
133
138 /* static */ void CargoPacket::InvalidateAllFrom(StationID sid)
139 {
140 for (CargoPacket *cp : CargoPacket::Iterate()) {
141 if (cp->source == sid) cp->source = INVALID_STATION;
142 }
143 }
144
145 /*
146 *
147 * Cargo list implementation
148 *
149 */
150
154 template <class Tinst, class Tcont>
155 CargoList<Tinst, Tcont>::~CargoList()
156 {
157 for (Iterator it(this->packets.begin()); it != this->packets.end(); ++it) {
158 delete *it;
159 }
160 }
161
166 template <class Tinst, class Tcont>
167 void CargoList<Tinst, Tcont>::OnCleanPool()
168 {
169 this->packets.clear();
170 }
171
178 template <class Tinst, class Tcont>
179 void CargoList<Tinst, Tcont>::RemoveFromCache(const CargoPacket *cp, uint count)
180 {
181 assert(count <= cp->count);
182 this->count -= count;
183 this->cargo_days_in_transit -= cp->days_in_transit * count;
184 }
185
191 template <class Tinst, class Tcont>
192 void CargoList<Tinst, Tcont>::AddToCache(const CargoPacket *cp)
193 {
194 this->count += cp->count;
195 this->cargo_days_in_transit += cp->days_in_transit * cp->count;
196 }
197
199 template <class Tinst, class Tcont>
200 void CargoList<Tinst, Tcont>::InvalidateCache()
201 {
202 this->count = 0;
203 this->cargo_days_in_transit = 0;
204
205 for (ConstIterator it(this->packets.begin()); it != this->packets.end(); it++) {
206 static_cast<Tinst *>(this)->AddToCache(*it);
207 }
208 }
209
217 template <class Tinst, class Tcont>
218 /* static */ bool CargoList<Tinst, Tcont>::TryMerge(CargoPacket *icp, CargoPacket *cp)
219 {
220 if (Tinst::AreMergable(icp, cp) &&
221 icp->count + cp->count <= CargoPacket::MAX_COUNT) {
222 icp->Merge(cp);
223 return true;
224 } else {
225 return false;
226 }
227 }
228
229 /*
230 *
231 * Vehicle cargo list implementation.
232 *
233 */
234
250 void VehicleCargoList::Append(CargoPacket *cp, MoveToAction action)
251 {
252 assert(cp != nullptr);
253 assert(action == MTA_LOAD ||
254 (action == MTA_KEEP && this->action_counts[MTA_LOAD] == 0));
255 this->AddToMeta(cp, action);
256
257 if (this->count == cp->count) {
258 this->packets.push_back(cp);
259 return;
260 }
261
262 uint sum = cp->count;
263 for (ReverseIterator it(this->packets.rbegin()); it != this->packets.rend(); it++) {
264 CargoPacket *icp = *it;
265 if (VehicleCargoList::TryMerge(icp, cp)) return;
266 sum += icp->count;
267 if (sum >= this->action_counts[action]) {
268 this->packets.push_back(cp);
269 return;
270 }
271 }
272
273 NOT_REACHED();
274 }
275
284 template<class Taction>
285 void VehicleCargoList::ShiftCargo(Taction action)
286 {
287 Iterator it(this->packets.begin());
288 while (it != this->packets.end() && action.MaxMove() > 0) {
289 CargoPacket *cp = *it;
290 if (action(cp)) {
291 it = this->packets.erase(it);
292 } else {
293 break;
294 }
295 }
296 }
297
306 template<class Taction>
307 void VehicleCargoList::PopCargo(Taction action)
308 {
309 if (this->packets.empty()) return;
310 Iterator it(--(this->packets.end()));
311 Iterator begin(this->packets.begin());
312 while (action.MaxMove() > 0) {
313 CargoPacket *cp = *it;
314 if (action(cp)) {
315 if (it != begin) {
316 this->packets.erase(it--);
317 } else {
318 this->packets.erase(it);
319 break;
320 }
321 } else {
322 break;
323 }
324 }
325 }
326
333 void VehicleCargoList::RemoveFromCache(const CargoPacket *cp, uint count)
334 {
335 this->feeder_share -= cp->FeederShare(count);
336 this->Parent::RemoveFromCache(cp, count);
337 }
338
344 void VehicleCargoList::AddToCache(const CargoPacket *cp)
345 {
346 this->feeder_share += cp->feeder_share;
347 this->Parent::AddToCache(cp);
348 }
349
356 void VehicleCargoList::RemoveFromMeta(const CargoPacket *cp, MoveToAction action, uint count)
357 {
358 assert(count <= this->action_counts[action]);
359 this->AssertCountConsistency();
360 this->RemoveFromCache(cp, count);
361 this->action_counts[action] -= count;
362 this->AssertCountConsistency();
363 }
364
370 void VehicleCargoList::AddToMeta(const CargoPacket *cp, MoveToAction action)
371 {
372 this->AssertCountConsistency();
373 this->AddToCache(cp);
374 this->action_counts[action] += cp->count;
375 this->AssertCountConsistency();
376 }
377
381 void VehicleCargoList::AgeCargo()
382 {
383 for (ConstIterator it(this->packets.begin()); it != this->packets.end(); it++) {
384 CargoPacket *cp = *it;
385 /* If we're at the maximum, then we can't increase no more. */
386 if (cp->days_in_transit == 0xFF) continue;
387
388 cp->days_in_transit++;
389 this->cargo_days_in_transit += cp->count;
390 }
391 }
392
400 void VehicleCargoList::SetTransferLoadPlace(TileIndex xy)
401 {
402 uint sum = 0;
403 for (Iterator it = this->packets.begin(); sum < this->action_counts[MTA_TRANSFER]; ++it) {
404 CargoPacket *cp = *it;
405 cp->loaded_at_xy = xy;
406 sum += cp->count;
407 }
408 }
409
419 /* static */ VehicleCargoList::MoveToAction VehicleCargoList::ChooseAction(const CargoPacket *cp, StationID cargo_next,
420 StationID current_station, bool accepted, StationIDStack next_station)
421 {
422 if (cargo_next == INVALID_STATION) {
423 return (accepted && cp->source != current_station) ? MTA_DELIVER : MTA_KEEP;
424 } else if (cargo_next == current_station) {
425 return MTA_DELIVER;
426 } else if (next_station.Contains(cargo_next)) {
427 return MTA_KEEP;
428 } else {
429 return MTA_TRANSFER;
430 }
431 }
432
446 bool VehicleCargoList::Stage(bool accepted, StationID current_station, StationIDStack next_station, uint8 order_flags, const GoodsEntry *ge, CargoPayment *payment)
447 {
448 this->AssertCountConsistency();
449 assert(this->action_counts[MTA_LOAD] == 0);
450 this->action_counts[MTA_TRANSFER] = this->action_counts[MTA_DELIVER] = this->action_counts[MTA_KEEP] = 0;
451 Iterator deliver = this->packets.end();
452 Iterator it = this->packets.begin();
453 uint sum = 0;
454
455 bool force_keep = (order_flags & OUFB_NO_UNLOAD) != 0;
456 bool force_unload = (order_flags & OUFB_UNLOAD) != 0;
457 bool force_transfer = (order_flags & (OUFB_TRANSFER | OUFB_UNLOAD)) != 0;
458 assert(this->count > 0 || it == this->packets.end());
459 while (sum < this->count) {
460 CargoPacket *cp = *it;
461
462 this->packets.erase(it++);
463 StationID cargo_next = INVALID_STATION;
464 MoveToAction action = MTA_LOAD;
465 if (force_keep) {
466 action = MTA_KEEP;
467 } else if (force_unload && accepted && cp->source != current_station) {
468 action = MTA_DELIVER;
469 } else if (force_transfer) {
470 action = MTA_TRANSFER;
471 /* We cannot send the cargo to any of the possible next hops and
472 * also not to the current station. */
473 FlowStatMap::const_iterator flow_it(ge->flows.find(cp->source));
474 if (flow_it == ge->flows.end()) {
475 cargo_next = INVALID_STATION;
476 } else {
477 FlowStat new_shares = flow_it->second;
478 new_shares.ChangeShare(current_station, INT_MIN);
479 StationIDStack excluded = next_station;
480 while (!excluded.IsEmpty() && !new_shares.GetShares()->empty()) {
481 new_shares.ChangeShare(excluded.Pop(), INT_MIN);
482 }
483 if (new_shares.GetShares()->empty()) {
484 cargo_next = INVALID_STATION;
485 } else {
486 cargo_next = new_shares.GetVia();
487 }
488 }
489 } else {
490 /* Rewrite an invalid source station to some random other one to
491 * avoid keeping the cargo in the vehicle forever. */
492 if (cp->source == INVALID_STATION && !ge->flows.empty()) {
493 cp->source = ge->flows.begin()->first;
494 }
495 bool restricted = false;
496 FlowStatMap::const_iterator flow_it(ge->flows.find(cp->source));
497 if (flow_it == ge->flows.end()) {
498 cargo_next = INVALID_STATION;
499 } else {
500 cargo_next = flow_it->second.GetViaWithRestricted(restricted);
501 }
502 action = VehicleCargoList::ChooseAction(cp, cargo_next, current_station, accepted, next_station);
503 if (restricted && action == MTA_TRANSFER) {
504 /* If the flow is restricted we can't transfer to it. Choose an
505 * unrestricted one instead. */
506 cargo_next = flow_it->second.GetVia();
507 action = VehicleCargoList::ChooseAction(cp, cargo_next, current_station, accepted, next_station);
508 }
509 }
510 Money share;
511 switch (action) {
512 case MTA_KEEP:
513 this->packets.push_back(cp);
514 if (deliver == this->packets.end()) --deliver;
515 break;
516 case MTA_DELIVER:
517 this->packets.insert(deliver, cp);
518 break;
519 case MTA_TRANSFER:
520 this->packets.push_front(cp);
521 /* Add feeder share here to allow reusing field for next station. */
522 share = payment->PayTransfer(cp, cp->count);
523 cp->AddFeederShare(share);
524 this->feeder_share += share;
525 cp->next_station = cargo_next;
526 break;
527 default:
528 NOT_REACHED();
529 }
530 this->action_counts[action] += cp->count;
531 sum += cp->count;
532 }
533 this->AssertCountConsistency();
534 return this->action_counts[MTA_DELIVER] > 0 || this->action_counts[MTA_TRANSFER] > 0;
535 }
536
538 void VehicleCargoList::InvalidateCache()
539 {
540 this->feeder_share = 0;
541 this->Parent::InvalidateCache();
542 }
543
556 template<VehicleCargoList::MoveToAction Tfrom, VehicleCargoList::MoveToAction Tto>
557 uint VehicleCargoList::Reassign(uint max_move, TileOrStationID)
558 {
559 static_assert(Tfrom != MTA_TRANSFER && Tto != MTA_TRANSFER);
560 static_assert(Tfrom - Tto == 1 || Tto - Tfrom == 1);
561 max_move = std::min(this->action_counts[Tfrom], max_move);
562 this->action_counts[Tfrom] -= max_move;
563 this->action_counts[Tto] += max_move;
564 return max_move;
565 }
566
574 template<>
575 uint VehicleCargoList::Reassign<VehicleCargoList::MTA_DELIVER, VehicleCargoList::MTA_TRANSFER>(uint max_move, TileOrStationID next_station)
576 {
577 max_move = std::min(this->action_counts[MTA_DELIVER], max_move);
578
579 uint sum = 0;
580 for (Iterator it(this->packets.begin()); sum < this->action_counts[MTA_TRANSFER] + max_move;) {
581 CargoPacket *cp = *it++;
582 sum += cp->Count();
583 if (sum <= this->action_counts[MTA_TRANSFER]) continue;
584 if (sum > this->action_counts[MTA_TRANSFER] + max_move) {
585 CargoPacket *cp_split = cp->Split(sum - this->action_counts[MTA_TRANSFER] + max_move);
586 sum -= cp_split->Count();
587 this->packets.insert(it, cp_split);
588 }
589 cp->next_station = next_station;
590 }
591
592 this->action_counts[MTA_DELIVER] -= max_move;
593 this->action_counts[MTA_TRANSFER] += max_move;
594 return max_move;
595 }
596
604 uint VehicleCargoList::Return(uint max_move, StationCargoList *dest, StationID next)
605 {
606 max_move = std::min(this->action_counts[MTA_LOAD], max_move);
607 this->PopCargo(CargoReturn(this, dest, max_move, next));
608 return max_move;
609 }
610
617 uint VehicleCargoList::Shift(uint max_move, VehicleCargoList *dest)
618 {
619 max_move = std::min(this->count, max_move);
620 this->PopCargo(CargoShift(this, dest, max_move));
621 return max_move;
622 }
623
632 uint VehicleCargoList::Unload(uint max_move, StationCargoList *dest, CargoPayment *payment)
633 {
634 uint moved = 0;
635 if (this->action_counts[MTA_TRANSFER] > 0) {
636 uint move = std::min(this->action_counts[MTA_TRANSFER], max_move);
637 this->ShiftCargo(CargoTransfer(this, dest, move));
638 moved += move;
639 }
640 if (this->action_counts[MTA_TRANSFER] == 0 && this->action_counts[MTA_DELIVER] > 0 && moved < max_move) {
641 uint move = std::min(this->action_counts[MTA_DELIVER], max_move - moved);
642 this->ShiftCargo(CargoDelivery(this, move, payment));
643 moved += move;
644 }
645 return moved;
646 }
647
654 uint VehicleCargoList::Truncate(uint max_move)
655 {
656 max_move = std::min(this->count, max_move);
657 this->PopCargo(CargoRemoval<VehicleCargoList>(this, max_move));
658 return max_move;
659 }
660
669 uint VehicleCargoList::Reroute(uint max_move, VehicleCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge)
670 {
671 max_move = std::min(this->action_counts[MTA_TRANSFER], max_move);
672 this->ShiftCargo(VehicleCargoReroute(this, dest, max_move, avoid, avoid2, ge));
673 return max_move;
674 }
675
676 /*
677 *
678 * Station cargo list implementation.
679 *
680 */
681
690 void StationCargoList::Append(CargoPacket *cp, StationID next)
691 {
692 assert(cp != nullptr);
693 this->AddToCache(cp);
694
695 StationCargoPacketMap::List &list = this->packets[next];
696 for (StationCargoPacketMap::List::reverse_iterator it(list.rbegin());
697 it != list.rend(); it++) {
698 if (StationCargoList::TryMerge(*it, cp)) return;
699 }
700
701 /* The packet could not be merged with another one */
702 list.push_back(cp);
703 }
704
717 template <class Taction>
718 bool StationCargoList::ShiftCargo(Taction &action, StationID next)
719 {
720 std::pair<Iterator, Iterator> range(this->packets.equal_range(next));
721 for (Iterator it(range.first); it != range.second && it.GetKey() == next;) {
722 if (action.MaxMove() == 0) return false;
723 CargoPacket *cp = *it;
724 if (action(cp)) {
725 it = this->packets.erase(it);
726 } else {
727 return false;
728 }
729 }
730 return true;
731 }
732
747 template <class Taction>
748 uint StationCargoList::ShiftCargo(Taction action, StationIDStack next, bool include_invalid)
749 {
750 uint max_move = action.MaxMove();
751 while (!next.IsEmpty()) {
752 this->ShiftCargo(action, next.Pop());
753 if (action.MaxMove() == 0) break;
754 }
755 if (include_invalid && action.MaxMove() > 0) {
756 this->ShiftCargo(action, INVALID_STATION);
757 }
758 return max_move - action.MaxMove();
759 }
760
769 uint StationCargoList::Truncate(uint max_move, StationCargoAmountMap *cargo_per_source)
770 {
771 max_move = std::min(max_move, this->count);
772 uint prev_count = this->count;
773 uint moved = 0;
774 uint loop = 0;
775 bool do_count = cargo_per_source != nullptr;
776 while (max_move > moved) {
777 for (Iterator it(this->packets.begin()); it != this->packets.end();) {
778 CargoPacket *cp = *it;
779 if (prev_count > max_move && RandomRange(prev_count) < prev_count - max_move) {
780 if (do_count && loop == 0) {
781 (*cargo_per_source)[cp->source] += cp->count;
782 }
783 ++it;
784 continue;
785 }
786 uint diff = max_move - moved;
787 if (cp->count > diff) {
788 if (diff > 0) {
789 this->RemoveFromCache(cp, diff);
790 cp->Reduce(diff);
791 moved += diff;
792 }
793 if (loop > 0) {
794 if (do_count) (*cargo_per_source)[cp->source] -= diff;
795 return moved;
796 } else {
797 if (do_count) (*cargo_per_source)[cp->source] += cp->count;
798 ++it;
799 }
800 } else {
801 it = this->packets.erase(it);
802 if (do_count && loop > 0) {
803 (*cargo_per_source)[cp->source] -= cp->count;
804 }
805 moved += cp->count;
806 this->RemoveFromCache(cp, cp->count);
807 delete cp;
808 }
809 }
810 loop++;
811 }
812 return moved;
813 }
814
823 uint StationCargoList::Reserve(uint max_move, VehicleCargoList *dest, TileIndex load_place, StationIDStack next_station)
824 {
825 return this->ShiftCargo(CargoReservation(this, dest, max_move, load_place), next_station, true);
826 }
827
840 uint StationCargoList::Load(uint max_move, VehicleCargoList *dest, TileIndex load_place, StationIDStack next_station)
841 {
842 uint move = std::min(dest->ActionCount(VehicleCargoList::MTA_LOAD), max_move);
843 if (move > 0) {
844 this->reserved_count -= move;
845 dest->Reassign<VehicleCargoList::MTA_LOAD, VehicleCargoList::MTA_KEEP>(move);
846 return move;
847 } else {
848 return this->ShiftCargo(CargoLoad(this, dest, max_move, load_place), next_station, true);
849 }
850 }
851
860 uint StationCargoList::Reroute(uint max_move, StationCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge)
861 {
862 return this->ShiftCargo(StationCargoReroute(this, dest, max_move, avoid, avoid2, ge), avoid, false);
863 }
864
865 /*
866 * We have to instantiate everything we want to be usable.
867 */
868 template class CargoList<VehicleCargoList, CargoPacketList>;
869 template class CargoList<StationCargoList, StationCargoPacketMap>;
870 template uint VehicleCargoList::Reassign<VehicleCargoList::MTA_DELIVER, VehicleCargoList::MTA_KEEP>(uint, TileOrStationID);
CargoPacket::feeder_share
Money feeder_share
Value of feeder pickup to be paid for on delivery of cargo.
Definition: cargopacket.h:45
CargoList< VehicleCargoList, CargoPacketList >::ConstIterator
CargoPacketList ::const_iterator ConstIterator
The const iterator for our container.
Definition: cargopacket.h:208
SmallStack
Minimal stack that uses a pool to avoid pointers.
Definition: smallstack_type.hpp:136
VehicleCargoList::ShiftCargo
void ShiftCargo(Taction action)
Shifts cargo from the front of the packet list and applies some action to it.
Definition: cargopacket.cpp:285
SmallStack::Pop
Titem Pop()
Pop an item from the stack.
Definition: smallstack_type.hpp:213
VehicleCargoList::Unload
uint Unload(uint max_move, StationCargoList *dest, CargoPayment *payment)
Unloads cargo at the given station.
Definition: cargopacket.cpp:632
OUFB_UNLOAD
@ OUFB_UNLOAD
Force unloading all cargo onto the platform, possibly not getting paid.
Definition: order_type.h:54
CargoList< VehicleCargoList, CargoPacketList >::MoveToAction
MoveToAction
Kind of actions that could be done with packets on move.
Definition: cargopacket.h:213
CargoReservation
Action of reserving cargo from a station to be loaded onto a vehicle.
Definition: cargoaction.h:89
VehicleCargoList::Shift
uint Shift(uint max_move, VehicleCargoList *dest)
Shifts cargo between two vehicles.
Definition: cargopacket.cpp:617
CargoList::OnCleanPool
void OnCleanPool()
Empty the cargo list, but don't free the cargo packets; the cargo packets are cleaned by CargoPacket'...
Definition: cargopacket.cpp:167
VehicleCargoList::Reroute
uint Reroute(uint max_move, VehicleCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge)
Routes packets with station "avoid" as next hop to a different place.
Definition: cargopacket.cpp:669
CargoList::TryMerge
static bool TryMerge(CargoPacket *cp, CargoPacket *icp)
Tries to merge the second packet into the first and return if that was successful.
Definition: cargopacket.cpp:218
VehicleCargoList::Stage
bool Stage(bool accepted, StationID current_station, StationIDStack next_station, uint8 order_flags, const GoodsEntry *ge, CargoPayment *payment)
Stages cargo for unloading.
Definition: cargopacket.cpp:446
OUFB_TRANSFER
@ OUFB_TRANSFER
Transfer all cargo onto the platform.
Definition: order_type.h:55
economy_base.h
CargoPacket::InvalidateAllFrom
static void InvalidateAllFrom(SourceType src_type, SourceID src)
Invalidates (sets source_id to INVALID_SOURCE) all cargo packets from given source.
Definition: cargopacket.cpp:127
StationCargoList::reserved_count
uint reserved_count
Amount of cargo being reserved for loading.
Definition: cargopacket.h:454
CargoPacket::source
StationID source
The station where the cargo came from first.
Definition: cargopacket.h:50
VehicleCargoList::InvalidateCache
void InvalidateCache()
Invalidates the cached data and rebuild it.
Definition: cargopacket.cpp:538
VehicleCargoList::RemoveFromMeta
void RemoveFromMeta(const CargoPacket *cp, MoveToAction action, uint count)
Removes a packet or part of it from the metadata.
Definition: cargopacket.cpp:356
VehicleCargoList::AssertCountConsistency
void AssertCountConsistency() const
Assert that the designation counts add up.
Definition: cargopacket.h:286
TileIndex
The index/ID of a Tile.
Definition: tile_type.h:85
StationCargoList
CargoList that is used for stations.
Definition: cargopacket.h:449
CargoList::~CargoList
~CargoList()
Destroy the cargolist ("frees" all cargo packets).
Definition: cargopacket.cpp:155
CargoReturn
Action of returning previously reserved cargo from the vehicle to the station.
Definition: cargoaction.h:97
RandomRange
static uint32 RandomRange(uint32 limit)
Pick a random number between 0 and limit - 1, inclusive.
Definition: random_func.hpp:81
StationCargoList::Reserve
uint Reserve(uint max_move, VehicleCargoList *dest, TileIndex load_place, StationIDStack next)
Reserves cargo for loading onto the vehicle.
Definition: cargopacket.cpp:823
VehicleCargoList::AddToCache
void AddToCache(const CargoPacket *cp)
Update the cache to reflect adding of this packet.
Definition: cargopacket.cpp:344
CargoPacket::days_in_transit
byte days_in_transit
Amount of days this packet has been in transit.
Definition: cargopacket.h:47
CargoPacket::loaded_at_xy
TileOrStationID loaded_at_xy
Location where this cargo has been loaded into the vehicle.
Definition: cargopacket.h:53
VehicleCargoList
CargoList that is used for vehicles.
Definition: cargopacket.h:269
CargoPacket::Merge
void Merge(CargoPacket *cp)
Merge another packet into this one.
Definition: cargopacket.cpp:104
FlowStat
Flow statistics telling how much flow should be sent along a link.
Definition: station_base.h:33
cargoaction.h
StationCargoList::Reroute
uint Reroute(uint max_move, StationCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge)
Routes packets with station "avoid" as next hop to a different place.
Definition: cargopacket.cpp:860
VehicleCargoReroute
Action of rerouting cargo staged for transfer in a vehicle.
Definition: cargoaction.h:134
SourceID
uint16 SourceID
Contains either industry ID, town ID or company ID (or INVALID_SOURCE)
Definition: cargo_type.h:153
VehicleCargoList::Truncate
uint Truncate(uint max_move=UINT_MAX)
Truncates the cargo in this list to the given amount.
Definition: cargopacket.cpp:654
CargoPacket::source_xy
TileIndex source_xy
The origin of the cargo (first station in feeder chain).
Definition: cargopacket.h:51
VehicleCargoList::AgeCargo
void AgeCargo()
Ages the all cargo in this list.
Definition: cargopacket.cpp:381
VehicleCargoList::feeder_share
Money feeder_share
Cache for the feeder share.
Definition: cargopacket.h:274
VehicleCargoList::AddToMeta
void AddToMeta(const CargoPacket *cp, MoveToAction action)
Adds a packet to the metadata.
Definition: cargopacket.cpp:370
FlowStat::GetShares
const SharesMap * GetShares() const
Get the actual shares as a const pointer so that they can be iterated over.
Definition: station_base.h:89
MultiMap::erase
iterator erase(iterator it)
Erase the value pointed to by an iterator.
Definition: multimap.hpp:302
CargoPayment
Helper class to perform the cargo payment.
Definition: economy_base.h:24
VehicleCargoList::Append
void Append(CargoPacket *cp, MoveToAction action=MTA_KEEP)
Appends the given cargo packet.
Definition: cargopacket.cpp:250
CargoDelivery
Action of final delivery of cargo.
Definition: cargoaction.h:39
CargoPacket::Split
CargoPacket * Split(uint new_size)
Split this packet in two and return the split off part.
Definition: cargopacket.cpp:89
CargoList::InvalidateCache
void InvalidateCache()
Invalidates the cached data and rebuilds it.
Definition: cargopacket.cpp:200
ST_INDUSTRY
@ ST_INDUSTRY
Source/destination is an industry.
Definition: cargo_type.h:148
CargoList< VehicleCargoList, CargoPacketList >::cargo_days_in_transit
uint cargo_days_in_transit
Cache for the sum of number of days in transit of each entity; comparable to man-hours.
Definition: cargopacket.h:225
VehicleCargoList::ChooseAction
static MoveToAction ChooseAction(const CargoPacket *cp, StationID cargo_next, StationID current_station, bool accepted, StationIDStack next_station)
Choose action to be performed with the given cargo packet.
Definition: cargopacket.cpp:419
CargoList< VehicleCargoList, CargoPacketList >::count
uint count
Cache for the number of cargo entities.
Definition: cargopacket.h:224
safeguards.h
CargoPacket::MAX_COUNT
static const uint16 MAX_COUNT
Maximum number of items in a single cargo packet.
Definition: cargopacket.h:65
VehicleCargoList::SetTransferLoadPlace
void SetTransferLoadPlace(TileIndex xy)
Sets loaded_at_xy to the current station for all cargo to be transferred.
Definition: cargopacket.cpp:400
CargoPacket::source_id
SourceID source_id
Index of source, INVALID_SOURCE if unknown/invalid.
Definition: cargopacket.h:49
CargoPacket::AddFeederShare
void AddFeederShare(Money new_share)
Adds some feeder share to the packet.
Definition: cargopacket.h:94
CargoPacket::Count
uint16 Count() const
Gets the number of 'items' in this packet.
Definition: cargopacket.h:100
CargoList< VehicleCargoList, CargoPacketList >::MTA_TRANSFER
@ MTA_TRANSFER
Transfer the cargo to the station.
Definition: cargopacket.h:215
VehicleCargoList::action_counts
uint action_counts[NUM_MOVE_TO_ACTION]
Counts of cargo to be transferred, delivered, kept and loaded.
Definition: cargopacket.h:275
stdafx.h
VehicleCargoList::RemoveFromCache
void RemoveFromCache(const CargoPacket *cp, uint count)
Update the cached values to reflect the removal of this packet or part of it.
Definition: cargopacket.cpp:333
CargoPacket::source_type
SourceType source_type
Type of source_id.
Definition: cargopacket.h:48
CargoPacket::Reduce
void Reduce(uint count)
Reduce the packet by the given amount and remove the feeder share.
Definition: cargopacket.cpp:115
MultiMap::equal_range
std::pair< iterator, iterator > equal_range(const Tkey &key)
Get a pair of iterators specifying a range of items with equal keys.
Definition: multimap.hpp:360
CargoList::RemoveFromCache
void RemoveFromCache(const CargoPacket *cp, uint count)
Update the cached values to reflect the removal of this packet or part of it.
Definition: cargopacket.cpp:179
CargoShift
Action of shifting cargo from one vehicle to another.
Definition: cargoaction.h:106
CargoList< VehicleCargoList, CargoPacketList >::ReverseIterator
CargoPacketList ::reverse_iterator ReverseIterator
The reverse iterator for our container.
Definition: cargopacket.h:206
CargoList< VehicleCargoList, CargoPacketList >::packets
CargoPacketList packets
The cargo packets in this list.
Definition: cargopacket.h:227
CargoList< VehicleCargoList, CargoPacketList >
GoodsEntry
Stores station stats for a single cargo.
Definition: station_base.h:167
CargoPacket::next_station
TileOrStationID next_station
Station where the cargo wants to go next.
Definition: cargopacket.h:54
station_base.h
SourceType
SourceType
Types of cargo source and destination.
Definition: cargo_type.h:147
Pool::PoolItem<&_cargopacket_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:386
Pool
Base class for all pools.
Definition: pool_type.hpp:81
CargoTransfer
Action of transferring cargo from a vehicle to a station.
Definition: cargoaction.h:71
GoodsEntry::flows
FlowStatMap flows
Planned flows through this station.
Definition: station_base.h:256
OUFB_NO_UNLOAD
@ OUFB_NO_UNLOAD
Totally no unloading will be done.
Definition: order_type.h:56
CargoRemoval< VehicleCargoList >
CargoPayment::PayTransfer
Money PayTransfer(const CargoPacket *cp, uint count)
Handle payment for transfer of the given cargo packet.
Definition: economy.cpp:1239
CargoList< VehicleCargoList, CargoPacketList >::MTA_LOAD
@ MTA_LOAD
Load the cargo from the station.
Definition: cargopacket.h:218
CargoPacket::count
uint16 count
The amount of cargo in this packet.
Definition: cargopacket.h:46
Pool::PoolItem<&_cargopacket_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:307
INVALID_SOURCE
static const SourceID INVALID_SOURCE
Invalid/unknown index of source.
Definition: cargo_type.h:154
FlowStat::GetVia
StationID GetVia() const
Get a station a package can be routed to.
Definition: station_base.h:131
BaseStation::xy
TileIndex xy
Base tile of the station.
Definition: base_station_base.h:53
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition: pool_func.hpp:224
StationCargoList::ShiftCargo
bool ShiftCargo(Taction &action, StationID next)
Shifts cargo from the front of the packet list for a specific station and applies some action to it.
Definition: cargopacket.cpp:718
CargoList< VehicleCargoList, CargoPacketList >::Iterator
CargoPacketList ::iterator Iterator
The iterator for our container.
Definition: cargopacket.h:204
CargoPacket
Container for cargo from the same location and time.
Definition: cargopacket.h:43
random_func.hpp
SmallStack::IsEmpty
bool IsEmpty() const
Check if the stack is empty.
Definition: smallstack_type.hpp:244
CargoList< VehicleCargoList, CargoPacketList >::MTA_KEEP
@ MTA_KEEP
Keep the cargo in the vehicle.
Definition: cargopacket.h:217
OverflowSafeInt< int64 >
VehicleCargoList::ActionCount
uint ActionCount(MoveToAction action) const
Returns the amount of cargo designated for a given purpose.
Definition: cargopacket.h:342
VehicleCargoList::Reassign
uint Reassign(uint max_move, TileOrStationID update=INVALID_TILE)
Moves some cargo from one designation to another.
Definition: cargopacket.cpp:557
CargoList< VehicleCargoList, CargoPacketList >::MTA_DELIVER
@ MTA_DELIVER
Deliver the cargo to some town or industry.
Definition: cargopacket.h:216
StationCargoList::Append
void Append(CargoPacket *cp, StationID next)
Appends the given cargo packet to the range of packets with the same next station.
Definition: cargopacket.cpp:690
VehicleCargoList::PopCargo
void PopCargo(Taction action)
Pops cargo from the back of the packet list and applies some action to it.
Definition: cargopacket.cpp:307
pool_func.hpp
CargoPacket::FeederShare
Money FeederShare() const
Gets the amount of money already paid to earlier vehicles in the feeder chain.
Definition: cargopacket.h:110
StationCargoReroute
Action of rerouting cargo in a station.
Definition: cargoaction.h:126
VehicleCargoList::Return
uint Return(uint max_move, StationCargoList *dest, StationID next_station)
Returns reserved cargo to the station and removes it from the cache.
Definition: cargopacket.cpp:604
_cargopacket_pool
CargoPacketPool _cargopacket_pool("CargoPacket")
The actual pool with cargo packets.
order_type.h
StationCargoList::Truncate
uint Truncate(uint max_move=UINT_MAX, StationCargoAmountMap *cargo_per_source=nullptr)
Truncates where each destination loses roughly the same percentage of its cargo.
Definition: cargopacket.cpp:769
SmallStack::Contains
bool Contains(const Titem &item) const
Check if the given item is contained in the stack.
Definition: smallstack_type.hpp:254
FlowStat::ChangeShare
void ChangeShare(StationID st, int flow)
Change share for specified station.
Definition: station_cmd.cpp:4426
CargoPacket::CargoPacket
CargoPacket()
Create a new packet for savegame loading.
Definition: cargopacket.cpp:27
StationCargoList::Load
uint Load(uint max_move, VehicleCargoList *dest, TileIndex load_place, StationIDStack next)
Loads cargo onto a vehicle.
Definition: cargopacket.cpp:840
CargoLoad
Action of loading cargo from a station onto a vehicle.
Definition: cargoaction.h:79
CargoList::AddToCache
void AddToCache(const CargoPacket *cp)
Update the cache to reflect adding of this packet.
Definition: cargopacket.cpp:192