source/libr2c2/vehicletype.cpp

   1 #include <msp/core/maputils.h>
   2 #include <msp/strings/format.h>
   3 #include "vehicletype.h"
   4
   5 using namespace std;
   6 using namespace Msp;
   7
   8 namespace R2C2 {
   9
  10 VehicleType::VehicleType(const ArticleNumber &an):
  11         art_nr(an),
  12         locomotive(false),
  13         swap_direction(false),
  14         length(0),
  15         width(0),
  16         height(0)
  17 { }
  18
  19 unsigned VehicleType::get_max_function() const
  20 {
  21         if(functions.empty())
  22                 return 0;
  23         return (--functions.end())->first;
  24 }
  25
  26 const VehicleType::Axle &VehicleType::get_fixed_axle(unsigned i) const
  27 {
  28         if(i>=axles.size())
  29                 throw out_of_range("VehicleType::get_fixed_axle");
  30         return axles[i];
  31 }
  32
  33 const VehicleType::Bogie &VehicleType::get_bogie(unsigned i) const
  34 {
  35         if(i>=bogies.size())
  36                 throw out_of_range("VehicleType::get_bogie");
  37         return bogies[i];
  38 }
  39
  40 const VehicleType::Axle &VehicleType::get_bogie_axle(unsigned i, unsigned j) const
  41 {
  42         if(i>=bogies.size())
  43                 throw out_of_range("VehicleType::get_bogie_axle");
  44         if(j>=bogies[i].axles.size())
  45                 throw out_of_range("VehicleType::get_bogie_axle");
  46         return bogies[i].axles[j];
  47 }
  48
  49 const VehicleType::Rod &VehicleType::get_rod(unsigned i) const
  50 {
  51         if(i>=rods.size())
  52                 throw out_of_range("VehicleType::get_rod");
  53         return rods[i];
  54 }
  55
  56 float VehicleType::get_front_axle_offset() const
  57 {
  58         float front = length/2;
  59         if(!axles.empty())
  60                 front = axles.front().position;
  61         if(!bogies.empty())
  62         {
  63                 const Bogie &bogie = bogies.front();
  64                 front = max(front, bogie.position+bogie.axles.front().position);
  65         }
  66         return front;
  67 }
  68
  69 float VehicleType::get_back_axle_offset() const
  70 {
  71         float back = -length/2;
  72         if(!axles.empty())
  73                 back = axles.back().position;
  74         if(!bogies.empty())
  75         {
  76                 const Bogie &bogie = bogies.back();
  77                 back = min(back, bogie.position+bogie.axles.back().position);
  78         }
  79         return back;
  80 }
  81
  82
  83 VehicleType::Axle::Axle():
  84         position(0),
  85         wheel_dia(0),
  86         powered(false)
  87 { }
  88
  89
  90 VehicleType::Bogie::Bogie():
  91         position(0),
  92         rotate_object(false)
  93 { }
  94
  95
  96 VehicleType::Rod::Rod():
  97         pivot(BODY),
  98         pivot_index(0),
  99         pivot_index2(0),
 100         limit(ROTATE),
 101         connect_index(-1),
 102         mirror_object(false)
 103 { }
 104
 105
 106 VehicleType::Loader::Loader(VehicleType &vt):
 107         DataFile::ObjectLoader<VehicleType>(vt)
 108 {
 109         add("axle",       &Loader::axle);
 110         add("bogie",      &Loader::bogie);
 111         add("function",   &Loader::function);
 112         add("height",     &Loader::height);
 113         add("length",     &Loader::length);
 114         add("locomotive", &VehicleType::locomotive);
 115         add("name",       &VehicleType::name);
 116         add("object",     &VehicleType::object);
 117         add("rod",        &Loader::rod);
 118         add("swap_direction", &VehicleType::swap_direction);
 119         add("width",      &Loader::width);
 120 }
 121
 122 void VehicleType::Loader::axle()
 123 {
 124         Axle axl;
 125         load_sub(axl);
 126         obj.axles.push_back(axl);
 127 }
 128
 129 void VehicleType::Loader::bogie()
 130 {
 131         Bogie bog;
 132         load_sub(bog);
 133         obj.bogies.push_back(bog);
 134 }
 135
 136 void VehicleType::Loader::function(unsigned i, const string &f)
 137 {
 138         obj.functions[i] = f;
 139 }
 140
 141 void VehicleType::Loader::height(float h)
 142 {
 143         obj.height = h/1000;
 144 }
 145
 146 void VehicleType::Loader::length(float l)
 147 {
 148         obj.length = l/1000;
 149 }
 150
 151 void VehicleType::Loader::rod()
 152 {
 153         Rod rd;
 154         Rod::Loader ldr(rd, rod_tags);
 155         load_sub_with(ldr);
 156         obj.rods.push_back(rd);
 157         if(!ldr.get_tag().empty())
 158                 rod_tags[ldr.get_tag()] = obj.rods.size()-1;
 159         rod_tags["previous"] = obj.rods.size()-1;
 160 }
 161
 162 void VehicleType::Loader::width(float w)
 163 {
 164         obj.width = w/1000;
 165 }
 166
 167
 168 VehicleType::Axle::Loader::Loader(Axle &a):
 169         DataFile::ObjectLoader<Axle>(a)
 170 {
 171         add("object",         &Axle::object);
 172         add("position",       &Loader::position);
 173         add("powered",        &Axle::powered);
 174         add("wheel_diameter", &Loader::wheel_diameter);
 175 }
 176
 177 void VehicleType::Axle::Loader::position(float p)
 178 {
 179         obj.position = p/1000;
 180 }
 181
 182 void VehicleType::Axle::Loader::wheel_diameter(float d)
 183 {
 184         obj.wheel_dia = d/1000;
 185 }
 186
 187
 188 VehicleType::Bogie::Loader::Loader(Bogie &b):
 189         DataFile::ObjectLoader<Bogie>(b)
 190 {
 191         add("axle",          &Loader::axle);
 192         add("object",        &Bogie::object);
 193         add("position",      &Loader::position);
 194         add("rotate_object", &Bogie::rotate_object);
 195 }
 196
 197 void VehicleType::Bogie::Loader::axle()
 198 {
 199         Axle axl;
 200         load_sub(axl);
 201         obj.axles.push_back(axl);
 202 }
 203
 204 void VehicleType::Bogie::Loader::position(float p)
 205 {
 206         obj.position = p/1000;
 207 }
 208
 209
 210 VehicleType::Rod::Loader::Loader(Rod &r, const map<string, unsigned> &t):
 211         DataFile::ObjectLoader<Rod>(r),
 212         tags(t)
 213 {
 214         add("connect",       &Loader::connect);
 215         add("limit",         &Rod::limit);
 216         add("mirror_object", &Rod::mirror_object);
 217         add("object",        &Rod::object);
 218         add("pivot_body",    &Loader::pivot_body);
 219         add("pivot_axle",    &Loader::pivot_axle);
 220         add("pivot_axle",    &Loader::pivot_bogie_axle);
 221         add("pivot_rod",     &Loader::pivot_rod);
 222         add("position",      &Loader::position);
 223         add("tag",           &Loader::set_tag);
 224 }
 225
 226 void VehicleType::Rod::Loader::connect(const string &t, float px, float pz, float ox, float oz)
 227 {
 228         obj.connect_index = get_item(tags, t);
 229         obj.connect_point = Vector(px/1000, 0, pz/1000);
 230         obj.connect_offset = Vector(ox/1000, 0, oz/1000);
 231 }
 232
 233 void VehicleType::Rod::Loader::pivot_body()
 234 {
 235         obj.pivot = BODY;
 236 }
 237
 238 void VehicleType::Rod::Loader::pivot_axle(unsigned i)
 239 {
 240         obj.pivot = AXLE;
 241         obj.pivot_index = i;
 242 }
 243
 244 void VehicleType::Rod::Loader::pivot_bogie_axle(unsigned i, unsigned j)
 245 {
 246         obj.pivot = BOGIE_AXLE;
 247         obj.pivot_index = i;
 248         obj.pivot_index2 = j;
 249 }
 250
 251 void VehicleType::Rod::Loader::pivot_rod(const string &t)
 252 {
 253         obj.pivot_index = get_item(tags, t);
 254         obj.pivot = ROD;
 255 }
 256
 257 void VehicleType::Rod::Loader::position(float x, float y, float z)
 258 {
 259         obj.pivot_point = Vector(x/1000, y/1000, z/1000);
 260 }
 261
 262 void VehicleType::Rod::Loader::set_tag(const string &t)
 263 {
 264         tag = t;
 265 }
 266
 267
 268 void operator>>(const LexicalConverter &c, VehicleType::Rod::Limit &l)
 269 {
 270         const string &s = c.get();
 271         if(s=="FIXED")
 272                 l = VehicleType::Rod::FIXED;
 273         else if(s=="ROTATE")
 274                 l = VehicleType::Rod::ROTATE;
 275         else if(s=="SLIDE_X")
 276                 l = VehicleType::Rod::SLIDE_X;
 277         else
 278                 throw lexical_error(format("conversion of '%s' to Rod::Limit", s));
 279 }
 280
 281 } // namespace R2C2