source/network/train.cpp

   1 #include "client.h"
   2 #include "train.h"
   3
   4 using namespace std;
   5
   6 namespace R2C2 {
   7
   8 NetTrain::NetTrain(Client &c, const TrainInfoPacket &pkt):
   9         client(c),
  10         loco_type(client.get_catalogue().get<VehicleType>(pkt.loco_type)),
  11         address(pkt.address),
  12         name(pkt.name),
  13         target_speed(0),
  14         reverse(false),
  15         functions(0)
  16 { }
  17
  18 void NetTrain::set_control(const string &c, float v)
  19 {
  20         if(v==controls[c])
  21                 return;
  22
  23         TrainControlPacket pkt;
  24         pkt.address = address;
  25         pkt.control = c;
  26         pkt.value = v;
  27         client.send(pkt);
  28 }
  29
  30 float NetTrain::get_control(const string &c) const
  31 {
  32         map<string, float>::const_iterator i = controls.find(c);
  33         return i!=controls.end() ? i->second : 0;
  34 }
  35
  36 void NetTrain::set_target_speed(float s)
  37 {
  38         TrainAIControlPacket pkt;
  39         pkt.address = address;
  40         pkt.target_speed = s;
  41         pkt.reverse = reverse;
  42         client.send(pkt);
  43 }
  44
  45 void NetTrain::set_reverse(bool r)
  46 {
  47         TrainAIControlPacket pkt;
  48         pkt.address = address;
  49         pkt.target_speed = target_speed;
  50         pkt.reverse = r;
  51         client.send(pkt);
  52 }
  53
  54 void NetTrain::set_function(unsigned i, bool set)
  55 {
  56         TrainFunctionPacket pkt;
  57         pkt.address = address;
  58         pkt.functions = functions;
  59         if(set)
  60                 pkt.functions |= 1<<i;
  61         else
  62                 pkt.functions &= ~(1<<i);
  63         client.send(pkt);
  64 }
  65
  66 void NetTrain::set_route(const string &r)
  67 {
  68         if(r==route)
  69                 return;
  70
  71         TrainRoutePacket pkt;
  72         pkt.address = address;
  73         pkt.route = r;
  74         client.send(pkt);
  75 }
  76
  77 void NetTrain::process_packet(const TrainControlPacket &pkt)
  78 {
  79         controls[pkt.control] = pkt.value;
  80         signal_control_changed.emit(pkt.control, pkt.value);
  81 }
  82
  83 void NetTrain::process_packet(const TrainFunctionPacket &pkt)
  84 {
  85         unsigned old_funcs = functions;
  86         functions = pkt.functions;
  87         for(unsigned i=0; i<9; ++i)
  88                 if(((functions^old_funcs)>>i)&1)
  89                         signal_function_changed.emit(i, (functions>>i)&1);
  90 }
  91
  92 void NetTrain::process_packet(const TrainAIControlPacket &pkt)
  93 {
  94         if(pkt.target_speed!=target_speed)
  95         {
  96                 target_speed = pkt.target_speed;
  97                 signal_target_speed_changed.emit(target_speed);
  98         }
  99
 100         if(pkt.reverse!=reverse)
 101         {
 102                 reverse = pkt.reverse;
 103                 signal_reverse_changed.emit(reverse);
 104         }
 105 }
 106
 107 void NetTrain::process_packet(const TrainStatusPacket &pkt)
 108 {
 109         status = pkt.status;
 110         signal_status_changed.emit(status);
 111 }
 112
 113 void NetTrain::process_packet(const TrainRoutePacket &pkt)
 114 {
 115         route = pkt.route;
 116         signal_route_changed.emit(route);
 117 }
 118
 119 } // namespace R2C2