Mercurial Mercurial > hedgewars / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hedgewars/uAIAmmoTests.pas
changeset 351 29bc9c36ad5f
parent 302 7aca131ecd7f
child 369 2aed85310727
equal deleted inserted replaced
350:c3ccec3834e8 351:29bc9c36ad5f 
    16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 
    16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 
    17  *)
 
    17  *)
 
    18 
    18 
    19 unit uAIAmmoTests;
 
    19 unit uAIAmmoTests;
 
    20 interface
 
    20 interface
 
    21 uses SDLh, uGears, uConsts;
 
    21 uses SDLh, uGears, uConsts, uFloat;
 
    22 
    22 
    23 function TestBazooka(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    23 (*function TestBazooka(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    24 function TestGrenade(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    24 function TestGrenade(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    25 function TestShotgun(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    25 function TestShotgun(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    26 function TestDesertEagle(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    26 function TestDesertEagle(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    27 function TestBaseballBat(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    27 function TestBaseballBat(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    28 function TestFirePunch(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    28 function TestFirePunch(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    48 {amMineStrike}    nil,
 
    48 {amMineStrike}    nil,
 
    49 {amBlowTorch}     nil
 
    49 {amBlowTorch}     nil
 
    50                   );
 
    50                   );
 
    51 
    51 
    52 const BadTurn = Low(integer);
 
    52 const BadTurn = Low(integer);
 
       
    53 *)
 
    53 
    54 
    54 implementation
 
    55 implementation
 
    55 uses uMisc, uAIMisc, uLand;
 
    56 uses uMisc, uAIMisc, uLand;
 
    56 
    57 {
 
    57 function Metric(x1, y1, x2, y2: integer): integer;
 
    58 function Metric(x1, y1, x2, y2: integer): integer;
 
    58 begin
 
    59 begin
 
    59 Result:= abs(x1 - x2) + abs(y1 - y2)
 
    60 Result:= abs(x1 - x2) + abs(y1 - y2)
 
    60 end;
 
    61 end;
 
    61 
    62 
    62 function TestBazooka(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    63 function TestBazooka(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    63 var Vx, Vy, r: Double;
 
    64 var Vx, Vy, r: hwFloat;
 
    64     rTime: Double;
 
    65     rTime: hwFloat;
 
    65     Score, EX, EY: integer;
 
    66     Score, EX, EY: integer;
 
    66 
    67 
    67     function CheckTrace: integer;
 
    68     function CheckTrace: integer;
 
    68     var x, y, dX, dY: Double;
 
    69     var x, y, dX, dY: hwFloat;
 
    69         t: integer;
 
    70         t: integer;
 
    70     begin
 
    71     begin
 
    71     x:= Me.X;
 
    72     x:= Me.X;
 
    72     y:= Me.Y;
 
    73     y:= Me.Y;
 
    73     dX:= Vx;
 
    74     dX:= Vx;
 
   113 until (rTime >= 4500)
 
   114 until (rTime >= 4500)
 
   114 end;
 
   115 end;
 
   115 
   116 
   116 function TestGrenade(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   117 function TestGrenade(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   117 const tDelta = 24;
 
   118 const tDelta = 24;
 
   118 var Vx, Vy, r: Double;
 
   119 var Vx, Vy, r: hwFloat;
 
   119     Score, EX, EY: integer;
 
   120     Score, EX, EY: integer;
 
   120     TestTime: Longword;
 
   121     TestTime: Longword;
 
   121 
   122 
   122     function CheckTrace: integer;
 
   123     function CheckTrace: integer;
 
   123     var x, y, dY: Double;
 
   124     var x, y, dY: hwFloat;
 
   124         t: integer;
 
   125         t: integer;
 
   125     begin
 
   126     begin
 
   126     x:= Me.X;
 
   127     x:= Me.X;
 
   127     y:= Me.Y;
 
   128     y:= Me.Y;
 
   128     dY:= -Vy;
 
   129     dY:= -Vy;
 
   165      end
 
   166      end
 
   166 until (TestTime = 5000)
 
   167 until (TestTime = 5000)
 
   167 end;
 
   168 end;
 
   168 
   169 
   169 function TestShotgun(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   170 function TestShotgun(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   170 var Vx, Vy, x, y: Double;
 
   171 var Vx, Vy, x, y: hwFloat;
 
   171 begin       
   172 begin       
   172 ExplR:= 0;
 
   173 ExplR:= 0;
 
   173 if Metric(round(Me.X), round(Me.Y), Targ.X, Targ.Y) < 80 then
 
   174 if Metric(round(Me.X), round(Me.Y), Targ.X, Targ.Y) < 80 then
 
   174    begin
 
   175    begin
 
   175    Result:= BadTurn;
 
   176    Result:= BadTurn;
 
   195 until (abs(Targ.X - x) + abs(Targ.Y - y) < 4) or (x < 0) or (y < 0) or (x > 2048) or (y > 1024);
 
   196 until (abs(Targ.X - x) + abs(Targ.Y - y) < 4) or (x < 0) or (y < 0) or (x > 2048) or (y > 1024);
 
   196 Result:= BadTurn
 
   197 Result:= BadTurn
 
   197 end;
 
   198 end;
 
   198 
   199 
   199 function TestDesertEagle(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   200 function TestDesertEagle(Me: PGear; Targ: TPoint; Level: Integer; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   200 var Vx, Vy, x, y, t: Double;
 
   201 var Vx, Vy, x, y, t: hwFloat;
 
   201     d: Longword;
 
   202     d: Longword;
 
   202 begin
 
   203 begin
 
   203 ExplR:= 0;
 
   204 ExplR:= 0;
 
   204 if abs(Me.X - Targ.X) + abs(Me.Y - Targ.Y) < 80 then
 
   205 if abs(Me.X - Targ.X) + abs(Me.Y - Targ.Y) < 80 then
 
   205    begin
 
   206    begin
 
   255 Result:= 0;
 
   256 Result:= 0;
 
   256 for i:= 0 to 4 do
 
   257 for i:= 0 to 4 do
 
   257     Result:= Result + RateShove(Me, round(Me.X) + 10 * hwSign(Targ.X - Me.X), round(Me.Y) - 20 * i - 5, 10, 30);
 
   258     Result:= Result + RateShove(Me, round(Me.X) + 10 * hwSign(Targ.X - Me.X), round(Me.Y) - 20 * i - 5, 10, 30);
 
   258 if Result <= 0 then Result:= BadTurn
 
   259 if Result <= 0 then Result:= BadTurn
 
   259 end;
 
   260 end;
 
   260 
   261 }
 
   261 end.
 
   262 end.
hedgewars