Fix a compile error

[r2c2.git] / source / libmarklin / train.cpp

diff --git a/source/libmarklin/train.cpp b/source/libmarklin/train.cpp
index 973cc07e8c5a234c9d0e11094b810585ba693344..efe1a142cb6daefc29162f1a99bd578f55de7f9b 100644 (file)
--- a/source/libmarklin/train.cpp
+++ b/source/libmarklin/train.cpp
@@ -30,6 +30,7 @@ Train::Train(Layout &l, const LocoType &t, unsigned a):
        layout(l),
        loco_type(t),
        address(a),
+       priority(0),
        pending_block(0),
        control(new AIControl(*this, new SimplePhysics)),
        timetable(0),
@@ -81,6 +82,11 @@ void Train::set_name(const string &n)
        signal_name_changed.emit(name);
 }
 
+void Train::set_priority(int p)
+{
+       priority = p;
+}
+
 Vehicle &Train::get_vehicle(unsigned i)
 {
        if(i>=vehicles.size())
@@ -163,8 +169,7 @@ void Train::set_route(const Route *r)
                }
        }
 
-       if(active)
-               reserve_more();
+       reserve_more();
 
        signal_route_changed.emit(route);
 }
@@ -322,10 +327,10 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt)
        float speed = control->get_speed();
        unsigned speed_notch = find_speed(abs(speed));
 
-       if(speed && (speed<0)!=reverse)
+       if(control->get_reverse()!=reverse)
        {
-               driver.set_loco_reverse(address, speed<0);
-               reverse = speed<0;
+               reverse = control->get_reverse();
+               driver.set_loco_reverse(address, reverse);
 
                release_blocks(rsv_blocks);
                reverse_blocks(cur_blocks);
@@ -372,12 +377,60 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt)
        }
        else if(end_of_route)
                set_route(0);
+
+       if(!cur_blocks.empty() && !cur_blocks.front().block->get_sensor_id())
+       {
+               Vehicle &veh = *(reverse ? vehicles.front() : vehicles.back());
+
+               list<BlockRef>::iterator i = cur_blocks.begin();
+               const Block::Endpoint &bep = i->block->get_endpoints()[i->entry];
+
+               Track *track = bep.track;
+               unsigned entry = bep.track_ep;
+
+               bool found = false;
+               float dist = veh.get_offset()-veh.get_type().get_length()/2;
+               while(1)
+               {
+                       if(track==veh.get_track())
+                       {
+                               found = true;
+                               break;
+                       }
+
+                       if(i!=cur_blocks.begin())
+                       {
+                               float path_len = track->get_type().get_path_length(track->get_active_path());
+                               dist += path_len;
+                       }
+
+                       unsigned exit = track->traverse(entry);
+                       Track *next = track->get_link(exit);
+                       entry = next->get_endpoint_by_link(*track);
+                       track = next;
+
+                       if(!i->block->get_tracks().count(track))
+                       {
+                               ++i;
+                               if(i==cur_blocks.end())
+                                       break;
+                       }
+               }
+
+               if(found && i!=cur_blocks.begin() && dist>10*layout.get_catalogue().get_scale())
+               {
+                       cur_blocks.front().block->reserve(0);
+                       cur_blocks.erase(cur_blocks.begin());
+               }
+       }
 }
 
 void Train::save(list<DataFile::Statement> &st) const
 {
        st.push_back((DataFile::Statement("name"), name));
 
+       st.push_back((DataFile::Statement("priority"), priority));
+
        for(vector<Vehicle *>::const_iterator i=vehicles.begin(); i!=vehicles.end(); ++i)
                if(i!=vehicles.begin())
                        st.push_back((DataFile::Statement("vehicle"), (*i)->get_type().get_article_number()));
@@ -470,8 +523,11 @@ void Train::sensor_event(unsigned addr, bool state)
 
                        if(pure_speed)
                        {
-                               RealSpeed &rs = real_speed[current_speed];
-                               rs.add(travel_dist/travel_time_secs, travel_time_secs);
+                               if(current_speed)
+                               {
+                                       RealSpeed &rs = real_speed[current_speed];
+                                       rs.add(travel_dist/travel_time_secs, travel_time_secs);
+                               }
                                set_status(format("Traveling %d kmh", get_travel_speed()));
                        }
 
@@ -539,15 +595,15 @@ void Train::sensor_event(unsigned addr, bool state)
                                if(layout.get_driver().get_sensor(i->block->get_sensor_id()))
                                        break;
                                else
+                               {
                                        end = i;
+                                       ++end;
+                               }
                        }
                
                if(end!=cur_blocks.begin())
-               {
                        // Free blocks up to the last inactive sensor
-                       ++end;
                        release_blocks(cur_blocks, cur_blocks.begin(), end);
-               }
        }
 }
 
@@ -576,6 +632,9 @@ void Train::block_reserved(const Block &block, const Train *train)
 
 unsigned Train::reserve_more()
 {
+       if(!active)
+               return 0;
+
        BlockRef *last = 0;
        if(!rsv_blocks.empty())
                last = &rsv_blocks.back();
@@ -648,19 +707,28 @@ unsigned Train::reserve_more()
                else if(route && route->get_tracks().count(entry_ep.track))
                        cur_route = route;
 
-               if(!link->reserve(this))
+               bool reserved = link->reserve(this);
+               if(!reserved)
                {
-                       // If we found another train and it's not headed straight for us, we can keep the blocks we got
-                       int other_entry = link->get_train()->get_entry_to_block(*link);
-                       if(other_entry<0)
-                               throw LogicError("Block reservation inconsistency");
-                       if(static_cast<unsigned>(entry)!=link->traverse(other_entry))
+                       // Ask a lesser priority train to free the block for us
+                       if(link->get_train()->get_priority()<priority)
+                               if(link->get_train()->free_block(*link))
+                                       reserved = link->reserve(this);
+
+                       if(!reserved)
                        {
-                               good = last;
-                               good_sens = nsens;
+                               // If we found another train and it's not headed straight for us, we can keep the blocks we got
+                               int other_entry = link->get_train()->get_entry_to_block(*link);
+                               if(other_entry<0)
+                                       throw LogicError("Block reservation inconsistency");
+                               if(static_cast<unsigned>(entry)!=link->traverse(other_entry))
+                               {
+                                       good = last;
+                                       good_sens = nsens;
+                               }
+                               pending_block = link;
+                               break;
                        }
-                       pending_block = link;
-                       break;
                }
 
                if(link->get_turnout_id())
@@ -769,7 +837,12 @@ unsigned Train::find_speed(float real) const
        if(!high)
        {
                if(!low)
-                       return 0;
+               {
+                       if(real)
+                               return 3;
+                       else
+                               return 0;
+               }
                return min(static_cast<unsigned>(low*real/real_speed[low].speed), 14U);
        }
 
@@ -851,6 +924,7 @@ Train::Loader::Loader(Train &t):
        add("block",       &Loader::block);
        add("block_hint",  &Loader::block_hint);
        add("name",        &Loader::name);
+       add("priority",    &Train::priority);
        add("real_speed",  &Loader::real_speed);
        add("route",       &Loader::route);
        add("timetable",   &Loader::timetable);