diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt
index 85e2b14901..56180e96e8 100644
--- a/engine/CMakeLists.txt
+++ b/engine/CMakeLists.txt
@@ -493,6 +493,7 @@ SET(LIBCOMPONENT
     src/components/drive_upgrade.cpp
     src/components/ftl_drive.cpp
     src/components/jump_drive.cpp
+    src/components/radar.cpp
     )
 
 SET(LIBGUI_SOURCES
diff --git a/engine/src/cmd/ai/aggressive.cpp b/engine/src/cmd/ai/aggressive.cpp
index 1ea679ec4a..4fec005403 100644
--- a/engine/src/cmd/ai/aggressive.cpp
+++ b/engine/src/cmd/ai/aggressive.cpp
@@ -1326,7 +1326,7 @@ static Unit *ChooseNavPoint(Unit *parent, Unit **otherdest, float *lurk_on_arriv
         if (a != b) {
             int retrycount = maxrand;
             while (--retrycount > 0
-                    && (UnitUtil::getDistance(a, b) < parent->GetComputerData().radar.maxrange * 4 || a == b)) {
+                    && (UnitUtil::getDistance(a, b) < parent->radar.GetMaxRange() * 4 || a == b)) {
                 b = GetRandomNav(stats->navs, additionalrand[retrycount]);
             }
             if (retrycount != 0) {
diff --git a/engine/src/cmd/ai/comm_ai.cpp b/engine/src/cmd/ai/comm_ai.cpp
index 90aab335df..4b7a95bf11 100644
--- a/engine/src/cmd/ai/comm_ai.cpp
+++ b/engine/src/cmd/ai/comm_ai.cpp
@@ -364,7 +364,7 @@ Unit *CommunicatingAI::GetRandomUnit(float playaprob, float targprob) {
     }
     //FIXME FOR TESTING ONLY
     //return parent->Target();
-    QVector where = parent->Position() + parent->GetComputerData().radar.maxrange * QVector(vsrandom.uniformInc(-1, 1),
+    QVector where = parent->Position() + parent->radar.GetMaxRange() * QVector(vsrandom.uniformInc(-1, 1),
             vsrandom.uniformInc(-1, 1),
             vsrandom.uniformInc(-1, 1));
     Collidable wherewrapper(0, 0, where);
@@ -393,7 +393,7 @@ void CommunicatingAI::RandomInitiateCommunication(float playaprob, float targpro
     if (target != NULL) {
         if (UnitUtil::getUnitSystemFile(target) == UnitUtil::getUnitSystemFile(parent)
                 && UnitUtil::getFlightgroupName(parent) != "Base" && !isDockedAtAll(target)
-                && UnitUtil::getDistance(parent, target) <= target->GetComputerData().radar.maxrange) {
+                && UnitUtil::getDistance(parent, target) <= target->radar.GetMaxRange()) {
             //warning--odd hack they can talk to you if you can sense them--it's like SETI@home
             for (std::list<CommunicationMessage *>::iterator i = messagequeue.begin(); i != messagequeue.end(); i++) {
                 Unit *un = (*i)->sender.GetUnit();
diff --git a/engine/src/cmd/ai/fire.cpp b/engine/src/cmd/ai/fire.cpp
index 686003b457..53e247027b 100644
--- a/engine/src/cmd/ai/fire.cpp
+++ b/engine/src/cmd/ai/fire.cpp
@@ -39,6 +39,7 @@
 #include "lin_time.h" //DEBUG ONLY
 #include "cmd/pilot.h"
 #include "universe.h"
+#include "unit_util.h"
 
 extern int numprocessed;
 extern double targetpick;
@@ -577,7 +578,7 @@ void FireAt::ChooseTargets(int numtargs, bool force) {
             "Targetting",
             "search_max_candidates",
             "64"));   //Cutoff candidate count (if that many hostiles found, stop search - performance/quality tradeoff, 0=no cutoff)
-    UnitWithinRangeLocator<ChooseTargetClass<2> > unitLocator(parent->GetComputerData().radar.maxrange, unitRad);
+    UnitWithinRangeLocator<ChooseTargetClass<2> > unitLocator(parent->radar.GetMaxRange(), unitRad);
     StaticTuple<float, 2> maxranges{};
 
     maxranges[0] = gunrange;
@@ -629,7 +630,7 @@ void FireAt::ChooseTargets(int numtargs, bool force) {
     for (vector<TurretBin>::iterator k = tbin.begin(); k != tbin.end(); ++k) {
         k->AssignTargets(my_target, parent->cumulative_transformation_matrix);
     }
-    parent->LockTarget(false);
+    parent->radar.Unlock();
     if (wasnull) {
         if (mytarg) {
             nextframenumpollers[hastarg] += 2;
@@ -657,7 +658,7 @@ void FireAt::ChooseTargets(int numtargs, bool force) {
         }
     }
     parent->Target(mytarg);
-    parent->LockTarget(true);
+    parent->radar.Lock(UnitUtil::isSignificant(parent));
     SignalChosenTarget();
 }
 
diff --git a/engine/src/cmd/ai/firekeyboard.cpp b/engine/src/cmd/ai/firekeyboard.cpp
index cb72144a65..c54a2e67fa 100644
--- a/engine/src/cmd/ai/firekeyboard.cpp
+++ b/engine/src/cmd/ai/firekeyboard.cpp
@@ -58,6 +58,7 @@
 #include "mount_size.h"
 #include "weapon_info.h"
 #include "vs_logging.h"
+#include "unit_util.h"
 
 extern bool toggle_pause();
 
@@ -1783,7 +1784,7 @@ void FireKeyboard::Execute() {
     }
     if (f().lockkey == PRESS) {
         f().lockkey = DOWN;
-        parent->LockTarget(!parent->TargetLocked());
+        parent->radar.ToggleLock();
     }
     if (f().ECMkey == PRESS) {
         f().ECMkey = DOWN;
@@ -1814,7 +1815,7 @@ void FireKeyboard::Execute() {
         f().targetskey = DOWN;
         ChooseTargets(parent, TargSig, false);
         refresh_target = true;
-        parent->LockTarget(true);
+        parent->radar.Lock(UnitUtil::isSignificant(parent));
     }
     if (f().targetukey == PRESS) {
         f().targetukey = DOWN;
@@ -1895,7 +1896,7 @@ void FireKeyboard::Execute() {
         f().rtargetskey = DOWN;
         ChooseTargets(parent, TargSig, true);
         refresh_target = true;
-        parent->LockTarget(true);
+        parent->radar.Lock(UnitUtil::isSignificant(parent));
     }
     if (f().rtargetukey == PRESS) {
         f().rtargetukey = DOWN;
@@ -2033,7 +2034,7 @@ void FireKeyboard::Execute() {
     }
     if (f().toggleautotracking == PRESS) {
         f().toggleautotracking = DOWN;
-        parent->GetComputerData().radar.trackingactive = !parent->GetComputerData().radar.trackingactive;
+        parent->radar.ToggleTracking();
     }
     if (f().misk == PRESS || f().rmisk == PRESS) {
         bool forward;
@@ -2059,7 +2060,7 @@ void FireKeyboard::Execute() {
             f().saveTargetKeys[i] = RELEASE;
             savedTargets[i] = parent->Target();
         }
-        if (f().restoreTargetKeys[i] == PRESS && parent->GetComputerData().radar.canlock) {
+        if (f().restoreTargetKeys[i] == PRESS && parent->radar.CanLock()) {
             f().restoreTargetKeys[i] = RELEASE;
             Unit *un;
             for (un_iter u = _Universe->activeStarSystem()->getUnitList().createIterator();
diff --git a/engine/src/cmd/armed.cpp b/engine/src/cmd/armed.cpp
index d70b506d52..afc3f69fb7 100644
--- a/engine/src/cmd/armed.cpp
+++ b/engine/src/cmd/armed.cpp
@@ -325,13 +325,7 @@ int Armed::LockMissile() const {
     return missilelock ? 1 : (dumblock ? -1 : 0);
 }
 
-void Armed::LockTarget(bool myboo) {
-    Unit *unit = static_cast<Unit *>(this);
-    unit->computer.radar.locked = myboo;
-    if (myboo && unit->computer.radar.canlock == false && false == UnitUtil::isSignificant(unit->Target())) {
-        unit->computer.radar.locked = false;
-    }
-}
+
 
 QVector Armed::PositionITTS(const QVector &absposit, Vector velocity, float speed, bool steady_itts) const {
     const Unit *unit = vega_dynamic_cast_ptr<const Unit>(this);
@@ -414,7 +408,7 @@ void Armed::setAverageGunSpeed() {
 
 bool Armed::TargetLocked(const Unit *checktarget) const {
     const Unit *unit = vega_dynamic_cast_ptr<const Unit>(this);
-    if (!unit->computer.radar.locked) {
+    if (!unit->radar.locked) {
         return false;
     }
     return (checktarget == NULL) || (unit->computer.target == checktarget);
@@ -424,19 +418,24 @@ bool Armed::TargetTracked(const Unit *checktarget) {
     Unit *unit = static_cast<Unit *>(this);
     static bool must_lock_to_autotrack = XMLSupport::parse_bool(
             vs_config->getVariable("physics", "must_lock_to_autotrack", "true"));
-    bool we_do_track = unit->computer.radar.trackingactive
+
+    bool we_do_track = unit->radar.tracking_active
             && (!_Universe->isPlayerStarship(unit) || TargetLocked() || !must_lock_to_autotrack);
     if (!we_do_track) {
         return false;
     }
+
     if (checktarget == NULL) {
         return true;
     }
+
     if (unit->computer.target != checktarget) {
         return false;
     }
-    float mycone = unit->computer.radar.trackingcone;
+
+    float mycone = unit->radar.tracking_cone;
     we_do_track = CloseEnoughToAutotrack(unit, unit->computer.target.GetUnit(), mycone);
+
     return we_do_track;
 }
 
@@ -455,7 +454,7 @@ float Armed::TrackingGuns(bool &missilelock) {
     missilelock = false;
     for (int i = 0; i < getNumMounts(); ++i) {
         if (mounts[i].status == Mount::ACTIVE && isAutoTrackingMount(mounts[i].size)) {
-            trackingcone = unit->computer.radar.trackingcone;
+            trackingcone = unit->radar.tracking_cone;
         }
         if (mounts[i].status == Mount::ACTIVE && mounts[i].type->lock_time > 0 && mounts[i].time_to_lock <= 0) {
             missilelock = true;
diff --git a/engine/src/cmd/armed.h b/engine/src/cmd/armed.h
index e7d6054ffa..680710f635 100644
--- a/engine/src/cmd/armed.h
+++ b/engine/src/cmd/armed.h
@@ -62,8 +62,6 @@ class Armed {
     //-1 is no lock necessary 1 is locked
     int LockMissile() const;
 
-    void LockTarget(bool myboo);
-
     //Finds the position from the local position if guns are aimed at it with speed
     QVector PositionITTS(const QVector &firingposit, Vector firingvelocity, float gunspeed, bool smooth_itts) const;
 
diff --git a/engine/src/cmd/computer.cpp b/engine/src/cmd/computer.cpp
index 83d3d5f90e..7ae79f32c7 100644
--- a/engine/src/cmd/computer.cpp
+++ b/engine/src/cmd/computer.cpp
@@ -38,58 +38,4 @@ Computer::Computer() : NavPoint(0, 0, 0),
         combat_mode(true) {
 }
 
-Computer::RADARLIM::RADARLIM() :
-        maxrange(0),
-        maxcone(-1),
-        lockcone(0),
-        trackingcone(0),
-        mintargetsize(0),
-        capability(Capability::IFF_NONE),
-        locked(false),
-        canlock(false),
-        trackingactive(true) {
 
-    maxrange = configuration()->computer_config.default_max_range;
-    trackingcone = configuration()->computer_config.default_tracking_cone;
-    lockcone = configuration()->computer_config.default_lock_cone;
-}
-
-Computer::RADARLIM::Brand::Value Computer::RADARLIM::GetBrand() const {
-    switch (capability & Capability::IFF_UPPER_MASK) {
-        case Capability::IFF_SPHERE:
-            return Brand::SPHERE;
-        case Capability::IFF_BUBBLE:
-            return Brand::BUBBLE;
-        case Capability::IFF_PLANE:
-            return Brand::PLANE;
-        default:
-            assert(false);
-            return Brand::SPHERE;
-    }
-}
-
-bool Computer::RADARLIM::UseFriendFoe() const {
-    // Backwardscompatibility
-    if (capability == 0) {
-        return false;
-    } else if ((capability == 1) || (capability == 2)) {
-        return true;
-    }
-
-    return (capability & Capability::IFF_FRIEND_FOE);
-}
-
-bool Computer::RADARLIM::UseObjectRecognition() const {
-    // Backwardscompatibility
-    if ((capability == 0) || (capability == 1)) {
-        return false;
-    } else if (capability == 2) {
-        return true;
-    }
-
-    return (capability & Capability::IFF_OBJECT_RECOGNITION);
-}
-
-bool Computer::RADARLIM::UseThreatAssessment() const {
-    return (capability & Capability::IFF_THREAT_ASSESSMENT);
-}
diff --git a/engine/src/cmd/computer.h b/engine/src/cmd/computer.h
index f455d96eba..13e1dc9339 100644
--- a/engine/src/cmd/computer.h
+++ b/engine/src/cmd/computer.h
@@ -42,57 +42,6 @@
  */
 class Computer {
 public:
-    class RADARLIM {
-    public:
-        struct Brand {
-            enum Value {
-                SPHERE = 0,
-                BUBBLE = 1,
-                PLANE = 2
-            };
-        };
-        struct Capability {
-            enum Value {
-                // For internal use
-                IFF_UPPER_SHIFT = 16,
-                IFF_LOWER_MASK = (1 << IFF_UPPER_SHIFT) - 1,
-                IFF_UPPER_MASK = ~IFF_LOWER_MASK,
-
-                // The lower 16 bits
-                IFF_NONE = 0,
-                IFF_FRIEND_FOE = 1 << 0,
-                IFF_OBJECT_RECOGNITION = 1 << 1,
-                IFF_THREAT_ASSESSMENT = 1 << 2,
-
-                // The upper 16 bits
-                IFF_SPHERE = Brand::SPHERE << IFF_UPPER_SHIFT,
-                IFF_BUBBLE = Brand::BUBBLE << IFF_UPPER_SHIFT,
-                IFF_PLANE = Brand::PLANE << IFF_UPPER_SHIFT
-            };
-        };
-        //the max range the radar can handle
-        float maxrange;
-        //the dot with (0,0,1) indicating the farthest to the side the radar can handle.
-        float maxcone;
-        float lockcone;
-        float trackingcone;
-        //The minimum radius of the target
-        float mintargetsize;
-        // What kind of type and capability the radar supports
-        int capability;
-        bool locked;
-        bool canlock;
-        bool trackingactive;
-
-        Brand::Value GetBrand() const;
-        bool UseFriendFoe() const;
-        bool UseObjectRecognition() const;
-        bool UseThreatAssessment() const;
-
-        RADARLIM();
-    };
-
-    RADARLIM radar;
     bool ecmactive;
     //The nav point the unit may be heading for
     Vector NavPoint;
diff --git a/engine/src/cmd/drawable.cpp b/engine/src/cmd/drawable.cpp
index 59f601802b..f63d1887ff 100644
--- a/engine/src/cmd/drawable.cpp
+++ b/engine/src/cmd/drawable.cpp
@@ -760,7 +760,7 @@ void Drawable::DrawSubunits(bool on_screen, Matrix wmat, Cloak cloak, float aver
                         (isAutoTrackingMount(unit->mounts[i].size)
                                 && (unit->mounts[i].time_to_lock <= 0)
                                 && unit->TargetTracked()) ? unit->Target() : NULL,
-                        unit->computer.radar.trackingcone);
+                        unit->radar.GetTrackingCone());
             }
         }
 
diff --git a/engine/src/cmd/unit_csv.cpp b/engine/src/cmd/unit_csv.cpp
index f707bbddc6..686747cf77 100644
--- a/engine/src/cmd/unit_csv.cpp
+++ b/engine/src/cmd/unit_csv.cpp
@@ -950,53 +950,8 @@ void Unit::LoadRow(std::string unit_identifier, string modification, bool saved_
     // End Drive Section
 
     computer.itts = UnitCSVFactory::GetVariable(unit_key, "ITTS", true);
-    computer.radar.canlock = UnitCSVFactory::GetVariable(unit_key, "Can_Lock", true);
-
-
-    // The Radar_Color column in the units.csv has been changed from a
-    // boolean value to a string. The boolean values are supported for
-    // backwardscompatibility.
-    // When we save this setting, it is simply converted from an integer
-    // number to a string, and we need to support this as well.
-    std::string iffval = UnitCSVFactory::GetVariable(unit_key, "Radar_Color", std::string());
-
-    if ((iffval.empty()) || (iffval == "FALSE") || (iffval == "0")) {
-        computer.radar.capability = Computer::RADARLIM::Capability::IFF_NONE;
-    } else if ((iffval == "TRUE") || (iffval == "1")) {
-        computer.radar.capability = Computer::RADARLIM::Capability::IFF_SPHERE
-                | Computer::RADARLIM::Capability::IFF_FRIEND_FOE;
-    } else if (iffval == "THREAT") {
-        computer.radar.capability = Computer::RADARLIM::Capability::IFF_SPHERE
-                | Computer::RADARLIM::Capability::IFF_FRIEND_FOE
-                | Computer::RADARLIM::Capability::IFF_THREAT_ASSESSMENT;
-    } else if (iffval == "BUBBLE_THREAT") {
-        computer.radar.capability = Computer::RADARLIM::Capability::IFF_BUBBLE
-                | Computer::RADARLIM::Capability::IFF_FRIEND_FOE
-                | Computer::RADARLIM::Capability::IFF_OBJECT_RECOGNITION
-                | Computer::RADARLIM::Capability::IFF_THREAT_ASSESSMENT;
-    } else if (iffval == "PLANE") {
-        computer.radar.capability = Computer::RADARLIM::Capability::IFF_PLANE
-                | Computer::RADARLIM::Capability::IFF_FRIEND_FOE;
-    } else if (iffval == "PLANE_THREAT") {
-        computer.radar.capability
-                = Computer::RADARLIM::Capability::IFF_PLANE
-                | Computer::RADARLIM::Capability::IFF_FRIEND_FOE
-                | Computer::RADARLIM::Capability::IFF_OBJECT_RECOGNITION
-                | Computer::RADARLIM::Capability::IFF_THREAT_ASSESSMENT;
-    } else {
-        unsigned int value = stoi(iffval, 0);
-        if (value == 0) {
-            // Unknown value
-            computer.radar.capability = Computer::RADARLIM::Capability::IFF_NONE;
-        } else {
-            computer.radar.capability = value;
-        }
-    }
 
-    computer.radar.maxrange = UnitCSVFactory::GetVariable(unit_key, "Radar_Range", FLT_MAX);
-    computer.radar.maxcone = cos(UnitCSVFactory::GetVariable(unit_key, "Max_Cone", 180.0f) * M_PI / 180);
-    computer.radar.trackingcone = cos(UnitCSVFactory::GetVariable(unit_key, "Tracking_Cone", 180.0f) * M_PI / 180);
-    computer.radar.lockcone = cos(UnitCSVFactory::GetVariable(unit_key, "Lock_Cone", 180.0f) * M_PI / 180);
+    radar.Load(unit_key);
 
     const static bool warp_energy_for_cloak = configuration()->warp_config.use_warp_energy_for_cloak;
     cloak.SetSource((warp_energy_for_cloak ? &ftl_energy : &energy));
@@ -1348,19 +1303,15 @@ const std::map<std::string, std::string> Unit::UnitToMap() {
     jump_drive.SaveToCSV(unit);
     ftl_drive.SaveToCSV(unit);
 
+    radar.SaveToCSV(unit);
+    cloak.SaveToCSV(unit);
 
     unit["Wormhole"] = tos(forcejump != 0);
     
     
     unit["ITTS"] = tos(computer.itts);
-    unit["Can_Lock"] = tos(computer.radar.canlock);
-    unit["Radar_Color"] = std::to_string(computer.radar.capability);
-    unit["Radar_Range"] = tos(computer.radar.maxrange);
-    unit["Tracking_Cone"] = tos(acos(computer.radar.trackingcone) * 180. / M_PI);
-    unit["Max_Cone"] = tos(acos(computer.radar.maxcone) * 180. / M_PI);
-    unit["Lock_Cone"] = tos(acos(computer.radar.lockcone) * 180. / M_PI);
 
-    cloak.SaveToCSV(unit);
+
     unit["Repair_Droid"] = tos(repair_droid);
     unit["ECM_Rating"] = tos(ecm > 0 ? ecm : -ecm);
     unit["Hud_Functionality"] = WriteHudDamage(this);
diff --git a/engine/src/cmd/unit_generic.cpp b/engine/src/cmd/unit_generic.cpp
index a9383a4ec0..bb97ad9a5d 100644
--- a/engine/src/cmd/unit_generic.cpp
+++ b/engine/src/cmd/unit_generic.cpp
@@ -143,13 +143,13 @@ bool Unit::InRange(const Unit *target, double &mm, bool cone, bool cap, bool loc
     if (this == target || target->cloak.Cloaked()) {
         return false;
     }
-    if (cone && computer.radar.maxcone > -.98) {
+    if (cone && radar.max_cone > -.98) {
         QVector delta(target->Position() - Position());
         mm = delta.Magnitude();
         if ((!lock) || (!TargetLocked(target))) {
             double tempmm = mm - target->rSize();
             if (tempmm > 0.0001) {
-                if ((ToLocalCoordinates(Vector(delta.i, delta.j, delta.k)).k / tempmm) < computer.radar.maxcone
+                if ((ToLocalCoordinates(Vector(delta.i, delta.j, delta.k)).k / tempmm) < radar.max_cone
                         && cone) {
                     return false;
                 }
@@ -159,8 +159,8 @@ bool Unit::InRange(const Unit *target, double &mm, bool cone, bool cap, bool loc
         mm = (target->Position() - Position()).Magnitude();
     }
     //owner==target?!
-    if (((mm - rSize() - target->rSize()) > computer.radar.maxrange)
-            || target->rSize() < computer.radar.mintargetsize) {
+    if (((mm - rSize() - target->rSize()) > radar.max_range)
+            || target->rSize() < radar.GetMinTargetSize()) {
         Flightgroup *fg = target->getFlightgroup();
         if ((target->rSize() < capship_size || (!cap)) && (fg == NULL ? true : fg->name != "Base")) {
             return target->isUnit() == Vega_UnitType::planet;
@@ -1163,41 +1163,16 @@ void Unit::DamageRandSys(float dam, const Vector &vec) {
         } else if (randnum >= .775) {
             computer.itts = false;             //Set the computer to not have an itts
         } else if (randnum >= .7) {
-            // Gradually degrade radar capabilities
-            typedef Computer::RADARLIM::Capability Capability;
-            int &capability = computer.radar.capability;
-            if (capability & Capability::IFF_THREAT_ASSESSMENT) {
-                capability &= ~Capability::IFF_THREAT_ASSESSMENT;
-            } else if (capability & Capability::IFF_OBJECT_RECOGNITION) {
-                capability &= ~Capability::IFF_OBJECT_RECOGNITION;
-            } else if (capability & Capability::IFF_FRIEND_FOE) {
-                capability &= ~Capability::IFF_FRIEND_FOE;
-            }
+            radar.Damage();
         } else if (randnum >= .5) {
             //THIS IS NOT YET SUPPORTED IN NETWORKING
             computer.target = nullptr;             //set the target to NULL
         } else if (randnum >= .4) {
             drive.retro.RandomDamage();
-        } else if (randnum >= .3275) {
-            const float maxdam = configuration()->physics_config.max_radar_cone_damage;
-            computer.radar.maxcone += (1 - dam);
-            if (computer.radar.maxcone > maxdam) {
-                computer.radar.maxcone = maxdam;
-            }
-        } else if (randnum >= .325) {
-            const float maxdam = configuration()->physics_config.max_radar_lock_cone_damage;
-            computer.radar.lockcone += (1 - dam);
-            if (computer.radar.lockcone > maxdam) {
-                computer.radar.lockcone = maxdam;
-            }
         } else if (randnum >= .25) {
-            const float maxdam = configuration()->physics_config.max_radar_track_cone_damage;
-            computer.radar.trackingcone += (1 - dam);
-            if (computer.radar.trackingcone > maxdam) {
-                computer.radar.trackingcone = maxdam;
-            }
+            radar.Damage();
         } else if (randnum >= .175) {
-            computer.radar.maxrange *= dam;
+            radar.Damage();
         } else {
             int which = rand() % (1 + UnitImages<void>::NUMGAUGES + MAXVDUS);
             pImage->cockpit_damage[which] *= dam;
@@ -1598,7 +1573,7 @@ void Unit::Target(Unit *targ) {
                 }
 
                 computer.target.SetUnit(targ);
-                LockTarget(false);
+                radar.Unlock();
             }
         } else {
             // TODO: this is unclear code. I translated it fully but 
@@ -3083,87 +3058,9 @@ bool Unit::UpAndDownGrade(const Unit *up,
     static float tc = XMLSupport::parse_float(vs_config->getVariable("physics", "autotracking", ".93"));
     static bool use_template_maxrange =
             XMLSupport::parse_bool(vs_config->getVariable("physics", "use_upgrade_template_maxrange", "true"));
-    //Radar stuff
-    if (!csv_cell_null_check || force_change_on_nothing
-            || cell_has_recursive_data(upgrade_name, up->faction,
-                    "Radar_Range|Radar_Color|ITTS|Can_Lock|Max_Cone|Lock_Cone|Tracking_Cone")) {
-        if (!csv_cell_null_check || force_change_on_nothing
-                || cell_has_recursive_data(upgrade_name, up->faction, "Radar_Range")) {
-            STDUPGRADECLAMP(computer.radar.maxrange,
-                    up->computer.radar.maxrange,
-                    use_template_maxrange ? templ->computer.radar.maxrange : FLT_MAX,
-                    0);
-        }
-        if (!csv_cell_null_check || force_change_on_nothing
-                || cell_has_recursive_data(upgrade_name, up->faction, "Radar_Color"))
-            STDUPGRADE(computer.radar.capability, up->computer.radar.capability, templ->computer.radar.capability, 0);
-        if (!csv_cell_null_check || force_change_on_nothing
-                || cell_has_recursive_data(upgrade_name, up->faction, "ITTS")) {
-            computer.itts = UpgradeBoolval(computer.itts,
-                    up->computer.itts,
-                    touchme,
-                    downgrade,
-                    numave,
-                    percentage,
-                    force_change_on_nothing);
-        }
-        if (!csv_cell_null_check || force_change_on_nothing
-                || cell_has_recursive_data(upgrade_name, up->faction, "Can_Lock")) {
-            computer.radar.canlock = UpgradeBoolval(computer.radar.canlock,
-                    up->computer.radar.canlock,
-                    touchme,
-                    downgrade,
-                    numave,
-                    percentage,
-                    force_change_on_nothing);
-        }
-        //Do the two reversed ones below
-        bool ccf = cancompletefully;
-        if (!csv_cell_null_check || force_change_on_nothing
-                || cell_has_recursive_data(upgrade_name, up->faction, "Max_Cone")) {
-            double myleak = 1 - computer.radar.maxcone;
-            double upleak = 1 - up->computer.radar.maxcone;
-            double templeak = 1 - (templ != NULL ? templ->computer.radar.maxcone : -1);
-            STDUPGRADE_SPECIFY_DEFAULTS(myleak, upleak, templeak, 0, 0, 0, false, computer.radar.maxcone);
-            if (touchme) {
-                computer.radar.maxcone = 1 - myleak;
-            }
-        }
-        if (up->computer.radar.lockcone != lc) {
-            double myleak = 1 - computer.radar.lockcone;
-            double upleak = 1 - up->computer.radar.lockcone;
-            double templeak = 1 - (templ != NULL ? templ->computer.radar.lockcone : -1);
-            if (templeak == 1 - lc) {
-                templeak = 2;
-            }
-            if (!csv_cell_null_check || force_change_on_nothing
-                    || cell_has_recursive_data(upgrade_name, up->faction, "Lock_Cone")) {
-                STDUPGRADE_SPECIFY_DEFAULTS(myleak, upleak, templeak, 0, 0, 0, false, computer.radar.lockcone);
-                if (touchme) {
-                    computer.radar.lockcone = 1 - myleak;
-                }
-            }
-        }
-        if (up->computer.radar.trackingcone != tc) {
-            double myleak = 1 - computer.radar.trackingcone;
-            double upleak = 1 - up->computer.radar.trackingcone;
-            double templeak = 1 - (templ != NULL ? templ->computer.radar.trackingcone : -1);
-            if (templeak == 1 - tc) {
-                templeak = 2;
-            }
-            if (!csv_cell_null_check || force_change_on_nothing
-                    || cell_has_recursive_data(upgrade_name, up->faction, "Tracking_Cone")) {
-                STDUPGRADE_SPECIFY_DEFAULTS(myleak, upleak, templeak, 0, 0, 0, false, computer.radar.trackingcone);
-                if (touchme) {
-                    computer.radar.trackingcone = 1 - myleak;
-                }
-            }
-        }
-        cancompletefully = ccf;
-    }
+    
     //NO CLUE FOR BELOW
-    if (downgrade) {
-       
+    if (downgrade) {       
     } else {
         //we are upgrading!
         if (touchme) {
@@ -4197,7 +4094,7 @@ void Unit::UpdatePhysics3(const Transformation &trans,
             Vector TargetPos(InvTransform(cumulative_transformation_matrix, (target->Position())).Cast());
             dist_sqr_to_target = TargetPos.MagnitudeSquared();
             TargetPos.Normalize();
-            if (TargetPos.k > computer.radar.lockcone) {
+            if (TargetPos.k > radar.lock_cone) {
                 increase_locking = true;
             }
         }
@@ -4299,23 +4196,26 @@ void Unit::UpdatePhysics3(const Transformation &trans,
         }
         if (mounts[i].type->type == WEAPON_TYPE::BEAM) {
             if (mounts[i].ref.gun) {
-                Unit *autotarg =
-                        (isAutoTrackingMount(mounts[i].size)
-                                && (mounts[i].time_to_lock <= 0)
-                                && TargetTracked()) ? target : NULL;
-                float trackingcone = computer.radar.trackingcone;
-                if (CloseEnoughToAutotrack(this, target, trackingcone)) {
+                bool autoTrack = isAutoTrackingMount(mounts[i].size);
+                bool timeLocked = mounts[i].time_to_lock <= 0;
+                bool tracked = TargetTracked();
+                Unit *autotarg = (autoTrack && timeLocked && tracked) ? target : nullptr;
+
+                float tracking_cone = radar.tracking_cone;
+                // TODO: fix this or remove
+                /*if (CloseEnoughToAutotrack(this, target, tracking_cone)) {
                     if (autotarg) {
-                        if (computer.radar.trackingcone < trackingcone) {
-                            trackingcone = computer.radar.trackingcone;
+                        if (radar.tracking_cone < tracking_cone) {
+                            tracking_cone = radar.tracking_cone;
                         }
                     }
                     autotarg = target;
-                }
+                }*/
+
                 mounts[i].ref.gun->UpdatePhysics(cumulative_transformation,
                         cumulative_transformation_matrix,
                         autotarg,
-                        trackingcone,
+                        tracking_cone,
                         target,
                         (HeatSink ? HeatSink : 1.0f) * mounts[i].functionality,
                         this,
@@ -4335,11 +4235,11 @@ void Unit::UpdatePhysics3(const Transformation &trans,
                     && TargetTracked()) {
                 autotrack = computer.itts ? 2 : 1;
             }
-            float trackingcone = computer.radar.trackingcone;
-            if (CloseEnoughToAutotrack(this, target, trackingcone)) {
+            float tracking_cone = radar.tracking_cone;
+            if (CloseEnoughToAutotrack(this, target, tracking_cone)) {
                 if (autotrack) {
-                    if (trackingcone > computer.radar.trackingcone) {
-                        trackingcone = computer.radar.trackingcone;
+                    if (tracking_cone > radar.tracking_cone) {
+                        tracking_cone = radar.tracking_cone;
                     }
                 }
                 autotrack = 2;
@@ -4353,7 +4253,7 @@ void Unit::UpdatePhysics3(const Transformation &trans,
             }
             if (!mounts[i].PhysicsAlignedFire(this, t1, m1, cumulative_velocity,
                     (!isSubUnit() || owner == NULL) ? this : owner, target, autotrack,
-                    trackingcone,
+                    tracking_cone,
                     hint)) {
                 const WeaponInfo *typ = mounts[i].type;
                 energy.Charge(static_cast<double>(typ->energy_rate) * (typ->type == WEAPON_TYPE::BEAM ? simulation_atom_var : 1));
diff --git a/engine/src/cmd/unit_generic.h b/engine/src/cmd/unit_generic.h
index dc48ce9d59..6a6cc3fb5d 100644
--- a/engine/src/cmd/unit_generic.h
+++ b/engine/src/cmd/unit_generic.h
@@ -75,6 +75,8 @@ void UncheckUnit( class Unit*un );
 #include "SharedPool.h"
 #include "role_bitmask.h"
 #include "upgradeable_unit.h"
+#include "cloak.h"
+
 
 
 #include "configuration/configuration.h"
@@ -92,6 +94,7 @@ void UncheckUnit( class Unit*un );
 #include "components/drive_upgrade.h"
 #include "components/ftl_drive.h"
 #include "components/jump_drive.h"
+#include "components/radar.h"
 
 extern char *GetUnitDir(const char *filename);
 
@@ -180,6 +183,7 @@ class Unit : public Armed, public Audible, public Drawable, public Damageable, p
     DriveUpgrade drive_upgrade = DriveUpgrade(&drive);
     FtlDrive ftl_drive = FtlDrive(&ftl_energy);
     JumpDrive jump_drive = JumpDrive(&ftl_energy);
+    CRadar radar;
 
     /// Radar and related systems
     // TODO: take a deeper look at this much later...
diff --git a/engine/src/components/afterburner.h b/engine/src/components/afterburner.h
index 06a2eb51e5..f5a1e43266 100644
--- a/engine/src/components/afterburner.h
+++ b/engine/src/components/afterburner.h
@@ -53,6 +53,7 @@ class Afterburner : public Component, public EnergyConsumer {
     void Damage() override;
     void DamageByPercent(double percent) override;
     void Repair() override;
+    // TODO: virtual void Destroy(); and other functions
 };
 
 #endif // VEGA_STRIKE_ENGINE_COMPONENTS_AFTERBURNER_H
diff --git a/engine/src/components/afterburner_upgrade.cpp b/engine/src/components/afterburner_upgrade.cpp
index 6f016a31d2..bba13d8460 100644
--- a/engine/src/components/afterburner_upgrade.cpp
+++ b/engine/src/components/afterburner_upgrade.cpp
@@ -37,14 +37,11 @@ AfterburnerUpgrade::AfterburnerUpgrade(Afterburner *afterburner):
 }
 
 
-
 // Component Methods
 void AfterburnerUpgrade::Load(std::string unit_key) {
-    Component::Load(unit_key);
-
-    thrust = UnitCSVFactory::GetVariable(unit_key, "Afterburner_Accel", 1.0);
-    speed = UnitCSVFactory::GetVariable(unit_key, "Afterburner_Speed_Governor", 1.0);
-    consumption = UnitCSVFactory::GetVariable(unit_key, "Afterburner_Usage_Cost", 1.0);
+    // Not supported with the current file format
+    // Instead, we save the modified Afterburner stats and load the upgrade above.
+    // Then, if we sell the upgrade, we get the original.
 }      
 
 void AfterburnerUpgrade::SaveToCSV(std::map<std::string, std::string>& unit) const {
@@ -104,3 +101,5 @@ bool AfterburnerUpgrade::Upgrade(const std::string upgrade_key) {
     return true;
 }
 
+
+// TODO: deal with damage somehow
\ No newline at end of file
diff --git a/engine/src/components/cloak.h b/engine/src/components/cloak.h
index 05d74bc2b8..24b8cd951d 100644
--- a/engine/src/components/cloak.h
+++ b/engine/src/components/cloak.h
@@ -84,6 +84,8 @@ class Cloak : public Component, public EnergyConsumer
     bool Damaged() const override;
     bool Installed() const override;
 
+// Cloak Methods
+
     void Update();
     void Toggle(); // Toggle cloak on/off
 
diff --git a/engine/src/components/radar.cpp b/engine/src/components/radar.cpp
new file mode 100644
index 0000000000..121a231693
--- /dev/null
+++ b/engine/src/components/radar.cpp
@@ -0,0 +1,249 @@
+/*
+ * radar.cpp
+ *
+ * Copyright (c) 2001-2002 Daniel Horn
+ * Copyright (c) 2002-2019 pyramid3d and other Vega Strike Contributors
+ * Copyright (c) 2019-2023 Stephen G. Tuggy, Benjamen R. Meyer, Roy Falk and other Vega Strike Contributors
+ *
+ * https://github.com/vegastrike/Vega-Strike-Engine-Source
+ *
+ * This file is part of Vega Strike.
+ *
+ * Vega Strike is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Vega Strike is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Vega Strike. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+// -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*-
+
+#include "radar.h"
+#include "configuration/configuration.h"
+#include "unit_csv_factory.h"
+#include "components/component.h"
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+
+CRadar::CRadar():
+        max_range(0),
+        max_cone(-1),
+        lock_cone(0),
+        tracking_cone(0),
+        min_target_size(0),
+        type(RadarType::SPHERE),
+        capabilities(RadarCapabilities::NONE),
+        locked(false),
+        can_lock(false),
+        tracking_active(true) {
+    max_range = configuration()->computer_config.default_max_range;
+    tracking_cone = configuration()->computer_config.default_tracking_cone;
+    lock_cone = configuration()->computer_config.default_lock_cone;
+}
+
+// Component Methods
+void CRadar::Load(std::string unit_key) {
+    Component::Load(unit_key);
+
+    // Consumer
+    // TODO: energy
+    SetConsumption(0);
+
+    // Radar
+    can_lock = UnitCSVFactory::GetVariable(unit_key, "Can_Lock", true);
+
+    // TODO: fix this
+    // The Radar_Color column in the units.csv has been changed from a
+    // boolean value to a string. The boolean values are supported for
+    // backwardscompatibility.
+    // When we save this setting, it is simply converted from an integer
+    // number to a string, and we need to support this as well.
+    std::string iffval = UnitCSVFactory::GetVariable(unit_key, "Radar_Color", std::string());
+
+    if ((iffval.empty()) || (iffval == "FALSE") || (iffval == "0")) {
+        capabilities = RadarCapabilities::NONE;
+    } else if ((iffval == "TRUE") || (iffval == "1")) {
+        type = RadarType::SPHERE;
+        capabilities = RadarCapabilities::FRIEND_FOE;
+    } else if (iffval == "THREAT") {
+        type = RadarType::SPHERE;
+        capabilities = RadarCapabilities::FRIEND_FOE |
+                RadarCapabilities::THREAT_ASSESSMENT;
+    } else if (iffval == "BUBBLE_THREAT") {
+        type = RadarType::BUBBLE;
+        capabilities = RadarCapabilities::FRIEND_FOE |
+                RadarCapabilities::OBJECT_RECOGNITION |
+                RadarCapabilities::THREAT_ASSESSMENT;
+    } else if (iffval == "PLANE") {
+        type = RadarType::PLANE;
+        capabilities = RadarCapabilities::FRIEND_FOE;
+    } else if (iffval == "PLANE_THREAT") {
+        type = RadarType::PLANE;
+        capabilities = RadarCapabilities::FRIEND_FOE |
+                RadarCapabilities::OBJECT_RECOGNITION |
+                RadarCapabilities::THREAT_ASSESSMENT;
+    } else {
+        std::cout << "Try stoi " << unit_key << std::endl;
+        unsigned int value = stoi(iffval, 0);
+        std::cout << "Success stoi " << unit_key << std::endl;
+        if (value == 0) {
+            // Unknown value
+            capabilities = RadarCapabilities::NONE;
+        } else {
+            capabilities = value;
+        }
+    }
+
+    tracking_active = true;
+    max_range = UnitCSVFactory::GetVariable(unit_key, "Radar_Range", 1000000);
+    max_cone = cos(UnitCSVFactory::GetVariable(unit_key, "Max_Cone", 180.0) * M_PI / 180);
+    tracking_cone = cos(UnitCSVFactory::GetVariable(unit_key, "Tracking_Cone", 180.0f) * M_PI / 180);
+    lock_cone = cos(UnitCSVFactory::GetVariable(unit_key, "Lock_Cone", 180.0) * M_PI / 180);
+}      
+
+void CRadar::SaveToCSV(std::map<std::string, std::string>& unit) const {
+    unit["Can_Lock"] = std::to_string(can_lock);
+    unit["Radar_Color"] = std::to_string(capabilities);
+    unit["Radar_Range"] = max_range.Serialize();
+
+    // TODO: can't serialize if also doing acos on it
+    // Also, can't use Resource because games stores in radian
+    // and these can be minus.
+    unit["Tracking_Cone"] = std::to_string(acos(tracking_cone) * 180. / M_PI);
+    unit["Max_Cone"] = std::to_string(acos(max_cone) * 180. / M_PI);
+    unit["Lock_Cone"] = std::to_string(acos(lock_cone) * 180. / M_PI);
+}
+
+bool CRadar::CanDowngrade() const {
+    return false;
+}
+
+bool CRadar::Downgrade() {
+    return false;
+}
+
+bool CRadar::CanUpgrade(const std::string upgrade_key) const {
+    return false;
+}
+
+bool CRadar::Upgrade(const std::string upgrade_key) {
+    return false;
+}
+
+void CRadar::Damage() {
+    max_range.RandomDamage();
+    // max_cone.RandomDamage();
+    // lock_cone.RandomDamage();
+    // tracking_cone.RandomDamage();
+
+    // We calculate percent operational as a simple average
+    operational = max_range.Percent() * 100;
+
+    // Leaving this code here when we move to Resource<double> for max, lock and tracking cones.
+    // operational = (max_range.Percent() + max_cone.Percent() + lock_cone.Percent() +
+    //               tracking_cone.Percent()) / 4 * 100;
+}
+
+void CRadar::DamageByPercent(double percent) {
+    max_range.DamageByPercent(percent);
+    // max_cone.DamageByPercent(percent);
+    // lock_cone.DamageByPercent(percent);
+    // tracking_cone.DamageByPercent(percent);
+
+    // We calculate percent operational as a simple average
+    operational = max_range.Percent() * 100;
+}
+
+void CRadar::Repair() {
+    max_range.RepairFully();
+
+    operational.RepairFully();
+}
+
+void CRadar::Destroy() {
+    max_range.Destroy();
+    operational = 0;
+}
+
+
+// Radar Code
+
+// This code replaces and fixes the old code in Armed::LockTarget(bool)
+void CRadar::Lock(bool always_lock) {
+    if(!can_lock && !always_lock) {
+        this->locked = false;
+        return;
+    }
+
+    this->locked = true;
+}
+
+void CRadar::Unlock() {
+    locked = false;
+}
+
+void CRadar::ToggleLock(bool always_lock) {
+    if(locked) {
+        locked = false;
+        return;
+    }
+
+    Lock(always_lock);
+}
+
+RadarType CRadar::GetType() const {
+    return type;
+}
+
+bool CRadar::UseFriendFoe() const {
+    return (capabilities & RadarCapabilities::FRIEND_FOE);
+}
+
+bool CRadar::UseObjectRecognition() const {
+    return (capabilities & RadarCapabilities::OBJECT_RECOGNITION);
+}
+
+bool CRadar::UseThreatAssessment() const {
+    return (capabilities & RadarCapabilities::THREAT_ASSESSMENT);
+}
+
+float CRadar::GetMaxRange() const { 
+    return max_range.Value(); 
+}
+
+float CRadar::GetMaxCone() const { 
+    return max_cone; 
+}
+
+float CRadar::GetLockCone() const { 
+    return lock_cone; 
+}
+
+float CRadar::GetTrackingCone() const { 
+    return tracking_cone; 
+}
+
+float CRadar::GetMinTargetSize() const { 
+    return min_target_size; 
+}
+
+bool CRadar::Locked() const { 
+    return locked; 
+}
+
+bool CRadar::CanLock() const { 
+    return can_lock; 
+}
+
+bool CRadar::Tracking() const { 
+    return tracking_active; 
+}
\ No newline at end of file
diff --git a/engine/src/components/radar.h b/engine/src/components/radar.h
new file mode 100644
index 0000000000..482a162489
--- /dev/null
+++ b/engine/src/components/radar.h
@@ -0,0 +1,124 @@
+/*
+ * radar.h
+ *
+ * Copyright (c) 2001-2002 Daniel Horn
+ * Copyright (c) 2002-2019 pyramid3d and other Vega Strike Contributors
+ * Copyright (c) 2019-2023 Stephen G. Tuggy, Benjamen R. Meyer, Roy Falk and other Vega Strike Contributors
+ *
+ * https://github.com/vegastrike/Vega-Strike-Engine-Source
+ *
+ * This file is part of Vega Strike.
+ *
+ * Vega Strike is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Vega Strike is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Vega Strike. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+// -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*-
+
+#ifndef VEGA_STRIKE_ENGINE_COMPONENTS_RADAR_H
+#define VEGA_STRIKE_ENGINE_COMPONENTS_RADAR_H
+
+#include <string>
+#include <map>
+#include <memory>
+#include <iostream>
+
+#include "component.h"
+#include "energy_consumer.h"
+
+
+enum class RadarType {
+    SPHERE,
+    BUBBLE,
+    PLANE
+};
+
+enum RadarCapabilities {
+    NONE = 0,
+    FRIEND_FOE = 1,
+    OBJECT_RECOGNITION = 2,
+    THREAT_ASSESSMENT = 4
+};
+
+// Can't call it radar because of namespace collision
+class CRadar : public Component, public EnergyConsumer {
+    // TODO: move floats to doubles
+    //the max range the radar can handle
+    Resource<double> max_range;
+
+    //the dot with (0,0,1) indicating the farthest to the side the radar can handle.
+    // TODO: make this a resource when we move from radian to degrees
+    double max_cone;
+    double lock_cone;
+    double tracking_cone;
+
+    //The minimum radius of the target
+    double min_target_size;
+
+    // What kind of type and capability the radar supports
+    RadarType type;
+    unsigned int capabilities;
+    bool locked;
+    bool can_lock;
+    bool tracking_active;
+
+    friend class Armed;
+    friend class Unit;
+public:
+    CRadar();
+
+// Component Methods
+    void Load(std::string unit_key) override;      
+    
+    void SaveToCSV(std::map<std::string, std::string>& unit) const override;
+
+    bool CanDowngrade() const override;
+
+    bool Downgrade() override;
+
+    bool CanUpgrade(const std::string upgrade_key) const override;
+
+    bool Upgrade(const std::string upgrade_key) override;
+
+    void Damage() override;
+    void DamageByPercent(double percent) override;
+    void Repair() override;
+    void Destroy() override;
+
+// Radar Methods
+
+    // always_lock - override some checks for targets such as planets
+    void Lock(bool always_lock = false);
+    void Unlock();
+    void ToggleLock(bool always_lock = false);
+
+    void Track(const bool track) { tracking_active = track; }
+    void ToggleTracking() { tracking_active = !tracking_active; }
+
+    RadarType GetType() const; // Formerly GetBrand
+    bool UseFriendFoe() const;
+    bool UseObjectRecognition() const;
+    bool UseThreatAssessment() const;
+
+    float GetMaxRange() const;
+    float GetMaxCone() const;
+    float GetLockCone() const;
+    float GetTrackingCone() const;
+    float GetMinTargetSize() const;
+
+    bool Locked() const;
+    bool CanLock() const;
+    bool Tracking() const;
+};
+
+#endif // VEGA_STRIKE_ENGINE_COMPONENTS_RADAR_H
diff --git a/engine/src/components/tests/afterburner_tests.cpp b/engine/src/components/tests/afterburner_tests.cpp
index d7a7ba2ad1..f799f00c97 100644
--- a/engine/src/components/tests/afterburner_tests.cpp
+++ b/engine/src/components/tests/afterburner_tests.cpp
@@ -65,10 +65,11 @@ TEST(Afterburner, Sanity) {
     EXPECT_EQ(afterburner.speed.MaxValue(), 100.0);
     EXPECT_EQ(afterburner.GetConsumption(), 2.0);
 
+    // Disabled. Afterburner_Upgrade does not get saved to file.
     //EXPECT_EQ(upgrade.GetMass(), 5.0);
-    EXPECT_EQ(upgrade.thrust, 1.5);
-    EXPECT_EQ(upgrade.speed, 1.5);
-    EXPECT_EQ(upgrade.consumption, 1.5);
+    // EXPECT_EQ(upgrade.thrust, 1.5);
+    // EXPECT_EQ(upgrade.speed, 1.5);
+    // EXPECT_EQ(upgrade.consumption, 1.5);
 }
 
 TEST(Afterburner, UpgradeDowngrade) {
diff --git a/engine/src/gfx/cockpit.cpp b/engine/src/gfx/cockpit.cpp
index ce85c32d66..c999725418 100644
--- a/engine/src/gfx/cockpit.cpp
+++ b/engine/src/gfx/cockpit.cpp
@@ -2655,26 +2655,29 @@ void GameCockpit::OnPauseEnd() {
 }
 
 void GameCockpit::updateRadar(Unit *ship) {
-    if (ship) {
-        // We may have bought a new radar brand while docked, so the actual
-        // radar display is instantiated when we undock.
-        switch (ship->GetComputerData().radar.GetBrand()) {
-            case Computer::RADARLIM::Brand::BUBBLE:
-                radarDisplay = Radar::Factory(Radar::Type::BubbleDisplay);
-                break;
+    if (!ship) {
+        return;
+    }
 
-            case Computer::RADARLIM::Brand::PLANE:
-                radarDisplay = Radar::Factory(Radar::Type::PlaneDisplay);
-                break;
+    // We may have bought a new radar brand while docked, so the actual
+    // radar display is instantiated when we undock.
+    RadarType type = ship->radar.GetType();
+    Radar::Type::Value displayType = Radar::Type::Value::NullDisplay;
 
-            default:
-                radarDisplay = Radar::Factory(Radar::Type::SphereDisplay);
-                break;
-        }
-        // Send notification that I have undocked
-        radarDisplay->OnDockEnd();
+    if(type == RadarType::BUBBLE) {
+        displayType = Radar::Type::BubbleDisplay;
+    } else if(type == RadarType::PLANE) {
+        displayType = Radar::Type::PlaneDisplay;
+    } else if(type == RadarType::SPHERE) {
+        displayType = Radar::Type::SphereDisplay;
+    }
+
+    if(displayType != Radar::Type::Value::NullDisplay) {
+        radarDisplay = Radar::Factory(displayType);
     }
 
+    // Send notification that I have undocked
+    radarDisplay->OnDockEnd();
 }
 
 void GameCockpit::SetParent(Unit *unit, const char *filename, const char *unitmodname, const QVector &startloc) {
diff --git a/engine/src/gfx/nav/drawsystem.cpp b/engine/src/gfx/nav/drawsystem.cpp
index ce164c5997..bc42afc615 100644
--- a/engine/src/gfx/nav/drawsystem.cpp
+++ b/engine/src/gfx/nav/drawsystem.cpp
@@ -60,6 +60,7 @@
 #include "navscreen.h"
 #include "gfx/masks.h"
 #include "galaxy_gen.h"
+#include "unit_util.h"
 
 //**********************************
 //Main function for drawing a CURRENT system
@@ -438,6 +439,7 @@ void NavigationSystem::DrawSystem() {
     //give back the selected tail IF there is one
     //IF given back, undo the selection state
     //**********************************
+    Unit *current_player = UniverseUtil::getPlayerX(UniverseUtil::getCurrentPlayer());
     if (1 || checkbit(buttonstates, 1)) {
         //button #2 is down, wanting a (selection)
         if (mouselist.get_n_contents() > 0) {
@@ -448,8 +450,8 @@ void NavigationSystem::DrawSystem() {
                 unsetbit(buttonstates, 1);
                 //JUST FOR NOW, target == current selection. later it'll be used for other shit, that will then set target.
                 if (currentselection.GetUnit()) {
-                    (UniverseUtil::getPlayerX(UniverseUtil::getCurrentPlayer()))->Target(currentselection.GetUnit());
-                    (UniverseUtil::getPlayerX(UniverseUtil::getCurrentPlayer()))->LockTarget(currentselection.GetUnit());
+                    current_player->Target(currentselection.GetUnit());
+                    current_player->radar.Lock(UnitUtil::isSignificant(current_player));
                 }
             }
         }
diff --git a/engine/src/gfx/radar/sensor.cpp b/engine/src/gfx/radar/sensor.cpp
index 972477522a..3aeac5890d 100644
--- a/engine/src/gfx/radar/sensor.cpp
+++ b/engine/src/gfx/radar/sensor.cpp
@@ -51,19 +51,19 @@ Unit *Sensor::GetPlayer() const {
 bool Sensor::UseFriendFoe() const {
     assert(player);
 
-    return player->GetComputerData().radar.UseFriendFoe();
+    return player->radar.UseFriendFoe();
 }
 
 bool Sensor::UseObjectRecognition() const {
     assert(player);
 
-    return player->GetComputerData().radar.UseObjectRecognition();
+    return player->radar.UseObjectRecognition();
 }
 
 bool Sensor::UseThreatAssessment() const {
     assert(player);
 
-    return player->GetComputerData().radar.UseThreatAssessment();
+    return player->radar.UseThreatAssessment();
 }
 
 float Sensor::GetCloseRange() const {
@@ -73,19 +73,19 @@ float Sensor::GetCloseRange() const {
 float Sensor::GetMaxRange() const {
     assert(player);
 
-    return player->GetComputerData().radar.maxrange;
+    return player->radar.GetMaxRange();
 }
 
 float Sensor::GetMaxCone() const {
     assert(player);
 
-    return player->GetComputerData().radar.maxcone;
+    return player->radar.GetMaxCone();
 }
 
 float Sensor::GetLockCone() const {
     assert(player);
 
-    return player->GetComputerData().radar.lockcone;
+    return player->radar.GetLockCone();
 }
 
 Track Sensor::CreateTrack(const Unit *target) const {
@@ -154,7 +154,7 @@ class CollectRadarTracks {
             if (!isCurrentTarget &&
                     !draw_significant_blips &&
                     (getTopLevelOwner() == target->owner) &&
-                    (distance > player->GetComputerData().radar.maxrange)) {
+                    (distance > player->radar.GetMaxRange())) {
                 return true;
             }
 
diff --git a/engine/src/gfx/radar/sensor.h b/engine/src/gfx/radar/sensor.h
index 42b7cc6641..d6c17de359 100644
--- a/engine/src/gfx/radar/sensor.h
+++ b/engine/src/gfx/radar/sensor.h
@@ -36,6 +36,8 @@
 class Unit;
 struct GFXColor;  // Edit from class to struct as defined in gfxlib_struct.
 
+// TODO: this is basically a wrapper over CRadar. Remove
+
 namespace Radar {
 
 // Sensor is a proxy for two types of information:
diff --git a/engine/src/resource/manifest.cpp b/engine/src/resource/manifest.cpp
index 7534771955..71d7493f80 100644
--- a/engine/src/resource/manifest.cpp
+++ b/engine/src/resource/manifest.cpp
@@ -75,18 +75,23 @@ Manifest::Manifest(int dummy) {
         boost::json::array root_array = json_value.get_array();
 
         for(boost::json::value& item_value : root_array) {
-            boost::json::object item = item_value.get_object();
-
-            std::string name = JsonGetStringWithDefault(item, "file", "");
-            std::string category = JsonGetStringWithDefault(item, "categoryname", "");
-            int price = std::stoi(JsonGetStringWithDefault(item, "price", "0"));
-            double mass = std::stod(JsonGetStringWithDefault(item, "mass", "0.0"));
-            double volume = std::stod(JsonGetStringWithDefault(item, "volume", "0.0"));
-            std::string description = JsonGetStringWithDefault(item, "description", "");
-
-            Cargo cargo = Cargo(name, category, price, 1, mass, volume);
-            cargo.SetDescription(description);
-            _items.push_back(cargo);
+            try {
+                boost::json::object item = item_value.get_object();
+
+                std::string name = JsonGetStringWithDefault(item, "file", "");
+                std::string category = JsonGetStringWithDefault(item, "categoryname", "");
+                int price = std::stoi(JsonGetStringWithDefault(item, "price", "0"));
+                double mass = std::stod(JsonGetStringWithDefault(item, "mass", "0.0"));
+                double volume = std::stod(JsonGetStringWithDefault(item, "volume", "0.0"));
+                std::string description = JsonGetStringWithDefault(item, "description", "");
+
+                Cargo cargo = Cargo(name, category, price, 1, mass, volume);
+                cargo.SetDescription(description);
+                _items.push_back(cargo);
+            } catch (...) {
+                std::cerr << "Failed to parse " << item_value << std::endl;
+            }
+            
         }
     }
 }