author  unc0rr 
Sun, 28 Sep 2008 22:47:13 +0000  
changeset 1296  d7fffad44b7e 
parent 1293  5943efa67299 
child 1507  d18c67b7ad4c 
permissions  rwrr 
71  1 
(* 
1066  2 
* Hedgewars, a free turn based strategy game 
883  3 
* Copyright (c) 20052008 Andrey Korotaev <unC0Rr@gmail.com> 
71  4 
* 
183  5 
* This program is free software; you can redistribute it and/or modify 
6 
* it under the terms of the GNU General Public License as published by 

7 
* the Free Software Foundation; version 2 of the License 

71  8 
* 
183  9 
* This program is distributed in the hope that it will be useful, 
10 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 

11 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

12 
* GNU General Public License for more details. 

71  13 
* 
183  14 
* You should have received a copy of the GNU General Public License 
15 
* along with this program; if not, write to the Free Software 

16 
* Foundation, Inc., 59 Temple Place  Suite 330, Boston, MA 021111307, USA 

71  17 
*) 
18 

4  19 
unit uAIAmmoTests; 
20 
interface 

351  21 
uses SDLh, uGears, uConsts, uFloat; 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

22 
const amtest_OnTurn = $00000001; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

23 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

24 
type TAttackParams = record 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

25 
Time: Longword; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

26 
Angle, Power: LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

27 
ExplX, ExplY, ExplR: LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

28 
AttackPutX, AttackPutY: LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

29 
end; 
433  30 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

31 
function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

32 
function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
994  33 
function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

34 
function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

35 
function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

36 
function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

37 
function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

38 
function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

39 

465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

40 
type TAmmoTestProc = function (Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

41 
TAmmoTest = record 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

42 
proc: TAmmoTestProc; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

43 
flags: Longword; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

44 
end; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

45 

465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

46 
const AmmoTests: array[TAmmoType] of TAmmoTest = 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

47 
( 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

48 
(proc: @TestGrenade; flags: 0), // amGrenade 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

49 
(proc: nil; flags: 0), // amClusterBomb 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

50 
(proc: @TestBazooka; flags: 0), // amBazooka 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

51 
(proc: nil; flags: 0), // amUFO 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

52 
(proc: @TestShotgun; flags: 0), // amShotgun 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

53 
(proc: nil; flags: 0), // amPickHammer 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

54 
(proc: nil; flags: 0), // amSkip 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

55 
(proc: nil; flags: 0), // amRope 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

56 
(proc: nil; flags: 0), // amMine 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

57 
(proc: @TestDesertEagle; flags: 0), // amDEagle 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

58 
(proc: nil; flags: 0), // amDynamite 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

59 
(proc: @TestFirePunch; flags: 0), // amFirePunch 
925  60 
(proc: nil; flags: 0), // amWhip 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

61 
(proc: @TestBaseballBat; flags: 0), // amBaseballBat 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

62 
(proc: nil; flags: 0), // amParachute 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

63 
(proc: @TestAirAttack; flags: amtest_OnTurn), // amAirAttack 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

64 
(proc: nil; flags: 0), // amMineStrike 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

65 
(proc: nil; flags: 0), // amBlowTorch 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

66 
(proc: nil; flags: 0), // amGirder 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

67 
(proc: nil; flags: amtest_OnTurn), // amTeleport 
924  68 
(proc: nil; flags: 0), // amSwitch 
994  69 
(proc: @TestMortar; flags: 0), // amMortar 
1088  70 
(proc: nil; flags: 0), // amKamikaze 
1221  71 
(proc: nil; flags: 0), // amCake 
1261  72 
(proc: nil; flags: 0), // amSeduction 
1263  73 
(proc: nil; flags: 0), // amBanana 
74 
(proc: nil; flags: 0) // amHellishBomb 

66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

75 
); 
4  76 

439  77 
const BadTurn = Low(LongInt) div 4; 
369  78 

4  79 
implementation 
75  80 
uses uMisc, uAIMisc, uLand; 
370
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

81 

371  82 
function Metric(x1, y1, x2, y2: LongInt): LongInt; 
4  83 
begin 
370
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

84 
Metric:= abs(x1  x2) + abs(y1  y2) 
4  85 
end; 
86 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

87 
function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
351  88 
var Vx, Vy, r: hwFloat; 
498  89 
rTime: LongInt; 
371  90 
Score, EX, EY: LongInt; 
91 
Result: LongInt; 

4  92 

371  93 
function CheckTrace: LongInt; 
351  94 
var x, y, dX, dY: hwFloat; 
371  95 
t: LongInt; 
96 
Result: LongInt; 

4  97 
begin 
370
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

98 
x:= Me^.X; 
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

99 
y:= Me^.Y; 
4  100 
dX:= Vx; 
101 
dY:= Vy; 

498  102 
t:= rTime; 
4  103 
repeat 
104 
x:= x + dX; 

105 
y:= y + dY; 

106 
dX:= dX + cWindSpeed; 

107 
dY:= dY + cGravity; 

108 
dec(t) 

370
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

109 
until TestColl(hwRound(x), hwRound(y), 5) or (t <= 0); 
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

110 
EX:= hwRound(x); 
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

111 
EY:= hwRound(y); 
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

112 
Result:= RateExplosion(Me, EX, EY, 101); 
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

113 
if Result = 0 then Result:=  Metric(Targ.X, Targ.Y, EX, EY) div 64; 
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

114 
CheckTrace:= Result 
4  115 
end; 
116 

117 
begin 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

118 
ap.Time:= 0; 
375  119 
rTime:= 350; 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

120 
ap.ExplR:= 0; 
70  121 
Result:= BadTurn; 
4  122 
repeat 
375  123 
rTime:= rTime + 300 + Level * 50 + random(300); 
556
49675457d76e
Bots aims not directly at the center of enemy hedgehog
unc0rr
parents:
554
diff
changeset

124 
Vx:=  cWindSpeed * rTime * _0_5 + (int2hwFloat(Targ.X + AIrndSign(2))  Me^.X) / int2hwFloat(rTime); 
498  125 
Vy:= cGravity * rTime * _0_5  (int2hwFloat(Targ.Y)  Me^.Y) / int2hwFloat(rTime); 
370
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

126 
r:= Distance(Vx, Vy); 
498  127 
if not (r > _1) then 
4  128 
begin 
64  129 
Score:= CheckTrace; 
130 
if Result <= Score then 

131 
begin 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

132 
ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random((Level  1) * 9)); 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

133 
ap.Power:= hwRound(r * cMaxPower)  random((Level  1) * 17 + 1); 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

134 
ap.ExplR:= 100; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

135 
ap.ExplX:= EX; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

136 
ap.ExplY:= EY; 
143  137 
Result:= Score 
64  138 
end; 
4  139 
end 
375  140 
until (rTime > 4250); 
370
c75410fe3133
 Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset

141 
TestBazooka:= Result 
39  142 
end; 
374  143 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

144 
function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
70  145 
const tDelta = 24; 
351  146 
var Vx, Vy, r: hwFloat; 
374  147 
Score, EX, EY, Result: LongInt; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

148 
TestTime: Longword; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

149 

371  150 
function CheckTrace: LongInt; 
351  151 
var x, y, dY: hwFloat; 
371  152 
t: LongInt; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

153 
begin 
374  154 
x:= Me^.X; 
155 
y:= Me^.Y; 

66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

156 
dY:= Vy; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

157 
t:= TestTime; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

158 
repeat 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

159 
x:= x + Vx; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

160 
y:= y + dY; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

161 
dY:= dY + cGravity; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

162 
dec(t) 
374  163 
until TestColl(hwRound(x), hwRound(y), 5) or (t = 0); 
164 
EX:= hwRound(x); 

165 
EY:= hwRound(y); 

166 
if t < 50 then CheckTrace:= RateExplosion(Me, EX, EY, 101) 

994  167 
else CheckTrace:= BadTurn 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

168 
end; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

169 

9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

170 
begin 
70  171 
Result:= BadTurn; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

172 
TestTime:= 0; 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

173 
ap.ExplR:= 0; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

174 
repeat 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

175 
inc(TestTime, 1000); 
498  176 
Vx:= (int2hwFloat(Targ.X)  Me^.X) / int2hwFloat(TestTime + tDelta); 
177 
Vy:= cGravity * ((TestTime + tDelta) div 2)  (int2hwFloat(Targ.Y)  Me^.Y) / int2hwFloat(TestTime + tDelta); 

374  178 
r:= Distance(Vx, Vy); 
498  179 
if not (r > _1) then 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

180 
begin 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

181 
Score:= CheckTrace; 
70  182 
if Result < Score then 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

183 
begin 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

184 
ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level)); 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

185 
ap.Power:= hwRound(r * cMaxPower) + AIrndSign(random(Level) * 15); 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

186 
ap.Time:= TestTime; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

187 
ap.ExplR:= 100; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

188 
ap.ExplX:= EX; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

189 
ap.ExplY:= EY; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

190 
Result:= Score 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

191 
end; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

192 
end 
439  193 
until (TestTime = 4000); 
374  194 
TestGrenade:= Result 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

195 
end; 
375  196 

994  197 
function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
198 
const tDelta = 24; 

1001  199 
var Vx, Vy: hwFloat; 
994  200 
Score, EX, EY, Result: LongInt; 
201 
TestTime: Longword; 

202 

203 
function CheckTrace: LongInt; 

204 
var x, y, dY: hwFloat; 

998  205 
Result: LongInt; 
994  206 
begin 
998  207 
x:= Me^.X; 
208 
y:= Me^.Y; 

209 
dY:= Vy; 

210 

211 
repeat 

212 
x:= x + Vx; 

213 
y:= y + dY; 

214 
dY:= dY + cGravity; 

215 
EX:= hwRound(x); 

216 
EY:= hwRound(y); 

217 
until TestColl(EX, EY, 5) or (EY > 1000); 

218 

1176
2969efb7050f
Disallow AI to hurts itself with mortar (in quite rare cases it tries to shoot directly up)
unc0rr
parents:
1089
diff
changeset

219 
if (EY < 1000) and not dY.isNegative then 
998  220 
begin 
221 
Result:= RateExplosion(Me, EX, EY, 91); 

222 
if (Result = 0) then 

223 
if (dY > _0_15) then 

1024  224 
Result:=  abs(Targ.Y  EY) div 32 
998  225 
else 
226 
Result:= BadTurn 

227 
else if (Result < 0) then Result:= BadTurn 

228 
end 

229 
else 

230 
Result:= BadTurn; 

231 

232 
CheckTrace:= Result 

994  233 
end; 
234 

235 
function Solve: LongWord; 

236 
var A, B, D, T: hwFloat; 

237 
C: LongInt; 

238 
begin 

998  239 
A:= hwSqr(cGravity) * _0_25; 
240 
B:=  cGravity * (Targ.Y  hwRound(Me^.Y))  _1; 

241 
C:= sqr(Targ.Y  hwRound(Me^.Y)) + sqr(Targ.X  hwRound(Me^.X)); 

242 
D:= hwSqr(B)  (A * C * 4); 

994  243 
if D.isNegative = false then 
998  244 
begin 
245 
D:= (  B + hwSqrt(D)) * _0_5 / A; 

246 
if D.isNegative = false then 

247 
T:= hwSqrt(D) 

248 
else 

249 
T:= _0; 

250 
Solve:= hwRound(T) 

251 
end else Solve:= 0 

994  252 
end; 
253 

254 
begin 

255 
Result:= BadTurn; 

256 
ap.ExplR:= 0; 

257 

998  258 
if (Level > 2) then exit(BadTurn); 
994  259 

260 
TestTime:= Solve; 

261 

998  262 
if TestTime = 0 then exit(BadTurn); 
994  263 

264 
Vx:= (int2hwFloat(Targ.X)  Me^.X) / int2hwFloat(TestTime); 

265 
Vy:= cGravity * (TestTime div 2)  (int2hwFloat(Targ.Y)  Me^.Y) / int2hwFloat(TestTime); 

266 

267 
Score:= CheckTrace; 

268 
if Result < Score then 

269 
begin 

270 
ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level)); 

271 
ap.Power:= 1; 

272 
ap.ExplR:= 100; 

273 
ap.ExplX:= EX; 

274 
ap.ExplY:= EY; 

275 
Result:= Score 

276 
end; 

277 

278 
TestMortar:= Result 

279 
end; 

280 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

281 
function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
351  282 
var Vx, Vy, x, y: hwFloat; 
375  283 
rx, ry, Result: LongInt; 
284 
begin 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

285 
ap.ExplR:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

286 
ap.Time:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

287 
ap.Power:= 1; 
439  288 
if Metric(hwRound(Me^.X), hwRound(Me^.Y), Targ.X, Targ.Y) < 80 then 
289 
exit(BadTurn); 

498  290 
Vx:= (int2hwFloat(Targ.X)  Me^.X) * _1div1024; 
291 
Vy:= (int2hwFloat(Targ.Y)  Me^.Y) * _1div1024; 

375  292 
x:= Me^.X; 
293 
y:= Me^.Y; 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

294 
ap.Angle:= DxDy2AttackAngle(Vx, Vy); 
70  295 
repeat 
296 
x:= x + vX; 

297 
y:= y + vY; 

375  298 
rx:= hwRound(x); 
299 
ry:= hwRound(y); 

300 
if TestColl(rx, ry, 2) then 

70  301 
begin 
509  302 
x:= x + vX * 8; 
303 
y:= y + vY * 8; 

304 
Result:= RateShotgun(Me, rx, ry) * 2; 

375  305 
if Result = 0 then Result:=  Metric(Targ.X, Targ.Y, rx, ry) div 64 
143  306 
else dec(Result, Level * 4000); 
375  307 
exit(Result) 
70  308 
end 
498  309 
until (Abs(Targ.X  hwRound(x)) + Abs(Targ.Y  hwRound(y)) < 4) or (x < _0) or (y < _0) or (x > _2048) or (y > _1024); 
375  310 
TestShotgun:= BadTurn 
70  311 
end; 
438  312 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

313 
function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
351  314 
var Vx, Vy, x, y, t: hwFloat; 
75  315 
d: Longword; 
438  316 
Result: LongInt; 
75  317 
begin 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

318 
ap.ExplR:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

319 
ap.Time:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

320 
ap.Power:= 1; 
498  321 
if Abs(hwRound(Me^.X)  Targ.X) + Abs(hwRound(Me^.Y)  Targ.Y) < 80 then 
439  322 
exit(BadTurn); 
498  323 
t:= _0_5 / Distance(int2hwFloat(Targ.X)  Me^.X, int2hwFloat(Targ.Y)  Me^.Y); 
324 
Vx:= (int2hwFloat(Targ.X)  Me^.X) * t; 

325 
Vy:= (int2hwFloat(Targ.Y)  Me^.Y) * t; 

438  326 
x:= Me^.X; 
327 
y:= Me^.Y; 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

328 
ap.Angle:= DxDy2AttackAngle(Vx, Vy); 
75  329 
d:= 0; 
330 
repeat 

331 
x:= x + vX; 

332 
y:= y + vY; 

438  333 
if ((hwRound(x) and $FFFFF800) = 0)and((hwRound(y) and $FFFFFC00) = 0) 
334 
and (Land[hwRound(y), hwRound(x)] <> 0) then inc(d); 

498  335 
until (Abs(Targ.X  hwRound(x)) + Abs(Targ.Y  hwRound(y)) < 4) or (x < _0) or (y < _0) or (x > _2048) or (y > _1024) or (d > 200); 
336 
if Abs(Targ.X  hwRound(x)) + Abs(Targ.Y  hwRound(y)) < 3 then Result:= max(0, (4  d div 50) * 7 * 1024) 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

337 
else Result:= BadTurn; 
438  338 
TestDesertEagle:= Result 
75  339 
end; 
438  340 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

341 
function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
433  342 
var Result: LongInt; 
79  343 
begin 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

344 
ap.ExplR:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

345 
if (Level > 2) or (Abs(hwRound(Me^.X)  Targ.X) + Abs(hwRound(Me^.Y)  Targ.Y) > 25) then 
433  346 
exit(BadTurn); 
347 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

348 
ap.Time:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

349 
ap.Power:= 1; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

350 
if (Targ.X)  hwRound(Me^.X) >= 0 then ap.Angle:= cMaxAngle div 4 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

351 
else ap.Angle:=  cMaxAngle div 4; 
498  352 
Result:= RateShove(Me, hwRound(Me^.X) + 10 * hwSign(int2hwFloat(Targ.X)  Me^.X), hwRound(Me^.Y), 15, 30); 
433  353 
if Result <= 0 then Result:= BadTurn else inc(Result); 
354 
TestBaseballBat:= Result 

79  355 
end; 
356 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

357 
function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
433  358 
var i, Result: LongInt; 
82  359 
begin 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

360 
ap.ExplR:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

361 
ap.Time:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

362 
ap.Power:= 1; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

363 
ap.Angle:= 0; 
1292
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

364 
if (Abs(hwRound(Me^.X)  Targ.X) > 25) 
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

365 
or (Abs(hwRound(Me^.Y)  50  Targ.Y) > 50) then 
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

366 
begin 
1296
d7fffad44b7e
Prevent AI to damage a teammate when trying to dig with firepunch (patch not tested)
unc0rr
parents:
1293
diff
changeset

367 
if TestColl(hwRound(Me^.Y), hwRound(Me^.Y)  16, 6) 
d7fffad44b7e
Prevent AI to damage a teammate when trying to dig with firepunch (patch not tested)
unc0rr
parents:
1293
diff
changeset

368 
and (RateShove(Me, hwRound(Me^.X) + 10 * hwSign(Me^.dX), hwRound(Me^.Y)  40, 30, 30) = 0) then 
1293  369 
Result:= Succ(BadTurn) 
1292
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

370 
else 
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

371 
Result:= BadTurn; 
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

372 
exit(Result) 
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

373 
end; 
433  374 

82  375 
Result:= 0; 
376 
for i:= 0 to 4 do 

1292
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

377 
Result:= Result + RateShove(Me, hwRound(Me^.X) + 10 * hwSign(int2hwFloat(Targ.X)  Me^.X), 
498  378 
hwRound(Me^.Y)  20 * i  5, 10, 30); 
1292
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

379 
if Result <= 0 then 
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

380 
Result:= BadTurn 
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

381 
else 
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

382 
inc(Result); 
a63a13eda583
Bot could use firepunch if it doesn't find anything else useful, and it has land above his head
unc0rr
parents:
1263
diff
changeset

383 

433  384 
TestFirePunch:= Result 
82  385 
end; 
433  386 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

387 
function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
556
49675457d76e
Bots aims not directly at the center of enemy hedgehog
unc0rr
parents:
554
diff
changeset

388 
const cShift = 4; 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

389 
var X, Y, dY: hwFloat; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

390 
b: array[0..9] of boolean; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

391 
dmg: array[0..9] of LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

392 
fexit: boolean; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

393 
i, t, Result: LongInt; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

394 
begin 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

395 
ap.ExplR:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

396 
ap.Time:= 0; 
554  397 
if (Level > 3) then exit(BadTurn); 
398 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

399 
ap.AttackPutX:= Targ.X; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

400 
ap.AttackPutY:= Targ.Y; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

401 

556
49675457d76e
Bots aims not directly at the center of enemy hedgehog
unc0rr
parents:
554
diff
changeset

402 
X:= int2hwFloat(Targ.X  135  cShift); // hh center  cShift 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

403 
X:= X  cBombsSpeed * hwSqrt(int2hwFloat((Targ.Y + 128) * 2) / cGravity); 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

404 
Y:= _128; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

405 
dY:= _0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

406 

465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

407 
for i:= 0 to 9 do 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

408 
begin 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

409 
b[i]:= true; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

410 
dmg[i]:= 0 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

411 
end; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

412 
Result:= 0; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

413 

465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

414 
repeat 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

415 
X:= X + cBombsSpeed; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

416 
Y:= Y + dY; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

417 
dY:= dY + cGravity; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

418 
fexit:= true; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

419 

465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

420 
for i:= 0 to 9 do 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

421 
if b[i] then 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

422 
begin 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

423 
fexit:= false; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

424 
if TestColl(hwRound(X) + i * 30, hwRound(Y), 4) then 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

425 
begin 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

426 
b[i]:= false; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

427 
dmg[i]:= RateExplosion(Me, hwRound(X) + i * 30, hwRound(Y), 58) 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

428 
// 58 (instead of 60) for better prediction (hh moves after explosion of one of the rockets) 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

429 
end 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

430 
end; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

431 
until fexit or (Y > _1024); 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

432 

465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

433 
for i:= 0 to 5 do inc(Result, dmg[i]); 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

434 
t:= Result; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

435 
ap.AttackPutX:= Targ.X  60; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

436 

465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

437 
for i:= 0 to 3 do 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

438 
begin 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

439 
dec(t, dmg[i]); 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

440 
inc(t, dmg[i + 6]); 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

441 
if t > Result then 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

442 
begin 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

443 
Result:= t; 
556
49675457d76e
Bots aims not directly at the center of enemy hedgehog
unc0rr
parents:
554
diff
changeset

444 
ap.AttackPutX:= Targ.X  30  cShift + i * 30 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

445 
end 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

446 
end; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

447 

465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

448 
if Result <= 0 then Result:= BadTurn; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

449 
TestAirAttack:= Result 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

450 
end; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset

451 

4  452 
end. 