Mercurial Mercurial > sheepy-clone / 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 79 29b477319854
parent 78 66bb79dd248d
child 80 3c3dc6a148ca
equal deleted inserted replaced
78:66bb79dd248d 79:29b477319854 
    37 
    37 
    38 function TestBazooka(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    38 function TestBazooka(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    39 function TestGrenade(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    39 function TestGrenade(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    40 function TestShotgun(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    40 function TestShotgun(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    41 function TestDesertEagle(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    41 function TestDesertEagle(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
       
    42 function TestBaseballBat(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    42 
    43 
    43 type TAmmoTestProc = function (Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    44 type TAmmoTestProc = function (Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
    44 const AmmoTests: array[TAmmoType] of TAmmoTestProc =
 
    45 const AmmoTests: array[TAmmoType] of TAmmoTestProc =
 
    45                  (
 
    46                  (
 
    46 {amGrenade}       TestGrenade,
 
    47 {amGrenade}       TestGrenade,
 
    51 {amPickHammer}    nil,
 
    52 {amPickHammer}    nil,
 
    52 {amSkip}          nil,
 
    53 {amSkip}          nil,
 
    53 {amRope}          nil,
 
    54 {amRope}          nil,
 
    54 {amMine}          nil,
 
    55 {amMine}          nil,
 
    55 {amDEagle}        TestDesertEagle,
 
    56 {amDEagle}        TestDesertEagle,
 
    56 {amDynamite}      nil
 
    57 {amDynamite}      nil,
 
       
    58 {amBaseballBat}   TestBaseballBat
 
    57                   );
 
    59                   );
 
    58 
    60 
    59 implementation
 
    61 implementation
 
    60 uses uMisc, uAIMisc, uLand;
 
    62 uses uMisc, uAIMisc, uLand;
 
    61 const BadTurn = Low(integer);
 
    63 const BadTurn = Low(integer);
 
   173 end;
 
   175 end;
 
   174 
   176 
   175 function TestShotgun(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   177 function TestShotgun(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   176 var Vx, Vy, x, y: real;
 
   178 var Vx, Vy, x, y: real;
 
   177 begin
 
   179 begin
 
       
   180 ExplR:= 0;
 
   178 if Metric(round(Me.X), round(Me.Y), Targ.X, Targ.Y) < 80 then
 
   181 if Metric(round(Me.X), round(Me.Y), Targ.X, Targ.Y) < 80 then
 
   179    begin
 
   182    begin
 
   180    Result:= BadTurn;
 
   183    Result:= BadTurn;
 
   181    exit
 
   184    exit
 
   182    end;
 
   185    end;
 
   183 Time:= 0;
 
   186 Time:= 0;
 
   184 Power:= 1;
 
   187 Power:= 1;
 
   185 ExplR:= 0;
 
       
   186 Vx:= (Targ.X - Me.X)/1024;
 
   188 Vx:= (Targ.X - Me.X)/1024;
 
   187 Vy:= (Targ.Y - Me.Y)/1024;
 
   189 Vy:= (Targ.Y - Me.Y)/1024;
 
   188 x:= Me.X;
 
   190 x:= Me.X;
 
   189 y:= Me.Y;
 
   191 y:= Me.Y;
 
   190 Angle:= DxDy2AttackAngle(Vx, -Vy);
 
   192 Angle:= DxDy2AttackAngle(Vx, -Vy);
 
   191 repeat
 
   193 repeat
 
   192   x:= x + vX;
 
   194   x:= x + vX;
 
   193   y:= y + vY;
 
   195   y:= y + vY;
 
   194   if TestColl(round(x), round(y), 2) then
 
   196   if TestColl(round(x), round(y), 2) then
 
   195      begin
 
   197      begin
 
   196      Result:= RateExplosion(Me, round(x), round(y), 25) * 2;
 
   198      Result:= RateShove(Me, round(x), round(y), 25, 25) * 1024;
 
   197      if Result = 0 then Result:= - Metric(Targ.X, Targ.Y, round(x), round(y)) div 64;
 
   199      if Result = 0 then Result:= - Metric(Targ.X, Targ.Y, round(x), round(y)) div 64;
 
   198      exit
 
   200      exit
 
   199      end
 
   201      end
 
   200 until (abs(Targ.X - x) + abs(Targ.Y - y) < 4) or (x < 0) or (y < 0) or (x > 2048) or (y > 1024);
 
   202 until (abs(Targ.X - x) + abs(Targ.Y - y) < 4) or (x < 0) or (y < 0) or (x > 2048) or (y > 1024);
 
   201 Result:= BadTurn
 
   203 Result:= BadTurn
 
   203 
   205 
   204 function TestDesertEagle(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   206 function TestDesertEagle(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
   205 var Vx, Vy, x, y, t: real;
 
   207 var Vx, Vy, x, y, t: real;
 
   206     d: Longword;
 
   208     d: Longword;
 
   207 begin
 
   209 begin
 
       
   210 ExplR:= 0;
 
   208 if abs(Me.X - Targ.X) + abs(Me.Y - Targ.Y) < 80 then
 
   211 if abs(Me.X - Targ.X) + abs(Me.Y - Targ.Y) < 80 then
 
   209    begin
 
   212    begin
 
   210    Result:= BadTurn;
 
   213    Result:= BadTurn;
 
   211    exit
 
   214    exit
 
   212    end;
 
   215    end;
 
   213 Time:= 0;
 
   216 Time:= 0;
 
   214 Power:= 1;
 
   217 Power:= 1;
 
   215 ExplR:= 0;
 
       
   216 t:= sqrt(sqr(Targ.X - Me.X) + sqr(Targ.Y - Me.Y)) * 2;
 
   218 t:= sqrt(sqr(Targ.X - Me.X) + sqr(Targ.Y - Me.Y)) * 2;
 
   217 Vx:= (Targ.X - Me.X) / t;
 
   219 Vx:= (Targ.X - Me.X) / t;
 
   218 Vy:= (Targ.Y - Me.Y) / t;
 
   220 Vy:= (Targ.Y - Me.Y) / t;
 
   219 x:= Me.X;
 
   221 x:= Me.X;
 
   220 y:= Me.Y;
 
   222 y:= Me.Y;
 
   228 until (abs(Targ.X - x) + abs(Targ.Y - y) < 2) or (x < 0) or (y < 0) or (x > 2048) or (y > 1024) or (d > 200);
 
   230 until (abs(Targ.X - x) + abs(Targ.Y - y) < 2) or (x < 0) or (y < 0) or (x > 2048) or (y > 1024) or (d > 200);
 
   229 if abs(Targ.X - x) + abs(Targ.Y - y) < 2 then Result:= max(0, (4 - d div 50) * 7 * 1024)
 
   231 if abs(Targ.X - x) + abs(Targ.Y - y) < 2 then Result:= max(0, (4 - d div 50) * 7 * 1024)
 
   230                                          else Result:= Low(integer)
 
   232                                          else Result:= Low(integer)
 
   231 end;
 
   233 end;
 
   232 
   234 
       
   235 function TestBaseballBat(Me: PGear; Targ: TPoint; out Time: Longword; out Angle, Power: integer; out ExplX, ExplY, ExplR: integer): integer;
 
       
   236 begin
 
       
   237 ExplR:= 0;
 
       
   238 if abs(Me.X - Targ.X) + abs(Me.Y - Targ.Y) >= 25 then
 
       
   239    begin
 
       
   240    Result:= BadTurn;
 
       
   241    exit
 
       
   242    end;
 
       
   243 Time:= 0;
 
       
   244 Power:= 1;
 
       
   245 Angle:= DxDy2AttackAngle(Sign(Targ.X - Me.X), 1);
 
       
   246 Result:= RateShove(Me, round(Me.X) + 10 * Sign(Targ.X - Me.X), round(Me.Y), 15, 30)
 
       
   247 end;
 
       
   248 
   233 end.
 
   249 end.
sheepy-clone