Merge pull request #79457 from PatrikLundell/vehicle

Start to make vehicle coordinates make sense

src/activity_item_handling.cpp

@@ -589,8 +589,8 @@ static bool vehicle_activity( Character &you, const tripoint_bub_ms &src_loc, in
     // so , NPCs can remove the last part on a position, then there is no vehicle there anymore,
     // for someone else who stored that position at the start of their activity.
     // so we may need to go looking a bit further afield to find it , at activities end.
-    for( const tripoint_bub_ms &pt : veh->get_points( true ) ) {
-        you.activity.coord_set.insert( here.get_abs( pt ) );
+    for( const tripoint_abs_ms &pt : veh->get_points( true ) ) {
+        you.activity.coord_set.insert( pt );
     }
     // values[0]
     you.activity.values.push_back( here.get_abs( src_loc ).x() );

src/avatar.cpp

@@ -688,11 +688,11 @@ void avatar::grab( object_type grab_type_new, const tripoint_rel_ms &grab_point_
         map &m = get_map();
         if( gtype == object_type::VEHICLE ) {
             if( const optional_vpart_position ovp = m.veh_at( pos_bub() + gpoint ) ) {
-                for( const tripoint_bub_ms &target : ovp->vehicle().get_points() ) {
+                for( const tripoint_abs_ms &target : ovp->vehicle().get_points() ) {
                     if( erase ) {
-                        memorize_clear_decoration( m.get_abs( target ), /* prefix = */ "vp_" );
+                        memorize_clear_decoration( target, /* prefix = */ "vp_" );
                     }
-                    m.memory_cache_dec_set_dirty( target, true );
+                    m.memory_cache_dec_set_dirty( m.get_bub( target ), true );
                 }
             }
         } else if( gtype != object_type::NONE ) {

src/cata_tiles.cpp

@@ -3936,7 +3936,7 @@ bool cata_tiles::draw_vpart( const tripoint_bub_ms &p, lit_level ll, int &height
             avatar &you = get_avatar();
             if( !veh.forward_velocity() && !veh.player_in_control( you )
                 && !( you.get_grab_type() == object_type::VEHICLE
-                      && veh.get_points().count( ( you.pos_bub() + you.grab_point ) ) )
+                      && veh.get_points().count( ( you.pos_abs() + you.grab_point ) ) )
                 && here.memory_cache_dec_is_dirty( p ) ) {
                 you.memorize_decoration( here.get_abs( p ), vd.get_tileset_id(), subtile, rotation );
             }

src/creature.cpp

@@ -228,6 +228,16 @@ void Creature::setpos( map *here, const tripoint_bub_ms &p, bool check_gravity/*
     }
 }
 
+void Creature::setpos( const tripoint_abs_ms &p, bool check_gravity/* = true*/ )
+{
+    const tripoint_abs_ms old_loc = pos_abs();
+    set_pos_abs_only( p );
+    on_move( old_loc );
+    if( check_gravity ) {
+        gravity_check();
+    }
+}
+
 bool Creature::will_be_cramped_in_vehicle_tile( const tripoint_abs_ms &loc ) const
 {
     map &here = get_map();
@@ -668,10 +678,10 @@ bool Creature::sees( const tripoint_bub_ms &t, bool is_avatar, int range_mod ) c
 
 // Helper function to check if potential area of effect of a weapon overlaps vehicle
 // Maybe TODO: If this is too slow, precalculate a bounding box and clip the tested area to it
-static bool overlaps_vehicle( const std::set<tripoint_bub_ms> &veh_area, const tripoint_bub_ms &pos,
+static bool overlaps_vehicle( const std::set<tripoint_abs_ms> &veh_area, const tripoint_abs_ms &pos,
                               const int area )
 {
-    for( const tripoint_bub_ms &tmp : tripoint_range<tripoint_bub_ms>( pos - tripoint( area, area, 0 ),
+    for( const tripoint_abs_ms &tmp : tripoint_range<tripoint_abs_ms>( pos - tripoint( area, area, 0 ),
             pos + tripoint( area - 1, area - 1, 0 ) ) ) {
         if( veh_area.count( tmp ) > 0 ) {
             return true;
@@ -813,7 +823,7 @@ Creature *Creature::auto_find_hostile_target( int range, int &boo_hoo, int area
             continue; // Handle this late so that boo_hoo++ can happen
         }
         // Expensive check for proximity to vehicle
-        if( self_area_iff && overlaps_vehicle( in_veh->get_points(), m->pos_bub(), area ) ) {
+        if( self_area_iff && overlaps_vehicle( in_veh->get_points(), m->pos_abs(), area ) ) {
             continue;
         }
 

src/creature.h

@@ -319,6 +319,7 @@ class Creature : public viewer
         virtual void gravity_check( map *here );
         void setpos( const tripoint_bub_ms &p, bool check_gravity = true );
         void setpos( map *here, const tripoint_bub_ms &p, bool check_gravity = true );
+        void setpos( const tripoint_abs_ms &p, bool check_gravity = true );
 
         /** Checks if the creature fits confortably into a given tile. */
         bool will_be_cramped_in_vehicle_tile( const tripoint_abs_ms &loc ) const;

src/game.cpp

@@ -5912,9 +5912,9 @@ void game::control_vehicle()
     if( veh ) {
         // If we reached here, we gained control of a vehicle.
         // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
-        for( const tripoint_bub_ms &target : veh->get_points() ) {
-            u.memorize_clear_decoration( m.get_abs( target ), "vp_" );
-            m.memory_cache_dec_set_dirty( target, true );
+        for( const tripoint_abs_ms &target : veh->get_points() ) {
+            u.memorize_clear_decoration( target, "vp_" );
+            m.memory_cache_dec_set_dirty( m.get_bub( target ), true );
         }
         veh->is_following = false;
         veh->is_patrolling = false;

src/handle_action.cpp

@@ -760,7 +760,6 @@ static void grab()
         //solid vehicles can't be grabbed while boarded
         const optional_vpart_position vp_boarded = here.veh_at( you.pos_bub() );
         if( vp_boarded ) {
-            const std::set<tripoint_bub_ms> grabbed_veh_points = vp->vehicle().get_points();
             if( &vp_boarded->vehicle() == &vp->vehicle() &&
                 !empty( vp->vehicle().get_avail_parts( VPFLAG_OBSTACLE ) ) ) {
                 add_msg( m_info, _( "You can't move the %s while you're boarding it." ), veh_name );

src/map.cpp

@@ -375,12 +375,12 @@ void map::memory_cache_ter_set_dirty( const tripoint_bub_ms &p, bool value ) con
 void map::memory_clear_vehicle_points( const vehicle &veh ) const
 {
     avatar &player_character = get_avatar();
-    for( const tripoint_bub_ms &p : veh.get_points() ) {
+    for( const tripoint_abs_ms &p : veh.get_points() ) {
         if( !inbounds( p ) ) {
             continue;
         }
-        memory_cache_dec_set_dirty( p, true );
-        player_character.memorize_clear_decoration( get_abs( p ), "vp_" );
+        memory_cache_dec_set_dirty( get_bub( p ), true );
+        player_character.memorize_clear_decoration( p, "vp_" );
     }
 }
 
@@ -602,11 +602,11 @@ std::unique_ptr<vehicle> map::detach_vehicle( vehicle *veh )
     level_cache &ch = get_cache( z );
     for( size_t i = 0; i < current_submap->vehicles.size(); i++ ) {
         if( current_submap->vehicles[i].get() == veh ) {
-            for( const tripoint_bub_ms &pt : veh->get_points() ) {
+            for( const tripoint_abs_ms &pt : veh->get_points() ) {
                 if( inbounds( pt ) ) {
-                    memory_cache_dec_set_dirty( pt, true );
+                    memory_cache_dec_set_dirty( get_bub( pt ), true );
                 }
-                get_avatar().memorize_clear_decoration( get_abs( pt ), "vp_" );
+                get_avatar().memorize_clear_decoration( pt, "vp_" );
             }
             ch.vehicle_list.erase( veh );
             ch.zone_vehicles.erase( veh );
@@ -744,11 +744,12 @@ bool map::vehproceed( VehicleList &vehicle_list )
     return true;
 }
 
+// TODO: Make reality bubble independent.
 static bool sees_veh( const Creature &c, vehicle &veh, bool force_recalc )
 {
-    const auto &veh_points = veh.get_points( force_recalc );
-    return std::any_of( veh_points.begin(), veh_points.end(), [&c]( const tripoint_bub_ms & pt ) {
-        return c.sees( pt );
+    const std::set<tripoint_abs_ms> &veh_points = veh.get_points( force_recalc );
+    return std::any_of( veh_points.begin(), veh_points.end(), [&c]( const tripoint_abs_ms & pt ) {
+        return c.sees( get_map().get_bub( pt ) );
     } );
 }
 
@@ -886,10 +887,11 @@ vehicle *map::move_vehicle( vehicle &veh, const tripoint_rel_ms &dp, const tiler
     if( !vertical && !veh.valid_wheel_config() && !( veh.is_watercraft() && veh.can_float() ) &&
         !veh.is_flying_in_air() && dp.z() == 0 ) {
         veh.velocity -= std::clamp( veh.velocity, -2000, 2000 ); // extra drag
-        for( const tripoint_bub_ms &p : veh.get_points() ) {
-            const ter_id &pter = ter( p );
+        for( const tripoint_abs_ms &p : veh.get_points() ) {
+            const tripoint_bub_ms pos = get_bub( p );
+            const ter_id &pter = ter( pos );
             if( pter == ter_t_dirt || pter == ter_t_grass ) {
-                ter_set( p, ter_t_dirtmound );
+                ter_set( pos, ter_t_dirtmound );
             }
         }
     }
@@ -7136,7 +7138,7 @@ bool map::draw_maptile( const catacurses::window &w, const tripoint_bub_ms &p,
 
         if( !veh->forward_velocity() && !veh->player_in_control( player_character )
             && !( player_character.get_grab_type() == object_type::VEHICLE
-                  && veh->get_points().count( ( player_character.pos_bub() +
+                  && veh->get_points().count( ( player_character.pos_abs() +
                                                 player_character.grab_point ) ) ) ) {
             memory_sym = sym;
         }

src/mapgen.cpp

@@ -7002,13 +7002,14 @@ std::unique_ptr<vehicle> map::add_vehicle_to_map(
              */
             std::unique_ptr<RemovePartHandler> handler_ptr;
             bool did_merge = false;
-            for( const tripoint_bub_ms &map_pos : first_veh->get_points( true ) ) {
-                std::vector<vehicle_part *> parts_to_move = veh_to_add->get_parts_at( map_pos, "",
+            for( const tripoint_abs_ms &map_pos : first_veh->get_points( true ) ) {
+                const tripoint_bub_ms map_bub_pos = get_bub( map_pos ); // TODO: Make usages use this map.
+                std::vector<vehicle_part *> parts_to_move = veh_to_add->get_parts_at( map_bub_pos, "",
                         part_status_flag::any );
                 if( !parts_to_move.empty() ) {
                     // Store target_point by value because first_veh->parts may reallocate
                     // to a different address after install_part()
-                    std::vector<vehicle_part *> first_veh_parts = first_veh->get_parts_at( map_pos, "",
+                    std::vector<vehicle_part *> first_veh_parts = first_veh->get_parts_at( map_bub_pos, "",
                             part_status_flag:: any );
                     // This happens if this location is occupied by a fake part.
                     if( first_veh_parts.empty() || first_veh_parts.front()->is_fake ) {
@@ -7024,7 +7025,7 @@ std::unique_ptr<vehicle> map::add_vehicle_to_map(
                                   veh_to_add->name, veh_to_add->type.str(),
                                   veh_to_add->pos_abs().to_string(),
                                   to_degrees( veh_to_add->turn_dir ),
-                                  map_pos.to_string() );
+                                  map_bub_pos.to_string() );
                     }
                     did_merge = true;
                     const point_rel_ms target_point = first_veh_parts.front()->mount;

src/veh_appliance.cpp

@@ -406,12 +406,11 @@ void veh_app_interact::refill()
         act.targets.push_back( target );
         act.str_values.push_back( pt->info().id.str() );
         const point_rel_ms q = veh->coord_translate( pt->mount );
-        map &here = get_map();
-        for( const tripoint_bub_ms &p : veh->get_points( true ) ) {
-            act.coord_set.insert( here.get_abs( p ) );
+        for( const tripoint_abs_ms &p : veh->get_points( true ) ) {
+            act.coord_set.insert( p );
         }
-        act.values.push_back( here.get_abs( veh->pos_bub() ).x() + q.x() );
-        act.values.push_back( here.get_abs( veh->pos_bub() ).y() + q.y() );
+        act.values.push_back( veh->pos_abs().x() + q.x() );
+        act.values.push_back( veh->pos_abs().y() + q.y() );
         act.values.push_back( a_point.x() );
         act.values.push_back( a_point.y() );
         act.values.push_back( -a_point.x() );
@@ -496,8 +495,8 @@ void veh_app_interact::remove()
     } else if( query_yn( _( "Are you sure you want to take down the %s?" ), veh->name ) ) {
         act = player_activity( ACT_VEHICLE, to_moves<int>( time ), static_cast<int>( 'O' ) );
         act.str_values.push_back( vpinfo.id.str() );
-        for( const tripoint_bub_ms &p : veh->get_points( true ) ) {
-            act.coord_set.insert( here.get_abs( p ) );
+        for( const tripoint_abs_ms &p : veh->get_points( true ) ) {
+            act.coord_set.insert( p );
         }
         const tripoint_abs_ms a_point_abs( here.get_abs( a_point_bub ) );
         act.values.push_back( a_point_abs.x() );

src/veh_interact.cpp

@@ -176,12 +176,11 @@ player_activity veh_interact::serialize_activity()
     // otherwise (e.g. installing a new frame), just use part 0
     const point_rel_ms q = veh->coord_translate( pt ? pt->mount : veh->part( 0 ).mount );
     const vehicle_part *vpt = pt ? pt : &veh->part( 0 );
-    map &here = get_map();
-    for( const tripoint_bub_ms &p : veh->get_points( true ) ) {
-        res.coord_set.insert( here.get_abs( p ) );
+    for( const tripoint_abs_ms &p : veh->get_points( true ) ) {
+        res.coord_set.insert( p );
     }
-    res.values.push_back( here.get_abs( veh->pos_bub() ).x() + q.x() );   // values[0]
-    res.values.push_back( here.get_abs( veh->pos_bub() ).y() + q.y() );   // values[1]
+    res.values.push_back( veh->pos_abs().x() + q.x() );   // values[0]
+    res.values.push_back( veh->pos_abs().y() + q.y() );   // values[1]
     res.values.push_back( dd.x() );   // values[2]
     res.values.push_back( dd.y() );   // values[3]
     res.values.push_back( -dd.x() );   // values[4]

src/vehicle.cpp

@@ -3522,6 +3522,16 @@ tripoint_bub_ms vehicle::bub_part_pos( const vehicle_part &pt ) const
     return pos_bub() + pt.precalc[ 0 ];
 }
 
+tripoint_abs_ms vehicle::abs_part_pos( const int index ) const
+{
+    return abs_part_pos( parts[index] );
+}
+
+tripoint_abs_ms vehicle::abs_part_pos( const vehicle_part &pt ) const
+{
+    return pos_abs() + pt.precalc[0];
+}
+
 void vehicle::set_submap_moved( const tripoint_bub_sm &p )
 {
     const point_abs_ms old_msp = pos_abs().xy();
@@ -6613,7 +6623,7 @@ void vehicle::refresh( const bool remove_fakes )
     zones_dirty = true;
     coeff_air_dirty = true;
     invalidate_mass();
-    occupied_cache_pos = { -1, -1, -1 };
+    occupied_cache_pos = tripoint_abs_ms::invalid;
     refresh_active_item_cache();
 }
 
@@ -7877,19 +7887,19 @@ bool vehicle::restore_folded_parts( const item &it )
     return true;
 }
 
-const std::set<tripoint_bub_ms> &vehicle::get_points( const bool force_refresh,
+const std::set<tripoint_abs_ms> &vehicle::get_points( const bool force_refresh,
         const bool no_fake ) const
 {
-    if( force_refresh || occupied_cache_pos != pos_bub() ||
+    if( force_refresh || occupied_cache_pos != pos_abs() ||
         occupied_cache_direction != face.dir() ) {
-        occupied_cache_pos = pos_bub();
+        occupied_cache_pos = pos_abs();
         occupied_cache_direction = face.dir();
         occupied_points.clear();
         for( const std::pair<const point_rel_ms, std::vector<int>> &part_location : relative_parts ) {
             if( no_fake && part( part_location.second.front() ).is_fake ) {
                 continue;
             }
-            occupied_points.insert( bub_part_pos( part_location.second.front() ) );
+            occupied_points.insert( abs_part_pos( part_location.second.front() ) );
         }
     }
 
@@ -7910,13 +7920,13 @@ void vehicle::part_project_points( const tripoint_rel_ms &dp )
         }
         // Coordinates of where part will go due to movement (dx/dy/dz)
         //  and turning (precalc[1])
-        vp.next_pos = pos_bub() + dp + vp.precalc[1];
+        vp.next_pos = pos_abs() + dp + vp.precalc[1];
     }
 }
 
-std::set<tripoint_bub_ms> vehicle::get_projected_part_points() const
+std::set<tripoint_abs_ms> vehicle::get_projected_part_points() const
 {
-    std::set<tripoint_bub_ms> projected_points;
+    std::set<tripoint_abs_ms> projected_points;
 
     for( int p = 0; p < part_count(); p++ ) {
         const vehicle_part &vp = parts.at( p );
@@ -8242,18 +8252,21 @@ bounding_box vehicle::get_bounding_box( bool use_precalc, bool no_fake )
 
     precalc_mounts( 0, turn_dir, point_rel_ms::zero );
 
-    for( const tripoint_bub_ms &p : get_points( true, no_fake ) ) {
+    for( const tripoint_abs_ms &p : get_points( true, no_fake ) ) {
         point_rel_ms pt;
         if( use_precalc ) {
             const int i_use = 0;
             // TODO: Check if this is correct. part_at takes a vehicle relative position, not a bub one...
-            int part_idx = part_at( rebase_rel( p.xy() ) );
+            // int part_idx = part_at((p - pos_abs()).xy()); // Suggested correction.
+            int part_idx = part_at( rebase_rel( get_map().get_bub( p ).xy() ) );
             if( part_idx < 0 ) {
                 continue;
             }
             pt = parts[part_idx].precalc[i_use].xy();
         } else {
-            pt = rebase_rel( p.xy() );
+            // TODO: Check if this is correct. part_at takes a vehicle relative position, not a bub one...
+            // pt = (p - pos_abs()).xy(); // Suggested correction.
+            pt = rebase_rel( get_map().get_bub( p ).xy() );
         }
         if( pt.x() < min_x ) {
             min_x = pt.x();
@@ -8391,7 +8404,7 @@ std::set<int> vehicle::advance_precalc_mounts( const point_sm_ms &new_pos,
         }
         pos = new_pos;
     }
-    occupied_cache_pos = { -1, -1, -1 };
+    occupied_cache_pos = tripoint_abs_ms::invalid;
     return smzs;
 }