author  unc0rr 
Wed, 18 Mar 2009 15:48:43 +0000  
changeset 1899  5763f46d7486 
parent 1854  6e05013899b2 
child 1941  b1ef1f86148c 
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 
1507  25 
Time: Longword; 
26 
Angle, Power: LongInt; 

27 
ExplX, ExplY, ExplR: LongInt; 

28 
AttackPutX, AttackPutY: LongInt; 

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; 
1507  41 
TAmmoTest = record 
42 
proc: TAmmoTestProc; 

43 
flags: Longword; 

44 
end; 

543
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 = 
1507  47 
( 
48 
(proc: @TestGrenade; flags: 0), // amGrenade 

49 
(proc: nil; flags: 0), // amClusterBomb 

50 
(proc: @TestBazooka; flags: 0), // amBazooka 

51 
(proc: nil; flags: 0), // amUFO 

52 
(proc: @TestShotgun; flags: 0), // amShotgun 

53 
(proc: nil; flags: 0), // amPickHammer 

54 
(proc: nil; flags: 0), // amSkip 

55 
(proc: nil; flags: 0), // amRope 

56 
(proc: nil; flags: 0), // amMine 

57 
(proc: @TestDesertEagle; flags: 0), // amDEagle 

58 
(proc: nil; flags: 0), // amDynamite 

59 
(proc: @TestFirePunch; flags: 0), // amFirePunch 

60 
(proc: nil; flags: 0), // amWhip 

61 
(proc: @TestBaseballBat; flags: 0), // amBaseballBat 

62 
(proc: nil; flags: 0), // amParachute 

63 
(proc: @TestAirAttack; flags: amtest_OnTurn), // amAirAttack 

64 
(proc: nil; flags: 0), // amMineStrike 

65 
(proc: nil; flags: 0), // amBlowTorch 

66 
(proc: nil; flags: 0), // amGirder 

67 
(proc: nil; flags: amtest_OnTurn), // amTeleport 

68 
(proc: nil; flags: 0), // amSwitch 

69 
(proc: @TestMortar; flags: 0), // amMortar 

70 
(proc: nil; flags: 0), // amKamikaze 

71 
(proc: nil; flags: 0), // amCake 

72 
(proc: nil; flags: 0), // amSeduction 

73 
(proc: nil; flags: 0), // amBanana 

74 
(proc: nil; flags: 0), // amHellishBomb 

1573  75 
(proc: nil; flags: 0), // amNapalm 
1601  76 
(proc: nil; flags: 0), // amDrill 
1689  77 
(proc: nil; flags: 0), // amBallgun 
1849  78 
(proc: nil; flags: 0), // amRCPlane 
79 
(proc: nil; flags: 0), // amLowGravity 

80 
(proc: nil; flags: 0), // amExtraDamage 

81 
(proc: nil; flags: 0), // amInvulnerable 

1854  82 
(proc: nil; flags: 0), // amExtraTime 
83 
(proc: nil; flags: 0) // amLaserSight 

1507  84 
); 
4  85 

439  86 
const BadTurn = Low(LongInt) div 4; 
369  87 

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

90 

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

93 
Metric:= abs(x1  x2) + abs(y1  y2) 
4  94 
end; 
95 

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

96 
function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
351  97 
var Vx, Vy, r: hwFloat; 
498  98 
rTime: LongInt; 
371  99 
Score, EX, EY: LongInt; 
100 
Result: LongInt; 

4  101 

371  102 
function CheckTrace: LongInt; 
351  103 
var x, y, dX, dY: hwFloat; 
371  104 
t: LongInt; 
105 
Result: LongInt; 

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

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

108 
y:= Me^.Y; 
4  109 
dX:= Vx; 
110 
dY:= Vy; 

498  111 
t:= rTime; 
4  112 
repeat 
113 
x:= x + dX; 

114 
y:= y + dY; 

115 
dX:= dX + cWindSpeed; 

116 
dY:= dY + cGravity; 

117 
dec(t) 

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

118 
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

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

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

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

122 
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

123 
CheckTrace:= Result 
4  124 
end; 
125 

126 
begin 

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

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

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

133 
Vx:=  cWindSpeed * rTime * _0_5 + (int2hwFloat(Targ.X + AIrndSign(2))  Me^.X) / int2hwFloat(rTime); 
498  134 
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

135 
r:= Distance(Vx, Vy); 
498  136 
if not (r > _1) then 
4  137 
begin 
64  138 
Score:= CheckTrace; 
139 
if Result <= Score then 

140 
begin 

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

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

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

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

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

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

150 
TestBazooka:= Result 
39  151 
end; 
374  152 

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

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

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

158 

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

162 
begin 
374  163 
x:= Me^.X; 
164 
y:= Me^.Y; 

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

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

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

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

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

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

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

171 
dec(t) 
374  172 
until TestColl(hwRound(x), hwRound(y), 5) or (t = 0); 
173 
EX:= hwRound(x); 

174 
EY:= hwRound(y); 

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

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

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

178 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

204 
end; 
375  205 

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

1001  208 
var Vx, Vy: hwFloat; 
994  209 
Score, EX, EY, Result: LongInt; 
210 
TestTime: Longword; 

211 

212 
function CheckTrace: LongInt; 

213 
var x, y, dY: hwFloat; 

998  214 
Result: LongInt; 
994  215 
begin 
998  216 
x:= Me^.X; 
217 
y:= Me^.Y; 

218 
dY:= Vy; 

219 

220 
repeat 

221 
x:= x + Vx; 

222 
y:= y + dY; 

223 
dY:= dY + cGravity; 

224 
EX:= hwRound(x); 

225 
EY:= hwRound(y); 

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

227 

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

228 
if (EY < 1000) and not dY.isNegative then 
998  229 
begin 
230 
Result:= RateExplosion(Me, EX, EY, 91); 

231 
if (Result = 0) then 

232 
if (dY > _0_15) then 

1024  233 
Result:=  abs(Targ.Y  EY) div 32 
998  234 
else 
235 
Result:= BadTurn 

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

237 
end 

238 
else 

239 
Result:= BadTurn; 

240 

241 
CheckTrace:= Result 

994  242 
end; 
243 

244 
function Solve: LongWord; 

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

246 
C: LongInt; 

247 
begin 

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

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

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

994  252 
if D.isNegative = false then 
998  253 
begin 
254 
D:= (  B + hwSqrt(D)) * _0_5 / A; 

255 
if D.isNegative = false then 

256 
T:= hwSqrt(D) 

257 
else 

258 
T:= _0; 

259 
Solve:= hwRound(T) 

260 
end else Solve:= 0 

994  261 
end; 
262 

263 
begin 

264 
Result:= BadTurn; 

265 
ap.ExplR:= 0; 

266 

998  267 
if (Level > 2) then exit(BadTurn); 
994  268 

269 
TestTime:= Solve; 

270 

998  271 
if TestTime = 0 then exit(BadTurn); 
994  272 

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

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

275 

276 
Score:= CheckTrace; 

277 
if Result < Score then 

278 
begin 

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

280 
ap.Power:= 1; 

281 
ap.ExplR:= 100; 

282 
ap.ExplX:= EX; 

283 
ap.ExplY:= EY; 

284 
Result:= Score 

285 
end; 

286 

287 
TestMortar:= Result 

288 
end; 

289 

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

290 
function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; 
351  291 
var Vx, Vy, x, y: hwFloat; 
375  292 
rx, ry, Result: LongInt; 
293 
begin 

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

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

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

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

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

375  301 
x:= Me^.X; 
302 
y:= Me^.Y; 

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

303 
ap.Angle:= DxDy2AttackAngle(Vx, Vy); 
70  304 
repeat 
305 
x:= x + vX; 

306 
y:= y + vY; 

375  307 
rx:= hwRound(x); 
308 
ry:= hwRound(y); 

309 
if TestColl(rx, ry, 2) then 

70  310 
begin 
509  311 
x:= x + vX * 8; 
312 
y:= y + vY * 8; 

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

375  314 
if Result = 0 then Result:=  Metric(Targ.X, Targ.Y, rx, ry) div 64 
143  315 
else dec(Result, Level * 4000); 
375  316 
exit(Result) 
70  317 
end 
498  318 
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  319 
TestShotgun:= BadTurn 
70  320 
end; 
438  321 

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

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

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

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

329 
ap.Power:= 1; 
498  330 
if Abs(hwRound(Me^.X)  Targ.X) + Abs(hwRound(Me^.Y)  Targ.Y) < 80 then 
439  331 
exit(BadTurn); 
498  332 
t:= _0_5 / Distance(int2hwFloat(Targ.X)  Me^.X, int2hwFloat(Targ.Y)  Me^.Y); 
333 
Vx:= (int2hwFloat(Targ.X)  Me^.X) * t; 

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

438  335 
x:= Me^.X; 
336 
y:= Me^.Y; 

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

337 
ap.Angle:= DxDy2AttackAngle(Vx, Vy); 
75  338 
d:= 0; 
339 
repeat 

340 
x:= x + vX; 

341 
y:= y + vY; 

1753  342 
if ((hwRound(x) and LAND_WIDTH_MASK) = 0)and((hwRound(y) and LAND_HEIGHT_MASK) = 0) 
438  343 
and (Land[hwRound(y), hwRound(x)] <> 0) then inc(d); 
498  344 
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); 
345 
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

346 
else Result:= BadTurn; 
438  347 
TestDesertEagle:= Result 
75  348 
end; 
438  349 

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

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

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

354 
if (Level > 2) or (Abs(hwRound(Me^.X)  Targ.X) + Abs(hwRound(Me^.Y)  Targ.Y) > 25) then 
433  355 
exit(BadTurn); 
356 

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

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

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

359 
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

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

79  364 
end; 
365 

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

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

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

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

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

372 
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

373 
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

374 
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

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

376 
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

377 
and (RateShove(Me, hwRound(Me^.X) + 10 * hwSign(Me^.dX), hwRound(Me^.Y)  40, 30, 30) = 0) then 
1293  378 
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

379 
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

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 
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

382 
end; 
433  383 

82  384 
Result:= 0; 
385 
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

386 
Result:= Result + RateShove(Me, hwRound(Me^.X) + 10 * hwSign(int2hwFloat(Targ.X)  Me^.X), 
498  387 
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

388 
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

389 
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

390 
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

391 
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

392 

433  393 
TestFirePunch:= Result 
82  394 
end; 
433  395 

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

396 
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

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

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

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

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

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

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

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

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

405 
ap.Time:= 0; 
554  406 
if (Level > 3) then exit(BadTurn); 
407 

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

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

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

410 

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

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

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

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

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

415 

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

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

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

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

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

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

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

422 

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

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

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

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

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

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

428 

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

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

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

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

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

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

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

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

436 
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

437 
// 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

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

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

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

441 

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

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

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

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

445 

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

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

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

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

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

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

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

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

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

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

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

456 

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

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

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

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

460 

4  461 
end. 