author | unc0rr |
Sat, 17 Oct 2009 13:44:50 +0000 | |
changeset 2527 | a2c8b72069e8 |
parent 2457 | ecf0c7e7995b |
child 2616 | 6e2b341dc408 |
permissions | -rw-r--r-- |
71 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
883 | 3 |
* Copyright (c) 2005-2008 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 02111-1307, 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 |
( |
2357
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2177
diff
changeset
|
48 |
(proc: nil; flags: 0), // amNothing |
1507 | 49 |
(proc: @TestGrenade; flags: 0), // amGrenade |
50 |
(proc: nil; flags: 0), // amClusterBomb |
|
51 |
(proc: @TestBazooka; flags: 0), // amBazooka |
|
52 |
(proc: nil; flags: 0), // amUFO |
|
53 |
(proc: @TestShotgun; flags: 0), // amShotgun |
|
54 |
(proc: nil; flags: 0), // amPickHammer |
|
55 |
(proc: nil; flags: 0), // amSkip |
|
56 |
(proc: nil; flags: 0), // amRope |
|
57 |
(proc: nil; flags: 0), // amMine |
|
58 |
(proc: @TestDesertEagle; flags: 0), // amDEagle |
|
59 |
(proc: nil; flags: 0), // amDynamite |
|
60 |
(proc: @TestFirePunch; flags: 0), // amFirePunch |
|
61 |
(proc: nil; flags: 0), // amWhip |
|
62 |
(proc: @TestBaseballBat; flags: 0), // amBaseballBat |
|
63 |
(proc: nil; flags: 0), // amParachute |
|
64 |
(proc: @TestAirAttack; flags: amtest_OnTurn), // amAirAttack |
|
65 |
(proc: nil; flags: 0), // amMineStrike |
|
66 |
(proc: nil; flags: 0), // amBlowTorch |
|
67 |
(proc: nil; flags: 0), // amGirder |
|
68 |
(proc: nil; flags: amtest_OnTurn), // amTeleport |
|
69 |
(proc: nil; flags: 0), // amSwitch |
|
70 |
(proc: @TestMortar; flags: 0), // amMortar |
|
71 |
(proc: nil; flags: 0), // amKamikaze |
|
72 |
(proc: nil; flags: 0), // amCake |
|
73 |
(proc: nil; flags: 0), // amSeduction |
|
74 |
(proc: nil; flags: 0), // amBanana |
|
75 |
(proc: nil; flags: 0), // amHellishBomb |
|
1573 | 76 |
(proc: nil; flags: 0), // amNapalm |
2017 | 77 |
(proc: nil; flags: 0), // amDrill |
78 |
(proc: nil; flags: 0), // amBallgun |
|
1849 | 79 |
(proc: nil; flags: 0), // amRCPlane |
80 |
(proc: nil; flags: 0), // amLowGravity |
|
81 |
(proc: nil; flags: 0), // amExtraDamage |
|
82 |
(proc: nil; flags: 0), // amInvulnerable |
|
1854 | 83 |
(proc: nil; flags: 0), // amExtraTime |
2017 | 84 |
(proc: nil; flags: 0), // amLaserSight |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset
|
85 |
(proc: nil; flags: 0), // amVampiric |
2177
c045698e044f
Initial attempt at jetpack. Pluses, more like lunar lander (takes fall damage). Minuses, can't seem to cancel it or use alt weapon
nemo
parents:
2023
diff
changeset
|
86 |
(proc: nil; flags: 0), // amSniperRifle |
2457
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2376
diff
changeset
|
87 |
(proc: nil; flags: 0), // amJetpack |
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2376
diff
changeset
|
88 |
(proc: nil; flags: 0) // amMolotov |
1507 | 89 |
); |
4 | 90 |
|
439 | 91 |
const BadTurn = Low(LongInt) div 4; |
369 | 92 |
|
4 | 93 |
implementation |
75 | 94 |
uses uMisc, uAIMisc, uLand; |
370
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
95 |
|
371 | 96 |
function Metric(x1, y1, x2, y2: LongInt): LongInt; |
4 | 97 |
begin |
370
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
98 |
Metric:= abs(x1 - x2) + abs(y1 - y2) |
4 | 99 |
end; |
100 |
||
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
101 |
function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; |
351 | 102 |
var Vx, Vy, r: hwFloat; |
498 | 103 |
rTime: LongInt; |
371 | 104 |
Score, EX, EY: LongInt; |
105 |
Result: LongInt; |
|
4 | 106 |
|
371 | 107 |
function CheckTrace: LongInt; |
351 | 108 |
var x, y, dX, dY: hwFloat; |
371 | 109 |
t: LongInt; |
110 |
Result: LongInt; |
|
4 | 111 |
begin |
370
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
112 |
x:= Me^.X; |
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
113 |
y:= Me^.Y; |
4 | 114 |
dX:= Vx; |
115 |
dY:= -Vy; |
|
498 | 116 |
t:= rTime; |
4 | 117 |
repeat |
118 |
x:= x + dX; |
|
119 |
y:= y + dY; |
|
120 |
dX:= dX + cWindSpeed; |
|
121 |
dY:= dY + cGravity; |
|
122 |
dec(t) |
|
370
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
123 |
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
|
124 |
EX:= hwRound(x); |
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
125 |
EY:= hwRound(y); |
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
126 |
Result:= RateExplosion(Me, EX, EY, 101); |
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
127 |
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
|
128 |
CheckTrace:= Result |
4 | 129 |
end; |
130 |
||
131 |
begin |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
132 |
ap.Time:= 0; |
375 | 133 |
rTime:= 350; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
134 |
ap.ExplR:= 0; |
70 | 135 |
Result:= BadTurn; |
4 | 136 |
repeat |
375 | 137 |
rTime:= rTime + 300 + Level * 50 + random(300); |
556
49675457d76e
Bots aims not directly at the center of enemy hedgehog
unc0rr
parents:
554
diff
changeset
|
138 |
Vx:= - cWindSpeed * rTime * _0_5 + (int2hwFloat(Targ.X + AIrndSign(2)) - Me^.X) / int2hwFloat(rTime); |
498 | 139 |
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
|
140 |
r:= Distance(Vx, Vy); |
498 | 141 |
if not (r > _1) then |
4 | 142 |
begin |
64 | 143 |
Score:= CheckTrace; |
144 |
if Result <= Score then |
|
145 |
begin |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
146 |
ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random((Level - 1) * 9)); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
147 |
ap.Power:= hwRound(r * cMaxPower) - random((Level - 1) * 17 + 1); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
148 |
ap.ExplR:= 100; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
149 |
ap.ExplX:= EX; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
150 |
ap.ExplY:= EY; |
143 | 151 |
Result:= Score |
64 | 152 |
end; |
4 | 153 |
end |
375 | 154 |
until (rTime > 4250); |
370
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
155 |
TestBazooka:= Result |
39 | 156 |
end; |
374 | 157 |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
158 |
function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; |
70 | 159 |
const tDelta = 24; |
351 | 160 |
var Vx, Vy, r: hwFloat; |
374 | 161 |
Score, EX, EY, Result: LongInt; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
162 |
TestTime: Longword; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
163 |
|
371 | 164 |
function CheckTrace: LongInt; |
351 | 165 |
var x, y, dY: hwFloat; |
371 | 166 |
t: LongInt; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
167 |
begin |
374 | 168 |
x:= Me^.X; |
169 |
y:= Me^.Y; |
|
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
170 |
dY:= -Vy; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
171 |
t:= TestTime; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
172 |
repeat |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
173 |
x:= x + Vx; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
174 |
y:= y + dY; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
175 |
dY:= dY + cGravity; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
176 |
dec(t) |
374 | 177 |
until TestColl(hwRound(x), hwRound(y), 5) or (t = 0); |
178 |
EX:= hwRound(x); |
|
179 |
EY:= hwRound(y); |
|
180 |
if t < 50 then CheckTrace:= RateExplosion(Me, EX, EY, 101) |
|
994 | 181 |
else CheckTrace:= BadTurn |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
182 |
end; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
183 |
|
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
184 |
begin |
70 | 185 |
Result:= BadTurn; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
186 |
TestTime:= 0; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
187 |
ap.ExplR:= 0; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
188 |
repeat |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
189 |
inc(TestTime, 1000); |
498 | 190 |
Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime + tDelta); |
191 |
Vy:= cGravity * ((TestTime + tDelta) div 2) - (int2hwFloat(Targ.Y) - Me^.Y) / int2hwFloat(TestTime + tDelta); |
|
374 | 192 |
r:= Distance(Vx, Vy); |
498 | 193 |
if not (r > _1) then |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
194 |
begin |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
195 |
Score:= CheckTrace; |
70 | 196 |
if Result < Score then |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
197 |
begin |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
198 |
ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level)); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
199 |
ap.Power:= hwRound(r * cMaxPower) + AIrndSign(random(Level) * 15); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
200 |
ap.Time:= TestTime; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
201 |
ap.ExplR:= 100; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
202 |
ap.ExplX:= EX; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
203 |
ap.ExplY:= EY; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
204 |
Result:= Score |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
205 |
end; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
206 |
end |
439 | 207 |
until (TestTime = 4000); |
374 | 208 |
TestGrenade:= Result |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
209 |
end; |
375 | 210 |
|
994 | 211 |
function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; |
212 |
const tDelta = 24; |
|
1001 | 213 |
var Vx, Vy: hwFloat; |
994 | 214 |
Score, EX, EY, Result: LongInt; |
215 |
TestTime: Longword; |
|
216 |
||
217 |
function CheckTrace: LongInt; |
|
218 |
var x, y, dY: hwFloat; |
|
998 | 219 |
Result: LongInt; |
994 | 220 |
begin |
998 | 221 |
x:= Me^.X; |
222 |
y:= Me^.Y; |
|
223 |
dY:= -Vy; |
|
2376 | 224 |
|
998 | 225 |
repeat |
226 |
x:= x + Vx; |
|
227 |
y:= y + dY; |
|
228 |
dY:= dY + cGravity; |
|
229 |
EX:= hwRound(x); |
|
230 |
EY:= hwRound(y); |
|
231 |
until TestColl(EX, EY, 5) or (EY > 1000); |
|
2376 | 232 |
|
1176
2969efb7050f
Disallow AI to hurts itself with mortar (in quite rare cases it tries to shoot directly up)
unc0rr
parents:
1089
diff
changeset
|
233 |
if (EY < 1000) and not dY.isNegative then |
998 | 234 |
begin |
235 |
Result:= RateExplosion(Me, EX, EY, 91); |
|
236 |
if (Result = 0) then |
|
237 |
if (dY > _0_15) then |
|
1024 | 238 |
Result:= - abs(Targ.Y - EY) div 32 |
998 | 239 |
else |
240 |
Result:= BadTurn |
|
241 |
else if (Result < 0) then Result:= BadTurn |
|
242 |
end |
|
243 |
else |
|
244 |
Result:= BadTurn; |
|
245 |
||
246 |
CheckTrace:= Result |
|
994 | 247 |
end; |
248 |
||
249 |
function Solve: LongWord; |
|
250 |
var A, B, D, T: hwFloat; |
|
251 |
C: LongInt; |
|
252 |
begin |
|
998 | 253 |
A:= hwSqr(cGravity) * _0_25; |
254 |
B:= - cGravity * (Targ.Y - hwRound(Me^.Y)) - _1; |
|
255 |
C:= sqr(Targ.Y - hwRound(Me^.Y)) + sqr(Targ.X - hwRound(Me^.X)); |
|
256 |
D:= hwSqr(B) - (A * C * 4); |
|
994 | 257 |
if D.isNegative = false then |
998 | 258 |
begin |
259 |
D:= ( - B + hwSqrt(D)) * _0_5 / A; |
|
260 |
if D.isNegative = false then |
|
261 |
T:= hwSqrt(D) |
|
262 |
else |
|
263 |
T:= _0; |
|
264 |
Solve:= hwRound(T) |
|
265 |
end else Solve:= 0 |
|
994 | 266 |
end; |
267 |
||
268 |
begin |
|
269 |
Result:= BadTurn; |
|
270 |
ap.ExplR:= 0; |
|
271 |
||
998 | 272 |
if (Level > 2) then exit(BadTurn); |
994 | 273 |
|
274 |
TestTime:= Solve; |
|
275 |
||
998 | 276 |
if TestTime = 0 then exit(BadTurn); |
994 | 277 |
|
278 |
Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime); |
|
279 |
Vy:= cGravity * (TestTime div 2) - (int2hwFloat(Targ.Y) - Me^.Y) / int2hwFloat(TestTime); |
|
280 |
||
281 |
Score:= CheckTrace; |
|
282 |
if Result < Score then |
|
283 |
begin |
|
284 |
ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level)); |
|
285 |
ap.Power:= 1; |
|
286 |
ap.ExplR:= 100; |
|
287 |
ap.ExplX:= EX; |
|
288 |
ap.ExplY:= EY; |
|
289 |
Result:= Score |
|
290 |
end; |
|
291 |
||
292 |
TestMortar:= Result |
|
293 |
end; |
|
294 |
||
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
295 |
function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; |
1941 | 296 |
const |
297 |
MIN_RANGE = 80; |
|
298 |
MAX_RANGE = 400; |
|
351 | 299 |
var Vx, Vy, x, y: hwFloat; |
375 | 300 |
rx, ry, Result: LongInt; |
1941 | 301 |
range: integer; |
375 | 302 |
begin |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
303 |
ap.ExplR:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
304 |
ap.Time:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
305 |
ap.Power:= 1; |
1941 | 306 |
range:= Metric(hwRound(Me^.X), hwRound(Me^.Y), Targ.X, Targ.Y); |
307 |
if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then exit(BadTurn); |
|
498 | 308 |
Vx:= (int2hwFloat(Targ.X) - Me^.X) * _1div1024; |
309 |
Vy:= (int2hwFloat(Targ.Y) - Me^.Y) * _1div1024; |
|
375 | 310 |
x:= Me^.X; |
311 |
y:= Me^.Y; |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
312 |
ap.Angle:= DxDy2AttackAngle(Vx, -Vy); |
70 | 313 |
repeat |
314 |
x:= x + vX; |
|
315 |
y:= y + vY; |
|
375 | 316 |
rx:= hwRound(x); |
317 |
ry:= hwRound(y); |
|
318 |
if TestColl(rx, ry, 2) then |
|
70 | 319 |
begin |
509 | 320 |
x:= x + vX * 8; |
321 |
y:= y + vY * 8; |
|
322 |
Result:= RateShotgun(Me, rx, ry) * 2; |
|
375 | 323 |
if Result = 0 then Result:= - Metric(Targ.X, Targ.Y, rx, ry) div 64 |
143 | 324 |
else dec(Result, Level * 4000); |
375 | 325 |
exit(Result) |
70 | 326 |
end |
1941 | 327 |
until (Abs(Targ.X - hwRound(x)) + Abs(Targ.Y - hwRound(y)) < 4) or (x.isNegative) or (y.isNegative) or (x.Round > LAND_WIDTH) or (y.Round > LAND_HEIGHT); |
375 | 328 |
TestShotgun:= BadTurn |
70 | 329 |
end; |
438 | 330 |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
331 |
function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; |
351 | 332 |
var Vx, Vy, x, y, t: hwFloat; |
75 | 333 |
d: Longword; |
438 | 334 |
Result: LongInt; |
75 | 335 |
begin |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
336 |
ap.ExplR:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
337 |
ap.Time:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
338 |
ap.Power:= 1; |
498 | 339 |
if Abs(hwRound(Me^.X) - Targ.X) + Abs(hwRound(Me^.Y) - Targ.Y) < 80 then |
439 | 340 |
exit(BadTurn); |
498 | 341 |
t:= _0_5 / Distance(int2hwFloat(Targ.X) - Me^.X, int2hwFloat(Targ.Y) - Me^.Y); |
342 |
Vx:= (int2hwFloat(Targ.X) - Me^.X) * t; |
|
343 |
Vy:= (int2hwFloat(Targ.Y) - Me^.Y) * t; |
|
438 | 344 |
x:= Me^.X; |
345 |
y:= Me^.Y; |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
346 |
ap.Angle:= DxDy2AttackAngle(Vx, -Vy); |
75 | 347 |
d:= 0; |
1941 | 348 |
|
75 | 349 |
repeat |
350 |
x:= x + vX; |
|
351 |
y:= y + vY; |
|
1753 | 352 |
if ((hwRound(x) and LAND_WIDTH_MASK) = 0)and((hwRound(y) and LAND_HEIGHT_MASK) = 0) |
438 | 353 |
and (Land[hwRound(y), hwRound(x)] <> 0) then inc(d); |
1941 | 354 |
until (Abs(Targ.X - hwRound(x)) + Abs(Targ.Y - hwRound(y)) < 4) or (x.isNegative) or (y.isNegative) or (x.Round > LAND_WIDTH) or (y.Round > LAND_HEIGHT) or (d > 200); |
355 |
||
498 | 356 |
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
|
357 |
else Result:= BadTurn; |
438 | 358 |
TestDesertEagle:= Result |
75 | 359 |
end; |
438 | 360 |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
361 |
function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; |
433 | 362 |
var Result: LongInt; |
79 | 363 |
begin |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
364 |
ap.ExplR:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
365 |
if (Level > 2) or (Abs(hwRound(Me^.X) - Targ.X) + Abs(hwRound(Me^.Y) - Targ.Y) > 25) then |
433 | 366 |
exit(BadTurn); |
367 |
||
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
368 |
ap.Time:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
369 |
ap.Power:= 1; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
370 |
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
|
371 |
else ap.Angle:= - cMaxAngle div 4; |
498 | 372 |
Result:= RateShove(Me, hwRound(Me^.X) + 10 * hwSign(int2hwFloat(Targ.X) - Me^.X), hwRound(Me^.Y), 15, 30); |
433 | 373 |
if Result <= 0 then Result:= BadTurn else inc(Result); |
374 |
TestBaseballBat:= Result |
|
79 | 375 |
end; |
376 |
||
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
377 |
function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt; |
433 | 378 |
var i, Result: LongInt; |
82 | 379 |
begin |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
380 |
ap.ExplR:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
381 |
ap.Time:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
382 |
ap.Power:= 1; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
383 |
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
|
384 |
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
|
385 |
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
|
386 |
begin |
1296
d7fffad44b7e
Prevent AI to damage a teammate when trying to dig with firepunch (patch not tested)
unc0rr
parents:
1293
diff
changeset
|
387 |
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
|
388 |
and (RateShove(Me, hwRound(Me^.X) + 10 * hwSign(Me^.dX), hwRound(Me^.Y) - 40, 30, 30) = 0) then |
1293 | 389 |
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
|
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 |
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
|
392 |
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
|
393 |
end; |
433 | 394 |
|
82 | 395 |
Result:= 0; |
396 |
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
|
397 |
Result:= Result + RateShove(Me, hwRound(Me^.X) + 10 * hwSign(int2hwFloat(Targ.X) - Me^.X), |
498 | 398 |
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
|
399 |
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
|
400 |
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
|
401 |
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
|
402 |
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
|
403 |
|
433 | 404 |
TestFirePunch:= Result |
82 | 405 |
end; |
433 | 406 |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
407 |
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
|
408 |
const cShift = 4; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
409 |
var X, Y, dY: hwFloat; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
410 |
b: array[0..9] of boolean; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
411 |
dmg: array[0..9] of LongInt; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
412 |
fexit: boolean; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
413 |
i, t, Result: LongInt; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
414 |
begin |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
415 |
ap.ExplR:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
416 |
ap.Time:= 0; |
554 | 417 |
if (Level > 3) then exit(BadTurn); |
418 |
||
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
419 |
ap.AttackPutX:= Targ.X; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
420 |
ap.AttackPutY:= Targ.Y; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
421 |
|
556
49675457d76e
Bots aims not directly at the center of enemy hedgehog
unc0rr
parents:
554
diff
changeset
|
422 |
X:= int2hwFloat(Targ.X - 135 - cShift); // hh center - cShift |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
423 |
X:= X - cBombsSpeed * hwSqrt(int2hwFloat((Targ.Y + 128) * 2) / cGravity); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
424 |
Y:= -_128; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
425 |
dY:= _0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
426 |
|
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
427 |
for i:= 0 to 9 do |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
428 |
begin |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
429 |
b[i]:= true; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
430 |
dmg[i]:= 0 |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
431 |
end; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
432 |
Result:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
433 |
|
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
434 |
repeat |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
435 |
X:= X + cBombsSpeed; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
436 |
Y:= Y + dY; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
437 |
dY:= dY + cGravity; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
438 |
fexit:= true; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
439 |
|
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
440 |
for i:= 0 to 9 do |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
441 |
if b[i] 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 |
fexit:= false; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
444 |
if TestColl(hwRound(X) + i * 30, hwRound(Y), 4) then |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
445 |
begin |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
446 |
b[i]:= false; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
447 |
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
|
448 |
// 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
|
449 |
end |
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 |
until fexit or (Y > _1024); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
452 |
|
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
453 |
for i:= 0 to 5 do inc(Result, dmg[i]); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
454 |
t:= Result; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
455 |
ap.AttackPutX:= Targ.X - 60; |
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 |
for i:= 0 to 3 do |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
458 |
begin |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
459 |
dec(t, dmg[i]); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
460 |
inc(t, dmg[i + 6]); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
461 |
if t > Result then |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
462 |
begin |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
463 |
Result:= t; |
556
49675457d76e
Bots aims not directly at the center of enemy hedgehog
unc0rr
parents:
554
diff
changeset
|
464 |
ap.AttackPutX:= Targ.X - 30 - cShift + i * 30 |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
465 |
end |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
466 |
end; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
467 |
|
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
468 |
if Result <= 0 then Result:= BadTurn; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
469 |
TestAirAttack:= Result |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
470 |
end; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
471 |
|
4 | 472 |
end. |