Complete.Org: Mailing Lists: Archives: freeciv-ai: May 2003:
[freeciv-ai] (PR#3584) Renaming vulnerability/belligerence
Home

[freeciv-ai] (PR#3584) Renaming vulnerability/belligerence

[Top] [All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index] [Thread Index]
To: Gregory.Berkolaiko@xxxxxxxxxxxx
Subject: [freeciv-ai] (PR#3584) Renaming vulnerability/belligerence
From: "Juhani Heino" <juhani.heino@xxxxxxxxxx>
Date: Fri, 9 May 2003 04:40:58 -0700
Reply-to: rt@xxxxxxxxxxxxxx

> Editing:
> ========
> 1. unit_vulnerability_virtual must be multiplied by firepower!
> 2. Remove alternativ_hp from unit_vulnerability_virtual2
>   (not used).
> 
> 
> More renaming:
> ==============
> 1. unit_vulnerability_virtual2
>   -> unittype_def_rating_sq
> 2. unit_vulnerability_virtual
>   -> unit_def_rating_basic_sq
> 3. unit_vulnerability_basic
>   -> unit_def_rating
> 4. unit_vulnerability
>   -> unit_def_rating_sq
> 
> 
> Add:
> ====
> 1. unit_def_rating_basic  and make 
> unit_def_rating_basic_sq it's square.

All this in one bunch, so if this is committed, the case will
be closed.

I defined diff to be text/plain in Netscape, but let's see if
it helps in this upload.

Note that in aiunit.c I moved a function to more logical position
and diff shows it quite obscurely, of course. It may be easiest
to run the patch and then view the def_rating area.

Also take a close scrutiny at this time. Especially that
firepower in unit_def_rating_basic is what Greg meant.
I used unittype_def_rating_sq as a model, but if taken
literally, Greg said that current unit_def_rating_basic_sq
should be multiplied. Now unit_def_rating_basic_sq gets
multiplied with firepower twice. 

Also I have a feeling that there could be cleaner expressions
than  unit_types[def_type].firepower  and such, so please tell
me if I should think these over.

-- 
Juhani Heino
Finnish translator

--- ai/aiair.c.orig     Thu May  8 20:59:50 2003
+++ ai/aiair.c  Thu May  8 23:16:16 2003
@@ -126,7 +126,7 @@
                        * unit_win_chance(punit, pdefender));
 
   /* Defence value of the enemy 
-     victim_defence = unit_vulnerability_basic(punit, pdefender) / 10; */
+     victim_defence = unit_def_rating(punit, pdefender) / 10; */
   victim_defence = PROB_MULTIPLIER - unit_attack;
 
   balanced_cost = build_cost_balanced(punit->type);
--- ai/advmilitary.c.orig       Thu May  8 21:00:48 2003
+++ ai/advmilitary.c    Thu May  8 23:13:51 2003
@@ -811,8 +811,8 @@
 
       /* Estimate strength of the enemy. */
       
-      vuln = unit_vulnerability_virtual2(unit_type, victim_unit_type, x, y,
-                                         FALSE, veteran, FALSE, 0);
+      vuln = unittype_def_rating_sq(unit_type, victim_unit_type,
+                                    x, y, FALSE, veteran);
 
       /* Not bothering to s/!vuln/!pdef/ here for the time being. -- Syela
        * (this is noted elsewhere as terrible bug making warships yoyoing) 
@@ -1008,8 +1008,8 @@
     def_type = ai_choose_defender_versus(acity, myunit->type);
     if (move_time > 1) {
       def_vet = do_make_unit_veteran(acity, def_type);
-      vuln = unit_vulnerability_virtual2(myunit->type, def_type, x, y, FALSE,
-                                         def_vet, FALSE, 0);
+      vuln = unittype_def_rating_sq(myunit->type, def_type,
+                                    x, y, FALSE, def_vet);
       benefit = unit_types[def_type].build_cost;
     } else {
       vuln = 0;
@@ -1019,8 +1019,8 @@
 
     pdef = get_defender(myunit, x, y);
     if (pdef) {
-      int m = unit_vulnerability_virtual2(myunit->type, pdef->type, x, y, 
FALSE,
-                                          pdef->veteran, FALSE, 0);
+      int m = unittype_def_rating_sq(myunit->type, pdef->type,
+                                     x, y, FALSE, pdef->veteran);
       if (vuln < m) {
         vuln = m;
         benefit = unit_type(pdef)->build_cost;
--- ai/aihand.c.orig    Thu May  8 21:01:12 2003
+++ ai/aihand.c Thu May  8 23:05:35 2003
@@ -259,8 +259,8 @@
           */
           if (incity == pcity) {
             if (defender) {
-              if (unit_vulnerability_virtual(punit) <
-                  unit_vulnerability_virtual(defender)) {
+              if (unit_def_rating_basic_sq(punit) <
+                  unit_def_rating_basic_sq(defender)) {
                freelog(LOG_VERBOSE, "Disbanding %s in %s",
                        unit_type(punit)->name, pcity->name);
                 pack.unit_id = punit->id;
--- server/unittools.c.orig     Thu May  8 21:08:17 2003
+++ server/unittools.c  Thu May  8 21:18:32 2003
@@ -1306,7 +1306,7 @@
   db = get_tile_type(map_get_terrain(x, y))->defense_bonus;
   if (map_has_special(x, y, S_RIVER))
     db += (db * terrain_control.river_defense_bonus) / 100;
-  d = unit_vulnerability_virtual(punit) * db;
+  d = unit_def_rating_basic_sq(punit) * db;
 
   adjc_iterate(x, y, x1, y1) {
     if (ai_handicap(pplayer, H_FOG)
--- ai/aiunit.h.orig    Thu May  8 21:05:46 2003
+++ ai/aiunit.h Thu May  8 23:59:01 2003
@@ -65,10 +65,10 @@
 int unittype_att_rating(Unit_Type_id type, bool veteran,
                         int moves_left, int hp);
 int unit_att_rating(struct unit *punit);
-int unit_vulnerability_virtual(struct unit *punit);
-int unit_vulnerability_virtual2(Unit_Type_id att_type, Unit_Type_id def_type,
-                               int x, int y, bool fortified, bool veteran,
-                               bool use_alternative_hp, int alternative_hp);
+int unit_def_rating_basic(struct unit *punit);
+int unit_def_rating_basic_sq(struct unit *punit);
+int unittype_def_rating_sq(Unit_Type_id att_type, Unit_Type_id def_type,
+                           int x, int y, bool fortified, bool veteran);
 int kill_desire(int benefit, int attack, int loss, int vuln, int attack_count);
 
 bool is_on_unit_upgrade_path(Unit_Type_id test, Unit_Type_id base);
--- ai/aiunit.c.orig    Thu May  8 21:04:25 2003
+++ ai/aiunit.c Fri May  9 00:20:19 2003
@@ -69,7 +69,7 @@
 
 static int unit_move_turns(struct unit *punit, int x, int y);
 static bool unit_role_defender(Unit_Type_id type);
-static int unit_vulnerability(struct unit *punit, struct unit *pdef);
+static int unit_def_rating_sq(struct unit *punit, struct unit *pdef);
 
 /*
  * Cached values. Updated by update_simple_ai_types.
@@ -846,49 +846,56 @@
 }
 
 /********************************************************************** 
-  ...
+  Defence rating of this particular unit against this attacker.
 ***********************************************************************/
-static int unit_vulnerability_basic(struct unit *punit, struct unit *pdef)
+static int unit_def_rating(struct unit *attacker, struct unit *defender)
 {
-  return (get_total_defense_power(punit, pdef) *
-         (punit->id != 0 ? pdef->hp : unit_type(pdef)->hp) *
-         unit_type(pdef)->firepower / POWER_DIVIDER);
+  return get_total_defense_power(attacker, defender) *
+         (attacker->id != 0 ? defender->hp : unit_type(defender)->hp) *
+         unit_type(defender)->firepower / POWER_DIVIDER;
 }
 
 /********************************************************************** 
-  ...
+  Square of the previous function - used in actual computations.
 ***********************************************************************/
-int unit_vulnerability_virtual(struct unit *punit)
+static int unit_def_rating_sq(struct unit *attacker,
+                              struct unit *defender)
 {
-  int v = base_get_defense_power(punit) * punit->hp / POWER_DIVIDER;
-
+  int v = unit_def_rating(attacker, defender);
   return v * v;
 }
 
-/**************************************************************************
-  See get_virtual_defense_power for the arguments att_type, def_type,
-  x, y, fortified and veteran. If use_alternative_hp is FALSE the
-  (maximum) hps of the given unit type is used. If use_alternative_hp
-  is TRUE the given alternative_hp value is used.
-**************************************************************************/
-int unit_vulnerability_virtual2(Unit_Type_id att_type, Unit_Type_id def_type,
-                               int x, int y, bool fortified, bool veteran,
-                               bool use_alternative_hp, int alternative_hp)
-{
-  int v = (get_virtual_defense_power(att_type, def_type, x, y, fortified,
-                                    veteran) *
-          (use_alternative_hp ? alternative_hp : unit_types[def_type].
-           hp) * unit_types[def_type].firepower / POWER_DIVIDER);
-  return v * v;
+/********************************************************************** 
+  Basic defence rating of this particular unit.
+***********************************************************************/
+int unit_def_rating_basic(struct unit *punit)
+{
+  return base_get_defense_power(punit) * punit->hp *
+         unit_types[punit->type].firepower / POWER_DIVIDER;
 }
 
 /********************************************************************** 
-  ...
+  Square of the previous function - used in actual computations.
 ***********************************************************************/
-static int unit_vulnerability(struct unit *punit, struct unit *pdef)
+int unit_def_rating_basic_sq(struct unit *punit)
 {
-  int v = unit_vulnerability_basic(punit, pdef);
-  return (v * v);
+  int v = unit_def_rating_basic(punit);
+  return v * v;
+}
+
+/**************************************************************************
+  Defence rating of this kind of unit, squared.
+  See get_virtual_defense_power for the arguments att_type, def_type,
+  x, y, fortified and veteran.
+**************************************************************************/
+int unittype_def_rating_sq(Unit_Type_id att_type, Unit_Type_id def_type,
+                           int x, int y, bool fortified, bool veteran)
+{
+  int v = get_virtual_defense_power(att_type, def_type, x, y,
+                                    fortified, veteran) *
+          unit_types[def_type].hp *
+          unit_types[def_type].firepower / POWER_DIVIDER;
+  return v * v;
 }
 
 /********************************************************************** 
@@ -1088,7 +1095,7 @@
                 unit_owner(pdef)->name, unit_type(pdef)->name, punit->x, 
punit->y);
       } else {
         /* See description of kill_desire() about this variables. */
-        int vuln = unit_vulnerability(punit, pdef);
+        int vuln = unit_def_rating_sq(punit, pdef);
         int attack = reinforcements_value(punit, pdef->x, pdef->y)
                      + attack_power;
         int benefit = unit_type(pdef)->build_cost;
@@ -1545,7 +1552,7 @@
                     struct unit **aunit, struct city **acity)
 {
   int dist, def, best = 0;
-  int toughness = unit_vulnerability_virtual(punit);
+  int toughness = unit_def_rating_basic_sq(punit);
 
   if (toughness == 0) {
     /* useless */
@@ -1564,7 +1571,7 @@
       continue;
     }
     dist = unit_move_turns(punit, buddy->x, buddy->y);
-    def = (toughness - unit_vulnerability_virtual(buddy));
+    def = (toughness - unit_def_rating_basic_sq(buddy));
     if (get_transporter_capacity(buddy) == 0) {
       /* Reduce want based on distance. We can't do this for
        * transports since they move around all the time, leading
@@ -1634,7 +1641,7 @@
             if (assess_defense_unit(pcity, pdef, FALSE) >= val) val = 0;
           }
         unit_list_iterate_end; /* was getting confused without the is_military 
part in */
-        if (unit_vulnerability_virtual(punit) == 0) q = 0; /* thanks, JMT, 
Paul */
+        if (unit_def_rating_basic_sq(punit) == 0) q = 0; /* thanks, JMT, Paul 
*/
         else q = (pcity->ai.danger * 2 - def * 
unit_type(punit)->attack_strength /
              unit_type(punit)->defense_strength);
 /* this was a WAG, but it works, so now it's just good code! -- Syela */
@@ -1664,8 +1671,8 @@
     /* Check if city we are on our way to rescue is still in danger,
      * or unit we should protect is still alive */
     if ((aunit && aunit->ai.bodyguard != BODYGUARD_NONE 
-         && unit_vulnerability_virtual(punit) >
-         unit_vulnerability_virtual(aunit)) ||
+         && unit_def_rating_basic_sq(punit) >
+         unit_def_rating_basic_sq(aunit)) ||
          (acity && acity->owner == punit->owner && acity->ai.urgency != 0 &&
           acity->ai.danger > assess_defense_quadratic(acity))) {
       assert(punit->ai.ai_role == AIUNIT_ESCORT);
@@ -1702,7 +1709,7 @@
 
   if (q > 0) {
     q *= 100;
-    q /= unit_vulnerability_virtual(punit);
+    q /= unit_def_rating_basic_sq(punit);
     q >>= unit_move_turns(punit, pcity->x, pcity->y);
   }
 
@@ -2071,7 +2078,7 @@
       }
       
       if ((pdef = get_defender(punit, acity->x, acity->y))) {
-        vuln = unit_vulnerability(punit, pdef);
+        vuln = unit_def_rating_sq(punit, pdef);
         benefit = unit_type(pdef)->build_cost;
       } else { 
         vuln = 0; 
@@ -2083,11 +2090,9 @@
 
       if (move_time > 1) {
         Unit_Type_id def_type = ai_choose_defender_versus(acity, punit->type);
-        int v 
-          = unit_vulnerability_virtual2(punit->type, def_type, acity->x,
-                                        acity->y, FALSE,
-                                        do_make_unit_veteran(acity, def_type),
-                                        FALSE, 0);
+        int v = unittype_def_rating_sq(punit->type, def_type,
+                                       acity->x, acity->y, FALSE,
+                                       do_make_unit_veteran(acity, def_type));
         if (v > vuln) {
           /* They can build a better defender! */ 
           vuln = v; 
@@ -2234,7 +2239,7 @@
         continue;
       }
 
-      vuln = unit_vulnerability(punit, aunit);
+      vuln = unit_def_rating_sq(punit, aunit);
       benefit = unit_type(aunit)->build_cost;
  
       move_time = turns_to_enemy_unit(punit->type, move_rate, 

[Prev in Thread] Current Thread [Next in Thread]