src/tbtr_template_vehicle.cpp

   1 #include "stdafx.h"
   2 #include "company_func.h"
   3 #include "train.h"
   4 #include "command_func.h"
   5 #include "engine_func.h"
   6 #include "vehicle_func.h"
   7 #include "autoreplace_func.h"
   8 #include "autoreplace_gui.h"
   9 #include "group.h"
  10 #include "articulated_vehicles.h"
  11 #include "core/random_func.hpp"
  12 #include "core/pool_type.hpp"
  13 #include "engine_type.h"
  14 #include "group_type.h"
  15 #include "core/pool_func.hpp"
  16
  17 #include "table/strings.h"
  18
  19 #include "newgrf.h"
  20
  21 #include "vehicle_type.h"
  22 #include "vehicle_base.h"
  23 #include "vehicle_func.h"
  24
  25 #include "table/train_cmd.h"
  26
  27
  28 #include "tbtr_template_vehicle.h"
  29
  30 // since doing stuff with sprites
  31 #include "newgrf_spritegroup.h"
  32 #include "newgrf_engine.h"
  33 #include "newgrf_cargo.h"
  34
  35 TemplatePool _template_pool("TemplatePool");
  36 INSTANTIATE_POOL_METHODS(Template)
  37
  38 TemplateReplacementPool _template_replacement_pool("TemplateReplacementPool");
  39 INSTANTIATE_POOL_METHODS(TemplateReplacement)
  40
  41
  42 TemplateVehicle::TemplateVehicle(VehicleType ty, EngineID eid, byte subtypeflag, Owner current_owner)
  43 {
  44         this->type = ty;
  45         this->engine_type = eid;
  46
  47         this->reuse_depot_vehicles = true;
  48         this->keep_remaining_vehicles = true;
  49
  50         this->first = this;
  51         this->next = 0x0;
  52         this->previous = 0x0;
  53         this->owner_b = _current_company;
  54
  55         this->sprite_seq.Set(SPR_IMG_QUERY);
  56         this->image_offset.x = 0;
  57         this->image_offset.y = 0;
  58
  59         this->owner = current_owner;
  60
  61         this->real_consist_length = 0;
  62 }
  63
  64 TemplateVehicle::~TemplateVehicle() {
  65         TemplateVehicle *v = this->Next();
  66         this->SetNext(nullptr);
  67
  68         delete v;
  69 }
  70
  71 /** getting */
  72 void TemplateVehicle::SetNext(TemplateVehicle *v) { this->next = v; }
  73 void TemplateVehicle::SetPrev(TemplateVehicle *v) { this->previous = v; }
  74 void TemplateVehicle::SetFirst(TemplateVehicle *v) { this->first = v; }
  75
  76 TemplateVehicle* TemplateVehicle::GetNextUnit() const
  77 {
  78                 TemplateVehicle *tv = this->Next();
  79                 while ( tv && HasBit(tv->subtype, GVSF_ARTICULATED_PART) ) tv = tv->Next();
  80                 if ( tv && HasBit(tv->subtype, GVSF_MULTIHEADED) && !HasBit(tv->subtype, GVSF_ENGINE) ) tv = tv->Next();
  81                 return tv;
  82 }
  83
  84 TemplateVehicle* TemplateVehicle::GetPrevUnit()
  85 {
  86         TemplateVehicle *tv = this->Prev();
  87         while ( tv && HasBit(tv->subtype, GVSF_ARTICULATED_PART|GVSF_ENGINE) ) tv = tv->Prev();
  88         if ( tv && HasBit(tv->subtype, GVSF_MULTIHEADED|GVSF_ENGINE) ) tv = tv->Prev();
  89         return tv;
  90 }
  91
  92 /** Length()
  93  * @return: length of vehicle, including current part
  94  */
  95 int TemplateVehicle::Length() const
  96 {
  97         int l=1;
  98         const TemplateVehicle *tmp=this;
  99         while ( tmp->Next() ) { tmp=tmp->Next(); l++; }
 100         return l;
 101 }
 102
 103 TemplateReplacement* GetTemplateReplacementByGroupID(GroupID gid)
 104 {
 105         TemplateReplacement *tr;
 106         FOR_ALL_TEMPLATE_REPLACEMENTS(tr) {
 107                 if ( tr->Group() == gid )
 108                         return tr;
 109         }
 110         return 0;
 111 }
 112
 113 bool IssueTemplateReplacement(GroupID gid, TemplateID tid) {
 114
 115         TemplateReplacement *tr = GetTemplateReplacementByGroupID(gid);
 116
 117         if ( tr ) {
 118                 /* Then set the new TemplateVehicle and return */
 119                 tr->SetTemplate(tid);
 120                 return true;
 121         }
 122
 123         else if ( TemplateReplacement::CanAllocateItem() ) {
 124                 tr = new TemplateReplacement(gid, tid);
 125                 return true;
 126         }
 127
 128         else return false;
 129 }
 130
 131 short TemplateVehicle::NumGroupsUsingTemplate() const
 132 {
 133         short amount = 0;
 134         const TemplateReplacement *tr;
 135         FOR_ALL_TEMPLATE_REPLACEMENTS(tr) {
 136                 if ( tr->sel_template == this->index )
 137                         amount++;
 138         }
 139         return amount;
 140 }
 141
 142 short DeleteTemplateReplacementsByGroupID(GroupID g_id)
 143 {
 144         short del_amount = 0;
 145         const TemplateReplacement *tr;
 146         FOR_ALL_TEMPLATE_REPLACEMENTS(tr) {
 147                 if ( tr->group == g_id ) {
 148                         delete tr;
 149                         del_amount++;
 150                 }
 151         }
 152         return del_amount;
 153 }
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189