OpenTTD
group_cmd.cpp
Go to the documentation of this file.
1 /* $Id$ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * 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.
6  * 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.
7  * 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/>.
8  */
9 
12 #include "stdafx.h"
13 #include "cmd_helper.h"
14 #include "command_func.h"
15 #include "train.h"
16 #include "vehiclelist.h"
17 #include "vehicle_func.h"
18 #include "autoreplace_base.h"
19 #include "autoreplace_func.h"
20 #include "string_func.h"
21 #include "company_func.h"
22 #include "core/pool_func.hpp"
23 #include "order_backup.h"
24 
25 #include "table/strings.h"
26 
27 #include "safeguards.h"
28 
29 GroupID _new_group_id;
30 
31 GroupPool _group_pool("Group");
33 
34 GroupStatistics::GroupStatistics()
35 {
36  this->num_engines = CallocT<uint16>(Engine::GetPoolSize());
37 }
38 
39 GroupStatistics::~GroupStatistics()
40 {
41  free(this->num_engines);
42 }
43 
48 {
49  this->num_vehicle = 0;
50  this->num_profit_vehicle = 0;
51  this->profit_last_year = 0;
52 
53  /* This is also called when NewGRF change. So the number of engines might have changed. Reallocate. */
54  free(this->num_engines);
55  this->num_engines = CallocT<uint16>(Engine::GetPoolSize());
56 }
57 
66 {
67  if (Group::IsValidID(id_g)) {
68  Group *g = Group::Get(id_g);
69  assert(g->owner == company);
70  assert(g->vehicle_type == type);
71  return g->statistics;
72  }
73 
74  if (IsDefaultGroupID(id_g)) return Company::Get(company)->group_default[type];
75  if (IsAllGroupID(id_g)) return Company::Get(company)->group_all[type];
76 
77  NOT_REACHED();
78 }
79 
86 {
87  return GroupStatistics::Get(v->owner, v->group_id, v->type);
88 }
89 
96 {
97  return GroupStatistics::Get(v->owner, ALL_GROUP, v->type);
98 }
99 
104 {
105  /* Set up the engine count for all companies */
106  Company *c;
107  FOR_ALL_COMPANIES(c) {
108  for (VehicleType type = VEH_BEGIN; type < VEH_COMPANY_END; type++) {
109  c->group_all[type].Clear();
110  c->group_default[type].Clear();
111  }
112  }
113 
114  /* Recalculate */
115  Group *g;
116  FOR_ALL_GROUPS(g) {
117  g->statistics.Clear();
118  }
119 
120  const Vehicle *v;
121  FOR_ALL_VEHICLES(v) {
122  if (!v->IsEngineCountable()) continue;
123 
126  }
127 
128  FOR_ALL_COMPANIES(c) {
130  }
131 }
132 
138 /* static */ void GroupStatistics::CountVehicle(const Vehicle *v, int delta)
139 {
140  assert(delta == 1 || delta == -1);
141 
144 
145  stats_all.num_vehicle += delta;
146  stats.num_vehicle += delta;
147 
148  if (v->age > VEHICLE_PROFIT_MIN_AGE) {
149  stats_all.num_profit_vehicle += delta;
150  stats_all.profit_last_year += v->GetDisplayProfitLastYear() * delta;
151  stats.num_profit_vehicle += delta;
152  stats.profit_last_year += v->GetDisplayProfitLastYear() * delta;
153  }
154 }
155 
161 /* static */ void GroupStatistics::CountEngine(const Vehicle *v, int delta)
162 {
163  assert(delta == 1 || delta == -1);
166 }
167 
172 {
175 
176  stats_all.num_profit_vehicle++;
177  stats_all.profit_last_year += v->GetDisplayProfitLastYear();
178  stats.num_profit_vehicle++;
180 }
181 
186 {
187  /* Set up the engine count for all companies */
188  Company *c;
189  FOR_ALL_COMPANIES(c) {
190  for (VehicleType type = VEH_BEGIN; type < VEH_COMPANY_END; type++) {
191  c->group_all[type].ClearProfits();
192  c->group_default[type].ClearProfits();
193  }
194  }
195 
196  /* Recalculate */
197  Group *g;
198  FOR_ALL_GROUPS(g) {
199  g->statistics.ClearProfits();
200  }
201 
202  const Vehicle *v;
203  FOR_ALL_VEHICLES(v) {
205  }
206 }
207 
213 {
214  /* Set up the engine count for all companies */
215  Company *c = Company::Get(company);
216  for (VehicleType type = VEH_BEGIN; type < VEH_COMPANY_END; type++) {
217  c->group_all[type].ClearAutoreplace();
218  c->group_default[type].ClearAutoreplace();
219  }
220 
221  /* Recalculate */
222  Group *g;
223  FOR_ALL_GROUPS(g) {
224  if (g->owner != company) continue;
225  g->statistics.ClearAutoreplace();
226  }
227 
228  for (EngineRenewList erl = c->engine_renew_list; erl != nullptr; erl = erl->next) {
229  const Engine *e = Engine::Get(erl->from);
230  GroupStatistics &stats = GroupStatistics::Get(company, erl->group_id, e->type);
231  if (!stats.autoreplace_defined) {
232  stats.autoreplace_defined = true;
233  stats.autoreplace_finished = true;
234  }
235  if (GetGroupNumEngines(company, erl->group_id, erl->from) > 0) stats.autoreplace_finished = false;
236  }
237 }
238 
246 static inline void UpdateNumEngineGroup(const Vehicle *v, GroupID old_g, GroupID new_g)
247 {
248  if (old_g != new_g) {
249  /* Decrease the num engines in the old group */
251 
252  /* Increase the num engines in the new group */
254  }
255 }
256 
257 
258 const Livery *GetParentLivery(const Group *g)
259 {
260  if (g->parent == INVALID_GROUP) {
261  const Company *c = Company::Get(g->owner);
262  return &c->livery[LS_DEFAULT];
263  }
264 
265  const Group *pg = Group::Get(g->parent);
266  return &pg->livery;
267 }
268 
269 
275 {
276  /* Company colour data is indirectly cached. */
277  Vehicle *v;
278  FOR_ALL_VEHICLES(v) {
279  if (v->group_id == g->index && (!v->IsGroundVehicle() || v->IsFrontEngine())) {
280  for (Vehicle *u = v; u != nullptr; u = u->Next()) {
281  u->colourmap = PAL_NONE;
282  u->InvalidateNewGRFCache();
283  }
284  }
285  }
286 
287  Group *cg;
288  FOR_ALL_GROUPS(cg) {
289  if (cg->parent == g->index) {
290  if (!HasBit(cg->livery.in_use, 0)) cg->livery.colour1 = g->livery.colour1;
291  if (!HasBit(cg->livery.in_use, 1)) cg->livery.colour2 = g->livery.colour2;
293  }
294  }
295 }
296 
297 
298 Group::Group(Owner owner)
299 {
300  this->owner = owner;
301  this->folded = false;
302 }
303 
304 Group::~Group()
305 {
306  free(this->name);
307 }
308 
309 
319 CommandCost CmdCreateGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
320 {
321  VehicleType vt = Extract<VehicleType, 0, 3>(p1);
322  if (!IsCompanyBuildableVehicleType(vt)) return CMD_ERROR;
323 
324  if (!Group::CanAllocateItem()) return CMD_ERROR;
325 
326  const Group *pg = Group::GetIfValid(GB(p2, 0, 16));
327  if (pg != nullptr) {
328  if (pg->owner != _current_company) return CMD_ERROR;
329  if (pg->vehicle_type != vt) return CMD_ERROR;
330  }
331 
332  if (flags & DC_EXEC) {
333  Group *g = new Group(_current_company);
334  g->replace_protection = false;
335  g->vehicle_type = vt;
336  g->parent = INVALID_GROUP;
337 
338  if (pg == nullptr) {
340  g->livery.colour1 = c->livery[LS_DEFAULT].colour1;
341  g->livery.colour2 = c->livery[LS_DEFAULT].colour2;
342  } else {
343  g->parent = pg->index;
344  g->livery.colour1 = pg->livery.colour1;
345  g->livery.colour2 = pg->livery.colour2;
346  }
347 
348  _new_group_id = g->index;
349 
352  }
353 
354  return CommandCost();
355 }
356 
357 
368 CommandCost CmdDeleteGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
369 {
370  Group *g = Group::GetIfValid(p1);
371  if (g == nullptr || g->owner != _current_company) return CMD_ERROR;
372 
373  /* Remove all vehicles from the group */
374  DoCommand(0, p1, 0, flags, CMD_REMOVE_ALL_VEHICLES_GROUP);
375 
376  /* Delete sub-groups */
377  Group *gp;
378  FOR_ALL_GROUPS(gp) {
379  if (gp->parent == g->index) {
380  DoCommand(0, gp->index, 0, flags, CMD_DELETE_GROUP);
381  }
382  }
383 
384  if (flags & DC_EXEC) {
385  /* Update backupped orders if needed */
387 
388  /* If we set an autoreplace for the group we delete, remove it. */
390  Company *c;
391  EngineRenew *er;
392 
394  FOR_ALL_ENGINE_RENEWS(er) {
395  if (er->group_id == g->index) RemoveEngineReplacementForCompany(c, er->from, g->index, flags);
396  }
397  }
398 
399  VehicleType vt = g->vehicle_type;
400 
401  /* Delete the Replace Vehicle Windows */
403  delete g;
404 
407  }
408 
409  return CommandCost();
410 }
411 
424 CommandCost CmdAlterGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
425 {
426  Group *g = Group::GetIfValid(GB(p1, 0, 16));
427  if (g == nullptr || g->owner != _current_company) return CMD_ERROR;
428 
429  if (!HasBit(p1, 16)) {
430  /* Rename group */
431  bool reset = StrEmpty(text);
432 
433  if (!reset) {
435  }
436 
437  if (flags & DC_EXEC) {
438  /* Delete the old name */
439  free(g->name);
440  /* Assign the new one */
441  g->name = reset ? nullptr : stredup(text);
442  }
443  } else {
444  /* Set group parent */
445  const Group *pg = Group::GetIfValid(GB(p2, 0, 16));
446 
447  if (pg != nullptr) {
448  if (pg->owner != _current_company) return CMD_ERROR;
449  if (pg->vehicle_type != g->vehicle_type) return CMD_ERROR;
450 
451  /* Ensure request parent isn't child of group.
452  * This is the only place that infinite loops are prevented. */
453  if (GroupIsInGroup(pg->index, g->index)) return_cmd_error(STR_ERROR_GROUP_CAN_T_SET_PARENT_RECURSION);
454  }
455 
456  if (flags & DC_EXEC) {
457  g->parent = (pg == nullptr) ? INVALID_GROUP : pg->index;
459 
460  if (g->livery.in_use == 0) {
461  const Livery *livery = GetParentLivery(g);
462  g->livery.colour1 = livery->colour1;
463  g->livery.colour2 = livery->colour2;
464 
467  }
468  }
469  }
470 
471  if (flags & DC_EXEC) {
475  }
476 
477  return CommandCost();
478 }
479 
480 
486 static void AddVehicleToGroup(Vehicle *v, GroupID new_g)
487 {
489 
490  switch (v->type) {
491  default: NOT_REACHED();
492  case VEH_TRAIN:
493  SetTrainGroupID(Train::From(v), new_g);
494  break;
495 
496  case VEH_ROAD:
497  case VEH_SHIP:
498  case VEH_AIRCRAFT:
499  if (v->IsEngineCountable()) UpdateNumEngineGroup(v, v->group_id, new_g);
500  v->group_id = new_g;
501  for (Vehicle *u = v; u != nullptr; u = u->Next()) {
502  u->colourmap = PAL_NONE;
503  u->InvalidateNewGRFCache();
504  u->UpdateViewport(true);
505  }
506  break;
507  }
508 
510 }
511 
524 CommandCost CmdAddVehicleGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
525 {
526  Vehicle *v = Vehicle::GetIfValid(GB(p2, 0, 20));
527  GroupID new_g = p1;
528 
529  if (v == nullptr || (!Group::IsValidID(new_g) && !IsDefaultGroupID(new_g) && new_g != NEW_GROUP)) return CMD_ERROR;
530 
531  if (Group::IsValidID(new_g)) {
532  Group *g = Group::Get(new_g);
533  if (g->owner != _current_company || g->vehicle_type != v->type) return CMD_ERROR;
534  }
535 
536  if (v->owner != _current_company || !v->IsPrimaryVehicle()) return CMD_ERROR;
537 
538  if (new_g == NEW_GROUP) {
539  /* Create new group. */
540  CommandCost ret = CmdCreateGroup(0, flags, v->type, INVALID_GROUP, nullptr);
541  if (ret.Failed()) return ret;
542 
543  new_g = _new_group_id;
544  }
545 
546  if (flags & DC_EXEC) {
547  AddVehicleToGroup(v, new_g);
548 
549  if (HasBit(p2, 31)) {
550  /* Add vehicles in the shared order list as well. */
551  for (Vehicle *v2 = v->FirstShared(); v2 != nullptr; v2 = v2->NextShared()) {
552  if (v2->group_id != new_g) AddVehicleToGroup(v2, new_g);
553  }
554  }
555 
557 
558  /* Update the Replace Vehicle Windows */
564  }
565 
566  return CommandCost();
567 }
568 
579 CommandCost CmdAddSharedVehicleGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
580 {
581  VehicleType type = Extract<VehicleType, 0, 3>(p2);
582  GroupID id_g = p1;
583  if (!Group::IsValidID(id_g) || !IsCompanyBuildableVehicleType(type)) return CMD_ERROR;
584 
585  if (flags & DC_EXEC) {
586  Vehicle *v;
587 
588  /* Find the first front engine which belong to the group id_g
589  * then add all shared vehicles of this front engine to the group id_g */
590  FOR_ALL_VEHICLES(v) {
591  if (v->type == type && v->IsPrimaryVehicle()) {
592  if (v->group_id != id_g) continue;
593 
594  /* For each shared vehicles add it to the group */
595  for (Vehicle *v2 = v->FirstShared(); v2 != nullptr; v2 = v2->NextShared()) {
596  if (v2->group_id != id_g) DoCommand(tile, id_g, v2->index, flags, CMD_ADD_VEHICLE_GROUP, text);
597  }
598  }
599  }
600 
602  }
603 
604  return CommandCost();
605 }
606 
607 
618 CommandCost CmdRemoveAllVehiclesGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
619 {
620  GroupID old_g = p1;
621  Group *g = Group::GetIfValid(old_g);
622 
623  if (g == nullptr || g->owner != _current_company) return CMD_ERROR;
624 
625  if (flags & DC_EXEC) {
626  Vehicle *v;
627 
628  /* Find each Vehicle that belongs to the group old_g and add it to the default group */
629  FOR_ALL_VEHICLES(v) {
630  if (v->IsPrimaryVehicle()) {
631  if (v->group_id != old_g) continue;
632 
633  /* Add The Vehicle to the default group */
634  DoCommand(tile, DEFAULT_GROUP, v->index, flags, CMD_ADD_VEHICLE_GROUP, text);
635  }
636  }
637 
639  }
640 
641  return CommandCost();
642 }
643 
654 CommandCost CmdSetGroupLivery(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
655 {
656  Group *g = Group::GetIfValid(p1);
657  bool primary = !HasBit(p2, 8);
658  Colours colour = Extract<Colours, 16, 8>(p2);
659 
660  if (g == nullptr || g->owner != _current_company) return CMD_ERROR;
661 
662  if (colour >= COLOUR_END && colour != INVALID_COLOUR) return CMD_ERROR;
663 
664  if (flags & DC_EXEC) {
665  if (primary) {
666  SB(g->livery.in_use, 0, 1, colour != INVALID_COLOUR);
667  if (colour == INVALID_COLOUR) colour = (Colours)GetParentLivery(g)->colour1;
668  g->livery.colour1 = colour;
669  } else {
670  SB(g->livery.in_use, 1, 1, colour != INVALID_COLOUR);
671  if (colour == INVALID_COLOUR) colour = (Colours)GetParentLivery(g)->colour2;
672  g->livery.colour2 = colour;
673  }
674 
677  }
678 
679  return CommandCost();
680 }
681 
687 static void SetGroupReplaceProtection(Group *g, bool protect)
688 {
689  g->replace_protection = protect;
690 
691  Group *pg;
692  FOR_ALL_GROUPS(pg) {
693  if (pg->parent == g->index) SetGroupReplaceProtection(pg, protect);
694  }
695 }
696 
709 CommandCost CmdSetGroupReplaceProtection(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
710 {
711  Group *g = Group::GetIfValid(p1);
712  if (g == nullptr || g->owner != _current_company) return CMD_ERROR;
713 
714  if (flags & DC_EXEC) {
715  if (HasBit(p2, 1)) {
717  } else {
718  g->replace_protection = HasBit(p2, 0);
719  }
720 
723  }
724 
725  return CommandCost();
726 }
727 
734 {
735  if (!v->IsPrimaryVehicle()) return;
736 
737  if (!IsDefaultGroupID(v->group_id)) GroupStatistics::CountVehicle(v, -1);
738 }
739 
740 
748 {
749  if (!Group::IsValidID(new_g) && !IsDefaultGroupID(new_g)) return;
750 
751  assert(v->IsFrontEngine() || IsDefaultGroupID(new_g));
752 
753  for (Vehicle *u = v; u != nullptr; u = u->Next()) {
754  if (u->IsEngineCountable()) UpdateNumEngineGroup(u, u->group_id, new_g);
755 
756  u->group_id = new_g;
757  u->colourmap = PAL_NONE;
758  u->InvalidateNewGRFCache();
759  u->UpdateViewport(true);
760  }
761 
762  /* Update the Replace Vehicle Windows */
765 }
766 
767 
776 {
777  assert(v->IsFrontEngine() || v->IsFreeWagon());
778 
779  GroupID new_g = v->IsFrontEngine() ? v->group_id : (GroupID)DEFAULT_GROUP;
780  for (Vehicle *u = v; u != nullptr; u = u->Next()) {
781  if (u->IsEngineCountable()) UpdateNumEngineGroup(u, u->group_id, new_g);
782 
783  u->group_id = new_g;
784  u->colourmap = PAL_NONE;
785  u->InvalidateNewGRFCache();
786  }
787 
788  /* Update the Replace Vehicle Windows */
791 }
792 
801 uint GetGroupNumEngines(CompanyID company, GroupID id_g, EngineID id_e)
802 {
803  uint count = 0;
804  const Engine *e = Engine::Get(id_e);
805  const Group *g;
806  FOR_ALL_GROUPS(g) {
807  if (g->parent == id_g) count += GetGroupNumEngines(company, g->index, id_e);
808  }
809  return count + GroupStatistics::Get(company, id_g, e->type).num_engines[id_e];
810 }
811 
821 {
822  uint count = 0;
823  const Group *g;
824  FOR_ALL_GROUPS(g) {
825  if (g->parent == id_g) count += GetGroupNumVehicle(company, g->index, type);
826  }
827  return count + GroupStatistics::Get(company, id_g, type).num_vehicle;
828 }
829 
839 {
840  uint count = 0;
841  const Group *g;
842  FOR_ALL_GROUPS(g) {
843  if (g->parent == id_g) count += GetGroupNumProfitVehicle(company, g->index, type);
844  }
845  return count + GroupStatistics::Get(company, id_g, type).num_profit_vehicle;
846 }
847 
857 {
858  Money sum = 0;
859  const Group *g;
860  FOR_ALL_GROUPS(g) {
861  if (g->parent == id_g) sum += GetGroupProfitLastYear(company, g->index, type);
862  }
863  return sum + GroupStatistics::Get(company, id_g, type).profit_last_year;
864 }
865 
866 void RemoveAllGroupsForCompany(const CompanyID company)
867 {
868  Group *g;
869 
870  FOR_ALL_GROUPS(g) {
871  if (company == g->owner) delete g;
872  }
873 }
874 
875 
882 bool GroupIsInGroup(GroupID search, GroupID group)
883 {
884  if (!Group::IsValidID(search)) return search == group;
885 
886  do {
887  if (search == group) return true;
888  search = Group::Get(search)->parent;
889  } while (search != INVALID_GROUP);
890 
891  return false;
892 }
Last company-ownable type.
Definition: vehicle_type.h:31
Owner
Enum for all companies/owners.
Definition: company_type.h:20
static void UpdateAfterLoad()
Update all caches after loading a game, changing NewGRF, etc.
Definition: group_cmd.cpp:103
CommandCost CmdSetGroupLivery(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Set the livery for a vehicle group.
Definition: group_cmd.cpp:654
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:257
bool replace_protection
If set to true, the global autoreplace have no effect on the group.
Definition: group.h:72
The information about a vehicle list.
Definition: vehiclelist.h:31
Owner owner
Group Owner.
Definition: group.h:69
static const int VEHICLE_PROFIT_MIN_AGE
Only vehicles older than this have a meaningful profit.
Definition: vehicle_func.h:29
VehicleType vehicle_type
Vehicle type of the group.
Definition: group.h:70
GroupStatistics statistics
NOSAVE: Statistics and caches on the vehicles in the group.
Definition: group.h:74
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3199
static void AddVehicleToGroup(Vehicle *v, GroupID new_g)
Do add a vehicle to a group.
Definition: group_cmd.cpp:486
CommandCost CmdCreateGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Create a new vehicle group.
Definition: group_cmd.cpp:319
Functions and type for generating vehicle lists.
uint GetGroupNumProfitVehicle(CompanyID company, GroupID id_g, VehicleType type)
Get the number of vehicles above profit minimum age in the group with GroupID id_g and its sub-groups...
Definition: group_cmd.cpp:838
Train vehicle type.
Definition: vehicle_type.h:26
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:246
Base for the train class.
CommandCost CmdSetGroupReplaceProtection(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
(Un)set global replace protection from a group
Definition: group_cmd.cpp:709
EngineRenewList engine_renew_list
Engine renewals of this company.
Definition: company_base.h:128
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:25
Ship vehicle type.
Definition: vehicle_type.h:28
Depot view; Window numbers:
Definition: window_type.h:346
void SetTrainGroupID(Train *v, GroupID new_g)
Affect the groupID of a train to new_g.
Definition: group_cmd.cpp:747
void UpdateTrainGroupID(Train *v)
Recalculates the groupID of a train.
Definition: group_cmd.cpp:775
Replace vehicle window; Window numbers:
Definition: window_type.h:213
uint16 * num_engines
Caches the number of engines of each type the company owns.
Definition: group.h:28
VehicleType
Available vehicle types.
Definition: vehicle_type.h:23
Functions related to vehicles.
Vehicle data structure.
Definition: vehicle_base.h:212
Tindex index
Index of this pool item.
Definition: pool_type.hpp:147
Money profit_last_year
Sum of profits for all vehicles.
Definition: group.h:34
Helper functions to extract data from command parameters.
bool autoreplace_finished
Have all autoreplacement finished?
Definition: group.h:31
uint16 num_profit_vehicle
Number of vehicles considered for profit statistics;.
Definition: group.h:33
uint GetGroupNumVehicle(CompanyID company, GroupID id_g, VehicleType type)
Get the number of vehicles in the group with GroupID id_g and its sub-groups.
Definition: group_cmd.cpp:820
static GroupStatistics & GetAllGroup(const Vehicle *v)
Returns the GroupStatistic for the ALL_GROUPO of a vehicle type.
Definition: group_cmd.cpp:95
Common return value for all commands.
Definition: command_type.h:25
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
static T SB(T &x, const uint8 s, const uint8 n, const U d)
Set n bits in x starting at bit s to d.
delete a group
Definition: command_type.h:320
Vehicle * FirstShared() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:675
static const GroupID NEW_GROUP
Sentinel for a to-be-created group.
Definition: group_type.h:17
static void UpdateNumEngineGroup(const Vehicle *v, GroupID old_g, GroupID new_g)
Update the num engines of a groupID.
Definition: group_cmd.cpp:246
static bool IsAllGroupID(GroupID id_g)
Checks if a GroupID stands for all vehicles of a company.
Definition: group.h:95
static const uint MAX_LENGTH_GROUP_NAME_CHARS
The maximum length of a group name in characters including &#39;\0&#39;.
Definition: group_type.h:22
Functions related to low-level strings.
Some methods of Pool are placed here in order to reduce compilation time and binary size...
GroupStatistics group_default[VEH_COMPANY_END]
NOSAVE: Statistics for the DEFAULT_GROUP group.
Definition: company_base.h:131
GroupPool _group_pool("Group")
Pool of groups.
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: vehicle_base.h:433
remove all vehicles from a group
Definition: command_type.h:324
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
Definition: command.cpp:443
static size_t GetPoolSize()
Returns first unused index.
Definition: pool_type.hpp:267
Statistics and caches on the vehicles in a group.
Definition: group.h:26
void PropagateChildLivery(const Group *g)
Propagate a livery change to a group&#39;s children.
Definition: group_cmd.cpp:274
char * name
Group Name.
Definition: group.h:68
DoCommandFlag
List of flags for a command.
Definition: command_type.h:344
T * Next() const
Get next vehicle in the chain.
Definition of base types and functions in a cross-platform compatible way.
void RemoveVehicleFromGroup(const Vehicle *v)
Decrease the num_vehicle variable before delete an front engine from a group.
Definition: group_cmd.cpp:733
A number of safeguards to prevent using unsafe methods.
uint16 GroupID
Type for all group identifiers.
Definition: group_type.h:15
VehicleType type
Vehicle type, ie VEH_ROAD, VEH_TRAIN, etc.
Definition: engine_base.h:42
Information about a particular livery.
Definition: livery.h:80
char * stredup(const char *s, const char *last)
Create a duplicate of the given string.
Definition: string.cpp:138
Vehicle view; Window numbers:
Definition: window_type.h:334
Company colour selection; Window numbers:
Definition: window_type.h:225
GroupStatistics group_all[VEH_COMPANY_END]
NOSAVE: Statistics for the ALL_GROUP group.
Definition: company_base.h:130
Functions related to order backups.
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:883
static GroupStatistics & Get(CompanyID company, GroupID id_g, VehicleType type)
Returns the GroupStatistics for a specific group.
Definition: group_cmd.cpp:65
TileIndex tile
Current tile index.
Definition: vehicle_base.h:230
uint GetGroupNumEngines(CompanyID company, GroupID id_g, EngineID id_e)
Get the number of engines with EngineID id_e in the group with GroupID id_g and its sub-groups...
Definition: group_cmd.cpp:801
static void CountVehicle(const Vehicle *v, int delta)
Update num_vehicle when adding or removing a vehicle.
Definition: group_cmd.cpp:138
static void SetGroupReplaceProtection(Group *g, bool protect)
Set replace protection for a group and its sub-groups.
Definition: group_cmd.cpp:687
static const GroupID INVALID_GROUP
Sentinel for invalid groups.
Definition: group_type.h:20
void Clear()
Clear all caches.
Definition: group_cmd.cpp:47
uint16 num_vehicle
Number of vehicles.
Definition: group.h:27
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:273
CommandCost CmdRemoveAllVehiclesGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Remove all vehicles from a group.
Definition: group_cmd.cpp:618
Money GetGroupProfitLastYear(CompanyID company, GroupID id_g, VehicleType type)
Get last year&#39;s profit for the group with GroupID id_g and its sub-groups.
Definition: group_cmd.cpp:856
bool Failed() const
Did this command fail?
Definition: command_type.h:161
byte colour2
Second colour, for vehicles with 2CC support.
Definition: livery.h:83
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:35
Base class for all pools.
Definition: pool_type.hpp:83
&#39;Train&#39; is either a loco or a wagon.
Definition: train.h:87
bool IsEngineCountable() const
Check if a vehicle is counted in num_engines in each company struct.
Definition: vehicle.cpp:712
Livery livery
Custom colour scheme for vehicles in this group.
Definition: group.h:73
bool GroupIsInGroup(GroupID search, GroupID group)
Test if GroupID group is a descendant of (or is) GroupID search.
Definition: group_cmd.cpp:882
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don&#39;t get linker errors.
Definition: pool_func.hpp:226
void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
Delete a window by its class and window number (if it is open).
Definition: window.cpp:1146
static void UpdateProfits()
Recompute the profits for all groups.
Definition: group_cmd.cpp:185
execute the given command
Definition: command_type.h:346
static const GroupID DEFAULT_GROUP
Ungrouped vehicles are in this group.
Definition: group_type.h:19
Functions related to companies.
CommandCost CmdAlterGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Alter a group.
Definition: group_cmd.cpp:424
add a vehicle to a group
Definition: command_type.h:322
bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Definition: vehicle_base.h:471
GroupID parent
Parent group.
Definition: group.h:78
static bool StrEmpty(const char *s)
Check if a string buffer is empty.
Definition: string_func.h:59
size_t Utf8StringLength(const char *s)
Get the length of an UTF-8 encoded string in number of characters and thus not the number of bytes th...
Definition: string.cpp:312
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:23
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:80
uint32 Pack() const
Pack a VehicleListIdentifier in a single uint32.
Definition: vehiclelist.cpp:23
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:581
bool autoreplace_defined
Are any autoreplace rules set?
Definition: group.h:30
CommandCost CmdDeleteGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Add all vehicles in the given group to the default group and then deletes the group.
Definition: group_cmd.cpp:368
Struct to store engine replacements.
static void UpdateAutoreplace(CompanyID company)
Update autoreplace_defined and autoreplace_finished of all statistics of a company.
Definition: group_cmd.cpp:212
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:54
Maximum number of companies.
Definition: company_type.h:25
static void ClearGroup(GroupID group)
Clear the group of all backups having this group ID.
Group data.
Definition: group.h:67
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function() ...
Definition: pool_type.hpp:216
Vehicle details; Window numbers:
Definition: window_type.h:195
Functions related to commands.
byte in_use
Bit 0 set if this livery should override the default livery first colour, Bit 1 for the second colour...
Definition: livery.h:81
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:235
static void CountEngine(const Vehicle *v, int delta)
Update num_engines when adding/removing an engine.
Definition: group_cmd.cpp:161
static WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition: vehicle_gui.h:93
Aircraft vehicle type.
Definition: vehicle_type.h:29
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: depend.cpp:131
bool IsFreeWagon() const
Check if the vehicle is a free wagon (got no engine in front of it).
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:288
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
CommandCost CmdAddVehicleGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Add a vehicle to a group.
Definition: group_cmd.cpp:524
#define FOR_ALL_VEHICLES(var)
Iterate over all vehicles.
Definition: vehicle_base.h:987
byte colour1
First colour, for all vehicles.
Definition: livery.h:82
CommandCost CmdAddSharedVehicleGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Add all shared vehicles of all vehicles from a group.
Definition: group_cmd.cpp:579
static void VehicleReachedProfitAge(const Vehicle *v)
Add a vehicle to the profit sum of its group.
Definition: group_cmd.cpp:171
Base class for autoreplaces/autorenews.
Vehicle * NextShared() const
Get the next vehicle of the shared vehicle chain.
Definition: vehicle_base.h:663
static CommandCost RemoveEngineReplacementForCompany(Company *c, EngineID engine, GroupID group, DoCommandFlag flags)
Remove an engine replacement for the company.
Functions related to autoreplacing.
Date age
Age in days.
Definition: vehicle_base.h:258
static bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
Definition: vehicle_func.h:91
Money GetDisplayProfitLastYear() const
Gets the profit vehicle had last year.
Definition: vehicle_base.h:572
Road vehicle type.
Definition: vehicle_type.h:27
GroupID group_id
Index of group Pool array.
Definition: vehicle_base.h:326
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3300
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1459
static const GroupID ALL_GROUP
All vehicles are in this group.
Definition: group_type.h:18