[Freeciv-Dev] Re: [PATCH] [1.1] move some common AI equations to kill_desire() (PR#1279)

[Raahul Kumar <raahul_da_man@xxxxxxxxx>]

--- Petr Baudis <pasky@xxxxxxxxxxx> wrote:
> Hello,
> 
>   attached patch introduces kill_desire() function, where it moves another
> common equation used in AI military functions.  Behaviour is not changed
> (autogames are same). Oh, yes, and it seems to me that it compiles.
> 

It looks ok. I'm disappointed more lines did not disappear, but that is
probably in the future.

>   I think it's ready to actually go in, altough I'm open to objections and
> ideas how to extend/correct it even more. The patch is pretty obvious and
> tiny
> and I want to keep it so - no more cleanups in this round. It unfortunately
> removes much less common code than I expected first, but anyway, it won't
> hurt,
> and I may move more redundant code to common functions in the future. I
> however
> hope that it'll get commited fast :).
> 
>   Ah, note that this patch is obviously only fifh in very long line. And as
> I'm
> modifying more files at once now, I'm counting revisions of the patch from
> 1.1.
>

Yikes. Heading off to your website now.
 
>   Happy reviewing ;),
> 
> -- 
> 
>                               Petr "Pasky" Baudis
> 
> * elinks maintainer                * IPv6 guy (XS26 co-coordinator)
> * IRCnet operator                  * FreeCiv AI hacker
> .
> No one can feel as helpless as the owner of a sick goldfish.
> .
> Public PGP key && geekcode && homepage: http://pasky.ji.cz/~pasky/
> > Index: advdomestic.c
> ===================================================================
> RCS file: /home/cvs/aiciv/freeciv-a2/ai/advdomestic.c,v
> retrieving revision 1.1.1.5
> retrieving revision 1.20
> diff -u -r1.1.1.5 -r1.20
> Index: advmilitary.c
> ===================================================================
> RCS file: /home/cvs/aiciv/freeciv-a2/ai/advmilitary.c,v
> retrieving revision 1.1.1.9
> retrieving revision 1.2
> diff -u -r1.1.1.9 -r1.2
> --- advmilitary.c     22 Feb 2002 19:32:40 -0000      1.1.1.9
> +++ advmilitary.c     24 Feb 2002 21:36:20 -0000      1.2
> @@ -620,7 +620,7 @@
>                unit_types[i].move_type == HELI_MOVING) && acity &&
>                acity->ai.invasion == 2) b0 = f * SHIELD_WEIGHTING;
>        else {
> -        b0 = (b * a - (f + (acity ? acity->ai.f : 0)) * d) * g *
> SHIELD_WEIGHTING / (a + g * d);
> +        b0 = kill_desire(b, a, (f + (acity ? acity->ai.f : 0)), d, g);
>          if (acity && b * acity->ai.a * acity->ai.a > acity->ai.f * d)
>            b0 -= (b * acity->ai.a * acity->ai.a - acity->ai.f * d) *
>                             g * SHIELD_WEIGHTING / (acity->ai.a * acity->ai.a
> + g * d);

Kill those a,b,c,d. I think you have better names for those.

> @@ -826,7 +826,7 @@
>                unit_types[v].move_type == HELI_MOVING) && acity &&
>                acity->ai.invasion == 2) b0 = f * SHIELD_WEIGHTING;
>      else {
> -      b0 = (b * a - (f + (acity ? acity->ai.f : 0)) * d) * g *
> SHIELD_WEIGHTING / (a + g * d);
> +      b0 = kill_desire(b, a, (f + (acity ? acity->ai.f : 0)), d, g);
>        if (acity && b * acity->ai.a * acity->ai.a > acity->ai.f * d)
>          b0 -= (b * acity->ai.a * acity->ai.a - acity->ai.f * d) *
>                 g * SHIELD_WEIGHTING / (acity->ai.a * acity->ai.a + g * d);
> Index: aiunit.c
> ===================================================================
> RCS file: /home/cvs/aiciv/freeciv-a2/ai/aiunit.c,v
> retrieving revision 1.1.1.10
> retrieving revision 1.45
> diff -u -r1.1.1.10 -r1.45
> --- aiunit.c  23 Feb 2002 21:03:31 -0000      1.1.1.10
> +++ aiunit.c  24 Feb 2002 21:36:20 -0000      1.45
> @@ -616,6 +616,30 @@
>  }
>  
>  /**************************************************************************
> +Compute how much we want to kill certain victim we've chosen.
> +
> +Benefit is something like 'attractiveness' of the victim, how nice it would
> be
> +to destroy it. Larger value, worse loss for enemy.
> +
> +Attack is the total possible attack power we can throw on the victim. Note
> that
> +we will even square this.
> +
> +Loss is the possible loss when we would lose the unit we want to attack.
> +
> +Vuln is vulnerability of our unit when attacking the enemy.
> +**************************************************************************/

Victim count is the only one missing. Victim count does not count stacked units
right as far as I know.

> +int kill_desire(int benefit, int attack, int loss, int vuln, int
> victim_count)
> +{
> +  int desire;
> +
> +  /*         attractiveness     danger */ 
> +  desire = ((benefit * attack - loss * vuln) * victim_count *
> SHIELD_WEIGHTING
> +            / (attack + vuln * victim_count));
> +
> +  return desire;
> +}
> +
> +/**************************************************************************
>  Military "want" estimates are amortized in this complicated way.
>  COMMENTME: Why not use simple amortize? -- GB

Greg, what happens if you do use simple amortize?

>  **************************************************************************/
> @@ -805,20 +829,10 @@
>                  unit_owner(pdef)->name, unit_type(pdef)->name);
>          
>        } else {
> +        /* See description of kill_desire() about this variables. */
>          int vuln = unit_vulnerability(punit, pdef);
> -        
> -        /* The total possible attack power we can throw on the victim. Note
> -         * that we will even square this. */
>          int attack = reinforcements_value(punit, pdef->x, pdef->y) + bellig;
> -        
> -        /* Something like 'attractiveness' of the victim, how nice it would
> be
> -         * to destroy it. Larger value, worse loss for enemy. */
>          int benefit = unit_type(pdef)->build_cost;
> -        
> -        /* We're only dealing with adjacent victims here. */
> -        int move_cost = 0;
> -        
> -        /* The possible loss when we would lose the unit we want to attack.
> */
>          int loss = unit_type(punit)->build_cost;
>          
>          attack *= attack;
> @@ -836,15 +850,10 @@
>          /* If we have non-zero belligerence... */
>          if (attack > 0 && is_my_turn(punit, pdef)) {
>            int desire;
> -          
> -          /* TODO: This equation is simplified version of much worse ones in
> -           * that long fat routines, but it's still a common pattern, so we
> -           * will can this equation to one separate readable function. We'll
> -           * also be able to remove move_cost and loss variables. */
> -         
> -          /*         attractiveness     danger */ 
> -          desire = ((benefit * attack - loss * vuln) * SHIELD_WEIGHTING
> -                    / (attack + vuln) - move_cost * SHIELD_WEIGHTING);
> +
> +          /* FIXME? Why we don't use stack_size as victim_count? --pasky */
> +
> +          desire = kill_desire(benefit, attack, loss, vuln, 1);
>            
>            /* No need to amortize! We're doing it in one-turn horizon (?). */
>            
> @@ -1520,7 +1529,7 @@
>            else if ((is_ground_unit(punit) || is_heli_unit(punit)) &&
>                     acity->ai.invasion == 2) b0 = f * SHIELD_WEIGHTING;
>            else {
> -            b0 = (b * a - (f + acity->ai.f) * d) * g * SHIELD_WEIGHTING / (a
> + g * d);
> +            b0 = kill_desire(b, a, (f + acity->ai.f), d, g);
>              if (b * acity->ai.a * acity->ai.a > acity->ai.f * d)
>                 b0 -= (b * acity->ai.a * acity->ai.a - acity->ai.f * d) *
>                        g * SHIELD_WEIGHTING / (acity->ai.a * acity->ai.a + g
> * d);
> Index: aiunit.h
> ===================================================================
> RCS file: /home/cvs/aiciv/freeciv-a2/ai/aiunit.h,v
> retrieving revision 1.1.1.4
> retrieving revision 1.7
> diff -u -r1.1.1.4 -r1.7
> --- aiunit.h  19 Feb 2002 19:33:54 -0000      1.1.1.4
> +++ aiunit.h  24 Feb 2002 21:36:21 -0000      1.7
> @@ -37,6 +37,7 @@
>  int unit_vulnerability_basic(struct unit *punit, struct unit *pdef);
>  int unit_vulnerability_virtual(struct unit *punit);
>  int unit_vulnerability(struct unit *punit, struct unit *pdef);
> +int kill_desire(int benefit, int attack, int loss, int vuln, int
> attack_count);
>  int military_amortize(int value, int delay, int build_cost);
>  
>  bool is_on_unit_upgrade_path(Unit_Type_id test, Unit_Type_id base);
> 


__________________________________________________
Do You Yahoo!?
Yahoo! Sports - Coverage of the 2002 Olympic Games
http://sports.yahoo.com