Don't store land unit stats in struct lndstr, part 1

New lnd_att(), lnd_def(), lnd_vul(), lnd_spd(), lnd_vis(), lnd_frg(),
lnd_acc(), lnd_dam(), lnd_aaf() replace the struct lndstr members with
the same names.

Make land unit selectors att, def, vul, spd, vis, frg, acc, dam, aaf
virtual.

diff --git a/include/land.h b/include/land.h
index bfa1657d8058f6cd2e03b36d54150bb26e1179f8..484a1573f392900632824f1d21391234194f53d8 100644 (file)
--- a/include/land.h
+++ b/include/land.h
@@ -79,18 +79,9 @@ struct lndstr {
     short lnd_land;            /* pointer to transporting unit */
     unsigned char lnd_nland;
     short lnd_access;          /* Last tick mob was updated (MOB_ACCESS) */
-    float lnd_att;             /* attack multiplier */
-    float lnd_def;             /* defense multiplier */
-    int lnd_vul;               /* vulnerability (0-100) */
-    int lnd_spd;               /* speed */
-    int lnd_vis;               /* visibility */
     int lnd_spy;               /* Seeing distance */
     int lnd_rad;               /* reaction radius */
-    int lnd_frg;               /* firing range */
-    int lnd_acc;               /* firing accuracy */
-    int lnd_dam;               /* # of guns firing */
     int lnd_ammo;              /* firing ammu used per shot */
-    int lnd_aaf;               /* aa fire */
     unsigned char lnd_fuelc;   /* fuel capacity */
     unsigned char lnd_fuelu;   /* fuel used per 10 mob */
     unsigned char lnd_maxlight;        /* maximum number of xlight planes */
@@ -166,6 +157,15 @@ extern int l_frg(struct lchrstr *, int);
 extern int l_acc(struct lchrstr *, int);
 extern int l_dam(struct lchrstr *, int);
 extern int l_aaf(struct lchrstr *, int);
+extern float lnd_att(struct lndstr *);
+extern float lnd_def(struct lndstr *);
+extern int lnd_vul(struct lndstr *);
+extern int lnd_spd(struct lndstr *);
+extern int lnd_vis(struct lndstr *);
+extern int lnd_frg(struct lndstr *);
+extern int lnd_acc(struct lndstr *);
+extern int lnd_dam(struct lndstr *);
+extern int lnd_aaf(struct lndstr *);
 
 extern int lnd_fire(struct lndstr *);
 extern double lnd_fire_range(struct lndstr *);

diff --git a/src/lib/commands/bomb.c b/src/lib/commands/bomb.c
index 74df69faa5e339a4619368e3ed7ae1600883ad0c..7d5653c55d91fd6f92b4302ef9170be96e8b6949 100644 (file)
--- a/src/lib/commands/bomb.c
+++ b/src/lib/commands/bomb.c
@@ -712,7 +712,7 @@ land_bomb(struct emp_qelem *list, struct sctstr *target)
     struct lndstr land;
     struct emp_qelem *qp;
     int unitno;
-    int ignore, flak, hitchance;
+    int ignore, aaf, flak, hitchance;
     struct plist *plp;
     int nukedam;
     int nunits;
@@ -755,11 +755,12 @@ land_bomb(struct emp_qelem *list, struct sctstr *target)
        if (unitno < 0)
            continue;
 
-       flak = (int)(techfact(land.lnd_tech, land.lnd_aaf) * 3.0);
+       aaf = lnd_aaf(&land);
+       flak = (int)(techfact(land.lnd_tech, aaf) * 3.0);
        if (flak) {
            PR(land.lnd_own,
               "Flak! Firing flak guns from unit %s (aa rating %d)\n",
-              prland(&land), land.lnd_aaf);
+              prland(&land), aaf);
            if (pinflak_planedamage(&plp->plane, plp->pcp, land.lnd_own, flak))
                continue;
        }

diff --git a/src/lib/commands/ldump.c b/src/lib/commands/ldump.c
index 97c84ca061d78f7e7a310a0885e817cff64e72b5..2a8fec22ede3a88471e2d413d64f86b0ddff295e 100644 (file)
--- a/src/lib/commands/ldump.c
+++ b/src/lib/commands/ldump.c
@@ -394,19 +394,19 @@ ldump(void)
                pr(" %d", land.lnd_item[I_RAD]);
                break;
            case 28:
-               pr(" %1.2f", land.lnd_att);
+               pr(" %1.2f", lnd_att(&land));
                break;
            case 29:
-               pr(" %1.2f", land.lnd_def);
+               pr(" %1.2f", lnd_def(&land));
                break;
            case 30:
-               pr(" %d", land.lnd_vul);
+               pr(" %d", lnd_vul(&land));
                break;
            case 31:
-               pr(" %d", land.lnd_spd);
+               pr(" %d", lnd_spd(&land));
                break;
            case 32:
-               pr(" %d", land.lnd_vis);
+               pr(" %d", lnd_vis(&land));
                break;
            case 33:
                pr(" %d", land.lnd_spy);
@@ -415,19 +415,19 @@ ldump(void)
                pr(" %d", land.lnd_rad);
                break;
            case 35:
-               pr(" %d", land.lnd_frg);
+               pr(" %d", lnd_frg(&land));
                break;
            case 36:
-               pr(" %d", land.lnd_acc);
+               pr(" %d", lnd_acc(&land));
                break;
            case 37:
-               pr(" %d", land.lnd_dam);
+               pr(" %d", lnd_dam(&land));
                break;
            case 38:
                pr(" %d", land.lnd_ammo);
                break;
            case 39:
-               pr(" %d", land.lnd_aaf);
+               pr(" %d", lnd_aaf(&land));
                break;
            case 40:
                pr(" %d", land.lnd_item[I_UW]);

diff --git a/src/lib/commands/look.c b/src/lib/commands/look.c
index 86b1e659afe14ac12afe30519feb0be999b7f2e5..9ca463676f3fe9221cad167f1224d6defd1d8ff8 100644 (file)
--- a/src/lib/commands/look.c
+++ b/src/lib/commands/look.c
@@ -228,7 +228,7 @@ look_land(struct lndstr *lookland)
            if (!(chance(LND_SPY_DETECT_CHANCE(lp->lnd_effic))))
                continue;
        }
-       vrange = ldround((lp->lnd_vis * range) / 20.0, 1);
+       vrange = ldround((lnd_vis(lp) * range) / 20.0, 1);
        dist = mapdist(lp->lnd_x, lp->lnd_y,
                       lookland->lnd_x, lookland->lnd_y);
        if (dist > vrange)

diff --git a/src/lib/commands/lstat.c b/src/lib/commands/lstat.c
index 78314a9f46f8d0ad78731df2870b14d19fa6fd87..b68f77e2e0dc74299df8311105570ed5806aa363 100644 (file)
--- a/src/lib/commands/lstat.c
+++ b/src/lib/commands/lstat.c
@@ -60,13 +60,13 @@ lsta(void)
        pr("%4d %-16.16s ", land.lnd_uid, lchr[(int)land.lnd_type].l_name);
        prxy("%4d,%-4d", land.lnd_x, land.lnd_y, player->cnum);
        pr(" %3d%% %3d %1.1f %1.1f %3d ",
-          land.lnd_effic, land.lnd_tech, land.lnd_att, land.lnd_def,
-          land.lnd_vul);
+          land.lnd_effic, land.lnd_tech, lnd_att(&land), lnd_def(&land),
+          lnd_vul(&land));
        pr("%2d %2d %2d %2d ",
-          land.lnd_spd, land.lnd_vis, land.lnd_spy, land.lnd_rad);
+          lnd_spd(&land), lnd_vis(&land), land.lnd_spy, land.lnd_rad);
        pr("%2d %2d %2d %2d %2d ",
-          land.lnd_frg,
-          land.lnd_acc, land.lnd_dam, land.lnd_ammo, land.lnd_aaf);
+          lnd_frg(&land),
+          lnd_acc(&land), lnd_dam(&land), land.lnd_ammo, lnd_aaf(&land));
        pr("\n");
     }
     if (nunits == 0) {

diff --git a/src/lib/commands/mfir.c b/src/lib/commands/mfir.c
index 702e13d09ee4e125717bac8774fe34346902e19d..e10b2c4748b76277e998e6668b8e7d22c77fa386 100644 (file)
--- a/src/lib/commands/mfir.c
+++ b/src/lib/commands/mfir.c
@@ -146,7 +146,7 @@ multifire(void)
            if (item.land.lnd_own != player->cnum)
                continue;
 
-           if (fland.lnd_dam == 0) {
+           if (lchr[fland.lnd_type].l_dam == 0) {
                pr("Unit %d cannot fire!\n", fland.lnd_uid);
                continue;
            }
@@ -352,7 +352,7 @@ multifire(void)
            fx = fland.lnd_x;
            fy = fland.lnd_y;
 
-           if (fland.lnd_dam == 0) {
+           if (lchr[fland.lnd_type].l_dam == 0) {
                pr("Unit %d cannot fire!\n", fland.lnd_uid);
                continue;
            }
@@ -376,7 +376,7 @@ multifire(void)
                continue;
            }
            if (target == targ_ship) {
-               if (chance(fland.lnd_acc / 100.0))
+               if (chance(lnd_acc(&fland) / 100.0))
                    dam = ldround(dam / 2.0, 1);
            }
        } else {

diff --git a/src/lib/global/land.c b/src/lib/global/land.c
index 6bced61deab9d6299a469595007c43de080a9524..e51b223966be833eba17c6d1d7d6944e1acd19f1 100644 (file)
--- a/src/lib/global/land.c
+++ b/src/lib/global/land.c
@@ -120,3 +120,57 @@ l_aaf(struct lchrstr *lcp, int tech)
 {
     return LND_AAF(lcp->l_aaf, MAX(0, tech - lcp->l_tech));
 }
+
+float
+lnd_att(struct lndstr *lp)
+{
+    return l_att(lchr + lp->lnd_type, lp->lnd_tech);
+}
+
+float
+lnd_def(struct lndstr *lp)
+{
+    return l_def(lchr + lp->lnd_type, lp->lnd_tech);
+}
+
+int
+lnd_vul(struct lndstr *lp)
+{
+    return l_vul(lchr + lp->lnd_type, lp->lnd_tech);
+}
+
+int
+lnd_spd(struct lndstr *lp)
+{
+    return l_spd(lchr + lp->lnd_type, lp->lnd_tech);
+}
+
+int
+lnd_vis(struct lndstr *lp)
+{
+    return lchr[lp->lnd_type].l_vis;
+}
+
+int
+lnd_frg(struct lndstr *lp)
+{
+    return l_frg(lchr + lp->lnd_type, lp->lnd_tech);
+}
+
+int
+lnd_acc(struct lndstr *lp)
+{
+    return l_acc(lchr + lp->lnd_type, lp->lnd_tech);
+}
+
+int
+lnd_dam(struct lndstr *lp)
+{
+    return l_dam(lchr + lp->lnd_type, lp->lnd_tech);
+}
+
+int
+lnd_aaf(struct lndstr *lp)
+{
+    return l_aaf(lchr + lp->lnd_type, lp->lnd_tech);
+}

diff --git a/src/lib/global/nsc.c b/src/lib/global/nsc.c
index f83d2682925190f0f968c4aba3d9168e14099611..c38d3ba295663e3f9404d8d045bec58f5c006f80 100644 (file)
--- a/src/lib/global/nsc.c
+++ b/src/lib/global/nsc.c
@@ -48,6 +48,15 @@
 static void *nsc_ver(struct valstr *, natid, void *);
 static void *nsc_pln_att(struct valstr *, natid, void *);
 static void *nsc_pln_def(struct valstr *, natid, void *);
+static void *nsc_lnd_att(struct valstr *, natid, void *);
+static void *nsc_lnd_def(struct valstr *, natid, void *);
+static void *nsc_lnd_vul(struct valstr *, natid, void *);
+static void *nsc_lnd_spd(struct valstr *, natid, void *);
+static void *nsc_lnd_vis(struct valstr *, natid, void *);
+static void *nsc_lnd_frg(struct valstr *, natid, void *);
+static void *nsc_lnd_acc(struct valstr *, natid, void *);
+static void *nsc_lnd_dam(struct valstr *, natid, void *);
+static void *nsc_lnd_aaf(struct valstr *, natid, void *);
 
 /* Ugly hack to improve legibility by avoid long lines */
 #define fldoff(fld) offsetof(CURSTR, fld)
@@ -341,24 +350,24 @@ struct castr land_ca[] = {
     {"land", fldoff(lnd_land), NSC_SHORT, 0, NULL, EF_BAD, 0},
     {"nland", fldoff(lnd_nland), NSC_UCHAR, 0, NULL, EF_BAD, NSC_EXTRA},
     {"access", fldoff(lnd_access), NSC_SHORT, 0, NULL, EF_BAD, 0},
-    {"att", fldoff(lnd_att), NSC_FLOAT, 0, NULL, EF_BAD, NSC_EXTRA},
-    {"def", fldoff(lnd_def), NSC_FLOAT, 0, NULL, EF_BAD, NSC_EXTRA},
-    {"vul", fldoff(lnd_vul), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
-    {"spd", fldoff(lnd_spd), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
-    {"vis", fldoff(lnd_vis), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
     {"spy", fldoff(lnd_spy), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
     {"rmax", fldoff(lnd_rad), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
-    {"frg", fldoff(lnd_frg), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
-    {"acc", fldoff(lnd_acc), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
-    {"dam", fldoff(lnd_dam), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
     {"ammo", fldoff(lnd_ammo), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
-    {"aaf", fldoff(lnd_aaf), NSC_INT, 0, NULL, EF_BAD, NSC_EXTRA},
     {"fuelc", fldoff(lnd_fuelc), NSC_UCHAR, 0, NULL, EF_BAD, NSC_EXTRA},
     {"fuelu", fldoff(lnd_fuelu), NSC_UCHAR, 0, NULL, EF_BAD, NSC_EXTRA},
     {"maxlight", fldoff(lnd_maxlight), NSC_UCHAR, 0, NULL,
      EF_BAD, NSC_EXTRA},
     {"timestamp", fldoff(lnd_timestamp), NSC_TIME, 0, NULL,
      EF_BAD, NSC_EXTRA},
+    {"att", 0, NSC_DOUBLE, 0, nsc_lnd_att, EF_BAD, NSC_EXTRA},
+    {"def", 0, NSC_DOUBLE, 0, nsc_lnd_def, EF_BAD, NSC_EXTRA},
+    {"vul", 0, NSC_LONG, 0, nsc_lnd_vul, EF_BAD, NSC_EXTRA},
+    {"spd", 0, NSC_LONG, 0, nsc_lnd_spd, EF_BAD, NSC_EXTRA},
+    {"vis", 0, NSC_LONG, 0, nsc_lnd_vis, EF_BAD, NSC_EXTRA},
+    {"frg", 0, NSC_LONG, 0, nsc_lnd_frg, EF_BAD, NSC_EXTRA},
+    {"acc", 0, NSC_LONG, 0, nsc_lnd_acc, EF_BAD, NSC_EXTRA},
+    {"dam", 0, NSC_LONG, 0, nsc_lnd_dam, EF_BAD, NSC_EXTRA},
+    {"aaf", 0, NSC_LONG, 0, nsc_lnd_aaf, EF_BAD, NSC_EXTRA},
     {NULL, 0, NSC_NOTYPE, 0, NULL, EF_BAD, 0}
 #undef CURSTR
 };
@@ -741,3 +750,66 @@ nsc_pln_att(struct valstr *val, natid cnum, void *ptr)
     val->val_as.lng = pln_att(ptr);
     return NULL;
 }
+
+static void *
+nsc_lnd_att(struct valstr *val, natid cnum, void *ptr)
+{
+    val->val_as.dbl = lnd_att(ptr);
+    return NULL;
+}
+
+static void *
+nsc_lnd_def(struct valstr *val, natid cnum, void *ptr)
+{
+    val->val_as.dbl = lnd_def(ptr);
+    return NULL;
+}
+
+static void *
+nsc_lnd_vul(struct valstr *val, natid cnum, void *ptr)
+{
+    val->val_as.lng = lnd_vul(ptr);
+    return NULL;
+}
+
+static void *
+nsc_lnd_spd(struct valstr *val, natid cnum, void *ptr)
+{
+    val->val_as.lng = lnd_spd(ptr);
+    return NULL;
+}
+
+static void *
+nsc_lnd_vis(struct valstr *val, natid cnum, void *ptr)
+{
+    val->val_as.lng = lnd_vis(ptr);
+    return NULL;
+}
+
+static void *
+nsc_lnd_frg(struct valstr *val, natid cnum, void *ptr)
+{
+    val->val_as.lng = lnd_frg(ptr);
+    return NULL;
+}
+
+static void *
+nsc_lnd_acc(struct valstr *val, natid cnum, void *ptr)
+{
+    val->val_as.lng = lnd_acc(ptr);
+    return NULL;
+}
+
+static void *
+nsc_lnd_dam(struct valstr *val, natid cnum, void *ptr)
+{
+    val->val_as.lng = lnd_dam(ptr);
+    return NULL;
+}
+
+static void *
+nsc_lnd_aaf(struct valstr *val, natid cnum, void *ptr)
+{
+    val->val_as.lng = lnd_aaf(ptr);
+    return NULL;
+}

diff --git a/src/lib/subs/aircombat.c b/src/lib/subs/aircombat.c
index cb20fe473e0dbb0d57ef0cae8321769cdee72768..c411c0330642f0cd26e50c87ffa1a900f64634d1 100644 (file)
--- a/src/lib/subs/aircombat.c
+++ b/src/lib/subs/aircombat.c
@@ -883,7 +883,7 @@ ac_landflak(struct emp_qelem *list, coord x, coord y)
     struct lndstr land;
     struct lchrstr *lcp;
     double flak, total, ngun;
-    int gun;
+    int aaf, gun;
     int rel;
     struct plist *plp;
     natid plane_owner;
@@ -900,14 +900,15 @@ ac_landflak(struct emp_qelem *list, coord x, coord y)
        if (land.lnd_own == 0 || land.lnd_own == plane_owner)
            continue;
        lcp = &lchr[(int)land.lnd_type];
-       if ((lcp->l_flags & L_FLAK) == 0 || land.lnd_aaf == 0)
+       aaf = lnd_aaf(&land);
+       if ((lcp->l_flags & L_FLAK) == 0 || aaf == 0)
            continue;
        if (land.lnd_ship >= 0 || land.lnd_land >= 0)
            continue;
        rel = getrel(getnatp(land.lnd_own), plane_owner);
        if (rel > HOSTILE)
            continue;
-       flak = land.lnd_aaf * 1.5 * land.lnd_effic / 100.0;
+       flak = aaf * 1.5 * land.lnd_effic / 100.0;
        ngun += flak;
        total += techfact(land.lnd_tech, flak * 2.0);
 
@@ -920,7 +921,7 @@ ac_landflak(struct emp_qelem *list, coord x, coord y)
            nats[land.lnd_own] = 1;
        }
        PR(land.lnd_own, "firing flak guns from unit %s (aa rating %d)\n",
-          prland(&land), land.lnd_aaf);
+          prland(&land), aaf);
        from = land.lnd_own;
     }
 

diff --git a/src/lib/subs/damage.c b/src/lib/subs/damage.c
index 250fce7ddd3894ef20e72e19df2bd0a7e7c61514..bc02275fc89d3aee9962706e9fee2e687b8dfd15 100644 (file)
--- a/src/lib/subs/damage.c
+++ b/src/lib/subs/damage.c
@@ -118,7 +118,7 @@ landdamage(struct lndstr *lp, int dam)
     damage_factor = m / (m + lp->lnd_harden);
 
     /* vulnerable units take more damage */
-    damage_factor *= lp->lnd_vul / 100.0;
+    damage_factor *= lnd_vul(lp) / 100.0;
 
     land_damage(lp, ldround(damage_factor * dam, 1));
 }

diff --git a/src/lib/subs/landgun.c b/src/lib/subs/landgun.c
index 737054f6c134f365280eb603b89e772e55188a63..00c71438e8813875da19989e6de62c2c57b9d0d5 100644 (file)
--- a/src/lib/subs/landgun.c
+++ b/src/lib/subs/landgun.c
@@ -198,7 +198,7 @@ lnd_fire(struct lndstr *lp)
        return -1;
     if (lp->lnd_item[I_MILIT] == 0)
        return -1;
-    guns = lp->lnd_dam;
+    guns = lnd_dam(lp);
     guns = MIN(guns, lp->lnd_item[I_GUN]);
     if (guns == 0)
        return -1;
@@ -287,7 +287,7 @@ shp_torp_hitchance(struct shpstr *sp, int range)
 double
 lnd_fire_range(struct lndstr *lp)
 {
-    return effrange(lp->lnd_frg, lp->lnd_tech);
+    return effrange(lnd_frg(lp), lp->lnd_tech);
 }
 
 int

diff --git a/src/lib/subs/lndsub.c b/src/lib/subs/lndsub.c
index 2e00d6f38740bbe9a986d66af1e9587de741ecbd..6de8e55609015cc3e208b20fd56edee575630a98 100644 (file)
--- a/src/lib/subs/lndsub.c
+++ b/src/lib/subs/lndsub.c
@@ -76,7 +76,7 @@ attack_val(int combat_mode, struct lndstr *lp)
        return 1;
 
     men = lp->lnd_item[I_MILIT];
-    value = men * lp->lnd_att * lp->lnd_effic / 100.0;
+    value = men * lnd_att(lp) * lp->lnd_effic / 100.0;
 
     switch (combat_mode) {
     case A_ATTACK:
@@ -113,7 +113,7 @@ defense_val(struct lndstr *lp)
        !(lcp->l_flags & L_MARINE))
        return men;
 
-    value = men * lp->lnd_def * lp->lnd_effic / 100.0;
+    value = men * lnd_def(lp) * lp->lnd_effic / 100.0;
     value *= ((double)land_mob_max + lp->lnd_harden) / land_mob_max;
 
     /* If there are military on the unit, you get at least a 1
@@ -331,7 +331,7 @@ void
 intelligence_report(int destination, struct lndstr *lp, int spy,
                    char *mess)
 {
-    struct lchrstr *lcp;
+    int vis = lnd_vis(lp);
     char buf1[80], buf2[80], buf3[80];
 
     if (destination == 0)
@@ -340,18 +340,16 @@ intelligence_report(int destination, struct lndstr *lp, int spy,
     if (lp->lnd_own == 0)
        return;
 
-    lcp = &lchr[(int)lp->lnd_type];
-
     memset(buf1, 0, sizeof(buf1));
     memset(buf2, 0, sizeof(buf2));
     memset(buf3, 0, sizeof(buf3));
-    if (chance((spy + lp->lnd_vis) / 10.0)) {
+    if (chance((spy + vis) / 10.0)) {
        if (destination == player->cnum)
            pr("%s %s", mess, prland(lp));
        else
            sprintf(buf1, "%s %s", mess, prland(lp));
 
-       if (chance((spy + lp->lnd_vis) / 20.0)) {
+       if (chance((spy + vis) / 20.0)) {
            if (destination == player->cnum)
                pr(" (eff %d, mil %d",
                   roundintby(lp->lnd_effic, 5),
@@ -361,7 +359,7 @@ intelligence_report(int destination, struct lndstr *lp, int spy,
                        roundintby(lp->lnd_effic, 5),
                        roundintby(lp->lnd_item[I_MILIT], 10));
 
-           if (chance((spy + lp->lnd_vis) / 20.0)) {
+           if (chance((spy + vis) / 20.0)) {
                int t;
                t = lp->lnd_tech - 20 + roll(40);
                t = MAX(t, 0);
@@ -890,8 +888,8 @@ lnd_hardtarget(struct lndstr *lp)
 
     getsect(lp->lnd_x, lp->lnd_y, &sect);
     return (int)((lp->lnd_effic / 100.0) *
-                (10 + dchr[sect.sct_type].d_dstr * 2 + lp->lnd_spd / 2.0
-                 - lp->lnd_vis));
+                (10 + dchr[sect.sct_type].d_dstr * 2 + lnd_spd(lp) / 2.0
+                 - lnd_vis(lp)));
 }
 
 static int
@@ -917,7 +915,7 @@ lnd_pathcost(struct lndstr *lp, double pathcost)
 {
     double effspd;
 
-    effspd = lp->lnd_spd;
+    effspd = lnd_spd(lp);
     if (lchr[(int)lp->lnd_type].l_flags & L_SUPPLY)
        effspd *= lp->lnd_effic * 0.01;
 
@@ -1150,7 +1148,7 @@ lnd_support(natid victim, natid attacker, coord x, coord y, int defending)
            nreport(land.lnd_own, N_FIRE_BACK, victim, 1);
        else
            nreport(land.lnd_own, N_FIRE_L_ATTACK, victim, 1);
-       if (roll(100) < land.lnd_acc)
+       if (roll(100) < lnd_acc(&land))
            dam2 /= 2;
        dam += dam2;
        if (land.lnd_own != attacker)
@@ -1238,18 +1236,9 @@ lnd_set_tech(struct lndstr *lp, int tlev)
        tlev = 0;
 
     lp->lnd_tech = tlev;
-    lp->lnd_att = l_att(lcp, tlev);
-    lp->lnd_def = l_def(lcp, tlev);
-    lp->lnd_vul = l_vul(lcp, tlev);
-    lp->lnd_spd = l_spd(lcp, tlev);
-    lp->lnd_vis = lcp->l_vis;
     lp->lnd_spy = lcp->l_spy;
     lp->lnd_rad = lcp->l_rad;
-    lp->lnd_frg = l_frg(lcp, tlev);
-    lp->lnd_acc = l_acc(lcp, tlev);
-    lp->lnd_dam = l_dam(lcp, tlev);
     lp->lnd_ammo = lcp->l_ammo;
-    lp->lnd_aaf = lcp->l_aaf;
     lp->lnd_fuelc = lcp->l_fuelc;
     lp->lnd_fuelu = lcp->l_fuelu;
     lp->lnd_maxlight = lcp->l_nxlight;

diff --git a/src/lib/subs/mission.c b/src/lib/subs/mission.c
index 3ddf8e1692256073e0c904003d619d3193fadcf5..6465633e8b0180e4bebb723ff454186efd3e571d 100644 (file)
--- a/src/lib/subs/mission.c
+++ b/src/lib/subs/mission.c
@@ -446,7 +446,7 @@ perform_mission(coord x, coord y, natid victim, struct emp_qelem *list,
                continue;
 
            if (sect.sct_type == SCT_WATER) {
-               if (chance(lp->lnd_acc / 100.0))
+               if (chance(lnd_acc(lp) / 100.0))
                    dam2 = ldround(dam2 / 2.0, 1);
            }
            dam += dam2;