Moved Stars45 to StarsEx

1 files changed, 384 insertions, 0 deletions

diff --git a/StarsEx/CombatUnit.cpp b/StarsEx/CombatUnit.cpp
new file mode 100644
index 0000000..b7af000
--- /dev/null
+++ b/StarsEx/CombatUnit.cpp
@@ -0,0 +1,384 @@
+/*  Starshatter: The Open Source Project
+    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
+    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
+    Copyright (c) 1997-2006, Destroyer Studios LLC.
+
+    AUTHOR:       John DiCamillo
+
+
+    OVERVIEW
+    ========
+    A ship, station, or ground unit in the dynamic campaign.
+*/
+
+#include "CombatUnit.h"
+#include "CombatGroup.h"
+#include "Campaign.h"
+#include "ShipDesign.h"
+#include "Ship.h"
+
+#include "Game.h"
+#include "ContentBundle.h"
+
+// +----------------------------------------------------------------------+
+#undef random
+inline double random() { return (double) rand() / (double) RAND_MAX; }
+
+// +----------------------------------------------------------------------+
+
+CombatUnit::CombatUnit(const char* n, const char* reg, int t, const char* d, int c, int i)
+: name(n), regnum(reg), type(t), design_name(d), design(0),
+count(c), iff(i), leader(false), dead_count(0), available(c),
+carrier(0), plan_value(0), launch_time(-1e6), jump_time(0),
+sustained_damage(0), target(0), group(0), heading(0)
+{ }
+
+CombatUnit::CombatUnit(const CombatUnit& u)
+: name(u.name), regnum(u.regnum), type(u.type), design_name(u.design_name),
+design(u.design), count(u.count), iff(u.iff),
+dead_count(u.dead_count), available(u.available),
+leader(u.leader), region(u.region), location(u.location),
+carrier(u.carrier), plan_value(0), launch_time(u.launch_time),
+jump_time(u.jump_time), sustained_damage(u.sustained_damage),
+target(0), group(0), heading(u.heading)
+{ }
+
+// +----------------------------------------------------------------------+
+
+const ShipDesign*
+CombatUnit::GetDesign()
+{
+    if (!design)
+    design = ShipDesign::Get(design_name);
+
+    return design;
+}
+
+int
+CombatUnit::GetShipClass() const
+{
+    if (design)
+    return design->type;
+
+    return type;
+}
+
+int
+CombatUnit::GetValue() const
+{
+    return GetSingleValue() * LiveCount();
+}
+
+int
+CombatUnit::GetSingleValue() const
+{
+    return Ship::Value(GetShipClass());
+}
+
+// +----------------------------------------------------------------------+
+
+const char*
+CombatUnit::GetDescription() const
+{
+    if (!design) {
+        CombatUnit* pThis = (CombatUnit*) this; // cast-away const
+        pThis->GetDesign();
+    }
+
+    static char desc[256];
+
+    if (!design) {
+        strcpy_s(desc, ContentBundle::GetInstance()->GetText("[unknown]").data());
+    }
+
+    else if (count > 1) {
+        sprintf_s(desc, "%dx %s %s", LiveCount(), design->abrv, design->DisplayName());
+    }
+
+    else {
+        if (regnum.length() > 0)
+        sprintf_s(desc, "%s-%s %s", design->abrv, (const char*) regnum, (const char*) name);
+        else
+        sprintf_s(desc, "%s %s", design->abrv, (const char*) name);
+
+        if (dead_count > 0) {
+            strcat_s(desc, " ");
+            strcat_s(desc, ContentBundle::GetInstance()->GetText("killed.in.action"));
+        }
+    }
+
+    return desc;
+}
+
+// +----------------------------------------------------------------------+
+
+bool
+CombatUnit::CanLaunch() const
+{
+    bool result = false;
+
+    switch (type) {
+    case Ship::FIGHTER:
+    case Ship::ATTACK:   result = (Campaign::Stardate() - launch_time) >= 300;
+        break;
+
+    case Ship::CORVETTE:
+    case Ship::FRIGATE:
+    case Ship::DESTROYER:
+    case Ship::CRUISER:
+    case Ship::CARRIER:  result = true;
+        break;
+    }
+
+    return result;
+}
+
+// +----------------------------------------------------------------------+
+
+Color
+CombatUnit::MarkerColor() const
+{
+    return Ship::IFFColor(iff);
+}
+
+bool
+CombatUnit::IsGroundUnit() const
+{
+    return (design && (design->type & Ship::GROUND_UNITS)) ? true : false;
+}
+
+bool
+CombatUnit::IsStarship() const
+{
+    return (design && (design->type & Ship::STARSHIPS)) ? true : false;
+}
+
+bool
+CombatUnit::IsDropship() const
+{
+    return (design && (design->type & Ship::DROPSHIPS)) ? true : false;
+}
+
+bool
+CombatUnit::IsStatic() const
+{
+    return design && (design->type >= Ship::STATION);
+}
+
+// +----------------------------------------------------------------------+
+
+double
+CombatUnit::MaxRange() const
+{
+    return 100e3;
+}
+
+double CombatUnit::MaxEffectiveRange() const
+{
+    return 50e3;
+}
+
+double CombatUnit::OptimumRange() const
+{
+    if (type == Ship::FIGHTER || type == Ship::ATTACK)
+    return 15e3;
+
+    return 30e3;
+}
+
+// +----------------------------------------------------------------------+
+
+bool CombatUnit::CanDefend(CombatUnit* unit) const
+{
+    if (unit == 0 || unit == this)
+    return false;
+
+    if (type > Ship::STATION)
+    return false;
+
+    double distance = (location - unit->location).length();
+
+    if (type > unit->type)
+    return false;
+
+    if (distance > MaxRange())
+    return false;
+
+    return true;
+}
+
+// +----------------------------------------------------------------------+
+
+double CombatUnit::PowerVersus(CombatUnit* tgt) const
+{
+    if (tgt == 0 || tgt == this || available < 1)
+    return 0;
+
+    if (type > Ship::STATION)
+    return 0;
+
+    double effectiveness = 1;
+    double distance = (location - tgt->location).length();
+
+    if (distance > MaxRange())
+    return 0;
+
+    if (distance > MaxEffectiveRange())
+    effectiveness = 0.5;
+
+    if (type == Ship::FIGHTER) {
+        if (tgt->type == Ship::FIGHTER || tgt->type == Ship::ATTACK)
+        return Ship::FIGHTER * 2 * available * effectiveness;
+        else
+        return 0;
+    }
+    else if (type == Ship::ATTACK) {
+        if (tgt->type > Ship::ATTACK)
+        return Ship::ATTACK * 3 * available * effectiveness;
+        else
+        return 0;
+    }
+    else if (type == Ship::CARRIER) {
+        return 0;
+    }
+    else if (type == Ship::SWACS) {
+        return 0;
+    }
+    else if (type == Ship::CRUISER) {
+        if (tgt->type <= Ship::ATTACK)
+        return type * effectiveness;
+
+        else
+        return 0;
+    }
+    else {
+        if (tgt->type > Ship::ATTACK)
+        return type * effectiveness;
+        else
+        return type * 0.1 * effectiveness;
+    }
+
+    return 0;
+}
+
+// +----------------------------------------------------------------------+
+
+int
+CombatUnit::AssignMission()
+{
+    int assign = count;
+
+    if (count > 4)
+    assign = 4;
+
+    if (assign > 0) {
+        available -= assign;
+        launch_time = Campaign::Stardate();
+        return assign;
+    }
+
+    return 0;
+}
+
+// +----------------------------------------------------------------------+
+
+void
+CombatUnit::CompleteMission()
+{
+    Disengage();
+
+    if (count > 4)
+    available += 4;
+
+    else
+    available += count;
+}
+
+// +----------------------------------------------------------------------+
+
+void
+CombatUnit::MoveTo(const Point& loc)
+{
+    if (!carrier)
+    location = loc;
+    else
+    location = carrier->location;
+}
+
+// +----------------------------------------------------------------------+
+
+void
+CombatUnit::Engage(CombatUnit* tgt)
+{
+    if (!tgt)
+    Disengage();
+
+    else if (!tgt->attackers.contains(this))
+    tgt->attackers.append(this);
+
+    target = tgt;
+}
+
+void
+CombatUnit::Disengage()
+{
+    if (target)
+    target->attackers.remove(this);
+
+    target = 0;
+}
+
+// +----------------------------------------------------------------------+
+
+static int KillGroup(CombatGroup* group)
+{
+    int value_killed = 0;
+
+    if (group) {
+        ListIter<CombatUnit>  u_iter = group->GetUnits();
+        while (++u_iter) {
+            CombatUnit* u = u_iter.value();
+            value_killed += u->Kill(u->LiveCount());
+        }
+
+        ListIter<CombatGroup> g_iter = group->GetComponents();
+        while (++g_iter) {
+            CombatGroup* g = g_iter.value();
+            value_killed += KillGroup(g);
+        }
+    }
+
+    return value_killed;
+}
+
+int
+CombatUnit::Kill(int n)
+{
+    int killed = n;
+
+    if (killed > LiveCount())
+    killed = LiveCount();
+
+    dead_count += killed;
+
+    int value_killed = killed * GetSingleValue();
+
+    if (killed) {
+        // if unit could support children, kill them too:
+        if (type == Ship::CARRIER ||
+                type == Ship::STATION ||
+                type == Ship::STARBASE) {
+
+            if (group) {
+                ListIter<CombatGroup> iter = group->GetComponents();
+                while (++iter) {
+                    CombatGroup* g = iter.value();
+                    value_killed += KillGroup(g);
+                }
+            }
+        }
+    }
+
+    return value_killed;
+}
+